SpringBoot + MybatisPlus 实现多数据源事务

已于 2023-07-22 12:23:32 修改
阅读量7.6k 收藏 36
点赞数 7
分类专栏： # 框架 工作实践 文章标签： SpingBoot spring mybatis mybatis-plus
于 2020-09-13 11:54:07 首次发布
原文链接：https://blog.csdn.net/u010928589/article/details/91348761
版权

针对使用SpringBoot + MybatisPlus架构，需要用到多数据源，并且在一个方法内可能多个数据源都有事务要求的情况，做实现方法分享，源代码如下：https://github.com/guzhangyu/learn-spring-cloud/tree/master/springboot-multidb
。

文章目录

1、 多数据源配置

动态指定数据源的类:

@Slf4j
public class DynamicRoutingDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        String dataSourceName = DynamicDataSourceContextHolder.getDataSourceRouterKey();
        log.info("当前数据源是：{}", dataSourceName);
        return DynamicDataSourceContextHolder.getDataSourceRouterKey();
    }
}

其中 DynamicDataSourceContextHolder用于保存当前线程上下文的数据源名:

/**
 * 数据源设置工具类
 */
@Slf4j
public class DynamicDataSourceContextHolder {

    /**
     * 存储已经注册的数据源的key
     */
    public static List<String> dataSourceIds = new ArrayList<>();

    /**
     * 线程级别的私有变量
     */
    private static final ThreadLocal<String> HOLDER = new ThreadLocal<>();

    public static String getDataSourceRouterKey () {
        return HOLDER.get();
    }

    public static void setDataSourceRouterKey (String dataSourceRouterKey) {
        log.info("切换至{}数据源", dataSourceRouterKey);
        HOLDER.set(dataSourceRouterKey);
    }

    /**
     * 设置数据源之前一定要先移除
     */
    public static void removeDataSourceRouterKey () {
        HOLDER.remove();
    }

    /**
     * 判断指定DataSrouce当前是否存在
     *
     * @param dataSourceId
     * @return
     */
    public static boolean containsDataSource(String dataSourceId){
        return dataSourceIds.contains(dataSourceId);
    }

}

加载多数据源的配置并注册数据源类，在启动类上需要加上 @Import(DynamicDataSourceRegister.class) 注解:

/**
 * 动态数据源注册
 * 实现 ImportBeanDefinitionRegistrar 实现数据源注册
 * 实现 EnvironmentAware 用于读取application.yml配置
 */
@Slf4j
public class DynamicDataSourceRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {


    /**
     * 配置上下文（也可以理解为配置文件的获取工具）
     */
    private Environment evn;

    /**
     * 别名
     */
    private final static ConfigurationPropertyNameAliases aliases = new ConfigurationPropertyNameAliases();

    /**
     * 由于部分数据源配置不同，所以在此处添加别名，避免切换数据源出现某些参数无法注入的情况
     */
    static {
        aliases.addAliases("url", new String[]{"jdbc-url"});
        aliases.addAliases("username", new String[]{"user"});
    }

    /**
     * 存储我们注册的数据源
     */
    private static final Map<String, DataSource> customDataSources = new HashMap<String, DataSource>();

    /**
     * 参数绑定工具 springboot2.0新推出
     */
    private Binder binder;

    /**
     * ImportBeanDefinitionRegistrar接口的实现方法，通过该方法可以按照自己的方式注册bean
     *
     * @param annotationMetadata
     * @param beanDefinitionRegistry
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {

        // 获取数据源配置
        Map config = (Map)binder.bind("spring.datasource.druid.master", Map.class).get().get("0");
        registerDataSource(config);

        config = (Map)binder.bind("spring.datasource.druid.slave", Map.class).get().get("0");
        registerDataSource(config);

        // bean定义类
        GenericBeanDefinition define = new GenericBeanDefinition();
        // 设置bean的类型，此处DynamicRoutingDataSource是继承AbstractRoutingDataSource的实现类
        define.setBeanClass(DynamicRoutingDataSource.class);
        // 需要注入的参数
        MutablePropertyValues mpv = define.getPropertyValues();
        // 添加默认数据源，避免key不存在的情况没有数据源可用
        mpv.add("defaultTargetDataSource", customDataSources.get("master"));
        // 添加其他数据源
        mpv.add("targetDataSources", customDataSources);
        // 将该bean注册为datasource，不使用springboot自动生成的datasource
        beanDefinitionRegistry.registerBeanDefinition("datasource", define);
        log.info("注册数据源成功，一共注册{}个数据源", customDataSources.keySet().size());
    }

    private DataSourceTransactionManager registerDataSource(Map config) {
        // 绑定参数
        DataSource consumerDatasource = bind(getDataSourceType((String) config.get("type")), config);
//      //设置事务
        DataSourceTransactionManager secondDataSourceTransactionManager = new DataSourceTransactionManager();
        secondDataSourceTransactionManager.setDataSource(consumerDatasource);

        // 获取数据源的key，以便通过该key可以定位到数据源
        String key = config.get("key").toString();
        customDataSources.put(key, consumerDatasource);
        // 数据源上下文，用于管理数据源与记录已经注册的数据源key
        DynamicDataSourceContextHolder.dataSourceIds.add(key);
        log.info("注册数据源{}成功", key);

        return secondDataSourceTransactionManager;
    }

    public DataSource getDataSource(String key){
        return customDataSources.get(key);
    }


    /**
     * 通过字符串获取数据源class对象
     *
     * @param typeStr
     * @return
     */
    private Class<? extends DataSource> getDataSourceType(String typeStr) {
        Class<? extends DataSource> type;
        try {
            if (StringUtils.hasLength(typeStr)) {
                // 字符串不为空则通过反射获取class对象
                type = (Class<? extends DataSource>) Class.forName(typeStr);
            } else {
                // 默认为hikariCP数据源，与springboot默认数据源保持一致
                type = DruidDataSource.class;
            }
            return type;
        } catch (Exception e) {
            throw new IllegalArgumentException("can not resolve class with type: " + typeStr); //无法通过反射获取class对象的情况则抛出异常，该情况一般是写错了，所以此次抛出一个runtimeexception
        }
    }

    /**
     * 绑定参数，以下三个方法都是参考DataSourceBuilder的bind方法实现的，目的是尽量保证我们自己添加的数据源构造过程与springboot保持一致
     *
     * @param result
     * @param properties
     */
    private void bind(DataSource result, Map properties) {
        ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
        Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
        // 将参数绑定到对象
        binder.bind(ConfigurationPropertyName.EMPTY, Bindable.ofInstance(result));
    }

    private <T extends DataSource> T bind(Class<T> clazz, Map properties) {
        ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
        Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
        // 通过类型绑定参数并获得实例对象
        return binder.bind(ConfigurationPropertyName.EMPTY, Bindable.of(clazz)).get();
    }

    /**
     * @param clazz
     * @param sourcePath 参数路径，对应配置文件中的值，如: spring.datasource
     * @param <T>
     * @return
     */
    private <T extends DataSource> T bind(Class<T> clazz, String sourcePath) {
        Map properties = binder.bind(sourcePath, Map.class).get();
        return bind(clazz, properties);
    }

    /**
     * EnvironmentAware接口的实现方法，通过aware的方式注入，此处是environment对象
     *
     * @param environment
     */
    @Override
    public void setEnvironment(Environment environment) {
        log.info("开始注册数据源");
        this.evn = environment;
        // 绑定配置器
        binder = Binder.get(evn);
    }
}

spring:
  datasource:
    druid:
      defaultDs: master
      master:
      - key: master
        name: master
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://localhost:3306/dorm?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=UTC
        username: root
        password: root

      slave:
      - key: slave
        name: slave
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://localhost:3306/jkm?useUnicode=true&useSSL=false&characterEncoding=utf8&serverTimezone=UTC
        username: root
        password: root
        
mybatis-plus:
  global-config:
    id-dtype: 0
    field-strategy: 0
    db-config:
      logic-delete-value: 0
      logic-not-delete-value: 1
  mapper-locations: classpath:mybatis/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    cache-enabled: true

通过aop实现在mapper层切换数据源：

@Target({ElementType.METHOD, ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
    String value() default "master"; //该值即key值
}

@Aspect
@Component
@Slf4j
public class MapperAspect {

    @Pointcut("execution(* com.learn.springboot.mapper.*Mapper.*(..))")
    public void pointCut(){
    }

    @Before("pointCut()")
    public void before(JoinPoint joinPoint) {
        DataSource annotation = getDataSourceAnnotation(joinPoint);

        String dsId = annotation == null ? "master" : annotation.value();
        log.info("选择数据源:{}", dsId);
        DynamicDataSourceContextHolder.setDataSourceRouterKey(dsId);
    }

    private DataSource getDataSourceAnnotation(JoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        DataSource annotation = method.getAnnotation(DataSource.class);
        if(annotation!=null) {
            return annotation;
        }

        Class<?>[] interfaces = joinPoint.getTarget().getClass().getInterfaces();
        for(Class<?> anInterface: interfaces) {
            annotation = anInterface.getAnnotation(DataSource.class);
            if(annotation!=null) {
                return annotation;
            }
        }
        return null;
    }

    @After("pointCut()")
    public void after() {
        DynamicDataSourceContextHolder.removeDataSourceRouterKey();
    }
}

2、多数据源事务支持

目标效果是在一个方法中可以指定哪几个数据源要加上事务支持。
Spring的事务管理器 DataSourceTransactionManager:
在这里插入图片描述
绑定到当前线程后，每次拿connection不会调用determineCurrentLookupKey() 方法去获取不同的数据源，从而拿到不同的connection，而是直接去拿这里绑定的connection。
所以使用原生的事务管理器并不能完成我们需要的功能，改成直接在aop中拿connection来开启事务：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface TransactionMulti {
    String[] value() default {};
    int transactionType() default Connection.TRANSACTION_READ_UNCOMMITTED;
}

@Aspect
@Component
@Slf4j
public class MultiTransactionManagerAop {

    private DynamicRoutingDataSource dataSourceRouting = new DynamicRoutingDataSource();


    @Pointcut("@annotation(com.learn.springboot.annotation.TransactionMulti)")
    public void annotationPointcut(){}


    @Around("annotationPointcut()")
    public void roundExecute(ProceedingJoinPoint joinpoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinpoint.getSignature();
        Method method = methodSignature.getMethod();
        TransactionMulti annotation = method.getAnnotation(TransactionMulti.class);
        String[] values = annotation.value();
        int transactionType = annotation.transactionType();
        //把涉及到的连接绑定到线程上,开启事务,关闭自动提交
        begin(values, transactionType);
        //正真执行了 方法
        joinpoint.proceed();
        //commit
        dataSourceRouting.doCommit();
    }

    @AfterThrowing(pointcut = "annotationPointcut()",throwing = "e")
    public void handleThrowing(JoinPoint joinPoint, Exception e) {//controller类抛出的异常在这边捕获
        try {
            dataSourceRouting.rollback();
        } catch (SQLException e1) {
            e1.printStackTrace();
        }
    }



    private void begin(String[] values,int transactionType) throws SQLException {
        for (String value : values) {
            DataSource dataSource = DynamicDataSourceRegister.getDataSource(value);
            if(dataSource == null){
                log.error("没有找到数据源:{}", value);
                continue;
            }
            Connection connection = dataSource.getConnection();
            prepareTransactionalConnection(connection,transactionType);
            connectBegin(connection);
            //绑定到线程上面
            dataSourceRouting.bindConnection(value, connection);
        }
    }

    /**
     * 开启事物的一些准本工作
     */
    private void connectBegin(Connection connection) throws SQLException {
        if(connection!=null){
            try {
                if(connection.getAutoCommit()){
                    connection.setAutoCommit(false);
                }
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

    /**
     * 设置隔离级别
     * @param con
     * @throws SQLException
     */
    protected void prepareTransactionalConnection(Connection con,int transactionType)
            throws SQLException {
        if (TransactionTypeEnum.isNotDefined(transactionType)){
            throw new SqlSessionException("当前事物隔离级别未被定义");
        }
        con.setTransactionIsolation(transactionType);
    }

}

public enum TransactionTypeEnum {

    TRANSACTION_NONE(0,"无事务"),
    TRANSACTION_READ_UNCOMMITTED(1,"允许读脏，不可重读，幻读"),
    TRANSACTION_READ_COMMITTED(2,"仅允许读取已提交的数据，即不能读脏，但是可能发生不可重读和幻读"),
    TRANSACTION_REPEATABLE_READ(4,"不可读脏，保证同一事务重复读取相同数据，但是可能发生幻读"),
    TRANSACTION_SERIALIZABLE(8,"串行事务，保证不读脏，可重复读，不可幻读");

    private int value;

    private String details;

    TransactionTypeEnum() {
    }

    TransactionTypeEnum(int value, String details) {
        this.value = value;
        this.details = details;
    }

    public static boolean isNotDefined(Integer value) {
        TransactionTypeEnum[] transactionTypeEnums = values();
        for (TransactionTypeEnum transactionTypeEnum : transactionTypeEnums) {
            if (transactionTypeEnum.getValue()==value) {
                return false;
            }
        }
        return true;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public String getDetails() {
        return details;
    }

    public void setDetails(String details) {
        this.details = details;
    }
}

这里有一个问题需要解决：因为现在事务自己管理，mybatis每次拿完connection就自动调用close和commit方法，这样导致我自己操作的事务失效，所以要先让mybatis不能自作主张关闭connection。
解决方法: spring data获取connection的时候，给它包装类，覆盖原来的close和commit方法。
类DynamicRoutingDataSource 中覆盖getConnection()方法：

   //把当前事务下的连接塞入,用于事务处理
    final static ThreadLocal<Map<String, ConnectWrap>> connectionThreadLocal = new ThreadLocal<>();

    /**
     * 如果 在connectionThreadLocal 中有 说明开启了事务,就从这里面拿
     *
     * @return
     * @throws SQLException
     */
    @Override
    public Connection getConnection() throws SQLException {
        Map<String, ConnectWrap> stringConnectionMap = connectionThreadLocal.get();
        if (stringConnectionMap == null) {
            //没开事务 直接走
            return determineTargetDataSource().getConnection();
        } else {
            //开了事务,从当前线程中拿,而且拿到的是 包装过的connect 只有我能关闭O__O "…
            String currentName = (String) determineCurrentLookupKey();
            return stringConnectionMap.get(currentName);
        }

    }

在这个包装类中
在这里插入图片描述
只有手动调用 commit(true) 和 close(true) 才会真正提交和关闭连接。
doCommit() 和 rollback() 方法如下:

 /**
     * 提交事物
     *
     * @throws SQLException
     */
    public void doCommit() throws SQLException {
        //System.out.println("commit:" + connectionThreadLocal.get().toString());
        Map<String, ConnectWrap> stringConnectionMap = connectionThreadLocal.get();
        if (stringConnectionMap == null) {
            return;
        }
        for (String dataSourceName : stringConnectionMap.keySet()) {
            ConnectWrap connection = stringConnectionMap.get(dataSourceName);
            connection.commit(true);
            connection.close(true);
        }
        removeConnectionThreadLocal();
    }

    /**
     * 撤销事物
     *
     * @throws SQLException
     */
    public void rollback() throws SQLException {
//        System.out.println("rollback:" + connectionThreadLocal.get().toString());
        Map<String, ConnectWrap> stringConnectionMap = connectionThreadLocal.get();
        if (stringConnectionMap == null) {
            return;
        }
        for (String dataSourceName : stringConnectionMap.keySet()) {
            ConnectWrap connection = stringConnectionMap.get(dataSourceName);
            connection.rollback();
            connection.close(true);
        }
        removeConnectionThreadLocal();
    }

    public void removeConnectionThreadLocal() {
//        System.out.println("remove:" + connectionThreadLocal.get().toString());
        connectionThreadLocal.remove();
    }

3、测试

@DataSource("slave")
public interface IdentifyScoreMapper extends BaseMapper<IdentifyScore> {

    @DataSource("slave")
    @Update("update identify_score set score = #{score} where id = 1")
    void updateScore(@Param("score") Integer socre);
}

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.learn.springboot.annotation.DataSource;
import com.learn.springboot.entity.Student;

/**
 * @Author zhangyugu
 * @Date 2020/9/12 7:19 下午
 * @Version 1.0
 */
@DataSource("master")
public interface StudentMapper extends BaseMapper<Student> {
}

@Service
public class TestTransactionService {

    @Resource
    StudentMapper studentMapper;

    @Resource
    IdentifyScoreMapper identifyScoreMapper;

//    @Transactional(rollbackFor = RuntimeException.class)
    @TransactionMulti(value = {"master", "slave"})
    public void test() {
        identifyScoreMapper.updateScore(77);
        Student student = new Student();
        student.setId(1L);
        student.setName("test");
        studentMapper.updateById(student);

        if(1==1) {
            throw new RuntimeException("ds");
        }

        identifyScoreMapper.updateScore(88);
        student = new Student();
        student.setId(2L);
        student.setName("test");
        studentMapper.updateById(student);
    }
}

@Import(DynamicDataSourceRegister.class)
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class MultidbApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(MultidbApplication.class, args);
        TestTransactionService testTransactionService = applicationContext.getBean(TestTransactionService.class);

        testTransactionService.test();
    }
}

通过抛出异常与不抛出异常两种情况，看数据库数据的变化情况可以进行测试。

智慧的牛
关注
专栏目录
Mybatis-Plus多数据源事务
ooaash的博客
06-08 5006
Mybatis-Plus多数据源
mybatisplus多数据源事务问题
昨夜星辰昨夜风，画楼西畔桂堂东
09-08 7763
mybtaisplus多数据源事务问题分析 文章目录mybtaisplus多数据源事务问题分析一.背景1.背景问题2.问题所在2.1 首先关注一下mybatis-plus数据源切换的几个类2.2 方法执行的几个步骤3.解决思路N.参考博客 一.背景 1.背景问题 在项目中，通过使用mybatis-plus操作多数据源的时候，一旦加上事务，会报 Table 'xxx' doesn't exist 异常，原因是在切换数据源的时候，没有切换成功，下面会有所解释。以下是spring版本和mybatis-plus的版
springboot+mybatis-plus+多源事务
sunguizhu的博客
04-26 2096
简单来说，就是如果有@DS注解，则会新建ThreadLocal，并绑定对应的数据库key（DS中的数值），原来的线程入栈，切换到新的ThreadLocal，并切换数据库连接，从而实现数据源的切换，如果没有@DS注解，则会走主库。，那么就会当做另起一个新的事务，也就会重新获取连接，而且在内层方法里面如果抛出异常的话，也会导致外层事务回滚的（相当于外部事务套了一个内部事务）。如果是在同一个事务里面，sqlsession是沿用同一个，导致connection不会切换，因此无法切换数据源，如果在。
MyBatis-Plus多数据源支持
最新发布
Flying_Fish_roe的博客
09-23 1461
通过 MyBatis-Plus 的多数据源支持，开发者可以轻松实现读写分离业务模块分离以及其他复杂的多数据源场景。通过简单的注解配置，动态数据源切换变得十分灵活和高效。
springboot+mybatis-plus多数据源+事务
李胜坤的博客
07-01 1260
springboot多数据源配置,注解失效
springboot+Mybatisplus实现多数据源
12-12
springboot+Mybatisplus实现多数据源,使用aop切面自动切换多数据源！！加群：687942640
多数据源事务集成-mybatis-plus
zchlove137的博客
12-16 3804
目前百度能搜索到的大部分是各自单独实现的aop以及多数据源的管理，使用起来比较复杂，而且做得也相对来说不是很完善，比如是否要考虑嵌套事务这种以及多数据源事务的支持方式，很多博主都没有涉及到，大多是简单的基于spring框架的拦截处理，自己实现不仅有不完善的缺点、可扩展性也是比较差的，后期版本维护升级或者支持更加复杂的功能就需要进行大改动以及全面的测试，风险系数也是蛮高的。mybatis-plus高版本在2021年下半年已经自己实现了在不借助外部协调者seata的情况下通过实现spring分布式事务的相关接口
springboot+mybatisplus+mysql 多数据源
10-27
本项目"springboot+mybatisplus+mysql 多数据源"是一个演示如何在Spring Boot框架下，结合MyBatisPlus和MySQL实现多数据源切换的示例。下面将详细解释其中涉及的关键技术点。 1. **Spring Boot**: Spring Boot是...
springboot+mybatisplus(mybatis)+mysql+oracle 多数据源项目
04-12
在多数据源场景下，Mybatis Plus可以方便地切换不同的数据源，实现对MySQL和Oracle的灵活操作。 项目的核心在于多数据源的配置。在Spring Boot中，我们可以通过@ConfigurationProperties注解来加载自定义的配置文件...
springboot+mybatisPlus+mysql动态数据源切换
10-17
本项目基于SpringBoot、Mybatis-Plus和MySQL，实现了动态数据源切换的功能，这使得系统能根据业务逻辑或用户权限在不同的数据库间灵活跳转，提高系统的灵活性和可扩展性。 首先，SpringBoot作为轻量级的Java框架，...
SpringBoot+mybatisPlus+atomikos+druid.zip
09-07
Spring Boot：mybatis-plus + atomikos + druid 实现不同实例数据库的多数据源配置和分布式事务管理（demo项目），想到工作上可能会用到多数据源，但是自己在这方面并不是很熟悉，于是在网上查阅了很多文章，结果...
springboot mybatis多数据源加事务嵌套
06-21
springboot mybatis多数据源加事务嵌套 事务之间的调用 回滚 亲测可用 定义2个库分别建立 CREATE TABLE `user` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '用户编号', `user_name` varchar(25) DEFAULT NULL COMMENT '用户名称', `description` varchar(25) DEFAULT NULL COMMENT '描述', PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8; CREATE TABLE `city` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '城市编号', `province_id` int(10) unsigned NOT NULL COMMENT '省份编号', `city_name` varchar(25) DEFAULT NULL COMMENT '城市名称', `description` varchar(25) DEFAULT NULL COMMENT '描述', PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
分布式，mybatis-plus，多数据源总结
03-14
分布式，mybatis-plus，多数据源总结分布式，mybatis-plus，多数据源总结
springboot + mybatis + atomikos 多数据源分布式事物管理
05-18
springboot + mybatis + atomikos 多数据源分布式事物管理;springboot + mybatis + atomikos 多数据源分布式事物管理
MyBatis-Plus多数据源配置与事务与批量注意点
asd372506589的博客
07-20 2594
1、针对问题1，在使用mp的时候可能执行一些批量的方法，比如saveBatch等，进入saveBatch方法中可以看到在这个方法上默认有@Transactional注解，对于该注解默认使用的都是主库，所以对于从库的一些操作因为无法切换从库产生一些问题。总结一些：对于mp的多数据源的事务或者查询问题首先看每次sql执行时选择的源，另外使用@DS与@Transactional与@DSTransactional三个注解基本可以解决遇到的事务失效等问题。1、发现配置多数据源之后批量执行的方法都走的主库。
springboot 整合Mybatis-plus 多数据源，实现多数据源事务，使用druid 连接池并启用监控等
小哇
10-29 858
【代码】springboot 整合Mybatis-plus 多数据源，使用druid 连接池并启用监控等。
MybatisPlus多数据源
kakams_008的博客
08-13 339
DS("master") //指定所操作的数据源,在application.yml中配置,可以加到方法上代表在指定方法操作指定的数据源。* type = IdType.AUTO,表示自增的主键，不使用这个新增后自增使用的是雪花算法。# 严格匹配数据源,默认false.true未匹配到指定数据源时抛异常,false使用默认数据源。//@TableId//id和id的名字不一样的时候，实体类和数据表中都使用uid的时候。/*实体类中是id，数据表中是uid的时候，使用value指定唯一的键。
mybatis-plus多数据源配置
yaoct的博客
12-02 7593
这里结合了springboot的多数据源配置，主要是手动创建数据源，再手动设置配置一些配置参数。
【mybatis-plus】自定义多数据源，动态切换数据源事务失效问题
主要从事JAVA开发，目前是CSDN博客Java领域新星创作者、阿里云博客专家、担任公司研发经理、技术负责人等。热爱编程，喜欢在Python、C、C++领域探索。
12-16 6131
背景做了一个和navicat一样的工具，web版工具，然后数据库链接信息都是存在一个主数据库表的里，所以这里涉及到了动态切换数据源，以及一些事务等。今天说下多数据源切换时，事务失效。
我现在是用springboot+mybatisplus配置多数据源，现在事务不好用，请告诉我应该怎么配置事务
07-16
你可以通过在Spring Boot中配置多数据源来实现事务的管理。首先，确保在pom.xml文件中添加了Spring Boot和MyBatis Plus的依赖。 接下来，你需要创建两个数据源的配置类。例如，假设你有两个数据源，分别是dataSource1和dataSource2，你可以创建如下的配置类： ```java @Configuration public class DataSourceConfig { @Primary @Bean(name = "dataSource1") @ConfigurationProperties(prefix = "spring.datasource.ds1") public DataSource dataSource1() { return DataSourceBuilder.create().build(); } @Bean(name = "dataSource2") @ConfigurationProperties(prefix = "spring.datasource.ds2") public DataSource dataSource2() { return DataSourceBuilder.create().build(); } } ``` 在这个示例中，我们使用了@ConfigurationProperties注解来绑定配置文件中以`spring.datasource.ds1`和`spring.datasource.ds2`为前缀的属性。 接下来，你需要配置事务管理器。在Spring Boot中，你可以使用`DataSourceTransactionManager`来管理事务。在你的配置类中，添加如下代码： ```java @Configuration @EnableTransactionManagement public class TransactionConfig { @Autowired @Qualifier("dataSource1") private DataSource dataSource1; @Autowired @Qualifier("dataSource2") private DataSource dataSource2; @Bean(name = "transactionManager1") public DataSourceTransactionManager transactionManager1() { return new DataSourceTransactionManager(dataSource1); } @Bean(name = "transactionManager2") public DataSourceTransactionManager transactionManager2() { return new DataSourceTransactionManager(dataSource2); } } ``` 在这个示例中，我们创建了两个`DataSourceTransactionManager`，分别与dataSource1和dataSource2关联。 最后，你需要在你的业务代码中使用`@Transactional`注解来开启事务。根据需要，你可以指定使用哪个数据源的事务管理器。 ```java @Service public class YourService { @Autowired @Qualifier("transactionManager1") private PlatformTransactionManager transactionManager1; @Transactional("transactionManager1") public void doSomething() { // 在这里执行你的业务逻辑 } } ``` 在这个示例中，我们使用了`@Transactional`注解，并通过指定`transactionManager1`来使用dataSource1的事务管理器。 这样，你就可以在Spring Boot中配置多数据源并使用事务管理器了。希望对你有所帮助！
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值