前言

在企业级应用开发中，事务管理是保障数据一致性与完整性的关键环节。Spring Boot 为我们提供了强大的事务管理支持，主要包括声明式事务和编程式事务两种方式。当涉及到多数据源的场景时，结合MyBatis-Plus框架，事务管理变得更加复杂但也更具灵活性。

本文将深入探讨如何在Spring Boot + MyBatis-Plus多数据源环境下实现这两种事务管理方式。

一、多数据源配置

首先，我们需要配置多个数据源。假设我们有两个数据源，分别为dataSource1和dataSource2。

1. 引入依赖

    
    
        org.springframework.boot
        spring-boot-starter-jdbc
    
    
    
        com.baomidou
        mybatis-plus-boot-starter
        最新版本
    
    
    
        mysql
        mysql-connector-java
    

2. 配置数据源

在application.yml文件中配置两个数据源的连接信息。

spring:
  datasource:
    primary:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
      username: root
      password: root
    secondary:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/db2?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
      username: root
      password: root

3. 配置数据源 Bean

创建配置类，定义两个数据源的 Bean。

@Configuration
public class DataSourceConfig {

    @Bean
    @Primary
    @ConfigurationProperties("spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
}

4. 配置 MyBatis-Plus

为每个数据源配置对应的MyBatis-Plus的SqlSessionFactory和MapperScannerConfigurer。

@Configuration
@MapperScan(basePackages = "com.example.demo.mapper.primary", sqlSessionFactoryRef = "primarySqlSessionFactory")
public class PrimaryMyBatisPlusConfig {

    @Bean
    @Primary
    public SqlSessionFactory primarySqlSessionFactory(@Qualifier("primaryDataSource") DataSource dataSource) throws Exception {
        MybatisSqlSessionFactoryBean bean = new MybatisSqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        MybatisConfiguration configuration = new MybatisConfiguration();
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setCacheEnabled(false);
        bean.setConfiguration(configuration);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/primary/*.xml"));
        GlobalConfig globalConfig = new GlobalConfig();
        globalConfig.setBanner(false);
        bean.setGlobalConfig(globalConfig);
        return bean.getObject();
    }

    @Bean
    @Primary
    public PlatformTransactionManager primaryTransactionManager(@Qualifier("primaryDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    /***
     * sqlSessionTemplate与Spring事务管理一起使用，可以确保实际使用的 SqlSession 是与当前的 Spring 事务相关联的。这样，会话的生命周期（包括根据 Spring 的事务配置，在必要时关闭、提交或回滚会话）将由 Spring 管理
     */
    @Bean
    @Primary
    public SqlSessionTemplate primarySqlSessionTemplate(@Qualifier("primarySqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

@Configuration
@MapperScan(basePackages = "com.example.demo.mapper.secondary", sqlSessionFactoryRef = "secondarySqlSessionFactory")
public class SecondaryMyBatisPlusConfig {

    @Bean
    public SqlSessionFactory secondarySqlSessionFactory(@Qualifier("secondaryDataSource") DataSource dataSource) throws Exception {
        MybatisSqlSessionFactoryBean bean = new MybatisSqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        MybatisConfiguration configuration = new MybatisConfiguration();
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setCacheEnabled(false);
        bean.setConfiguration(configuration);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:/mapper/secondary/*.xml"));
        GlobalConfig globalConfig = new GlobalConfig();
        globalConfig.setBanner(false);
        bean.setGlobalConfig(globalConfig);
        return bean.getObject();
    }

    @Bean
    public PlatformTransactionManager secondaryTransactionManager(@Qualifier("secondaryDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean
    public SqlSessionTemplate secondarySqlSessionTemplate(@Qualifier("secondarySqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

二、声明式事务在多数据源下的实现

在多数据源场景下使用声明式事务，需要注意事务管理器的选择。

1. 启用声明式事务

和单数据源一样，在主应用类上添加@EnableTransactionManagement注解。

@SpringBootApplication
@EnableTransactionManagement
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

2. 使用注解配置事务

在需要事务管理的方法或类上使用@Transactional注解，并指定事务管理器。

@Service
public class UserService {

    @Transactional(value = "primaryTransactionManager", rollbackFor = Exception.class)
    public void createUser(User user) {
        // 使用primaryDataSource对应的Mapper进行数据库操作
    }

    @Transactional(value = "secondaryTransactionManager", rollbackFor = Exception.class)
    public void updateUser(User user) {
        // 使用secondaryDataSource对应的Mapper进行数据库操作
    }
}

在上述代码中，createUser方法使用primaryTransactionManager事务管理器，确保对primaryDataSource数据源的操作在一个事务中；updateUser方法使用secondaryTransactionManager事务管理器，管理对secondaryDataSource数据源的操作。

3. 事务传播行为

在多数据源场景下，事务传播行为同样适用。例如，如果一个方法调用另一个跨数据源的事务方法，需要合理配置事务传播行为以确保数据的一致性。

@Transactional(value = "primaryTransactionManager", propagation = Propagation.REQUIRES_NEW)
public void complexOperation() {
    // 调用另一个数据源的事务方法
    userService.updateUser(new User());
}

三、编程式事务在多数据源下的实现

编程式事务在多数据源场景下，可以精确控制每个数据源的事务边界。

1. 使用 TransactionTemplate

为每个数据源配置对应的TransactionTemplate。

@Configuration
public class TransactionConfig {

    @Bean
    public TransactionTemplate primaryTransactionTemplate(@Qualifier("primaryTransactionManager") PlatformTransactionManager transactionManager) {
        return new TransactionTemplate(transactionManager);
    }

    @Bean
    public TransactionTemplate secondaryTransactionTemplate(@Qualifier("secondaryTransactionManager") PlatformTransactionManager transactionManager) {
        return new TransactionTemplate(transactionManager);
    }
}

然后在服务类中使用对应的TransactionTemplate执行事务操作。

@Service
public class ProductService {

    @Autowired
    @Qualifier("primaryTransactionTemplate")
    private TransactionTemplate primaryTransactionTemplate;

    @Autowired
    @Qualifier("secondaryTransactionTemplate")
    private TransactionTemplate secondaryTransactionTemplate;

    public void updateProductInPrimary(Product product) {
        primaryTransactionTemplate.execute(new TransactionCallback<Object>() {
            @Override
            public Object doInTransaction(TransactionStatus status) {
                try {
                    // 使用primaryDataSource对应的Mapper进行数据库操作
                    return null;
                } catch (Exception e) {
                    status.setRollbackOnly();
                    throw e;
                }
            }
        });
    }

    public void updateProductInSecondary(Product product) {
        secondaryTransactionTemplate.execute(new TransactionCallback<Object>() {
            @Override
            public Object doInTransaction(TransactionStatus status) {
                try {
                    // 使用secondaryDataSource对应的Mapper进行数据库操作
                    return null;
                } catch (Exception e) {
                    status.setRollbackOnly();
                    throw e;
                }
            }
        });
    }
}

2. 使用 TransactionManager

直接使用PlatformTransactionManager也可以实现编程式事务控制。

@Service
public class OrderService {

    @Autowired
    @Qualifier("primaryTransactionManager")
    private PlatformTransactionManager primaryTransactionManager;

    @Autowired
    @Qualifier("secondaryTransactionManager")
    private PlatformTransactionManager secondaryTransactionManager;

    public void placeOrderInPrimary(Order order) {
        TransactionDefinition def = new DefaultTransactionDefinition();
        TransactionStatus status = primaryTransactionManager.getTransaction(def);
        try {
            // 使用primaryDataSource对应的Mapper进行数据库操作
            primaryTransactionManager.commit(status);
        } catch (Exception e) {
            primaryTransactionManager.rollback(status);
            throw e;
        }
    }

    public void placeOrderInSecondary(Order order) {
        TransactionDefinition def = new DefaultTransactionDefinition();
        TransactionStatus status = secondaryTransactionManager.getTransaction(def);
        try {
            // 使用secondaryDataSource对应的Mapper进行数据库操作
            secondaryTransactionManager.commit(status);
        } catch (Exception e) {
            secondaryTransactionManager.rollback(status);
            throw e;
        }
    }
}

四、总结

在 Spring Boot + MyBatis-Plus 多数据源的环境中，无论是声明式事务还是编程式事务，都需要我们仔细配置和管理事务管理器，以确保不同数据源的操作能够在正确的事务控制下进行。声明式事务通过注解简化了事务配置，适用于大多数常规业务场景；而编程式事务则提供了更灵活、更精细的事务控制，适用于复杂的业务逻辑。通过合理运用这两种事务管理方式，我们能够构建出数据一致性高、稳定性强的企业级应用程序。在实际开发过程中，需要根据具体的业务需求和数据操作特点，选择最合适的事务管理策略。