0
0

Spring Boot 同一个方法中操作多个数据源保证事务一致性

前言

工作中开发过多数据源的系统，比如资产清查系统，数据的存储分成了两个库，一个当前库和归档库，系统就需要配置两个数据源来满足业务需求。在常规的业务场景下，对两个库的业务操作是分开的，井水不犯河水。但是有一个功能实现是个例外，就是归档。将当前库的数据进行归档，需要修改当前库数据的状态，并将当前库数据插入到归档库中，这就需要在同一个方法实现中同时操作两个数据源，直接使用声明式事务@Transcational注解是无法保证两个事务的一致性的。

声明式事务则只能做到方法级别的颗粒度，而且每个方法只能配置一个事务管理器，虽然可以将逻辑拆分到多个方法中，再为每个方法加上@Transactional注解，但还是会存在问题，无法很好地处理多事务的业务场景。而这种问题可以使用编程式事务来解决，编程式事务可以将做到代码级别的颗粒度，更加的灵活。

前置环境

JDK8 + SringBoot2 + MySQL8

数据库

分别创建数据库 test1 test2

分别在两个数据库中创建 user 表

create table user (
id int auto_increment primary key,
username varchar(255),
password varchar(255)
);

pom

  1.     <dependencyManagement>
  2.         <dependencies>
  3.             <dependency>
  4.                 <groupId>org.springframework.boot</groupId>
  5.                 <artifactId>spring-boot-dependencies</artifactId>
  6.                 <version>${spring-boot.version}</version>
  7.                 <type>pom</type>
  8.                 <scope>import</scope>
  9.             </dependency>
  10.         </dependencies>
  11.     </dependencyManagement>
  12.  
  13.     <dependencies>
  14.         <dependency>
  15.             <groupId>org.springframework.boot</groupId>
  16.             <artifactId>spring-boot-starter-web</artifactId>
  17.         </dependency>
  18.  
  19.         <dependency>
  20.             <groupId>org.springframework.boot</groupId>
  21.             <artifactId>spring-boot-starter-data-jpa</artifactId>
  22.         </dependency>
  23.  
  24.         <dependency>
  25.             <groupId>mysql</groupId>
  26.             <artifactId>mysql-connector-java</artifactId>
  27.         </dependency>
  28.     <dependencies>

yml

  1. server:
  2.   port: 8888
  4. spring:
  5.   datasource:
  6.     primary:
  7.       url: jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
  8.       username: root
  9.       password: mysql
  10.       driver-class-name: com.mysql.cj.jdbc.Driver
  11.     secondary:
  12.       url: jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
  13.       username: root
  14.       password: mysql
  15.       driver-class-name: com.mysql.cj.jdbc.Driver
  17.   jpa:
  18.     primary:
  19.       show-sql: true
  20.       properties:
  21.         hibernate:
  22.           hbm2ddl:
  23.             auto: update
  24.           dialect: org.hibernate.dialect.MySQL5InnoDBDialect
  25.     secondary:
  26.       show-sql: true
  27.       properties:
  28.         hibernate:
  29.           hbm2ddl:
  30.             auto: update
  31.           dialect: org.hibernate.dialect.MySQL5InnoDBDialect

Config

这里主要注入主库和从库各自的JDBCTemplate和TransactionManager，以便后续使用

主库数据源配置

  1. @Configuration
  2. @EnableTransactionManagement
  3. @EnableJpaRepositories (
  4.         basePackages = PrimaryDatasourceAndJpaConfig.REPOSITORY_PACKAGE,
  5.         entityManagerFactoryRef = "primaryEntityManagerFactory",
  6.         transactionManagerRef = "primaryTransactionManager"
  7. )
  8. public class PrimaryDatasourceAndJpaConfig {
  10.     private static final String REPOSITORY_PACKAGE = "com.jpa.dao.primary";
  11.     private static final String ENTITY_PACKAGE = "com.jpa.entity.primary";
  13.     //--------------数据源配置-------------------
  15.     /**
  16.      * 扫描spring.datasource.primary开头的配置信息
  17.      *
  18.      * @return 数据源配置信息
  19.      */
  20.     @Primary
  21.     @Bean(name = "primaryDataSourceProperties")
  22.     @ConfigurationProperties(prefix = "spring.datasource.primary")
  23.     public DataSourceProperties dataSourceProperties() {
  24.         return new DataSourceProperties();
  25.     }
  27.     /**
  28.      * 取主库数据源对象
  29.      *
  30.      * @param dataSourceProperties 注入名为primaryDataSourceProperties的bean
  31.      * @return 数据源对象
  32.      */
  33.     @Primary
  34.     @Bean(name = "primaryDataSource")
  35.     public DataSource dataSource(@Qualifier("primaryDataSourceProperties") DataSourceProperties dataSourceProperties) {
  36.         return dataSourceProperties.initializeDataSourceBuilder().build();
  37.     }
  39.     /**
  40.      * 该方法仅在需要使用JdbcTemplate对象时选用
  41.      *
  42.      * @param dataSource 注入名为primaryDataSource的bean
  43.      * @return 数据源JdbcTemplate对象
  44.      */
  45.     @Primary
  46.     @Bean(name = "primaryJdbcTemplate")
  47.     public JdbcTemplate jdbcTemplate(@Qualifier("primaryDataSource") DataSource dataSource) {
  48.         return new JdbcTemplate(dataSource);
  49.     }
  51.     /**
  52.      * 扫描spring.jpa.primary开头的配置信息
  53.      *
  54.      * @return jpa配置信息
  55.      */
  56.     @Primary
  57.     @Bean (name = "primaryJpaProperties")
  58.     @ConfigurationProperties (prefix = "spring.jpa.primary")
  59.     public JpaProperties jpaProperties() {
  60.         return new JpaProperties();
  61.     }
  63.     /**
  64.      * 获取主库实体管理工厂对象
  65.      *
  66.      * @param primaryDataSource 注入名为primaryDataSource的数据源
  67.      * @param jpaProperties     注入名为primaryJpaProperties的jpa配置信息
  68.      * @param builder           注入EntityManagerFactoryBuilder
  69.      * @return 实体管理工厂对象
  70.      */
  71.     @Primary
  72.     @Bean(name = "primaryEntityManagerFactory")
  73.     public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean(
  74.             @Qualifier ("primaryDataSource") DataSource primaryDataSource,
  75.             @Qualifier("primaryJpaProperties") JpaProperties jpaProperties,
  76.             EntityManagerFactoryBuilder builder
  77.     ) {
  78.         return builder
  79.                 // 设置数据源
  80.                 .dataSource(primaryDataSource)
  81.                 // 设置jpa配置
  82.                 .properties(jpaProperties.getProperties())
  83.                 // 设置实体包名
  84.                 .packages(ENTITY_PACKAGE)
  85.                 // 设置持久化单元名，用于@PersistenceContext注解获取EntityManager时指定数据源
  86.                 .persistenceUnit("primaryPersistenceUnit").build();
  87.     }
  89.     /**
  90.      * 获取实体管理对象
  91.      *
  92.      * @param factory 注入名为primaryEntityManagerFactory的bean
  93.      * @return 实体管理对象
  94.      */
  95.     @Primary
  96.     @Bean(name = "primaryEntityManager")
  97.     public EntityManager entityManager(@Qualifier("primaryEntityManagerFactory") EntityManagerFactory factory) {
  98.         return factory.createEntityManager();
  99.     }
  101.     /**
  102.      * 获取主库事务管理对象
  103.      *
  104.      * @param factory 注入名为primaryEntityManagerFactory的bean
  105.      * @return 事务管理对象
  106.      */
  107.     @Primary
  108.     @Bean(name = "primaryTransactionManager")
  109.     public JpaTransactionManager transactionManager(@Qualifier("primaryEntityManagerFactory") EntityManagerFactory factory) {
  110.         return new JpaTransactionManager(factory);
  111.     }
  112. }

从库数据源配置

  1. @Configuration
  2. @EnableTransactionManagement
  3. @EnableJpaRepositories(
  4.         basePackages = SecondaryDatasourceAndJpaConfig.REPOSITORY_PACKAGE,
  5.         entityManagerFactoryRef = "secondaryEntityManagerFactory",
  6.         transactionManagerRef = "secondaryTransactionManager"
  7. )
  8. public class SecondaryDatasourceAndJpaConfig {
  9.     
  10.     static final String REPOSITORY_PACKAGE = "com.jpa.dao.secondary";
  11.     static final String ENTITY_PACKAGE = "com.jpa.entity.secondary";
  13.     //--------------数据源配置-------------------
  15.     /**
  16.      * 扫描spring.datasource.secondary开头的配置信息
  17.      *
  18.      * @return 数据源配置信息
  19.      */
  20.     @Bean(name = "secondaryDataSourceProperties")
  21.     @ConfigurationProperties(prefix = "spring.datasource.secondary")
  22.     public DataSourceProperties dataSourceProperties() {
  23.         return new DataSourceProperties();
  24.     }
  26.     /**
  27.      * 获取次数据源对象
  28.      *
  29.      * @param dataSourceProperties 注入名为secondaryDataSourceProperties的bean
  30.      * @return 数据源对象
  31.      */
  32.     @Bean("secondaryDataSource")
  33.     public DataSource dataSource(@Qualifier("secondaryDataSourceProperties") DataSourceProperties dataSourceProperties) {
  34.         return dataSourceProperties.initializeDataSourceBuilder().build();
  35.     }
  37.     /**
  38.      * 该方法仅在需要使用JdbcTemplate对象时选用
  39.      *
  40.      * @param dataSource 注入名为secondaryDataSource的bean
  41.      * @return 数据源JdbcTemplate对象
  42.      */
  43.     @Bean(name = "secondaryJdbcTemplate")
  44.     public JdbcTemplate jdbcTemplate(@Qualifier("secondaryDataSource") DataSource dataSource) {
  45.         return new JdbcTemplate(dataSource);
  46.     }
  48.     /**
  49.      * 扫描spring.jpa.secondary
  50.      *
  51.      * @return jpa配置信息
  52.      */
  53.     @Bean(name = "secondaryJpaProperties")
  54.     @ConfigurationProperties(prefix = "spring.jpa.secondary")
  55.     public JpaProperties jpaProperties() {
  56.         return new JpaProperties();
  57.     }
  59.     /**
  60.      * 获取次库实体管理工厂对象
  61.      *
  62.      * @param secondaryDataSource 注入名为secondaryDataSource的数据源
  63.      * @param jpaProperties       注入名为secondaryJpaProperties的jpa配置信息
  64.      * @param builder             注入EntityManagerFactoryBuilder
  65.      * @return 实体管理工厂对象
  66.      */
  67.     @Bean(name = "secondaryEntityManagerFactory")
  68.     public LocalContainerEntityManagerFactoryBean entityManagerFactory(
  69.             @Qualifier("secondaryDataSource") DataSource secondaryDataSource,
  70.             @Qualifier("secondaryJpaProperties") JpaProperties jpaProperties,
  71.             EntityManagerFactoryBuilder builder
  72.     ) {
  73.         return builder
  74.                 // 设置数据源
  75.                 .dataSource(secondaryDataSource)
  76.                 // 设置jpa配置
  77.                 .properties(jpaProperties.getProperties())
  78.                 // 设置实体包名
  79.                 .packages(ENTITY_PACKAGE)
  80.                 // 设置持久化单元名，用于@PersistenceContext注解获取EntityManager时指定数据源
  81.                 .persistenceUnit("secondaryPersistenceUnit").build();
  82.     }
  84.     /**
  85.      * 获取实体管理对象
  86.      *
  87.      * @param factory 注入名为secondaryEntityManagerFactory的bean
  88.      * @return 实体管理对象
  89.      */
  90.     @Bean(name = "secondaryEntityManager")
  91.     public EntityManager entityManager(@Qualifier("secondaryEntityManagerFactory") EntityManagerFactory factory) {
  92.         return factory.createEntityManager();
  93.     }
  95.     /**
  96.      * 获取事务管理对象
  97.      *
  98.      * @param factory 注入名为secondaryEntityManagerFactory的bean
  99.      * @return 事务管理对象
  100.      */
  101.     @Bean(name = "secondaryTransactionManager")
  102.     public JpaTransactionManager transactionManager(@Qualifier("secondaryEntityManagerFactory") EntityManagerFactory factory) {
  103.         return new JpaTransactionManager(factory);
  104.     }
  105. }

声明式事务

错误写法

  1. @Service
  2. public class TestService {
  4.     @Resource
  5.     JdbcTemplate primaryJdbcTemplate;
  7.     @Resource
  8.     JdbcTemplate secondaryJdbcTemplate;
  10.     @Transactional
  11.     public void method() {
  13.         //do something 1
  14.         
  15.         primaryJdbcTemplate.execute("insert into user(username, password) values('张三', '123456')");
  17.         //do something 2
  19.         secondaryJdbcTemplate.execute("insert into user(username, password) values('李四', '123456');");
  21.         //do something 3
  22.     }
  23. }

@Transactional中没有指定事务管理器，这在单数据源系统中就不会有任何问题，在单数据源系统中，整个Spring容器中只定义了一个事务管理器，Spring启动事务的时候，默认会按类型在容器中查找事务管理器，而容器中就只有一个事务管理器，正好拿来用，不会有问题。

但是在多数据源系统中，Spring容器中是会存在多个事务管理器的，如果不指定事务管理器，如果使用的事务管理器和实际操作的数据源不一致的话，是管理不了事务的（由于配置主库数据源使用@primary注解，所有默认会使用主库的事务管理器），所以在数据源系统中使用声明式事务，必须指定事务管理器

上面代码将两个数据库操作都放在同一个方法中，无论拿到了哪个事务管理器，只要 do something 3 处发生了异常，那么其中的一个事务是不会回滚的

改进写法

  1. @Service
  2. public class TestService {
  4.     @Resource
  5.     JdbcTemplate primaryJdbcTemplate;
  7.     @Resource
  8.     JdbcTemplate secondaryJdbcTemplate;
  10.     @Transactional(value = "primaryTransactionManager")
  11.     public void method1() {
  13.         //do something 1
  15.         primaryJdbcTemplate.execute("insert into user(username, password) values('张三', '123456')");
  17.         //do something 2
  19.         method2();
  21.         //do something 5
  22.     }
  24.     @Transactional(value = "secondaryTransactionManager")
  25.     public void method2() {
  27.         //do something 3
  29.         secondaryJdbcTemplate.execute("insert into user(username, password) values('李四', '123456');");
  31.         //do something 4
  32.     }
  33. }

改进的写法，将不同数据源的操作拆到不同的方法中，分别加上了@Transactional注解，并指定了对应的事务管理器。这种写法相对之前的就规范了不少，但是还是存在问题，如果在 do something 5 处发生了异常，因为 method2 方法已经执行结束了，事务已经提交了，所以还是无法做到一起回滚。

编程式事务

  1. @Service
  2. public class TestService {
  4.     @Resource
  5.     JdbcTemplate primaryJdbcTemplate;
  7.     @Resource
  8.     JdbcTemplate secondaryJdbcTemplate;
  10.     @Resource
  11.     PlatformTransactionManager primaryTransactionManager;
  13.     @Resource
  14.     PlatformTransactionManager secondaryTransactionManager;
  16.     public void method() {
  17.         TransactionDefinition primaryDef = new DefaultTransactionDefinition();
  18.         TransactionStatus primaryStatus = primaryTransactionManager.getTransaction(primaryDef);
  20.         TransactionDefinition secondaryDef = new DefaultTransactionDefinition();
  21.         TransactionStatus secondaryStatus = secondaryTransactionManager.getTransaction(secondaryDef);
  23.         try {
  24.             //do something 1
  26.             primaryJdbcTemplate.execute("insert into user(username, password) values('张三', '123456')");
  28.             //do something 2
  30.             secondaryJdbcTemplate.execute("insert into user(username, password) values('李四', '123456');");
  32.             //do something 3
  34.             primaryTransactionManager.commit(primaryStatus);
  35.             secondaryTransactionManager.commit(secondaryStatus);
  36.         } catch (Exception e) {
  37.             primaryTransactionManager.rollback(primaryStatus);
  38.             secondaryTransactionManager.rollback(secondaryStatus);
  39.             throw new RuntimeException(e.getMessage());
  40.         }
  41.     }
  42. }

编程式事务的颗粒度时代码级别的，可以嵌入到方法里面，这样可以控制不同数据源的事务同时开启，一旦出现异常，则两个事务一起回滚，这样就保证了多数据事务的一致性。

这种实现实际上和分布式事务的XA模式思想一样，只不过分布式事务管理的是分布式系统中不同服务不同的数据源，而这里是一个服务同一个方法中操作多个数据源。本质上都是处理管理多数据源的事务。

标签： spring boot 后端 java
本文转载自: https://blog.csdn.net/typeracer/article/details/141431028
版权归原作者 编程经验分享 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Spring Boot 同一个方法中操作多个数据源保证事务一致性”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？