SpringBoot之数据访问和事务-专题三

四、数据访问

4.1、springboot整合使用JdbcTemplate

4.1.1 pom文件引入
  1. <parent>
  2. 		<groupId>org.springframework.boot</groupId>
  3. 		<artifactId>spring-boot-starter-parent</artifactId>
  4. 		<version>2.0.0.RELEASE</version>
  5. 	</parent>
  6. 	<dependencies>
  7. 		<!-- jdbcTemplate 依赖 -->
  8. 		<dependency>
  9. 			<groupId>org.springframework.boot</groupId>
  10. 			<artifactId>spring-boot-starter-jdbc</artifactId>
  11. 		</dependency>
  12. 		<!-- mysql 依赖 -->
  13. 		<dependency>
  14. 			<groupId>mysql</groupId>
  15. 			<artifactId>mysql-connector-java</artifactId>
  16. 		</dependency>
  17. 		<!-- 测试 -->
  18. 		<dependency>
  19. 			<groupId>org.springframework.boot</groupId>
  20. 			<artifactId>spring-boot-starter-test</artifactId>
  21. 			<scope>test</scope>
  22. 		</dependency>
  23. 		<!-- springboot-web组件 -->
  24. 		<dependency>
  25. 			<groupId>org.springframework.boot</groupId>
  26. 			<artifactId>spring-boot-starter-web</artifactId>
  27. 		</dependency>
  28. 	</dependencies>

4.1.2 application.properties新增配置

  1. spring.datasource.url=jdbc:mysql://localhost:3306/test
  2. spring.datasource.username=root
  3. spring.datasource.password=root
  4. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
4.1.3 UserService类
  1. @Service
  2. public class UserServiceImpl implements UserService {
  3. 	@Autowired
  4. 	private JdbcTemplate jdbcTemplate;
  5. 	public void createUser(String name, Integer age) {
  6. 		jdbcTemplate.update("insert into users values(null,?,?);", name, age);
  7. 	}
  8. }

4.1.4 App类

  1. @SpringBootApplication
  2. public class App {
  4. 	public static void main(String[] args) {
  5. 		SpringApplication.run(App.class, args);
  6. 	}
  8. }

注意: spring-boot-starter-parent要在1.5以上

4.2、springboot整合使用mybatis

4.2.1、pom文件引入
  1. <parent>
  2. 		<groupId>org.springframework.boot</groupId>
  3. 		<artifactId>spring-boot-starter-parent</artifactId>
  4. 		<version>2.0.0.RELEASE</version>
  5. 	</parent>
  6. 	<dependencies>
  7. 		<dependency>
  8. 			<groupId>org.springframework.boot</groupId>
  9. 			<artifactId>spring-boot-starter</artifactId>
  10. 		</dependency>
  11. 		<!-- 测试 -->
  12. 		<dependency>
  13. 			<groupId>org.springframework.boot</groupId>
  14. 			<artifactId>spring-boot-starter-test</artifactId>
  15. 			<scope>test</scope>
  16. 		</dependency>
  17. 		<dependency>
  18. 			<groupId>org.mybatis.spring.boot</groupId>
  19. 			<artifactId>mybatis-spring-boot-starter</artifactId>
  20. 			<version>1.1.1</version>
  21. 		</dependency>
  22. 		<!-- mysql 依赖 -->
  23. 		<dependency>
  24. 			<groupId>mysql</groupId>
  25. 			<artifactId>mysql-connector-java</artifactId>
  26. 		</dependency>
  27. 		<!-- springboot-web组件 -->
  28. 		<dependency>
  29. 			<groupId>org.springframework.boot</groupId>
  30. 			<artifactId>spring-boot-starter-web</artifactId>
  31. 		</dependency>
  32. 	</dependencies>

4.2.2、配置文件引入

  1. spring.datasource.url=jdbc:mysql://localhost:3306/test
  2. spring.datasource.username=root
  3. spring.datasource.password=root
  4. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
4.2.3、Mapper代码
  1. public interface UserMapper {
  2. 	@Select("SELECT * FROM USERS WHERE NAME = #{name}")
  3. 	User findByName(@Param("name") String name);
  4. 	@Insert("INSERT INTO USERS(NAME, AGE) VALUES(#{name}, #{age})")
  5. 	int insert(@Param("name") String name, @Param("age") Integer age);
  6. }
4.2.4、启动方式
  1. @MapperScan("com.mapper")
  2. @SpringBootApplication
  3. public class MybatisApp {
  5. 	public static void main(String[] args) {
  6. 		SpringApplication.run(MybatisApp.class, args);
  7. 	}
  9. }
4.2.5、Mybatis整合分页插件

pageHelper

PageHelper 是一款好用的开源免费的 Mybatis 第三方物理分页插件

物理分页

支持常见的 12 种数据库。Oracle,MySql,MariaDB,SQLite,DB2,PostgreSQL,SqlServer 等

支持多种分页方式

支持常见的 RowBounds(PageRowBounds)，PageHelper.startPage 方法调用，Mapper 接口参数调用

Maven依赖

  1. <parent>
  2. 		<groupId>org.springframework.boot</groupId>
  3. 		<artifactId>spring-boot-starter-parent</artifactId>
  4. 		<version>2.0.0.RELEASE</version>
  5. 	</parent>
  6. 	<dependencies>
  7. 		<dependency>
  8. 			<groupId>org.projectlombok</groupId>
  9. 			<artifactId>lombok</artifactId>
  10. 		</dependency>
  12. 		<dependency>
  13. 			<groupId>org.springframework.boot</groupId>
  14. 			<artifactId>spring-boot-starter</artifactId>
  15. 		</dependency>
  16. 		<!-- 测试 -->
  17. 		<dependency>
  18. 			<groupId>org.springframework.boot</groupId>
  19. 			<artifactId>spring-boot-starter-test</artifactId>
  20. 			<scope>test</scope>
  21. 		</dependency>
  22. 		<dependency>
  23. 			<groupId>org.mybatis.spring.boot</groupId>
  24. 			<artifactId>mybatis-spring-boot-starter</artifactId>
  25. 			<version>1.1.1</version>
  26. 		</dependency>
  27. 		<!-- mysql 依赖 -->
  28. 		<dependency>
  29. 			<groupId>mysql</groupId>
  30. 			<artifactId>mysql-connector-java</artifactId>
  31. 		</dependency>
  32. 		<!-- springboot-web组件 -->
  33. 		<dependency>
  34. 			<groupId>org.springframework.boot</groupId>
  35. 			<artifactId>spring-boot-starter-web</artifactId>
  36. 		</dependency>
  37. 		<!-- springboot 整合 pagehelper -->
  38. 		<dependency>
  39. 			<groupId>com.github.pagehelper</groupId>
  40. 			<artifactId>pagehelper-spring-boot-starter</artifactId>
  41. 			<version>1.2.5</version>
  42. 		</dependency>
  43. 		<dependency>
  44. 			<groupId>org.apache.commons</groupId>
  45. 			<artifactId>commons-lang3</artifactId>
  46. 			<version>3.7</version>
  47. 		</dependency>
  48. 	</dependencies>

配置文件

  1. spring.datasource.url=jdbc:mysql://localhost:3306/test
  2. spring.datasource.username=root
  3. spring.datasource.password=root
  4. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  6. logging.level.com.example.demo.dao=DEBUG
  7. pagehelper.helperDialect=mysql
  8. pagehelper.reasonable=true
  9. pagehelper.supportMethodsArguments=true
  10. pagehelper.params=count=countSql
  11. pagehelper.page-size-zero=true

Entity层

  1. @Data
  2. public class User {
  4. 	private Integer id;
  5. 	private String name;
  6. 	private Integer age;
  7. }

Mapper层

  1. public interface UserMapper {
  2. 	@Select("SELECT * FROM USERS ")
  3. 	List<User> findUserList();
  4. }

Service层

  1. @Service
  2. public class UserService {
  3. 	@Autowired
  4. 	private UserMapper userMapper;
  6. 	public PageInfo<User> findUserList(int page, int size) {
  7. 		// 开启分页插件,放在查询语句上面
  8. 		PageHelper.startPage(page, size);
  9. 		List<User> listUser = userMapper.findUserList();
  10. 		// 封装分页之后的数据
  11. 		PageInfo<User> pageInfoUser = new PageInfo<User>(listUser);
  12. 		return pageInfoUser;
  13. 	}
  15. }

Controller层

  1. @RestController
  2. public class IndexController {
  3. 	@Autowired
  4. 	private UserService userService;
  6. 	@RequestMapping("/findUser")
  7. 	public PageInfo<User> findUserList(int page, int size) {
  8. 		return userService.findUserList(page, size);
  9. 	}
  11. }

启动项目

  1. @MapperScan("com.mapper")
  2. @SpringBootApplication
  3. public class PageHelper {
  5. 	public static void main(String[] args) {
  6. 		SpringApplication.run(PageHelper.class, args);
  7. 	}
  9. }

4.3、springboot整合使用springjpa

4.3.1 pom文件引入依赖
  1. <parent>
  2. 		<groupId>org.springframework.boot</groupId>
  3. 		<artifactId>spring-boot-starter-parent</artifactId>
  4. 		<version>2.0.0.RELEASE</version>
  5. 	</parent>
  6. 	<dependencies>
  7. 		<dependency>
  8. 			<groupId>org.springframework.boot</groupId>
  9. 			<artifactId>spring-boot-starter-data-jpa</artifactId>
  10. 		</dependency>
  11. 		<dependency>
  12. 			<groupId>mysql</groupId>
  13. 			<artifactId>mysql-connector-java</artifactId>
  14. 		</dependency>
  15. 		<dependency>
  16. 			<groupId>org.springframework.boot</groupId>
  17. 			<artifactId>spring-boot-starter-web</artifactId>
  18. 		</dependency>
  19. 	</dependencies>
4.3.2 创建User实体类
  1. @Entity(name = "users")
  2. public class UserEntity {
  3. 	@Id
  4. 	@GeneratedValue(strategy = GenerationType.IDENTITY)
  5. 	private Integer id;
  6. 	@Column(name = "name")
  7. 	private String name;
  8. 	@Column(name = "age")
  9. 	private Integer age;
  10. }

4.3.3 创建UserDao

  1. public interface UserDao extends JpaRepository<User, Integer> {
  2. }

4.3.3 创建IndexController

  1. @RestController
  2. public class IndexController {
  3. 	@Autowired
  4. 	private UserDao userDao;
  6. 	@RequestMapping("/jpaFindUser")
  7. 	public Object jpaIndex(User user) {
  8. 		Optional<User> userOptional = userDao.findById(user.getId());
  9. 		User reusltUser = userOptional.get();
  10. 		return reusltUser == null ? "没有查询到数据" : reusltUser;
  11. 	}
  13. }

4.3.4 启动项目

  1. @SpringBootApplication
  2. public class JpaApp {
  4. 	public static void main(String[] args) {
  5. 		SpringApplication.run(JpaApp.class, args);
  6. 	}
  8. }

4.4、springboot整合多数据源

思考下，你们在项目中有使用到多数据源吗？

原理使用根据包名，加载不同的数据源

4.4.1配置文件中新增两个数据源
  1. ###datasource1
  2. spring.datasource.test1.driver-class-name = com.mysql.jdbc.Driver
  3. spring.datasource.test1.jdbc-url = jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf-8
  4. spring.datasource.test1.username = root
  5. spring.datasource.test1.password = root
  6. ###datasource2
  7. spring.datasource.test2.driver-class-name = com.mysql.jdbc.Driver
  8. spring.datasource.test2.jdbc-url = jdbc:mysql://localhost:3306/test02?useUnicode=true&characterEncoding=utf-8
  9. spring.datasource.test2.username = root
  10. spring.datasource.test2.password = root
4.4.2配置文件中新增两个数据源
  1. //DataSource01
  2. @Configuration // 注册到springboot容器中
  3. @MapperScan(basePackages = "com.example.test01", sqlSessionFactoryRef = "test1SqlSessionFactory")
  4. public class DataSource1Config {
  6. 	@Bean(name = "test1DataSource")
  7. 	@ConfigurationProperties(prefix = "spring.datasource.test1")
  8. 	@Primary
  9. 	public DataSource testDataSource() {
  10. 		return DataSourceBuilder.create().build();
  11. 	}
  13. 	@Bean(name = "test1SqlSessionFactory")
  14. 	@Primary
  15. 	public SqlSessionFactory testSqlSessionFactory(@Qualifier("test1DataSource") DataSource dataSource)
  16. 			throws Exception {
  17. 		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  18. 		bean.setDataSource(dataSource);
  19. 		// bean.setMapperLocations(
  20. 		// new
  21. 		// PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/test1/*.xml"));
  22. 		return bean.getObject();
  23. 	}
  25. 	@Bean(name = "test1TransactionManager")
  26. 	@Primary
  27. 	public DataSourceTransactionManager testTransactionManager(@Qualifier("test1DataSource") DataSource dataSource) {
  28. 		return new DataSourceTransactionManager(dataSource);
  29. 	}
  31. 	@Bean(name = "test1SqlSessionTemplate")
  32. 	@Primary
  33. 	public SqlSessionTemplate testSqlSessionTemplate(
  34. 			@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
  35. 		return new SqlSessionTemplate(sqlSessionFactory);
  36. 	}
  38. }

DataSource02

  1. //DataSource2
  2. @Configuration // 注册到springboot容器中
  3. @MapperScan(basePackages = "com.example.test02", sqlSessionFactoryRef = "test2SqlSessionFactory")
  4. public class DataSource2Config {
  6. 	@Bean(name = "test2DataSource")
  7. 	@ConfigurationProperties(prefix = "spring.datasource.test2")
  8. 	public DataSource testDataSource() {
  9. 		return DataSourceBuilder.create().build();
  10. 	}
  12. 	@Bean(name = "test2SqlSessionFactory")
  13. 	public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource)
  14. 			throws Exception {
  15. 		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  16. 		bean.setDataSource(dataSource);
  17. 		// bean.setMapperLocations(
  18. 		// new
  19. 		// PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/test2/*.xml"));
  20. 		return bean.getObject();
  21. 	}
  23. 	@Bean(name = "test2TransactionManager")
  24. 	public DataSourceTransactionManager testTransactionManager(@Qualifier("test2DataSource") DataSource dataSource) {
  25. 		return new DataSourceTransactionManager(dataSource);
  26. 	}
  28. 	@Bean(name = "test2SqlSessionTemplate")
  29. 	public SqlSessionTemplate testSqlSessionTemplate(
  30. 			@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
  31. 		return new SqlSessionTemplate(sqlSessionFactory);
  32. 	}
  34. }
4.4.2创建分包Mapper
  1. public interface User1Mapper {
  2. 	@Insert("insert into users values(null,#{name},#{age});")
  3. 	public int addUser(@Param("name") String name, @Param("age") Integer age);
  4. }
4.4.3 多数据源事务注意事项

在多数据源的情况下，使用@Transactional注解时，应该指定事务管理者

@Transactional(transactionManager = “test2TransactionManager”)

4.4.5启动项目

  1. @SpringBootApplication
  2. @MapperScan(basePackages = { "com.example.mapper" })
  3. public class App {
  4. 	public static void main(String[] args) {
  5. 		SpringApplication.run(App.class, args);
  6. 	}
  7. }

No qualifying bean of type [javax.sql.DataSource] is defined: expected single matching bean but found 2: test1DataSource,test2DataSource

加上@Primary即可。

There was an unexpected error (type=Internal Server Error, status=500).

No qualifying bean of type ‘org.springframework.transaction.PlatformTransactionManager’ available: expected single matching bean but found 2: test1TransactionManager,test2TransactionManager

指定事务管理器

Springboot1.5的时候 没有默认指向数据源 会报错

Springboot2.0的时候 不报错

五、事物管理

5.1.1SpringBoot整合事物管理

Springboot默认集成事物,只主要在方法上加上@Transactional即可

5.1.2SpringBoot分布式事物管理

使用springboot+jta+atomikos 分布式事物管理

Atomikos 是一个为Java平台提供增值服务的并且开源类事务管理器。

5.1.2.1 新增jta-atomikos依赖

  1. <dependency>
  2. 	<groupId>org.springframework.boot</groupId>
  3. 	<artifactId>spring-boot-starter-jta-atomikos</artifactId>
  4. </dependency>

5.1.2.2新增配置文件信息

  1. # Mysql 1
  2. mysql.datasource.test1.url = jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf-8
  3. mysql.datasource.test1.username = root
  4. mysql.datasource.test1.password = root
  6. mysql.datasource.test1.minPoolSize = 3
  7. mysql.datasource.test1.maxPoolSize = 25
  8. mysql.datasource.test1.maxLifetime = 20000
  9. mysql.datasource.test1.borrowConnectionTimeout = 30
  10. mysql.datasource.test1.loginTimeout = 30
  11. mysql.datasource.test1.maintenanceInterval = 60
  12. mysql.datasource.test1.maxIdleTime = 60
  14. # Mysql 2
  15. mysql.datasource.test2.url =jdbc:mysql://localhost:3306/test02?useUnicode=true&characterEncoding=utf-8
  16. mysql.datasource.test2.username =root
  17. mysql.datasource.test2.password =root
  19. mysql.datasource.test2.minPoolSize = 3
  20. mysql.datasource.test2.maxPoolSize = 25
  21. mysql.datasource.test2.maxLifetime = 20000
  22. mysql.datasource.test2.borrowConnectionTimeout = 30
  23. mysql.datasource.test2.loginTimeout = 30
  24. mysql.datasource.test2.maintenanceInterval = 60
  25. mysql.datasource.test2.maxIdleTime = 60

5.1.2.3 读取配置文件信息

  1. @Data
  2. @ConfigurationProperties(prefix = "mysql.datasource.test1")
  3. public class DBConfig1 {
  5. 	private String url;
  6. 	private String username;
  7. 	private String password;
  8. 	private int minPoolSize;
  9. 	private int maxPoolSize;
  10. 	private int maxLifetime;
  11. 	private int borrowConnectionTimeout;
  12. 	private int loginTimeout;
  13. 	private int maintenanceInterval;
  14. 	private int maxIdleTime;
  15. 	private String testQuery;
  16. }
  1. @Data
  2. @ConfigurationProperties(prefix = "mysql.datasource.test2")
  3. public class DBConfig2 {
  5. 	private String url;
  6. 	private String username;
  7. 	private String password;
  8. 	private int minPoolSize;
  9. 	private int maxPoolSize;
  10. 	private int maxLifetime;
  11. 	private int borrowConnectionTimeout;
  12. 	private int loginTimeout;
  13. 	private int maintenanceInterval;
  14. 	private int maxIdleTime;
  15. 	private String testQuery;
  16. }

5.1.2.4 创建多数据源

​

  1. @Configuration
  2. // basePackages 最好分开配置 如果放在同一个文件夹可能会报错
  3. @MapperScan(basePackages = "com.example.test01", sqlSessionTemplateRef = "testSqlSessionTemplate")
  4. public class MyBatisConfig1 {
  6. 	// 配置数据源
  7. 	@Primary
  8. 	@Bean(name = "testDataSource")
  9. 	public DataSource testDataSource(DBConfig1 testConfig) throws SQLException {
  10. 		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
  11. 		mysqlXaDataSource.setUrl(testConfig.getUrl());
  12. 		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
  13. 		mysqlXaDataSource.setPassword(testConfig.getPassword());
  14. 		mysqlXaDataSource.setUser(testConfig.getUsername());
  15. 		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
  17. 		AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
  18. 		xaDataSource.setXaDataSource(mysqlXaDataSource);
  19. 		xaDataSource.setUniqueResourceName("testDataSource");
  21. 		xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
  22. 		xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
  23. 		xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
  24. 		xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
  25. 		xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
  26. 		xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
  27. 		xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
  28. 		xaDataSource.setTestQuery(testConfig.getTestQuery());
  29. 		return xaDataSource;
  30. 	}
  32. 	@Primary
  33. 	@Bean(name = "testSqlSessionFactory")
  34. 	public SqlSessionFactory testSqlSessionFactory(@Qualifier("testDataSource") DataSource dataSource)
  35. 			throws Exception {
  36. 		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  37. 		bean.setDataSource(dataSource);
  38. 		return bean.getObject();
  39. 	}
  41. 	@Primary
  42. 	@Bean(name = "testSqlSessionTemplate")
  43. 	public SqlSessionTemplate testSqlSessionTemplate(
  44. 			@Qualifier("testSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
  45. 		return new SqlSessionTemplate(sqlSessionFactory);
  46. 	}
  47. }
  1. @Configuration
  2. @MapperScan(basePackages = "com.example.test02", sqlSessionTemplateRef = "test2SqlSessionTemplate")
  3. public class MyBatisConfig2 {
  5. 	// 配置数据源
  6. 	@Bean(name = "test2DataSource")
  7. 	public DataSource testDataSource(DBConfig2 testConfig) throws SQLException {
  8. 		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
  9. 		mysqlXaDataSource.setUrl(testConfig.getUrl());
  10. 		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
  11. 		mysqlXaDataSource.setPassword(testConfig.getPassword());
  12. 		mysqlXaDataSource.setUser(testConfig.getUsername());
  13. 		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
  15. 		AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
  16. 		xaDataSource.setXaDataSource(mysqlXaDataSource);
  17. 		xaDataSource.setUniqueResourceName("test2DataSource");
  19. 		xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
  20. 		xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
  21. 		xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
  22. 		xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
  23. 		xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
  24. 		xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
  25. 		xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
  26. 		xaDataSource.setTestQuery(testConfig.getTestQuery());
  27. 		return xaDataSource;
  28. 	}
  30. 	@Bean(name = "test2SqlSessionFactory")
  31. 	public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource)
  32. 			throws Exception {
  33. 		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  34. 		bean.setDataSource(dataSource);
  35. 		return bean.getObject();
  36. 	}
  38. 	@Bean(name = "test2SqlSessionTemplate")
  39. 	public SqlSessionTemplate testSqlSessionTemplate(
  40. 			@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
  41. 		return new SqlSessionTemplate(sqlSessionFactory);
  42. 	}
  43. }

5.1.2.4 启动加载配置

  1. @EnableConfigurationProperties(value = { DBConfig1.class, DBConfig2.class })

分布式事务，可以预览我的这个链接分布式事务

SpringBoot之数据访问和事务-专题三的更多相关文章

  1. Solon Web 开发，五、数据访问、事务与缓存应用

    Solon Web 开发 一.开始 二.开发知识准备 三.打包与运行 四.请求上下文 五.数据访问.事务与缓存应用 六.过滤器.处理.拦截器 七.视图模板与Mvc注解 八.校验.及定制与扩展 九.跨域 ...

  2. Spring数据访问和事务

    1.模型 2.解耦 3.实现 3.1 核心接口 3.2 代码分析 3.2.1 事务管理 3.2.2 数据访问 4.使用 4.1 编程模式 4.2 配置模式 4.2.1 声明式配置方式 4.2.2 注解 ...

  3. 六、SpringBoot与数据访问

    六.SpringBoot与数据访问 1.JDBC spring: datasource: username: root password: 123456 url: jdbc:mysql://192.1 ...

  4. SpringBoot(九) -- SpringBoot与数据访问

    一.简介 对于数据访问层,无论是SQL还是NOSQL,Spring Boot默认采用整合Spring Data的方式进行统一处理,添加大量自动配置,屏蔽了很多设置.引入各种xxxTemplate,xx ...

  5. 10分钟进阶SpringBoot - 05. 数据访问之JDBC（附加源码分析+代码下载）

    10分钟进阶SpringBoot - 05. 数据访问之JDBC 代码下载:https://github.com/Jackson0714/study-spring-boot.git 一.JDBC是什么 ...

  6. Spring （ 五 ）Spring之数据访问与事务管理

    个人博客网:https://wushaopei.github.io/    (你想要这里多有) 一.Spring之数据访问 1.Spring数据访问工程环境搭建 ​ jdbc.properties配置 ...

  7. java框架之SpringBoot(9)-数据访问及整合MyBatis

    简介 对于数据访问层,无论是 SQL 还是 NOSQL,SpringBoot 默认采用整合 SpringData 的方式进行统一处理,添加了大量的自动配置,引入了各种 Template.Reposit ...

  8. Spring 4 官方文档学习（九）数据访问之事务管理

    说明:未整理版,未完待续,请绕行 本部分的重点是数据访问以及数据访问层与业务层之间的交互. 1.Spring框架的事务管理 介绍 http://docs.spring.io/spring/docs/c ...

  9. SpringBoot 之数据访问

    1. Spring Boot 与 JDBC 默认使用 org.apache.tomcat.jdbc.pool.DataSource 数据源; // application.yml spring: da ...

随机推荐

  1. js加密（六）QB.com

    1. url: https://notice.qb.com/detail?noticeId=256 2. target: 3. 分析: 3.1 打开网址,刷新页面,看看都发送了哪些请求. 看到了发送了 ...

  2. 放眼全球，关注游戏质量变化：腾讯WeTest发布《2019中国移动游戏质量白皮书》

    2019是中国游戏市场,尤其是手游市场称得上是跌宕起伏的一年,同时也是各大厂商推陈出新突破过去的一年.面对竞争激烈的市场,手游厂商们不仅着眼于游戏质量的提升,更是将一众优秀的国产游戏带入到了海外市场, ...

  3. 利用单臂路由实现VLAN间的路由

    实验4:利用单臂路由实现VLAN间的路由. 实验原理:  实验内容: 本实验模拟公司网络场景,路由器R1是公司的出口网关,员工PC通过接入层交换机(如S2和S3)接入公司网络,接入层交换机又通过汇聚交 ...

  4. 让 typora和word一样好用

    让 typora和word一样好用  :https://github.com/itcastWsy/typora_copy_images typora是一款支持实时预览的markdown编辑器,作者在使 ...

  5. react组件之间传值方式

    1.父向子(通过props传值) 2.父向更深层的子(通过context传值) 3.子向父(通过回调函数传值:在父组件中创建一个函数来接收子组件传过来的参数值,通过父组件将这个函数做为子组件的属性传递 ...

  6. php中截取中文不乱吗

    php截取中文的使用是随处可见的,譬如,博客首页显示简介,可能会用到,或一些相册简介会用到,以前不知道,还傻傻的自己去写函数用来做“智能截取”,效果还不十分好,幸运的是,今天因为一位同学做项目,让我一 ...

  7. python opencv：使用鼠标当做画笔

    鼠标事件 import cv2 events=[i for i in dir(cv2) if 'EVENT'in i] print events 双击画圆圈 import cv2 import num ...

  8. 【代码总结】PHP面向对象之类与对象

    一.类和对象的关系 类的实体化结果是对象,而对象的抽象就是类.在开发过程中,我们通常都是先抽象(幻想)出一个类,再用该类去创建对象(实现幻想的内容).在程序中,直接使用的是我们(实现幻想)的对象,而不 ...

  9. 影响IPSec的网络问题

    影响IPSec VPN的网络问题:①.动态地址问题:两个 站点之间IPSec VPN的条件是站点之间有固定的IP地址,假如说分支站点采用ADSL上网链路,那么其IP地址是动态的,那么就在VPN时出现问 ...

  10. UCS内存问题排查

    UCS使用双列直插式内存模块(Dual In-line Memory Module (DIMM) )作为RAM模块. 根据文档介绍,主要有如下部分:1.Memory placement <内存放 ...