我要评论前言
工作中开发过多数据源的系统，比如资产清查系统，数据的存储分成了两个库，一个当前库和归档库，系统就需要配置两个数据源来满足业务需求。在常规的业务场景下，对两个库的业务操作是分开的，井水不犯河水。但是有一个功能实现是个例外，就是归档。将当前库的数据进行归档，需要修改当前库数据的状态，并将当前库数据插入到归档库中，这就需要在同一个方法实现中同时操作两个数据源，直接使用声明式事务@transcational注解是无法保证两个事务的一致性的。
声明式事务则只能做到方法级别的颗粒度，而且每个方法只能配置一个事务管理器，虽然可以将逻辑拆分到多个方法中，再为每个方法加上@transactional注解，但还是会存在问题，无法很好地处理多事务的业务场景。而这种问题可以使用编程式事务来解决，编程式事务可以将做到代码级别的颗粒度，更加的灵活。
前置环境
jdk8 + sringboot2 + mysql8
数据库
分别创建数据库 test1 test2
分别在两个数据库中创建 user 表
create table user (
id int auto_increment primary key,
username varchar(255),
password varchar(255)
);pom
<dependencymanagement>
<dependencies>
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-dependencies</artifactid>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencymanagement>
<dependencies>
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-web</artifactid>
</dependency>
<dependency>
<groupid>org.springframework.boot</groupid>
<artifactid>spring-boot-starter-data-jpa</artifactid>
</dependency>
<dependency>
<groupid>mysql</groupid>
<artifactid>mysql-connector-java</artifactid>
</dependency>
<dependencies>yml
server:
port: 8888
spring:
datasource:
primary:
url: jdbc:mysql://localhost:3306/test1?useunicode=true&characterencoding=utf-8&usessl=false&servertimezone=utc&allowpublickeyretrieval=true
username: root
password: mysql
driver-class-name: com.mysql.cj.jdbc.driver
secondary:
url: jdbc:mysql://localhost:3306/test2?useunicode=true&characterencoding=utf-8&usessl=false&servertimezone=utc&allowpublickeyretrieval=true
username: root
password: mysql
driver-class-name: com.mysql.cj.jdbc.driver
jpa:
primary:
show-sql: true
properties:
hibernate:
hbm2ddl:
auto: update
dialect: org.hibernate.dialect.mysql5innodbdialect
secondary:
show-sql: true
properties:
hibernate:
hbm2ddl:
auto: update
dialect: org.hibernate.dialect.mysql5innodbdialectconfig
这里主要注入主库和从库各自的jdbctemplate和transactionmanager，以便后续使用
主库数据源配置
@configuration
@enabletransactionmanagement
@enablejparepositories (
basepackages = primarydatasourceandjpaconfig.repository_package,
entitymanagerfactoryref = "primaryentitymanagerfactory",
transactionmanagerref = "primarytransactionmanager"
)
public class primarydatasourceandjpaconfig {
private static final string repository_package = "com.jpa.dao.primary";
private static final string entity_package = "com.jpa.entity.primary";
//--------------数据源配置-------------------
/**
* 扫描spring.datasource.primary开头的配置信息
*
* @return 数据源配置信息
*/
@primary
@bean(name = "primarydatasourceproperties")
@configurationproperties(prefix = "spring.datasource.primary")
public datasourceproperties datasourceproperties() {
return new datasourceproperties();
}
/**
* 取主库数据源对象
*
* @param datasourceproperties 注入名为primarydatasourceproperties的bean
* @return 数据源对象
*/
@primary
@bean(name = "primarydatasource")
public datasource datasource(@qualifier("primarydatasourceproperties") datasourceproperties datasourceproperties) {
return datasourceproperties.initializedatasourcebuilder().build();
}
/**
* 该方法仅在需要使用jdbctemplate对象时选用
*
* @param datasource 注入名为primarydatasource的bean
* @return 数据源jdbctemplate对象
*/
@primary
@bean(name = "primaryjdbctemplate")
public jdbctemplate jdbctemplate(@qualifier("primarydatasource") datasource datasource) {
return new jdbctemplate(datasource);
}
/**
* 扫描spring.jpa.primary开头的配置信息
*
* @return jpa配置信息
*/
@primary
@bean (name = "primaryjpaproperties")
@configurationproperties (prefix = "spring.jpa.primary")
public jpaproperties jpaproperties() {
return new jpaproperties();
}
/**
* 获取主库实体管理工厂对象
*
* @param primarydatasource 注入名为primarydatasource的数据源
* @param jpaproperties 注入名为primaryjpaproperties的jpa配置信息
* @param builder 注入entitymanagerfactorybuilder
* @return 实体管理工厂对象
*/
@primary
@bean(name = "primaryentitymanagerfactory")
public localcontainerentitymanagerfactorybean entitymanagerfactorybean(
@qualifier ("primarydatasource") datasource primarydatasource,
@qualifier("primaryjpaproperties") jpaproperties jpaproperties,
entitymanagerfactorybuilder builder
) {
return builder
// 设置数据源
.datasource(primarydatasource)
// 设置jpa配置
.properties(jpaproperties.getproperties())
// 设置实体包名
.packages(entity_package)
// 设置持久化单元名，用于@persistencecontext注解获取entitymanager时指定数据源
.persistenceunit("primarypersistenceunit").build();
}
/**
* 获取实体管理对象
*
* @param factory 注入名为primaryentitymanagerfactory的bean
* @return 实体管理对象
*/
@primary
@bean(name = "primaryentitymanager")
public entitymanager entitymanager(@qualifier("primaryentitymanagerfactory") entitymanagerfactory factory) {
return factory.createentitymanager();
}
/**
* 获取主库事务管理对象
*
* @param factory 注入名为primaryentitymanagerfactory的bean
* @return 事务管理对象
*/
@primary
@bean(name = "primarytransactionmanager")
public jpatransactionmanager transactionmanager(@qualifier("primaryentitymanagerfactory") entitymanagerfactory factory) {
return new jpatransactionmanager(factory);
}
}从库数据源配置
@configuration
@enabletransactionmanagement
@enablejparepositories(
basepackages = secondarydatasourceandjpaconfig.repository_package,
entitymanagerfactoryref = "secondaryentitymanagerfactory",
transactionmanagerref = "secondarytransactionmanager"
)
public class secondarydatasourceandjpaconfig {
static final string repository_package = "com.jpa.dao.secondary";
static final string entity_package = "com.jpa.entity.secondary";
//--------------数据源配置-------------------
/**
* 扫描spring.datasource.secondary开头的配置信息
*
* @return 数据源配置信息
*/
@bean(name = "secondarydatasourceproperties")
@configurationproperties(prefix = "spring.datasource.secondary")
public datasourceproperties datasourceproperties() {
return new datasourceproperties();
}
/**
* 获取次数据源对象
*
* @param datasourceproperties 注入名为secondarydatasourceproperties的bean
* @return 数据源对象
*/
@bean("secondarydatasource")
public datasource datasource(@qualifier("secondarydatasourceproperties") datasourceproperties datasourceproperties) {
return datasourceproperties.initializedatasourcebuilder().build();
}
/**
* 该方法仅在需要使用jdbctemplate对象时选用
*
* @param datasource 注入名为secondarydatasource的bean
* @return 数据源jdbctemplate对象
*/
@bean(name = "secondaryjdbctemplate")
public jdbctemplate jdbctemplate(@qualifier("secondarydatasource") datasource datasource) {
return new jdbctemplate(datasource);
}
/**
* 扫描spring.jpa.secondary
*
* @return jpa配置信息
*/
@bean(name = "secondaryjpaproperties")
@configurationproperties(prefix = "spring.jpa.secondary")
public jpaproperties jpaproperties() {
return new jpaproperties();
}
/**
* 获取次库实体管理工厂对象
*
* @param secondarydatasource 注入名为secondarydatasource的数据源
* @param jpaproperties 注入名为secondaryjpaproperties的jpa配置信息
* @param builder 注入entitymanagerfactorybuilder
* @return 实体管理工厂对象
*/
@bean(name = "secondaryentitymanagerfactory")
public localcontainerentitymanagerfactorybean entitymanagerfactory(
@qualifier("secondarydatasource") datasource secondarydatasource,
@qualifier("secondaryjpaproperties") jpaproperties jpaproperties,
entitymanagerfactorybuilder builder
) {
return builder
// 设置数据源
.datasource(secondarydatasource)
// 设置jpa配置
.properties(jpaproperties.getproperties())
// 设置实体包名
.packages(entity_package)
// 设置持久化单元名，用于@persistencecontext注解获取entitymanager时指定数据源
.persistenceunit("secondarypersistenceunit").build();
}
/**
* 获取实体管理对象
*
* @param factory 注入名为secondaryentitymanagerfactory的bean
* @return 实体管理对象
*/
@bean(name = "secondaryentitymanager")
public entitymanager entitymanager(@qualifier("secondaryentitymanagerfactory") entitymanagerfactory factory) {
return factory.createentitymanager();
}
/**
* 获取事务管理对象
*
* @param factory 注入名为secondaryentitymanagerfactory的bean
* @return 事务管理对象
*/
@bean(name = "secondarytransactionmanager")
public jpatransactionmanager transactionmanager(@qualifier("secondaryentitymanagerfactory") entitymanagerfactory factory) {
return new jpatransactionmanager(factory);
}
}声明式事务
错误写法
@service
public class testservice {
@resource
jdbctemplate primaryjdbctemplate;
@resource
jdbctemplate secondaryjdbctemplate;
@transactional
public void method() {
//do something 1
primaryjdbctemplate.execute("insert into user(username, password) values('张三', '123456')");
//do something 2
secondaryjdbctemplate.execute("insert into user(username, password) values('李四', '123456');");
//do something 3
}
}@transactional中没有指定事务管理器，这在单数据源系统中就不会有任何问题，在单数据源系统中，整个spring容器中只定义了一个事务管理器，spring启动事务的时候，默认会按类型在容器中查找事务管理器，而容器中就只有一个事务管理器，正好拿来用，不会有问题。
但是在多数据源系统中，spring容器中是会存在多个事务管理器的，如果不指定事务管理器，如果使用的事务管理器和实际操作的数据源不一致的话，是管理不了事务的（由于配置主库数据源使用@primary注解，所有默认会使用主库的事务管理器），所以在数据源系统中使用声明式事务，必须指定事务管理器
上面代码将两个数据库操作都放在同一个方法中，无论拿到了哪个事务管理器，只要 do something 3 处发生了异常，那么其中的一个事务是不会回滚的
改进写法
@service
public class testservice {
@resource
jdbctemplate primaryjdbctemplate;
@resource
jdbctemplate secondaryjdbctemplate;
@transactional(value = "primarytransactionmanager")
public void method1() {
//do something 1
primaryjdbctemplate.execute("insert into user(username, password) values('张三', '123456')");
//do something 2
method2();
//do something 5
}
@transactional(value = "secondarytransactionmanager")
public void method2() {
//do something 3
secondaryjdbctemplate.execute("insert into user(username, password) values('李四', '123456');");
//do something 4
}
}改进的写法，将不同数据源的操作拆到不同的方法中，分别加上了@transactional注解，并指定了对应的事务管理器。这种写法相对之前的就规范了不少，但是还是存在问题，如果在 do something 5 处发生了异常，因为 method2 方法已经执行结束了，事务已经提交了，所以还是无法做到一起回滚。
编程式事务
@service
public class testservice {
@resource
jdbctemplate primaryjdbctemplate;
@resource
jdbctemplate secondaryjdbctemplate;
@resource
platformtransactionmanager primarytransactionmanager;
@resource
platformtransactionmanager secondarytransactionmanager;
public void method() {
transactiondefinition primarydef = new defaulttransactiondefinition();
transactionstatus primarystatus = primarytransactionmanager.gettransaction(primarydef);
transactiondefinition secondarydef = new defaulttransactiondefinition();
transactionstatus secondarystatus = secondarytransactionmanager.gettransaction(secondarydef);
try {
//do something 1
primaryjdbctemplate.execute("insert into user(username, password) values('张三', '123456')");
//do something 2
secondaryjdbctemplate.execute("insert into user(username, password) values('李四', '123456');");
//do something 3
primarytransactionmanager.commit(primarystatus);
secondarytransactionmanager.commit(secondarystatus);
} catch (exception e) {
primarytransactionmanager.rollback(primarystatus);
secondarytransactionmanager.rollback(secondarystatus);
throw new runtimeexception(e.getmessage());
}
}
}编程式事务的颗粒度时代码级别的，可以嵌入到方法里面，这样可以控制不同数据源的事务同时开启，一旦出现异常，则两个事务一起回滚，这样就保证了多数据事务的一致性。
这种实现实际上和分布式事务的xa模式思想一样，只不过分布式事务管理的是分布式系统中不同服务不同的数据源，而这里是一个服务同一个方法中操作多个数据源。本质上都是处理管理多数据源的事务。
到此这篇关于springboot同一个方法操作多个数据源保证事务一致性的文章就介绍到这了,更多相关springboot 事务一致性内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论