【spring boot】SpringBoot初学（7）– 多数据源及其事务

前言

github： https://github.com/vergilyn/SpringBootDemo

代码位置：

参考：

Spring Boot Reference Guide , §77.2 Configure Two DataSources

springboot + mybatis + 多数据源

springboot + mybatis + 多数据源 （AOP实现）

一、准备

因为配置的是oracle、mysql、JdbcTemplate，所以需要各自的驱动jar和JdbcTemplate所需要的jar。

<!-- spring jdbc支持 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency><!-- mysql驱动支持 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency><!-- oracle驱动支持。注：此驱动maven不一定下载得到。-->
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc6</artifactId>
<version>11.1.0.7.0</version>
</dependency>

# DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.continue-on-error=false # Do not stop if an error occurs while initializing the database.
spring.datasource.data= # Data (DML) script resource references.
spring.datasource.data-username= # User of the database to execute DML scripts (if different).
spring.datasource.data-password= # Password of the database to execute DML scripts (if different).
spring.datasource.dbcp2.*= # Commons DBCP2 specific settings
spring.datasource.driver-class-name= # Fully qualified name of the JDBC driver. Auto-detected based on the URL by default.
spring.datasource.generate-unique-name=false # Generate a random datasource name.
spring.datasource.hikari.*= # Hikari specific settings
spring.datasource.initialize=true # Populate the database using 'data.sql'.
spring.datasource.jmx-enabled=false # Enable JMX support (if provided by the underlying pool).
spring.datasource.jndi-name= # JNDI location of the datasource. Class, url, username & password are ignored when set.
spring.datasource.name=testdb # Name of the datasource.
spring.datasource.password= # Login password of the database.
spring.datasource.platform=all # Platform to use in the schema resource (schema-${platform}.sql).
spring.datasource.schema= # Schema (DDL) script resource references.
spring.datasource.schema-username= # User of the database to execute DDL scripts (if different).
spring.datasource.schema-password= # Password of the database to execute DDL scripts (if different).
spring.datasource.separator=; # Statement separator in SQL initialization scripts.
spring.datasource.sql-script-encoding= # SQL scripts encoding.
spring.datasource.tomcat.*= # Tomcat datasource specific settings
spring.datasource.type= # Fully qualified name of the connection pool implementation to use. By default, it is auto-detected from the classpath.
spring.datasource.url= # JDBC url of the database.
spring.datasource.username=

oralce、mysql中的表结构是一模一样的。表名：MYSQL_PARENT、ORACLE_PARENT

字段：主键PARENT_ID,INT类型。非空字段PARENT_NAME,VARCHAR类型。

二、完整demo

代码结构说明：

1. mysql、oracle的包下，放各自DataSource的service、dao。

2. 包config放置多数据源的配置，其中包括DataSource、DataSourceTransactionManager等。

2.1 多数据源的DataSource、TransactionManager、JdbcTemplate配置

@Configuration
@PropertySource("classpath:config/dbMulti/db_multi.properties")
public class DBmultiConfig {
/* 此处 @Bean + @Qualifier("oracleDB") 等价于 @Bean("oracleDB").
* 如果写成@Bean("oracleDB"),在idea中,之后的@Qualifier("oracleDB")会有error提示.但不影响代码的正确性.
*/
@Bean
@Qualifier("oracleDB")
@Primary
@ConfigurationProperties("oracle.datasource")
public DataSource oracleDataSource() {
return DataSourceBuilder.create().build();
} @Bean(name = "oracleJT")
public JdbcTemplate oracleJdbcTemplate(@Qualifier("oracleDB")DataSource dataSource){
return new JdbcTemplate(dataSource);
}
@Bean("oracleTS")
public DataSourceTransactionManager oracleTransactionManager(@Qualifier("oracleDB")DataSource dataSource){
return new DataSourceTransactionManager(dataSource);
}
// 多数据源mybatis的sqlSession注入
// @Bean("oracleSS")
public SqlSessionFactory oracleSqlSession(@Qualifier("oracleDB")DataSource dataSource) throws Exception {
SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
factoryBean.setDataSource(dataSource);
//bean.setXX(...) 其余mybatis的设置
/* 例如：以下是mybatis基于*.xml文件配置,如果整个持久层操作不需要使用到xml文件的话（只用注解就可以搞定）. 则无需set.
* factoryBean.setTypeAliasesPackage(env.getProperty("mybatis.typeAliasesPackage")); // 指定基包
* factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(env.getProperty("mybatis.mapperLocations")));
*/
return factoryBean.getObject();
} @Bean
@Qualifier("mysqlDB")
@ConfigurationProperties("mysql.datasource")
public DataSource mysqlDataSource() {
return DataSourceBuilder.create().build();
} @Bean(name = "mysqlJT")
public JdbcTemplate mysqlJdbcTemplate(@Qualifier("mysqlDB") DataSource dataSource){
return new JdbcTemplate(dataSource);
} @Bean("mysqlTS")
public DataSourceTransactionManager mysqlTransactionManager(@Qualifier("mysqlDB")DataSource dataSource){
return new DataSourceTransactionManager(dataSource);
}
}

@Primary：标明此DataSource是一个主数据源。(其实@Primary的作用并不是用来标明主数据源的，参考@Primary用法：在spring中常被忽视的注解 @Primary)

oracleDataSource()、mysqlDataSource()：分别用来配置注入mysql、oracle的DataSource。

oracleTransactionManager()、mysqlTransactionManager()：分别用来配置注入mysql、oracle的DataSource的事务管理，都交由spring统一管理。

db_multi.properties：和datasource配置是一样的，只要保证最后的(.url .username)正确，前面的mysql.datasource、oracle.datasource可以随意命名的。

(基于mybatis的SqlSession并没有测试过，但应该思路没错。)

2.2 oracle、mysql的service&dao的实现

2.2.1 service

@Service
public class OracleService {
@Autowired
private MysqlService mysqlService;
@Autowired
private OracleDao oracleDao; @Transactional(transactionManager = "oracleTS",propagation = Propagation.REQUIRED)
public Parent getById(int parentId){
return oracleDao.getById(parentId);
} @Transactional(transactionManager = "oracleTS",rollbackFor = Exception.class)
public void insert(Parent p) throws Exception{
oracleDao.insert(p);
} @Transactional(transactionManager = "oracleTS",rollbackFor = Exception.class)
public void insertDBmulti(Parent parent,boolean isSameTransaction) throws Exception {
oracleDao.insert(parent);
if(isSameTransaction){
mysqlService.insert(parent);
}else{
try {
mysqlService.insert(parent);
}catch (Exception e){
e.printStackTrace();;
}
} }
@Transactional(transactionManager = "oracleTS",propagation = Propagation.REQUIRES_NEW,rollbackFor = Exception.class)
public void insertREQUIRES_NEW(Parent parent) throws Exception {
this.insert(parent);
}
}

2.2.2 dao

@Repository
public class OracleDao {
@Resource(name = "oracleJT")
private JdbcTemplate jdbcTemplate; public Parent getById(int parentId) {
String sql = "select * from oracle_parent where id = ?"; return jdbcTemplate.queryForObject(sql,new Object[]{parentId}
,new BeanPropertyRowMapper<Parent>(Parent.class));
} public void insert(Parent p) {
String sql = "insert into oracle_parent(parent_id,parent_name) values(?,?)"; jdbcTemplate.update(sql,new Object[]{p.getParentId(),p.getParentName()});
}
}

说明：

1、@Resource与@Qualifier+@Autowired的区别

@Resource是javax.annotation.Resource，即由j2ee提供。

而@Qualifier+@Autowired是由spring提供。

(网上的资料说，为了降低与spring的耦合度，建议使用@Resource。不理解为什么要降低与spring的耦合度...)

2、以上dao的demo每个类中都要注入各自DataSource的JdbcTemplate(mybatis则要注入SqlSession)

可借由extends各自继承一个父类的BaseDao，来简化代码。（也可用aop来实现）

3、service也存在2的问题。要频繁的写@Transactional配置，指定各自的TrancactionManager。

虽然，也可以借由aop来统一管理。但，个人并不建议。可能个人习惯事务要明确写明。

2.2.3 SpringBootApplication、Junit测试、其他

@SpringBootApplication
public class DBmultiApplication{
public static void main(String[] args) {
SpringApplication app = new SpringApplication(DBmultiApplication.class);
app.run(args);
}
}

@RunWith(SpringRunner.class)
@SpringBootTest(classes = DBmultiApplication.class)
public class DBmultiApplicationTest {
@Autowired
private MysqlService mysqlService;
@Autowired
private OracleService oracleService;
private final Parent parent = new Parent(100,"Vergilyn"); @Test
public void mysqlInsert() throws Exception {
mysqlService.insert(parent);
System.out.println("mysql insert end.");
} @Test
public void oracleInsert() throws Exception {
oracleService.insert(parent);
System.out.println("oracle insert end.");
} @Test
public void sameTransaction() throws Exception {
oracleService.insertDBmulti(parent, true);
System.out.println("sameTransaction() end."); } @Test
public void diffTransaction() throws Exception {
oracleService.insertDBmulti(parent, false);
System.out.println("diffTransaction() end.");
} /**
* 在mysql中,先调用oracle,此oracle的事务是：REQUIRES_NEW。
* 所以,即使在mysql方法中最后被回滚,oracle也被正确insert一行数据。
*/
@Test
public void insertREQUIRES_NEW() throws Exception {
mysqlService.insertREQUIRES_NEW(parent);
System.out.println("insertREQUIRES_NEW() end.");
}
}

测试说明：

1. mysqlInsert()、oracleInsert() 测试各自的DataSource、TransactionManager、JdbcTemplate是否配置正确。

2. sameTransaction当insert的时候，oracle、mysql要么都成功，要么同时回滚。

如demo，先在oracle插入一行数据，再在mysql中插入一行。如果，mysql中存在id=100的数据，导致mysql插入失败。那么产生RuntimeException，所以事务回滚。即oracle中不会被插入一行数据，此操作被回滚了。

而如diffTransaction()，在oracle中把mysql抛出的异常吃掉了。所以，oracle不会被回滚。

3.  如果insert之间互不影响，可有2种解决方式（自己知道的）

i. 把异常吃掉，那么就不会回滚了。如oracleService.insertDBmulti(...)

ii. 调用的其他事务另起一个新事务，如mysqlService.insertREQUIRES_NEW(...)，其中oracleService.insertREQUIRES_NEW(...)的事务并声明为propagation = Propagation.REQUIRES_NEW。