Spring Boot + MyBatis + MySQL读写分离

最新推荐文章于 2024-06-21 15:34:27 发布
最新推荐文章于 2024-06-21 15:34:27 发布
阅读量124 收藏
点赞数
文章标签： 数据库 mysql java mybatis spring
原文链接：https://mp.weixin.qq.com/s?__biz=MzUxOTAxODc2Mg==&mid=2247491506&idx=1&sn=25d874d24963e83672c44a445ac5d615&chksm=f9815fd7cef6d6c119a611dfa6786cfb70547b5c98ec2abbb9f98f5f1c64b8a82fa2fa4875df&scene=126&&sessionid=0
版权

往期热门文章：

 
 
 
 
 
 
1、从MySQL 5.6升级到8.0，Facebook付出了惨痛代价……
2、吊打 ThreadLocal，谈谈FastThreadLocal为啥能这么快？
3、手写了一个简单的JSON解析器，网友直乎：牛！
4、代码写的垃圾被嫌弃？
5、Redis的这些拓展方案
 
 
1.  引言
 
 
 
 
读写分离要做的事情就是对于一条SQL该选择哪个数据库去执行，至于谁来做选择数据库这件事儿，无非两个，要么中间件帮我们做，要么程序自己做。因此，一般来讲，读写分离有两种实现方式。
 
 
第一种是依靠中间件（比如：MyCat），也就是说应用程序连接到中间件，中间件帮我们做SQL分离；第二种是应用程序自己去做分离。这里我们选择程序自己来做，主要是利用Spring提供的路由数据源，以及AOP。
 
 
然而，应用程序层面去做读写分离最大的弱点（不足之处）在于无法动态增加数据库节点，因为数据源配置都是写在配置中的，新增数据库意味着新加一个数据源，必然改配置，并重启应用。当然，好处就是相对简单。
 
 
fe551c9fc7944e769639cce49f292668.png
 
 
2.  AbstractRoutingDataSource
 
 
 
 
基于特定的查找key路由到特定的数据源。它内部维护了一组目标数据源，并且做了路由key与目标数据源之间的映射，提供基于key查找数据源的方法。
 
 
aaec211bba687ddf3973220f6423ee06.png
 
 
3.  实践
 
 
 
 
关于配置请参考《MySQL主从复制配置》
 
 
地址：www.cnblogs.com/cjsblog/p/9706370.html
 
 
3.1.  maven依赖
 
 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.cjs.example</groupId>
    <artifactId>cjs-datasource-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>cjs-datasource-demo</name>
    <description></description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>


            <!--<plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.5</version>
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>5.1.46</version>
                    </dependency>
                </dependencies>
                <configuration>
                    <configurationFile>${basedir}/src/main/resources/myBatisGeneratorConfig.xml</configurationFile>
                    <overwrite>true</overwrite>
                </configuration>
                <executions>
                    <execution>
                        <id>Generate MyBatis Artifacts</id>
                        <goals>
                            <goal>generate</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>-->

        </plugins>
    </build>
</project>
 
 
3.2.  数据源配置
 
 
application.yml
 
 
spring:
  datasource:
    master:
      jdbc-url: jdbc:mysql://192.168.102.31:3306/test
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
    slave1:
      jdbc-url: jdbc:mysql://192.168.102.56:3306/test
      username: pig # 只读账户
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
    slave2:
      jdbc-url: jdbc:mysql://192.168.102.36:3306/test
      username: pig # 只读账户
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
 
 
多数据源配置
 
 
/**
 * 关于数据源配置，参考SpringBoot官方文档第79章《Data Access》
 * 79. Data Access
 * 79.1 Configure a Custom DataSource
 * 79.2 Configure Two DataSources
 */

@Configuration
public class DataSourceConfig {

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

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

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

    @Bean
    public DataSource myRoutingDataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
                                          @Qualifier("slave1DataSource") DataSource slave1DataSource,
                                          @Qualifier("slave2DataSource") DataSource slave2DataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DBTypeEnum.MASTER, masterDataSource);
        targetDataSources.put(DBTypeEnum.SLAVE1, slave1DataSource);
        targetDataSources.put(DBTypeEnum.SLAVE2, slave2DataSource);
        MyRoutingDataSource myRoutingDataSource = new MyRoutingDataSource();
        myRoutingDataSource.setDefaultTargetDataSource(masterDataSource);
        myRoutingDataSource.setTargetDataSources(targetDataSources);
        return myRoutingDataSource;
    }

}
 
 
这里，我们配置了4个数据源，1个master，2两个slave，1个路由数据源。前3个数据源都是为了生成第4个数据源，而且后续我们只用这最后一个路由数据源。
 
 
MyBatis配置
 
 
@EnableTransactionManagement
@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);
    }
}
 
 
由于 Spring 容器中现在有4个数据源，所以我们需要为事务管理器和MyBatis手动指定一个明确的数据源。
 
 
3.3.  设置路由key / 查找数据源
 
 
目标数据源就是那前3个这个我们是知道的，但是使用的时候是如果查找数据源的呢？
 
 
首先，我们定义一个枚举来代表这三个数据源
 
 
package com.cjs.example.enums;

public enum DBTypeEnum {

    MASTER, SLAVE1, SLAVE2;

}
 
 
接下来，通过ThreadLocal将数据源设置到每个线程上下文中
 
 
public class DBContextHolder {

    private static final ThreadLocal<DBTypeEnum> contextHolder = new ThreadLocal<>();

    private static final AtomicInteger counter = new AtomicInteger(-1);

    public static void set(DBTypeEnum dbType) {
        contextHolder.set(dbType);
    }

    public static DBTypeEnum get() {
        return contextHolder.get();
    }

    public static void master() {
        set(DBTypeEnum.MASTER);
        System.out.println("切换到master");
    }

    public static void slave() {
        // 轮询
        int index = counter.getAndIncrement() % 2;
        if (counter.get() > 9999) {
            counter.set(-1);
        }
        if (index == 0) {
            set(DBTypeEnum.SLAVE1);
            System.out.println("切换到slave1");
        }else {
            set(DBTypeEnum.SLAVE2);
            System.out.println("切换到slave2");
        }
    }

}
 
 
获取路由key
 
 
package com.cjs.example.bean;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.lang.Nullable;

public class MyRoutingDataSource extends AbstractRoutingDataSource {
    @Nullable
    @Override
    protected Object determineCurrentLookupKey() {
        return DBContextHolder.get();
    }

}
 
 
设置路由key
 
 
默认情况下，所有的查询都走从库，插入/修改/删除走主库。我们通过方法名来区分操作类型（CRUD）
 
 
@Aspect
@Component
public class DataSourceAop {

    @Pointcut("!@annotation(com.cjs.example.annotation.Master) " +
            "&& (execution(* com.cjs.example.service..*.select*(..)) " +
            "|| execution(* com.cjs.example.service..*.get*(..)))")
    public void readPointcut() {

    }

    @Pointcut("@annotation(com.cjs.example.annotation.Master) " +
            "|| execution(* com.cjs.example.service..*.insert*(..)) " +
            "|| execution(* com.cjs.example.service..*.add*(..)) " +
            "|| execution(* com.cjs.example.service..*.update*(..)) " +
            "|| execution(* com.cjs.example.service..*.edit*(..)) " +
            "|| execution(* com.cjs.example.service..*.delete*(..)) " +
            "|| execution(* com.cjs.example.service..*.remove*(..))")
    public void writePointcut() {

    }

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

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


    /**
     * 另一种写法：if...else... 判断哪些需要读从数据库，其余的走主数据库
     */
// @Before("execution(* com.cjs.example.service.impl.*.*(..))")
// public void before(JoinPoint jp) {
// String methodName = jp.getSignature().getName();
//
// if (StringUtils.startsWithAny(methodName, "get", "select", "find")) {
// DBContextHolder.slave();
// }else {
// DBContextHolder.master();
// }
// }
}
 
 
有一般情况就有特殊情况，特殊情况是某些情况下我们需要强制读主库，针对这种情况，我们定义一个主键，用该注解标注的就读主库
 
 
package com.cjs.example.annotation;

public @interface Master {
}
 
 
例如，假设我们有一张表member
 
 
@Service
public class MemberServiceImpl implements MemberService {

    @Autowired
    private MemberMapper memberMapper;

    @Transactional
    @Override
    public int insert(Member member) {
        return memberMapper.insert(member);
    }

    @Master
    @Override
    public int save(Member member) {
        return memberMapper.insert(member);
    }

    @Override
    public List<Member> selectAll() {
        return memberMapper.selectByExample(new MemberExample());
    }

    @Master
    @Override
    public String getToken(String appId) {
        // 有些读操作必须读主数据库
        // 比如，获取微信access_token，因为高峰时期主从同步可能延迟
        // 这种情况下就必须强制从主数据读
        return null;
    }
}
 
 
4.  测试
 
 
@RunWith(SpringRunner.class)
@SpringBootTest
public class CjsDatasourceDemoApplicationTests {

    @Autowired
    private MemberService memberService;

    @Test
    public void testWrite() {
        Member member = new Member();
        member.setName("zhangsan");
        memberService.insert(member);
    }

    @Test
    public void testRead() {
        for (int i = 0; i < 4; i++) {
            memberService.selectAll();
        }
    }

    @Test
    public void testSave() {
        Member member = new Member();
        member.setName("wangwu");
        memberService.save(member);
    }

    @Test
    public void testReadFromMaster() {
        memberService.getToken("1234");
    }

}
 
 
查看控制台
 
 
d31c29949901cde5bfb6370e4232bef5.png
 
 
0bf829e7947c8501d0815842292ad630.png
 
 
a40341f0fe5e91982d37a18b17a02f83.png
 
 
4a38383f4795476e1b9d406077124549.png
 
 
5.  工程结构
 
 
 
 
e10225f3b8527669d3001d87351b78ab.png
 
 
6.  参考
 
 
https://www.jianshu.com/p/f2f4256a2310
http://www.cnblogs.com/gl-developer/p/6170423.html
https://www.cnblogs.com/huangjuncong/p/8576935.html
https://blog.csdn.net/liu976180578/article/details/77684583
 
 
 
 
 
 
 
 
 
 
 
 
最近热文阅读：
 
 
 
 
1、从MySQL 5.6升级到8.0，Facebook付出了惨痛代价……
 
 
2、吊打 ThreadLocal，谈谈FastThreadLocal为啥能这么快？
 
 
3、手写了一个简单的JSON解析器，网友直乎：牛！
 
 
4、代码写的垃圾被嫌弃？
 
 
5、Redis的这些拓展方案
 
 
6、MySQL的自增 ID 用完了，怎么办？
 
 
7、多线程环境下，HashMap为什么会出现死循环？
 
 
8、10个经典场景带你玩转SQL优化
 
 
9、你真的会写for循环吗？来看看这些常见的for循环优化方式
 
 
10、编写Spring MVC控制器的14个技巧
 
 
792e77ff641d1aa011c7be45dd16f7d3.png
 
 
关注公众号，你想要的Java都在这里
 


                

        

        

    




    

      

        

            

              
                
                  Java之间
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
springboot+mysql读写分离

				
			

			

				

					07-29
				

			

		

		

			
				
springboot结合mysql主从来实现读写分离

一、实现的功能
    1、基于springboot框架，application.yml配置多个数据源，使用AOP以及AbstractRootingDataSource、ThreadLocal来实现多数据源切换，以实现读写分离。mysql的主从数据库需要进行设置数据之间的同步。
    2、AOP来实现数据源切换, 使用此注解来放入到service方法上
    3、@DataSource(dataSource = DBTypeEnum.SLAVE)

			
		

	



                

              
                



	

		

			

				
					
Springboot + Mysql8实现读写分离功能

				
			

			

				

					08-25
				

			

		

		

			
				
主要介绍了Springboot + Mysql8实现读写分离功能，本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下

			
		

	



                


  
              

                


	

		

			

				
					
在 windows 上 将 MySql 5.6 最小化升级到 8.0

				
			

			

				

					打不死的小五
				

				

					07-19
					
					2008
					
				

			

		

		

			
				
记录一下 在windows 上 升级 MySql 5.6 到 8.0的过程

			
		

	





	

		

			

				
					
mysql 5.6升级8.0_Mysql数据库从5.6.28版本升到8.0.11版本部署项目时遇到的问题及解决方法...

				
			

			

				

					weixin_28745975的博客
				

				

					02-01
					
					336
					
				

			

		

		

			
				
mysql数据库版本从5.6.28升到8.0.11过程中部署项目时遇到的问题和解决方法，具体介绍如下所示：首先这个项目用到了hibernate4.2.0，链接mysql5.6.28没问题，换到8.0.11，启动报错1.Caused by: org.hibernate.HibernateException: Connection cannot be null when 'hibernate.dial...

			
		

	



		

			
		



	

		

			

				
					
SpringBoot+Mysql8实现读写分离

				
			

			

				

					weixin_44742132的博客
				

				

					11-28
					
					706
					
				

			

		

		

			
				
在实际的生产环境中，为了确保数据库的稳定性，我们一般会给数据库配置双机热备机制，这样在master数据库崩溃后，slave数据库可以立即切换成主数据库，通过主从复制的方式将数据从主库同步...

			
		

	





	

		

			

				
					
springboot+mybatis+mysql实现读写分离.zip

				
			

			

				

					10-23
				

			

		

		

			
				
springboot+mybatis+mysql实现读写分离      先在建好mysql主从数据库的配置，然后在代码中根据读写分离或强制读取master数据库中的数据    mysql数据库设置主从，参考：  ...

			
		

	





	

		

			

				
					
基于Spring boot+mybatis+redis+mybatisPlus开发的大学生社团管理系统，适合毕业设计、课程设计

				
			

			

				

					06-15
				

			

		

		

			
				
基于前后端分离开发方式，使用Spring Boot、vue等技术开发社团管理系统。后端使用Spring boot、mybatis、redis、mybatisPlus。  1. 系统模块设计及技术选择。  * 后端使用maven构建五个模块模块，使用Spring Boot 、...

			
		

	





	

		

			

				
					
SpringBoot+Mybatis配合AOP和注解实现动态数据源切换配置.docx

				
			

			

				

					11-17
				

			

		

		

			
				
在环境准备中，我们新建一个 Spring Boot 项目，并在 pom 文件中引入相关依赖，包括 mysql-connector-java、spring-boot-starter-jdbc 和 aop 相关的依赖。然后，我们需要配置主数据库和次数据库的连接信息，并在 ...

			
		

	





	

		

			

				
					
springboot基于Mybatis mysql实现读写分离

				
			

			

				

					08-25
				

			

		

		

			
				
本文介绍了如何使用 Spring Boot 和 MyBatis 实现 MySQL 读写分离，包括搭建一主多从数据库集群、主库配置、从库配置、代码层面进行读写分离等方面的内容。读写分离可以提高数据库的整体性能，适用于读多写少的场景...

			
		

	





	

		

			

				
					
spring-boot-mybatis多数据源读写分离实例

				
			

			

				

					08-09
				

			

		

		

			
				
多数据源动态创建数据源，读写分离到不同的库 运用springboot mybatis mysql

			
		

	





	

		

			

				
					
springboot读mysql取文章_SpringBoot来实现MySQL读写分离技术

				
			

			

				

					weixin_39992788的博客
				

				

					01-28
					
					217
					
				

			

		

		

			
				
前言首先思考一个问题:在高并发的场景中,关于数据库都有哪些优化的手段？常用的有以下的实现方法:读写分离、加缓存、主从架构集群、分库分表等，在互联网应用中,大部分都是读多写少的场景,设置两个库,主库和读库。主库的职能是负责写,从库主要是负责读,可以建立读库集群,通过读写职能在数据源上的隔离达到减少读写冲突、 释压数据库负载、保护数据库的目的。在实际的使用中,凡是涉及到写的部分直接切换到主库，读的部分...

			
		

	





	

		

			

				
					
SpringBoot项目中实现MySQL读写分离

				
			

			

				

					embelfe_segge的博客
				

				

					07-28
					
					156
					
				

			

		

		

			
				
MySQL主从复制是一个异步的复制过程，底层是基于Mysql数据库自带的二进制日志功能。就是一台或多台MySQL数据库（slave，即从库）从另一台MySQL数据库（master，即主库）进行日志的复制，然后再解析日志并应用到自身，最终实现从库的数据和主库的数据保持一致。MySQL主从复制是MySQL数据库自带功能，无需借助第三方工具。这可能是由于linux是复制出来的，MySQL中还有一个是一样的，我们也需要修改。...

			
		

	





	

		

			

				
					
如何在 MySQL 中创建和使用事务?

					
最新发布

				
			

			

				

					lgbingyu00的博客
				

				

					06-21
					
					633
					
				

			

		

		

			
				
事务对于MySQL在业务生产系统中的作用非常重要，以上示例主要显示的数据的隔离性。当多条数据同时执行的时候，事务会保证业务执行同时成功或同时失败，这样使用有关联性的业务可以保持业务的一致性。

			
		

	





	

		

			

				
					
PostgreSQL源码分析——INSERT

				
			

			

				

					让我思考一下
				

				

					06-18
					
					293
					
				

			

		

		

			
				
这里我们对INSERT语句进行分析， 只分析其宏观过程，具体细节后续再分析。我们就分析下面的语句的执行过程。

			
		

	





	

		

			

				
					
PostgreSQL源码分析——CREATE DATABASE

				
			

			

				

					让我思考一下
				

				

					06-18
					
					573
					
				

			

		

		

			
				
这里我们分析一下在PostgreSQL中创建数据库的源码，在分析源码之前，最好先阅读《PostgreSQL指南内幕探索》的第一章，数据库集簇、数据库和数据表，弄清其空间布局，理解PG中，数据库、表、元组是怎么布局的。通俗一点说，创建一个数据库相当于创建一个数据目录，在这个目录下，存放该数据库中定义的表、索引等对象。

			
		

	





	

		

			

				
					
MySQL修改分隔符

				
			

			

				

					2401_83963227的博客
				

				

					06-18
					
					217
					
				

			

		

		

			
				
MySQL修改分隔符

			
		

	





	

		

			

				
					
大数据经典sql

				
			

			

				

					yshysh8的博客
				

				

					06-18
					
					296
					
				

			

		

		

			
				
经典sql面试题：连续登录天数

			
		

	





	

		

			

				
					
【Mysql】MySQL存储引擎的介绍

				
			

			

				

					tr6666的博客
				

				

					06-21
					
					363
					
				

			

		

		

			
				
在处理大量数据的系统中，如何快速准确的获取所需的信息是一个重要的问题。这就像在一个巨大的图书馆中寻找一本书，如果没有目录或指南，这将是一项艰巨的任务。在数据库中，我们使用索引来解决这个问题。本文将介绍MySQL中索引的使用。MySQL的存储引擎决定了如何存储数据、如何为数据建立索引以及如何为数据记录和检索提供接口。InnoDB是MySQL的默认存储引擎，提供了全面的事务支持，包括ACID事务和提交、回滚等操作。InnoDB使用行级锁定，支持外键约束，并具有崩溃恢复能力。

			
		

	





	

		

			

				
					
ORDER BY FIELD

				
			

			

				

					北尘
				

				

					06-15
					
					306
					
				

			

		

		

			
				
ORDER BY FIELD 是MySQL中的一个特殊排序函数，它允许你基于一个自定义的值列表对查询结果进行排序。在这个例子中，所有属于’HR’部门的员工会首先列出，接着是’IT’部门的员工，然后是’Finance’部门的员工，最后是其他所有部门的员工，这些其他部门的员工将按照他们在表中原本的顺序排列。假设有一个employees表，包含name和department两列，现在你想按照特定部门顺序列出员工，部门顺序为：‘HR’, ‘IT’, ‘Finance’，其他部门按照自然顺序跟随。

			
		

	





	

		

			

				
					
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、付费专栏及课程。

              

            

          

      

      余额充值