SpringBoot采用集成多个Mybatis框架实现多JDBC数据源 + 多数据源本地事务

最新推荐文章于 2024-04-12 17:47:23 发布
最新推荐文章于 2024-04-12 17:47:23 发布
阅读量249 收藏
点赞数
分类专栏： # SpringBoot 文章标签： spring boot mybatis 集成多个mybatis框架 多JDBC数据源 多数据源本地事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yy8623977/article/details/128301100
版权

目录

1. 原理

1.1 实现多数据源的原理

通过启动多个SqlSessionFactoryBean，每个SqlSessionFactoryBean对应一个datasource和指定位置的mapper.xml文件，就可以实现多个数据源了。而不用切换数据源，不用实现AbstractRoutingDataSource

1.2 多数据源本地事务的原理

在多数据源下，涉及到多个数据库的写入。Spring的声明式事务在一次请求线程中只能对一个数据源进行控制。因为一个DataSourceTransactionManager无法完成对多数据源的控制

需要多个DataSourceTransactionManager可以完成，但@Transactional注解无法管理多个数据源，这里我们通过变通的方式让@Transactional管理多个DataSourceTransactionManager

将每个datasource都分别和一个DataSourceTransactionManager进行绑定。然后可以通过嵌套事务的方式进行调用

2. Mysql数据准备

分别创建write_db1.user和write_db2.user

mysql> create database write_db1;
Query OK, 1 row affected (0.14 sec)

mysql> create database write_db2;
Query OK, 1 row affected (0.01 sec)

mysql> create table write_db1.user (
    -> id bigint(20) auto_increment not null comment '主键ID',
    -> name varchar(30) null default null comment '姓名',
    -> primary key (id)
    -> );
Query OK, 0 rows affected, 1 warning (0.29 sec)

mysql> 
mysql> create table write_db2.user (
    -> id bigint(20) auto_increment not null comment '主键ID',
    -> name varchar(30) null default null comment '姓名',
    -> primary key (id)
    -> );
Query OK, 0 rows affected, 1 warning (0.04 sec)

mysql>

3. pom.xml依赖

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.31</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.15</version>
        </dependency>

        <!-- 支持spring 2.5.3 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>

	  <!-- 用于编程式事务 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

4. application.properties配置

指定了datasource1和datasource2两个DataSource

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

# 用于读的数据库
spring.datasource.datasource1.url=jdbc:mysql://192.168.28.12:3306/write_db1
spring.datasource.datasource1.username=root
spring.datasource.datasource1.password=Root_123
spring.datasource.datasource1.driver-class-name=com.mysql.cj.jdbc.Driver

# 用于写的数据库
spring.datasource.datasource2.url=jdbc:mysql://192.168.28.12:3306/write_db2
spring.datasource.datasource2.username=root
spring.datasource.datasource2.password=Root_123
spring.datasource.datasource2.driver-class-name=com.mysql.cj.jdbc.Driver

5. 创建两个SqlSessionFactory

5.1 DataSource1Config

其实就是将datasource1和指定的Mapper接口、Mapper.xml文件进行绑定。然后将datasource1TransactionManager和datasource1绑定，datasource1TransactionTemplate和datasource1TransactionManager进行绑定

说明：

  • 通过@MapperScan注解，指定Mapper接口的位置和SqlSessionFactory的名称
  • 指定了要连接的数据源datasource1
  • 指定了Mapper.xml文件的位置
package com.hh.springboottest.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;

import javax.sql.DataSource;


@Configuration
@MapperScan(basePackages = {"com.hh.springboottest.mapper.datasource1"},
        sqlSessionFactoryRef = "datasource1SqlSessionFactory")
public class DataSource1Config {

    @ConfigurationProperties(prefix = "spring.datasource.datasource1")
    // 向IOC容器添加name = dataSource1的DataSource
    @Bean
    public DataSource dataSource1() {
        DruidDataSource druidDataSource = new DruidDataSource();

        return druidDataSource;
    }


    @Bean
    @Primary
    public SqlSessionFactory datasource1SqlSessionFactory(@Qualifier("dataSource1") DataSource dataSource) throws Exception {

        final SqlSessionFactoryBean datasource1SqlSessionFactoryBean = new SqlSessionFactoryBean();
        // 指定数据源
        datasource1SqlSessionFactoryBean.setDataSource(dataSource);
        // 指定数据源对应的mapper.xml文件
        datasource1SqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/datasource1/*.xml"));

        return datasource1SqlSessionFactoryBean.getObject();
    }

    @Bean
    @Primary
    public DataSourceTransactionManager datasource1TransactionManager() {
        DataSourceTransactionManager datasource1TransactionManager =
                new DataSourceTransactionManager();

        datasource1TransactionManager.setDataSource(dataSource1());
        return datasource1TransactionManager;
    }

    @Bean
    public TransactionTemplate datasource1TransactionTemplate() {
        return new TransactionTemplate(datasource1TransactionManager());
    }


}

5.1 DataSource2Config

package com.hh.springboottest.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.support.TransactionTemplate;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = {"com.hh.springboottest.mapper.datasource2"},
        sqlSessionFactoryRef = "datasource2SqlSessionFactory")
public class DataSource2Config {


    @ConfigurationProperties(prefix = "spring.datasource.datasource2")
    // 向IOC容器添加name = dataSource2的DataSource
    @Bean
    public DataSource dataSource2() {
        DruidDataSource druidDataSource = new DruidDataSource();

        return druidDataSource;
    }


    @Bean
    public SqlSessionFactory datasource2SqlSessionFactory(@Qualifier("dataSource2") DataSource dataSource) throws Exception {

        final SqlSessionFactoryBean datasource2SqlSessionFactoryBean = new SqlSessionFactoryBean();
        // 指定数据源
        datasource2SqlSessionFactoryBean.setDataSource(dataSource);
        // 指定数据源对应的mapper.xml文件
        datasource2SqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:mapper/datasource2/*.xml"));

        return datasource2SqlSessionFactoryBean.getObject();
    }


    @Bean
    public DataSourceTransactionManager datasource2TransactionManager() {
        DataSourceTransactionManager datasource2TransactionManager =
                new DataSourceTransactionManager();

        datasource2TransactionManager.setDataSource(dataSource2());
        return datasource2TransactionManager;
    }


    @Bean
    public TransactionTemplate datasource2TransactionTemplate() {
        return new TransactionTemplate(datasource2TransactionManager());
    }

}

6. 动态数据源测试

6.1 创建User类

package com.hh.springboottest.myController;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

@NoArgsConstructor
@AllArgsConstructor
@Data
@ToString
public class User {

    private Long id;
    private String name;

}

6.2 Mapper接口实现

Datasource1UserMapper.java

package com.hh.springboottest.mapper.datasource1;

import com.hh.springboottest.myController.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface Datasource1UserMapper {


    public void saveUser(User user);

}

Datasource2UserMapper.java

package com.hh.springboottest.mapper.datasource2;

import com.hh.springboottest.myController.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface Datasource2UserMapper {


    public void saveUser(User user);
}

6.3 Mapper.xml实现

resources/mapper/datasource1/Datasource1UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hh.springboottest.mapper.datasource1.Datasource1UserMapper">

    <!-- public void saveUser(User user); -->
    <insert id="saveUser" parameterType="com.hh.springboottest.myController.User">
        INSERT INTO user(id, name) VALUES(#{id}, #{name})
    </insert>

</mapper>

resources/mapper/datasource2/Datasource2UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hh.springboottest.mapper.datasource2.Datasource2UserMapper">

    <!-- public void saveUser(User user); -->
    <insert id="saveUser" parameterType="com.hh.springboottest.myController.User">
        INSERT INTO user(id, name) VALUES(#{id}, #{name})
    </insert>

</mapper>

6.4 Service实现

Service接口实现

package com.hh.springboottest.service;

import com.hh.springboottest.myController.User;

public interface UserService {

    // 向datasource1的数据库插入数据
    public void datasource1SaveUser(User user);

    // 向datasource2的数据库插入数据
    public void datasource2SaveUser(User user);

    // 用于调用datasource1SaveUser和datasource2SaveUser
    public void saveMultiUser();

    // 嵌套在saveMultiUser里面进行调用
    public void saveMultiUserInner();
}

ServiceImpl实现类

说明：

  • 编程式事务：通过两层lambda表达式嵌套，实现两个数据源的统一事务管理，对异常进行捕获，然后手动进行回滚
  • 声明式事务：通过两层事务注解方法进行嵌套，实现两个数据源的统一事务管理。不能进行异常捕获，自动进行回滚，然后抛出异常
package com.hh.springboottest.service.impl;

import com.hh.springboottest.mapper.datasource1.Datasource1UserMapper;
import com.hh.springboottest.mapper.datasource2.Datasource2UserMapper;
import com.hh.springboottest.myController.User;
import com.hh.springboottest.service.UserService;
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionTemplate;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    Datasource1UserMapper datasource1UserMapper;

    @Autowired
    Datasource2UserMapper datasource2UserMapper;


    @Autowired
    TransactionTemplate datasource1TransactionTemplate;

    @Autowired
    TransactionTemplate datasource2TransactionTemplate;


    /**
     * @Description: 向datasource1的数据库插入数据
     *
     * @Params:    [user]
     * @Return:    void
     */
    @Override
    public void datasource1SaveUser(User user) {
        datasource1UserMapper.saveUser(user);
    }

    /**
     * @Description: 向datasource2的数据库插入数据
     *
     * @Params:    [user]
     * @Return:    void
     */
    @Override
    public void datasource2SaveUser(User user) {
        datasource2UserMapper.saveUser(user);
    }


    /**
    * @Description: 用于调用datasource1SaveUser和datasource2SaveUser  
    *      
    * 编程式事务方式。被0除，回滚所以插入的数据
    *
    * @Params:    []
    * @Return:    void
    */
//    public void saveMultiUser() {
//        datasource1TransactionTemplate.execute((datasource1Status)->{
//            datasource2TransactionTemplate.execute((datasource2Status)->{
//                try {
//                    datasource1SaveUser(new User(1L, "read_name1"));
//                    datasource2SaveUser(new User(1L, "write_name1"));
//                    datasource1SaveUser(new User(2L, "read_name2"));
//                    datasource2SaveUser(new User(2L, "write_name2"));
//                    Integer d = 1 / 0;
//                } catch (Exception e) {
//                    e.printStackTrace();
//                    datasource1Status.setRollbackOnly();
//                    datasource2Status.setRollbackOnly();
//                    return false;
//                }
//                return true;
//            });
//            return true;
//        });
//    }


    /**
     * @Description: 用于调用datasource1SaveUser和datasource2SaveUser
     *
     * 声明式事务方式。被0除，回滚所以插入的数据
     *
     * @Params:    []
     * @Return:    void
     */
    @Transactional(transactionManager = "datasource1TransactionManager")
    public void saveMultiUser() {
        UserService currentUserService = (UserService) AopContext.currentProxy();
        currentUserService.saveMultiUserInner();
    }


    /**
    * @Description: 嵌套在saveMultiUser里面进行调用  
    * 
    * @Params:    []
    * @Return:    void
    */
    @Transactional(transactionManager = "datasource2TransactionManager")
    public void saveMultiUserInner() {
        datasource1SaveUser(new User(1L, "read_name1"));
        datasource2SaveUser(new User(1L, "write_name1"));
        datasource1SaveUser(new User(2L, "read_name2"));
        datasource2SaveUser(new User(2L, "write_name2"));
        Integer myDiv = 1 / 0;
    }

}

6.5 测试

说明：

  • EnableTransactionManagement：开启事务控制功能
  • EnableAspectJAutoProxy注解表示开启AOP功能，exposeProxy为true表示让proxy被AOP框架当做ThreadLocal进行暴露，以便通过org.springframework.aop.framework.AopContext类进行获取，默认关闭，不能通过本类调用本类
package com.hh.springboottest;


import com.hh.springboottest.myController.User;
import com.hh.springboottest.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Slf4j
@SpringBootTest
@EnableTransactionManagement   
@EnableAspectJAutoProxy(exposeProxy = true)
public class MyApplicationTest {



    @Autowired
    UserService userService;

    @Test
    public void saveMultiUserTest() {
        userService.saveMultiUser();
    }

}

运行程序，结果如下：

2022-12-13 22:04:29.857  INFO 21468 --- [           main] com.alibaba.druid.pool.DruidDataSource   : {dataSource-2} inited

java.lang.ArithmeticException: / by zero

	at com.hh.springboottest.service.impl.UserServiceImpl.saveMultiUserInner(UserServiceImpl.java:117)
......省略部分......

数据库未插入一条数据，因为回滚了

7. AOP + 自定义注解实现事务(未测试)

这里只做了一部分的记录，并未运行进行测试

自定注解，然后通过多线程的方式执行多个事务方法

package com.hh.springboottest.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


@Component
@Aspect
public class MultiTransactionAop {

    // ComboTransaction类需要自己定义，还未定义
    private final ComboTransaction comboTransaction;

    @Autowired
    public MultiTransactionAop(ComboTransaction comboTransaction) {
        this.comboTransaction = comboTransaction
    }

    @Pointcut("within(com.hh.springboottest.service.impl.*)")
    public void pointCut() {

    }

    @Around("pointCut() && @annotation(multiTransactional)")
    public Object inMultiTransactions(ProceedingJoinPoint pjp, MultiTransactional multiTransactional) {
        return comboTransaction.inCombinedTx(() -> {
            try {
                return pjp.proceed();       // 执行目标方法
            } catch (Throwable throwable) {
                if (throwable instanceof RuntimeException) {
                    throw (RuntimeException) throwable;
                }
                throw new RuntimeException(throwable);
            }
        }, multiTransactional.value());

    }

}
Bulut0907
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java jdbc连接多个数据库
qq_42959668的博客
09-18 8539
第一次接触jdbc连接多个数据库 jdbc连接多个数据库 记录最近项目中用到了mysql数据库，并且连接多个库。网上查阅资料发现大部分让改造方法。 于是我用了最笨的办法定义变量，并且在查询的时候代入变量 一，建立jdbc连接 public class DBHelper { public static String bank =null; //这里就是定义的变量，在url里引入变量 ...
Spring Boot 整合 JdbcTemplate 多数据源
泠青沼
03-13 1648
在单数据源的情况下，Spring Boot的配置非常简单，只需要在application.properties文件中配置连接参数即可。但是往往随着业务量发展，我们通常会进行数据库拆分或是引入其他数据库，从而我们需要配置多个数据源，下面基于之前的JdbcTemplate例子介绍多数据源的配置方式
JDBC同时操作多个数据库
11-25
JDBC操作俩数据库啊、
多数据源事务控制
最新发布
qq_63431773的博客
04-12 425
在多数据源下，由于涉及到数据库的多个读写。一旦发生异常就可能会导致数据不一致的情况，在这种情况希望使用事务进行回退。但是Spring的声明式事务在一次请求线程中只能使用一个数据源进行控制但是对于多源数据库：单一事务管理器(TransactionManager)无法切换数据源，需要配置多个TransactionManager。@Transactionnal是无法管理多个数据源的。如果想真正实现多源数据库事务控制，肯定是需要分布式事务。这里讲解多源数据库事务控制的一种变通方式。
SpringBoot 配置多个JdbcTemplate
oyc的博客
09-22 4672
SpringBoot 配置多个JdbcTemplate 前言 开发中使用多数据源配置是一个非常常见的需求。Spring和SpringBoot中，对此都有相应的解决方案。 多数据源的首选分布式数据库中间件MyCat或者Sharing-Jdbc去解决相关问题。使用MyCat，然后分表策略使用shardin...
SpringBoot采用AOP基于注解的方式实现多JDBC数据源
Bulut0907
10-03 247
我们可以通过来帮我们实现动态数据源的切换，而且AbstractRoutingDataSource实现了很多DataSource的方法，稳定性更好targetDataSources：需要动态切换的所有DataSourcedefaultTargetDataSource：默认DataSourceresolvedDataSources：内部在afterPropertiesSet方法中自动从targetDataSources传递根据key从resolvedDataSources获取DataSource。
Spring Boot多数据源事务管理
热门推荐
卓立的博客
11-04 1万+
在开发企业应用时，对于使用者的一个操作实际上对应底层数据库的多个读写。由于数据操作在顺序执行的过程中，任何一步操作都有可能发生异常，异常会导致后续操作无法完成，此时由于业务逻辑并未正确的完成，之前成功操作数据的并不可靠，会产生不一致的数据，需要在这种情况下进行回退。事务的作用就是为了保证用户的每一个操作都是可靠的，事务中的每一步操作都必须成功执行，只要有发生异常就回退到事务开始未进行操作的状态。了...
详解springboot+mybatis多数据源最简解决方案
08-30
SpringBoot框架中，使用MyBatis框架来实现多数据源解决方案是非常常见的场景。本篇文章将详细介绍如何使用SpringBoot框架来实现多数据源解决方案，并提供了一个简单的解决方案供大家参考。 多数据源解决方案的必要...
SpringBoot整合mybatis-plus实现多数据源的动态切换且支持分页查询.pdf
10-07
SpringBoot整合mybatis-plus实现多数据源的动态切换且支持分页查询，案例以postgresql和oracle数据库为数据源，分别使用mybatis-plus分页插件和pagehelper分页插件实现分页查询。
springboot +mybatis+oracle 配置多个数据源,配置两个数据库信息
12-25
本配置示例将详细介绍如何在Spring Boot中整合MyBatis与Oracle数据库，并配置两个不同的数据源。 首先，我们需要理解数据源（DataSource）的概念。数据源是Java应用程序与数据库之间的桥梁，它负责管理数据库连接，...
详解SpringBoot和Mybatis配置多数据源
08-30
SpringBoot作为一个流行的Java框架，提供了非常便捷的方式来配置多数据源，并且可以与Mybatis框架进行集成。本文将详细介绍如何在SpringBoot中配置多数据源，并与Mybatis框架进行集成。 多数据源配置的必要性 在...
spring boot + mybatis(通用mapper) druid多数据源切换配置
08-14
1.配置数据源，2.动态数据源切换，3.注册动态数据源，4.动态数据源注解切点，5.通过切点切换数据源，6.在service层通过注解切换不同数据源，7.启动项目
springboot mybatis 集成多数据源 两种实现方式
06-30
在Spring Boot应用中集成MyBatis并实现多数据源，是一种常见的需求，特别是在大型系统中，可能需要连接多个数据库以实现数据隔离或者读写分离。本文将详细介绍两种不同的实现方式，分别为静态添加和动态添加数据源。...
MyBatis整合Springboot多数据源实现
Java技术攻略的博客
04-12 182
数据源，实际就是数据库连接池，负责管理数据库连接，在Springboot中，数据源通常以一个bean的形式存在于IOC容器中，也就是我们可以通过依赖注入的方式拿到数据源，然后再从数据源中获取数据库连接。那么什么是多数据源呢，其实就是IOC容器中有多个数据源的bean，这些数据源可以是不同的数据源类型，也可以连接不同的数据库。本文将对多数据如何加载，如何结合MyBatis使用进行说明，知识点脑图如下所示。数据源，其实就是数据库连接池，负责数据库连接的管理和借出。目前使用较多也是性能较优的有如下几款数据源。
springboot多数据源多事务配置
瞳孔里的阳光
05-11 1001
springboot多数据源多事务配置 工作中使用到了多数据源，网上多为主从模式，但实际工组中需要项目独立的多数据源，没有分布式事务。虽然可以拆分成多个独立的项目，但是考虑到项目成本、调试成本、协作成本等因素，放弃拆分，采用一个项目配置。以下代码仅供个人记录以及保留解决思路。 说明： 独立模式表示可配置同种类数据库不同版本 使用场景： 例1 有以下三个数据库：1）业务数据库 2）业务数据备份库 3）日志、监控数据库（数据量比较大）。 这三个数据库在不进行项目拆分情况下，需要同时配置在一个项目中，一般业务数
Spring Boot 项目中的三种多数据源方案，一个比一个强！
tuantuanyua的博客
07-24 4202
“ 摘要: 原创出处 http://www.iocoder.cn/Spring-Boot/dynamic-datasource/ 「芋道源码」欢迎转载，保留摘要，谢谢！ 1. 概述 2. 实现方式 2.1 方案一 2.2 方案二 2.3 方案三 3. baomidou 多数据源 4. baomidou 读写分离 5. MyBatis 多数据源 6. Spring Data JPA 多数据源
spring boot整合多数据源以及多数据源事务
Zhang_1994_bf的博客
11-21 292
引入jar包 <!-- https://mvnrepository.com/artifact/com.alibaba/druid --> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid</artifactId> <v...
SpringBoot配置多数据源和事务管理
weixin_43868443的博客
08-06 3172
配置第一个数据源 @Configuration public class RTxManager { public RTxManager() { } @Bean( name = {"RDBSource"} ) @ConfigurationProperties( prefix = "spring.datasource" ) @Primary public DataSource dataSource() {
springboot添加多数据源并实现事务一致性
weixin_43956650的博客
04-13 5781
写在前面 事务一致性一定要你的数据库引擎支持，我用的数据库是mysql,常见两种搜索引擎，MyISAM和InnoDb,关于它们的区别，网上很多人罗列了，我这里最重要的就是InnoDb支持事务，MyISAM不支持事务。在mysql里面，可以单独为每张表指定不同的搜索引擎，在执行下面的事务操作时，一定要确保你操作的表是支持事务的！！！（写在前面是因为，我因为一开始没有注意，所以整了两套方案，最后发现都不行，才去排查这个问题，大家不要犯跟我一样的错误呜呜呜呜呜~）。 下面开始正文： 小小的提一下关于分布式事务 事
springboot 整合druid+mybatis+jta分布式事务+多数据源aop注解动态切换
08-30
Spring Boot 是一个用于快速构建 Java 应用程序的框架。它可以与多种其他框架和组件进行整合，以实现更丰富的功能。在这里，我们将讨论如何使用 Spring Boot 整合 Druid、MyBatis、JTA 分布式事务以及多数据源，同时使用 AOP 注解实现动态切换。 首先，我们可以在 Spring Boot 中集成 Druid 数据源。Druid 是一个高性能的 JDBC 连接池，可以提供监控和统计功能。我们可以通过在 pom.xml 文件中添加相关的依赖，并在 application.properties 文件中配置数据源信息，来实现 Druid 的集成。 接下来，我们可以整合 MyBatis 框架，它是一种优秀的持久化解决方案。我们可以使用 MyBatis 来操作数据库，并将其与 Druid 数据源进行整合。为此，我们需要在 pom.xml 文件中添加 MyBatis 和 MyBatis-Spring 的依赖，并配置 MyBatis 的相关配置文件。 此外，我们还可以使用 JTA（Java Transaction API）实现分布式事务。JTA 可以在分布式环境中协调多个参与者的事务操作。我们可以在 pom.xml 文件中添加 JTA 的依赖，并在 Spring Boot 的配置文件中配置 JTA 的相关属性，以实现分布式事务的支持。 在实现多数据源时，我们可以使用 Spring Boot 的 AbstractRoutingDataSource 来实现动态切换数据源。这个类可以根据当前线程或其他条件选择不同的数据源来进行数据操作。我们可以通过继承 AbstractRoutingDataSource 并实现 determineCurrentLookupKey() 方法来指定当前数据源的 key。然后，在配置文件中配置多个数据源，并将数据源注入到 AbstractRoutingDataSource 中，从而实现动态切换。 最后，我们可以使用 AOP（Aspect Oriented Programming）注解来实现动态切换。AOP 是一种编程范式，可以通过在代码中插入特定的切面（Aspect）来实现横切关注点的处理。我们可以在代码中使用注解来标记需要切换数据源的方法，然后使用 AOP 技术来拦截这些方法，并根据注解中指定的数据源信息来进行数据源的切换。 综上所述，通过整合 Druid、MyBatis、JTA 分布式事务以及多数据源，并使用 AOP 注解实现动态切换，我们可以在 Spring Boot 中实现强大而灵活的应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值