springboot实现多数据源事务
dynamic-datasource实现多数据源事务
引入dynamic-datasource包
<!-- 多数据源配置-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
<version>3.5.1</version>
</dependency>
数据源配置
#报告数据源
spring.datasource.dynamic.datasource.sci-report.url=jdbc:mysql://192.168.x.x:3306/sci_report_generate?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&autoReconnect=true&useSSL=false&rewriteBatchedStatements=true
spring.datasource.dynamic.datasource.sci-report.username=xxxx
spring.datasource.dynamic.datasource.sci-report.password=xxxx
spring.datasource.dynamic.datasource.sci-report.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.dynamic.datasource.sci-report.type=com.sci99.report.common.config.datasource.IdleConnectDruidDataSource
#时间日期服务数据源
spring.datasource.dynamic.datasource.sci-timeservice.url=jdbc:sqlserver://192.168.x.xx;databaseName=SCI_Base;applicationIntent=ReadOnly;multiSubnetFailover=true
spring.datasource.dynamic.datasource.sci-timeservice.username=xxxxx
spring.datasource.dynamic.datasource.sci-timeservice.password=xxxxx
spring.datasource.dynamic.datasource.sci-timeservice.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver
spring.datasource.dynamic.datasource.sci-timeservice.type=com.alibaba.druid.pool.DruidDataSource
#发送邮件
spring.datasource.dynamic.datasource.sci-email.url=jdbc:sqlserver://192.168.x.xx;databaseName=Email_VIP;multiSubnetFailover=true
spring.datasource.dynamic.datasource.sci-email.username=xxxx
spring.datasource.dynamic.datasource.sci-email.password=xxxxx
spring.datasource.dynamic.datasource.sci-email.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver
spring.datasource.dynamic.datasource.sci-email.type=com.alibaba.druid.pool.DruidDataSource
创建两个service
@DS("sci-report")
@Service("reportApproveRecordService")
public class ReportApproveRecordService{
int update(ReportApproveRecordEntity reportApproveRecordEntity);
}
@DS("sci-email")
@Service("sendEmailService")
public class SendEmailService {
void sendEmail(String subject, String body, boolean ishtml, List<String> emailList);
}
编写调用其他service的测试service，添加@DSTransactional注释
@DS("sci-report")
@Service("sendEmailService")
public class ReportInfoService{
@Autowired
private ReportApproveRecordService reportApproveRecordService;
@Autowired
private SendEmailService sendEmailService;
@DSTransactional
public void delayApplyDeal(JSONObject obj) throws Exception {
//任务id
String taskId = obj.getString("taskId");
//1、如果审批同意，修改报告的延期时间
//审批结果 1 同意 2不同意
Integer approveStatus = obj.getInteger("approveStatus");
Date delayTime = obj.getDate("delayTime");
String subject = obj.getString("subject");
String body = obj.getString("body");
if(StrUtil.isEmpty(taskId) || approveStatus == null || delayTime == null || StrUtil.isEmpty(subject) || StrUtil.isEmpty(body)){
throw new Exception("传入参数有误");
}
if(approveStatus == 1){
Integer pid = 112;
//根据合同项获取对应客户邮箱
List<String>emailaddressList = getEmailaddressList(pid);
if(emailaddressList.size() == 0){
throw new RuntimeException(pid+"：未获取到订阅该产品的客户邮箱列表");
}
String applyTimeStr = DateUtil.format(DateUtil.date(),"yyyy年MM月dd日");
body = body+String.format("\n<p style=\"font-size: 16px;font-weight:bold; font-family:Simsun;text-align: right;\">%s</p>",applyTimeStr);
//往邮件通道中插入数据
sendEmailService.sendEmail(subject,body,true,emailaddressList);
log.info(reportId+"：发送延期邮件结束");
}
//3.修改申请记录
Integer status = approveStatus == 1?2:3; //1 待审批 2 审批同意 3 审批不同意
ReportApproveRecordEntity ReportApproveRecordEntity = new ReportApproveRecordEntity ();
ReportApproveRecordEntity.setTaskId(taskId);
ReportApproveRecordEntity.setStatus(status );
ReportApproveRecordEntity.setDealStatus(1);
ReportApproveRecordEntity.setUpdateTime(new Date());
reportApproveRecordService.update(ReportApproveRecordEntity );
}
}
特别注意
1.同数据源的多个表数据更改，可以用@Transactional实现事务
2.@Transactional和@DSTransactional不可以混用，否则会发生死锁。
Atomikos 实现多数据源事务
Atomikos 是一个Java事务管理解决方案，用于处理分布式事务。它提供了一个可靠和可扩展的事务管理器，可以协调多个资源（如数据库、消息队列等）之间的事务操作，以保证分布式系统的数据一致性与隔离性。
Atomikos 提供了以下主要功能和特点：
- 分布式事务协调：Atomikos 使用两阶段提交（Two-Phase Commit）协议来确保分布式事务的一致性。它充当协调者角色，与参与者（各个资源管理器）进行协作并决定是否提交或回滚事务。
- 事务原子性：Atomikos 确保在分布式环境中进行的事务操作以原子方式执行。如果其中任何一个资源的操作失败，Atomikos 将自动回滚整个事务，确保数据的一致性。
- 分布式数据源和连接池：Atomikos 提供了分布式数据源和连接池，用于管理多个数据库连接和资源。它能够有效地管理连接和提供高性能和可伸缩性。
- 事务隔离级别：Atomikos 支持不同的事务隔离级别，包括读未提交（Read Uncommitted）、读已提交（Read Committed）、可重复读（Repeatable Read）和串行化（Serializable）。
- 高可靠性和扩展性：Atomikos 可以在分布式环境中进行集群部署，提供高可靠性和扩展性。多个 Atomikos 事务管理器可以一起工作，以保证负载均衡和容错。
引入Atomikos 依赖
<!-- atomikos 依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jta-atomikos</artifactId>
</dependency>
多数据源配置
# 多数据源配置
spring:
datasource:
properties:
user_db:
url: jdbc:mysql://127.0.0.1:3306/user_db
user: root
password: root
data_db:
url: jdbc:mysql://127.0.0.1:3306/data_db
user: root
password: root
多数据源配置类:DataSourceConfiguration
给配置类负责创建多个数据源以及对应的SqlSessionFactory.代码如下:
@Configuration
@ConfigurationProperties("spring.datasource")
public class DataSourceConfiguration {
private Map<String,Map<String,String>> properties; // spring.datasource.properties
private Map<String,DataSource> sourceMap; // 用来保存数据源信息
public Map<String, Map<String,String>> getProperties() {
return properties;
}
public void setProperties(Map<String, Map<String,String>> properties) {
this.properties = properties;
}
/**
* 添加user_db数据源
* @return
*/
@Bean("user_db")
@DependsOn({"datasourceMap"})
public DataSource userDatasource(){
return sourceMap.get("user_db");
}
/**
* 添加user_db SqlSessionFactory
* @return
* @throws Exception
*/
@Bean("user_db_sql_session_factory")
@DependsOn("user_db")
public SqlSessionFactory userDbSqlSessionFactory() throws Exception {
MybatisSqlSessionFactoryBean bean = new MybatisSqlSessionFactoryBean();
bean.setDataSource(this.sourceMap.get("user_db"));
// 设置mapper位置
bean.setTypeAliasesPackage("com.atomikos.dao.user");
// 设置mapper.xml文件的路径
bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/user/*.xml"));
return bean.getObject();
}
/**
* 添加 data_db 数据源
* @return
*/
@Bean("data_db")
@DependsOn({"datasourceMap"})
public DataSource dataDatasource(){
return sourceMap.get("data_db");
}
/**
* 添加data_db SqlSessionFactory
* @return
* @throws Exception
*/
@Bean("data_db_sql_session_factory")
@DependsOn("data_db")
public SqlSessionFactory dataDbSqlSessionFactory() throws Exception {
MybatisSqlSessionFactoryBean bean = new MybatisSqlSessionFactoryBean();
bean.setDataSource(this.sourceMap.get("data_db"));
// 设置mapper位置
bean.setTypeAliasesPackage("com.atomikos.dao.data");
// 设置mapper.xml文件的路径
bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/data/*.xml"));
return bean.getObject();
}
/**
* 创建XA 数据源并添加到sourceMap中
* @param dataSourceConfiguration
* @return
*/
@Bean("datasourceMap")
@Primary
public Map<String, DataSource> datasourceMap(DataSourceConfiguration dataSourceConfiguration){
Map<String, DataSource> map = new LinkedHashMap<>();
for(Map.Entry<String,Map<String, String>> entry:dataSourceConfiguration.properties.entrySet()){
// 读取每个数据源的配置创建datasource
MysqlXADataSource dataSource = new MysqlXADataSource();
dataSource.setUrl(entry.getValue().get("url"));
dataSource.setUser(entry.getValue().get("user"));
dataSource.setPassword(entry.getValue().get("password"));
// 创建atomikosDataSource数据源
AtomikosDataSourceBean atomikosDataSource = new AtomikosDataSourceBean();
atomikosDataSource.setMaxPoolSize(10);
atomikosDataSource.setMinPoolSize(5);
atomikosDataSource.setBeanName(entry.getKey()); // 设置bean的名称
atomikosDataSource.setXaDataSource(dataSource); // 设置Xa数据源
atomikosDataSource.setTestQuery("select now()");
map.put(entry.getKey(), atomikosDataSource);
}
this.sourceMap = map;
return map;
}
}
多数据源事务管理器配置:AtomikosConfig
@Configuration
@EnableTransactionManagement
@MapperScans({@MapperScan(basePackages={"com.atomikos.dao.user"},sqlSessionFactoryRef = "user_db_sql_session_factory"),
@MapperScan(basePackages = {"com.atomikos.dao.data"},sqlSessionFactoryRef = "data_db_sql_session_factory")})
public class AtomikosConfig {
// 用于在应用程序中执行事务的控制操作。
@Bean(name = "userTransaction")
@SneakyThrows(Exception.class)
public UserTransaction userTransaction() throws SystemException {
final UserTransactionImp userTransactionImp = new UserTransactionImp();
userTransactionImp.setTransactionTimeout(1000);
return userTransactionImp;
}
// 用于管理和控制分布式事务的整个生命周期。
@Bean(name = "atomikosTransactionManager")
@SneakyThrows(Exception.class)
public TransactionManager atomikosTransactionManager() {
final UserTransactionManager userTransactionManager = new UserTransactionManager();
userTransactionManager.setForceShutdown(false);
return userTransactionManager;
}
// JtaTransactionManager 的主要作用是管理和协调分布式事务，它支持使用 JTA 来处理分布式事务，与 JTA 兼容的事务管理器进行交互。
@Bean(name = "transactionManager")
@SneakyThrows(Throwable.class)
public PlatformTransactionManager transactionManager(
@Qualifier("atomikosTransactionManager") TransactionManager atomikosTransactionManager,
@Qualifier("userTransaction") UserTransaction userTransaction) throws SystemException {
return new JtaTransactionManager(userTransaction(), atomikosTransactionManager());
}
}
上述代码需要使用@MapperScans注解绑定sqlsessionfactory的扫描包.
创建测试类
@RestController
public class TestController {
@Autowired
private TUserService tUserService;
@Autowired
private TDataService tDataService;
@Autowired
private TUser1Service tUser1Service;
@Transactional(rollbackFor = Exception.class)
@GetMapping("/test")
public String test(){
TUser user = new TUser();
user.setUsername("aaa");
tUserService.save(user);
// 不同数据源
//TData data = new TData();
//data.setContent("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
//tDataService.save(data);
// 相同数据源
TUser1 user1 = new TUser1();
user1.setUsername("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
tUser1Service.save(user1);
return "sdsw";
}
}
特别注意
多数据源项目分层时要根据数据源分层。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
