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

最新推荐文章于 2024-09-15 15:12:46 发布

编程经验分享

最新推荐文章于 2024-09-15 15:12:46 发布

阅读量1.7k

点赞数 14

分类专栏： # Spring 文章标签： spring boot 后端 java

本文链接：https://blog.csdn.net/typeracer/article/details/141431028

版权

Spring 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

前言

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

Config

这里主要注入主库和从库各自的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模式思想一样，只不过分布式事务管理的是分布式系统中不同服务不同的数据源，而这里是一个服务同一个方法中操作多个数据源。本质上都是处理管理多数据源的事务。