SpringBoot_第七章(读写分离_MybatisPlus和自定义路由实现)

已于 2023-11-29 23:51:41 修改
阅读量409 收藏 3
点赞数 1
分类专栏： 框架_SpringBoot 文章标签： java
于 2023-11-01 20:28:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huyiju/article/details/134164372
版权

目录

1：MybatisPlus（读写分离）

1.1：首先创建三个数据库1主2从

1.2：代码实例

1.3：优缺点分析

2：SpringBoot路由数据源（读写分离）

2.1：实现原理

2.2：代码实现

2.3：测试代码 

2.4：优缺点分析

这里列举了两种读写分离实现方案,如下

1：MybatisPlus（读写分离）

1.1：首先创建三个数据库1主2从

表名是user表

1.2：代码实例

1：导入pom


        <!--MybatisPlus的jar 3.0基于jdk8-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.1</version>
        </dependency>

        <!-- mybatisPlus多数据源依赖  实现读写分离-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
            <version>3.6.1</version>
        </dependency>

        <!-- mysql的依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>

        <!--直接使用druid的starter 连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.16</version>
        </dependency>

2：配置spring的主从

server:
  port: 8082

spring:
  datasource:
    dynamic:
      primary: master #设置默认的数据源或者数据源组,默认值即为master
      strict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
      datasource:
        master:
          url: jdbc:mysql://localhost:3306/W1?useUnicode=true&characterEncoding=utf-8&useSSL=false
          username: root
          password: 123456
          driver-class-name: com.mysql.cj.jdbc.Driver
          type: com.alibaba.druid.pool.DruidDataSource #配置德鲁伊数据源
          druid:
            initial-size: 10 #连接池初始化大小
            min-idle: 10 #最小空闲连接数
            max-active: 20 #最大连接数

        slave_1:
          url: jdbc:mysql://localhost:3306/W1R1?useUnicode=true&characterEncoding=utf-8&useSSL=false
          username: root
          password: 123456
          driver-class-name: com.mysql.cj.jdbc.Driver
          type: com.alibaba.druid.pool.DruidDataSource #配置德鲁伊数据源
          druid:
            initial-size: 10 #连接池初始化大小
            min-idle: 10 #最小空闲连接数
            max-active: 20 #最大连接数
        slave_2:
          url: jdbc:mysql://localhost:3306/W1R2?useUnicode=true&characterEncoding=utf-8&useSSL=false
          username: root
          password: 123456
          driver-class-name: com.mysql.cj.jdbc.Driver
          type: com.alibaba.druid.pool.DruidDataSource #配置德鲁伊数据源
          druid:
            initial-size: 10 #连接池初始化大小
            min-idle: 10 #最小空闲连接数
            max-active: 20 #最大连接数


        #......省略
        #以上会配置一个默认库master，一个组slave下有两个子库slave_1,slave_2

3：代码实例 @DS("slave") 注解用来切换数据源

/**
* @description 针对表【User】的数据库操作Service实现
* @createDate 2023-11-01 17:17:57
*/
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService{


    @Resource
    UserMapper userMapper;
    
    //多个从库 负载均衡轮训查询 也可以注解到类上
    //@DS("slave")
    @DS("slave")
    public User selectRW_S(Integer id) {
        return userMapper.selectById(id);
    }
    //主库查询数据
    //@DS("master")
    @DS("master")
    public User selectRW_M(Integer id) {
        return userMapper.selectById(id);
    }

    //无注解，不指定数据, 默认查询主库
    @Override
    public User selectRW(Integer id) {
        return userMapper.selectById(id);
    }
}

controller代码根据请求不同访问不同的数据源

@RestController
public class UserControllerRW {

    @Resource
    UserServiceImpl userService;

    //查询主库 @DS("master")
    @GetMapping(value = "selectRW1")
    public User selectRW_M(@RequestParam(name = "id",required = true) Integer id){
        User user = userService.selectRW_M(id);
        System.out.println(user);
        return user;
    }

    //查询从库 @DS("slave") 轮训查询
    @GetMapping(value = "selectRW2")
    public User selectRW_S(@RequestParam(name = "id",required = true) Integer id){
        User user = userService.selectRW_S(id);
        System.out.println(user);
        return user;
    }

    //无注解，不指定数据, 默认查询主库
    @GetMapping(value = "selectRW3")
    public User selectRW(@RequestParam(name = "id",required = true) Integer id){
        User user = userService.selectRW(id);
        System.out.println(user);
        return user;
    }
}

查询结果截图

1.3：优缺点分析

dynamic-datasource的jar包的官方文档

基础必读（免费） · dynamic-datasource · 看云

本框架只做切换数据的事情，不限制你的具体操作，从库也可以增删改查，读写分离只是他的一个小功能，分库分表要自己实现

  • 支持 数据源分组 ，适用于多种场景 纯粹多库 读写分离 一主多从 混合模式。
  • 支持数据库敏感配置信息 加密(可自定义) ENC()。
  • 支持每个数据库独立初始化表结构schema和数据库database。
  • 支持无数据源启动，支持懒加载数据源（需要的时候再创建连接）。
  • 支持 自定义注解 ，需继承DS(3.2.0+)。
  • 提供并简化对Druid，HikariCp，BeeCp,Dbcp2的快速集成。
  • 提供对Mybatis-Plus，Quartz，ShardingJdbc，P6sy，Jndi等组件的集成方案。
  • 提供 自定义数据源来源 方案（如全从数据库加载）。
  • 提供项目启动后 动态增加移除数据源 方案。
  • 提供Mybatis环境下的 纯读写分离 方案。
  • 提供使用 spel动态参数 解析数据源方案。内置spel，session，header，支持自定义。
  • 支持 多层数据源嵌套切换 。（ServiceA >>> ServiceB >>> ServiceC）。
  • 提供 基于seata的分布式事务方案 。
  • 提供 本地多数据源事务方案。

2：SpringBoot路由数据源（读写分离）

2.1：实现原理

实现方案是通过在spring容器中注入多个数据源，通过不同的key来找到指定的数据源，AbstractRoutingDataSource的源码知道，AbstractRoutingDataSource里边通过Map可以过个数据源，通过key查找。

2.2：代码实现

1：maven依赖 

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

     
        <!--mybatis依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.2</version>
        </dependency>

        <!--aop依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>


        <!-- mysql的依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.33</version>
        </dependency>

        <!--直接使用druid的starter 连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.16</version>
        </dependency>
        
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>

    </dependencies>

2：配置数据源的1主2从的application.properties

#读写分离数据源配置
#读写分离数据源配置
#配置主数据库
spring.datasource.master.jdbc-url=jdbc:mysql://localhost:3306/W1?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.master.username=root
spring.datasource.master.password=123456
spring.datasource.master.driver-class-name=com.mysql.cj.jdbc.Driver

#配置读数据库1
spring.datasource.read1.jdbc-url=jdbc:mysql://localhost:3306/W1R1?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.read1.username=root
spring.datasource.read1.password=123456
spring.datasource.read1.driver-class-name=com.mysql.cj.jdbc.Driver


#配置读数据库2
spring.datasource.read2.jdbc-url=jdbc:mysql://localhost:3306/W1R2?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.read2.username=root
spring.datasource.read2.password=123456
spring.datasource.read2.driver-class-name=com.mysql.cj.jdbc.Driver

3：代码注入多个数据源

@Configuration
public class MyDataSourceConfig {

    /**
     * 主库
     * @return
     */
    @Bean(value = "master")
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource masterDataSource(){
        return DataSourceBuilder.create().build();
    }

    /**
     * 从库1
     * @return
     */
    @Bean(value = "read1")
    @ConfigurationProperties(prefix = "spring.datasource.read1")
    public DataSource read1DataSource(){
        return DataSourceBuilder.create().build();
    }


    /**
     * 从库2
     * @return
     */
    @Bean(value = "read2")
    @ConfigurationProperties(prefix = "spring.datasource.read2")
    public DataSource read2DataSource(){
        return DataSourceBuilder.create().build();
    }


    /**
     * 配置4个数据源 1个路由数据源 3个自定义数据源
     * 自定义的路由数据源
     * @return
     */
    @Bean(value = "myRoutingDataSource")
    public DataSource myRoutingDataSource(@Qualifier(value="master")DataSource master,
                                        @Qualifier(value="read1")DataSource read1,
                                        @Qualifier(value="read2") DataSource read2){

        //自定义路由数据源
        MyRoutingDataSource routingDataSource=new MyRoutingDataSource();
        //目标数据源 master  read1 read2
        Map<Object, Object> targetDataSources=new HashMap<>();
        targetDataSources.put("master",master);
        targetDataSources.put("read1",read1);
        targetDataSources.put("read2",read2);
        //放入默认数据源是 master
        routingDataSource.setDefaultTargetDataSource(master);
        routingDataSource.setTargetDataSources(targetDataSources);
        return routingDataSource;
    }


}

 4：数据源切换代码实现

public class DBContextHolder {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal();
    private static final AtomicInteger count = new AtomicInteger(1);

    //ThreadLocal的get、set方法设置数据源
    public static String get() {
        return contextHolder.get();
    }
    public static void set(String dataSource) {
        contextHolder.set(dataSource);
    }

    public static void remove() {
        contextHolder.remove();
    }

    /**
     * 获取 主数据库
     */
    public static void master() {
        set("master");
        System.out.println("切换到master数据源");
    }

    /**
     * 获取从数据库 随机获取 或者随机获取
     */
    public static void read() {
//        //轮询数据源进行读操作
//        Random random=new Random();
//        int index = random.nextInt(10);
//        System.out.println("随机数："+index);
//        if(index>5){
//            set("read1");
//            System.out.println("切换到read1数据源");
//        }else {
//            set("read2");
//            System.out.println("切换到read2数据源");
//        }

        int index = count.getAndIncrement()%2;
        System.out.println("模数：" + index);
        System.out.println("随机数：" + count);

        //轮询数据源进行读操作
        if (count.get() > 10) {
            count.set(1);
        }
        if (index == 0) {
            set("read1");
            System.out.println("切换到slave1数据源");
        } else {
            set("read2");
            System.out.println("切换到slave2数据源");
        }

    }

    public static void main(String[] args) {
        //轮询数据源进行读操作
        Random random = new Random();
        int index = random.nextInt(10);
        System.out.println(index);
    }

}

5：获取路由数据源

/**
 * 自定义路由数据源 继承AbstractRoutingDataSource
 */
public class MyRoutingDataSource extends AbstractRoutingDataSource {

    /**
     *  通过指定的key来确认当前的数据源方法
     *
     *  目标数据源 master  read1  read2
     *         Map<Object, Object> targetDataSources=new HashMap<>();
     *         targetDataSources.put("master",master);
     *         targetDataSources.put("read1",read1);
     *         targetDataSources.put("read2",read2);
     *
     *
     *  根据Aop 在执行不同方法之前  设置不同的数据源的key
     */

    @Override
    protected Object determineCurrentLookupKey() {
        return DBContextHolder.get();
    }
}

 6：mybatis的数据源配置

/**
 * mybatis的数据源配置
 * 由于Spring容器中现在有4个数据源，所以我们需要为事务管理器和MyBatis手动指定一个明确的数据源。
 */
@Configuration
public class MyBatisConfig {

    @Resource(name = "myRoutingDataSource")
    private DataSource myRoutingDataSource;

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(myRoutingDataSource);
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
        return sqlSessionFactoryBean.getObject();
    }

    @Bean
    public PlatformTransactionManager platformTransactionManager() {
        return new DataSourceTransactionManager(myRoutingDataSource);
    }
}

7：AOP切入处理，在service方法中通过切面提前设置数据源的key

@Aspect
@Component
public class DataSourceAop {

    /**
     * 不存在自定义的Master注解
     * 所有service包下的的所有select和get方法 
     * 设置为读从库数据
     */
    @Pointcut("!@annotation(com.example.springboot08_rw1.annotation.Master) " +
            "&& (execution(* com.example.springboot08_rw1.service..*.select*(..)) " +
            "|| execution(* com.example.springboot08_rw1.service..*.get*(..)))")
    public void readPointcut() {

    }

    /**
     * 存在Master注解或者add insert等方法 去主库操作
     */
    @Pointcut("@annotation(com.example.springboot08_rw1.annotation.Master) " +
            "|| execution(* com.example.springboot08_rw1.service..*.insert*(..)) " +
            "|| execution(* com.example.springboot08_rw1.service..*.add*(..)) " +
            "|| execution(* com.example.springboot08_rw1.service..*.update*(..)) " +
            "|| execution(* com.example.springboot08_rw1.service..*.edit*(..)) " +
            "|| execution(* com.example.springboot08_rw1.service..*.delete*(..)) " +
            "|| execution(* com.example.springboot08_rw1.service..*.remove*(..))")
    public void writePointcut() {
    }


    @Before("readPointcut()")
    public void read() {
        DBContextHolder.read();
    }


    @Before("writePointcut()")
    public void write() {
        DBContextHolder.master();
    }

//    /**
//     * 另一种写法：if...else...  判断哪些需要读从数据库，其余的走主数据库
//     */
//    @Before("execution(* com.example.springboot08_rw1.service.UserServiceImpl.select*(..))")
//    public void before(JoinPoint jp) {
//        String methodName = jp.getSignature().getName();
//        System.out.println("方法名字:"+methodName);
        if (StringUtils.startsWithAny(methodName, "get", "select", "find")) {
        }else {
            DBContextHolder.master();
        }
//
//        DBContextHolder.read();
//
//    }

}




//自定义注解

public @interface Master {
}

2.3：测试代码 

service代码

@Service
public class UserServiceImpl implements  UserService {
    @Resource
    UserMapper userMapper;
    
    /**
     * 添加自定义注解  @Master 主库查询
     */
    @Master
    public User selectById_Master(Integer id) {
        return userMapper.selectById(1);
    }

    /**
     *  不使用注解  走从库查询
     */
    public User selectById_MoRen(Integer id) {
        return userMapper.selectById(1);
    }

    /**
     * 不使用注解 add方法 走主库
     */
    public User add(Integer id) {
        return userMapper.selectById(1);
    }
}

controller层的代码测试

@RestController
public class UserController {

    @Autowired
    UserServiceImpl userService;

    //两个从库切换查询
    @GetMapping(value = "selectUser")
    public User select(){
       return userService.selectById_MoRen(1);
    }
    //使用注解 查询主库
    @GetMapping(value = "selectUser1")
    public User select1(){
        return userService.selectById_Master(1);
    }
    //方法是add 查询主库
    @GetMapping(value = "selectUser2")
    public User select2(){
        return userService.add(1);
    }
}

页面效果

http://localhost:8082/selectUser两个从切换查询

http://localhost:8082/selectUser1主库查询

http://localhost:8082/selectUser2主库查询

2.4：优缺点分析

SpringBoot读写分离_springboot 读写分离-CSDN博客

代码比较复杂，需要制定好spring的数据源切换的基础原理，分库分表代码进一步负载话

浅水壁虎
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis Plus轻松实现数据读写分离
qq_30895747的博客
12-24 979
这个拦截器会在方法执行前根据注解来选择数据源，如果方法上有 `@ReadDataSource` 注解，则选择读数据源，如果方法上有 `@WriteDataSource` 注解，则选择写数据源，否则默认使用写数据源。通过以上配置，你可以在 Service 层的方法上使用 `@ReadDataSource` 和 `@WriteDataSource` 注解来标识读操作和写操作，拦截器会根据注解选择相应的数据源。在这个示例中，`write` 数据源代表主数据库，`read` 数据源代表从数据库。
springboot+druid+mybatisplus+sharding-jdbc读写分离
SampsonKong的博客
01-13 401
springboot+druid+mybatisplus+sharding-jdbc读写分离
Java：SpringBoot整合Sharding-Jdbc实现数据库读写分离
彭世瑜的博客
02-09 687
读写分离实现效果：写操作使用master主库，读操作使用slave从库。数据库连接池使用druid，项目启动报错，使用hikari成功启动。配置 application.yml。完整依赖 pom.xml。
mybatis-plus读写分离
chenz_sai的博客
08-03 3349
mybatis-plus读写分离demo。
mybatis-plus实现代码层面的读写分离
u012017645的专栏
12-03 1470
一、添加mybatis-plus相关依赖 <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.3.0</version> </dependency> <dependency> <groupId>
mybatis-plus 动态数据源读写分离
json8888的博客
09-27 811
这里要注意需要把“argument”进行类型的判断，argument 就是你查询Mapper的参数，这里我获取的是argument[0]，则Mapper参数的位置在第一个。在实际项目的开发过程中，一定会存在主库与从库的分布式模式，主库进行增删改，从库进行查询。这样可以保证对不同的数据库进行操作，减少对数据库的压力。调用上面的addDatasource()方法，数据源就会创建成功，这里要注意的是，每一次增删改查都需要调用此方法，以防数据源不存在。实现DynamicDatasourceService。
SpringBoot+MyBatisPlus实现读写分离
最新发布
sloveb123的博客
06-20 652
随着业务量的不断增长，数据库的读写压力也越来越大。为了解决这个问题，我们可以采用读写分离的方案来分担数据库的读写负载。本文将介绍如何使用 Spring Boot + MyBatis Plus + MySQL 实现读写分离。通过本文的介绍，我们了解了如何使用 Spring Boot + MyBatis Plus + MySQL 实现读写分离。读写分离可以有效地分担数据库的读写负载，提高数据库的性能和可用性。希望本文能对读写分离的实现有所帮助。
ShardingSphere:SpringBoot2+MybatisPlus+读写分离+分库分表
06-17
ShardingSphere:SpringBoot2+MybatisPlus+读写分离+分库分表 课程目标 快速的掌握读写分离+分表的实战，即插即用适用人群IT从业人员，开发人员，Java从业者，互联网从业者，性能调优人群课程简介 ShardingSphere是...
springboot+mysql读写分离
07-29
springboot结合mysql主从来实现读写分离 一、实现的功能 1、基于springboot框架，application.yml配置多个数据源，使用AOP以及AbstractRootingDataSource、ThreadLocal来实现多数据源切换，以实现读写分离。mysql...
ShardingSphere:SpringBoot2+MybatisPlus读写分离+分表
06-17
他们均提供标准化的数据分片、读写分离、柔性事务和数据治理功能，可适用于如Java同构、异构语言、容器、云原生等各种多样化的应用场景。Sharding-JDBC可以通过Java，YAML，Spring命名空间和Spring Boot S
MyBatis做读写分离
08-28
MyBatis做读写分离
SpringBoot+MybatisPlus多数据源配置，主从库读写分离完整例子
03-20
具体介绍可以查看楼主博客：http://blog.csdn.net/fjekin/article/details/79583744
springboot+mybatis+druid+redis实现数据库读写分离和缓存
04-12
在现代Web应用开发中，数据库读写分离和缓存技术是提高系统性能和可扩展性的关键策略。本项目采用SpringBoot、MyBatis、Druid和Redis这四个核心技术来实现这一目标。以下将详细讲解这些组件如何协同工作，以及它们...
Springboot + Mysql8实现读写分离功能
08-25
在 Springboot 应用程序中，实现读写分离功能可以通过配置多个数据源和 RoutingDataSource 实现。下面将详细介绍 Springboot + Mysql8 实现读写分离功能的步骤： 1. 安装和配置 Mysql8 数据库 在实现读写分离功能...
使用springboot aop来实现读写分离和事物配置
08-19
使用SpringBoot AOP实现读写分离和事务配置 使用SpringBoot AOP来实现读写分离和事务配置是当前流行的技术方案之一。本文将详细介绍使用SpringBoot AOP来实现读写分离和事务配置的原理、实现步骤和配置方法。 一、...
Mybatis-Plus 实战教程
技术老鸟
12-04 1753
1.1 什么是mybatis-plus 官网:https://mybatis.plus/guide/ MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 1.2 官方愿景 1.3 特性 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量
Mybatis读写分离
ooaash的博客
06-19 473
现成工具介绍 MyCat 活跃的、性能好的开源数据库中间件。它是一个透明化的数据库代理端，在生产环境使用需要保证服务的高可用。 ShardingSphere ShardingSphere由 JDBC、Proxy 和 Sidecar（规划中）这 3 款既能够独立部署，又支持混合部署配合使用的产品组成。其中ShardingSphere-Proxy与MyCat是相同的定位，而ShardingSphere-JDBC在 Java 的 JDBC 层提供的额外服务。 SpringBoot集成ShardingSphere-
mybatis实现读写分离
zchlove137的博客
08-01 2299
现网生产环境mysql基本上都会采用多主多从的集群模式，能够同时提高读和写的并发性能。那么在微服务中如何在不同的业务操作不同的库又同时对代码没有侵入性呢？在此给出两种常用的方式：1、spring aop的方式动态拦截切换数据源 2、采用mybatis-plus的方式，通过注解和配置的方式简单实现。无论哪一种方式在同一个被拦截的service层，不通过spring bean容器管理进行调用都无法有效切换数据源
SpringBoot整合MyCat实现读写分离的方法
08-19
主要介绍了SpringBoot整合MyCat实现读写分离的方法，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
springboot+mybatisplus+druid实现读写分离
05-05
实现读写分离可以利用 SpringBoot、MybatisPlus 和 Druid 进行配置。下面是一个简单的实现过程： 1. 添加 MybatisPlus 和 Druid 的 Maven 依赖。 ```xml <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.4.0</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.2.6</version> </dependency> ``` 2. 在配置文件中添加 Druid 数据源相关配置。 ```yaml spring: datasource: username: root password: 123456 url: jdbc:mysql://localhost:3306/db_name?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai driver-class-name: com.mysql.cj.jdbc.Driver type: com.alibaba.druid.pool.DruidDataSource druid: initialSize: 5 maxActive: 10 minIdle: 5 maxWait: 60000 timeBetweenEvictionRunsMillis: 60000 validationQuery: SELECT 1 FROM DUAL testWhileIdle: true testOnBorrow: false testOnReturn: false poolPreparedStatements: true maxPoolPreparedStatementPerConnectionSize: 20 filters: stat,wall,log4j connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000 ``` 3. 配置 MybatisPlus 的多数据源功能。 ```java @Configuration public class DataSourceConfig { @Bean @ConfigurationProperties(prefix = "spring.datasource.master") public DataSource masterDataSource() { return DruidDataSourceBuilder.create().build(); } @Bean @ConfigurationProperties(prefix = "spring.datasource.slave") public DataSource slaveDataSource() { return DruidDataSourceBuilder.create().build(); } @Bean public DynamicDataSource dynamicDataSource(@Qualifier("masterDataSource") DataSource masterDataSource, @Qualifier("slaveDataSource") DataSource slaveDataSource) { Map<Object, Object> targetDataSources = new HashMap<>(); targetDataSources.put(DataSourceType.MASTER.getType(), masterDataSource); targetDataSources.put(DataSourceType.SLAVE.getType(), slaveDataSource); return new DynamicDataSource(masterDataSource, targetDataSources); } } ``` 4. 创建一个 DataSourceHolder 类，用于保存当前线程的数据源类型。 ```java public class DataSourceHolder { private static final ThreadLocal<String> HOLDER = new ThreadLocal<>(); public static String getDataSource() { return HOLDER.get(); } public static void setDataSource(String dataSource) { HOLDER.set(dataSource); } public static void clearDataSource() { HOLDER.remove(); } } ``` 5. 创建一个枚举类型 DataSourceType，用于表示数据源类型。 ```java public enum DataSourceType { MASTER("master"), SLAVE("slave"); private final String type; DataSourceType(String type) { this.type = type; } public String getType() { return type; } } ``` 6. 创建一个 DynamicDataSource 类，继承 AbstractRoutingDataSource，用于动态切换数据源。 ```java public class DynamicDataSource extends AbstractRoutingDataSource { private final Map<Object, Object> targetDataSources; public DynamicDataSource(DataSource defaultDataSource, Map<Object, Object> targetDataSources) { super.setDefaultTargetDataSource(defaultDataSource); this.targetDataSources = targetDataSources; super.setTargetDataSources(targetDataSources); super.afterPropertiesSet(); } @Override protected Object determineCurrentLookupKey() { return DataSourceHolder.getDataSource(); } @Override public void setTargetDataSources(Map<Object, Object> targetDataSources) { this.targetDataSources.putAll(targetDataSources); super.setTargetDataSources(this.targetDataSources); super.afterPropertiesSet(); } @Override public void addTargetDataSource(Object key, Object dataSource) { this.targetDataSources.put(key, dataSource); super.setTargetDataSources(this.targetDataSources); super.afterPropertiesSet(); } } ``` 7. 创建一个 AopDataSourceConfig 类，用于配置切面，实现动态切换数据源。 ```java @Configuration public class AopDataSourceConfig { @Bean public DataSourceAspect dataSourceAspect() { return new DataSourceAspect(); } } ``` ```java @Aspect public class DataSourceAspect { @Pointcut("@annotation(com.example.demo.annotation.Master) " + "|| execution(* com.example.demo.service..*.select*(..)) " + "|| execution(* com.example.demo.service..*.get*(..)) " + "|| execution(* com.example.demo.service..*.query*(..)) " + "|| execution(* com.example.demo.service..*.find*(..)) " + "|| execution(* com.example.demo.service..*.count*(..))") public void read() { } @Pointcut("execution(* com.example.demo.service..*.insert*(..)) " + "|| execution(* com.example.demo.service..*.update*(..)) " + "|| execution(* com.example.demo.service..*.delete*(..))") public void write() { } @Around("read()") public Object read(ProceedingJoinPoint joinPoint) throws Throwable { try { DataSourceHolder.setDataSource(DataSourceType.SLAVE.getType()); return joinPoint.proceed(); } finally { DataSourceHolder.clearDataSource(); } } @Around("write()") public Object write(ProceedingJoinPoint joinPoint) throws Throwable { try { DataSourceHolder.setDataSource(DataSourceType.MASTER.getType()); return joinPoint.proceed(); } finally { DataSourceHolder.clearDataSource(); } } } ``` 8. 在 Service 层的方法上使用 @Master 注解，表示强制使用主库。 ```java @Service public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService { @Override @Master public boolean save(User user) { return super.save(user); } } ``` 这样就实现了读写分离功能。需要注意的是，在使用 MybatisPlus 进行 CRUD 操作时，需要使用对应的 Service 方法，例如 selectList、selectPage、insert、updateById、deleteById，而不是直接调用 Mapper 方法。否则，数据源切换将不会生效。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值