SpringBoot+MyBatis+MySQL实现读写分离!

 1、引言

读写分离要做的事情就是对于一条SQL该选择哪个数据库去执行,至于谁来做选择数据库这件事儿,无非两个,要么中间件帮我们做,要么程序自己做。

成都创新互联公司是一家专业提供曲松企业网站建设,专注与网站设计、成都做网站成都h5网站建设、小程序制作等业务。10年已为曲松众多企业、政府机构等服务。创新互联专业网站设计公司优惠进行中。

因此,一般来讲,读写分离有两种实现方式。第一种是依靠中间件(比如:MyCat),也就是说应用程序连接到中间件,中间件帮我们做SQL分离;第二种是应用程序自己去做分离。这里我们选择程序自己来做,主要是利用Spring提供的路由数据源,以及AOP

然而,应用程序层面去做读写分离最大的弱点(不足之处)在于无法动态增加数据库节点,因为数据源配置都是写在配置中的,新增数据库意味着新加一个数据源,必然改配置,并重启应用。当然,好处就是相对简单。

2、AbstractRoutingDataSource

基于特定的查找key路由到特定的数据源。它内部维护了一组目标数据源,并且做了路由key与目标数据源之间的映射,提供基于key查找数据源的方法。

3、实践

3.1. maven依赖 

 
 
 
 
  1.  
  2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
  3.     4.0.0 
  4.     com.cjs.example 
  5.     cjs-datasource-demo 
  6.     0.0.1-SNAPSHOT 
  7.     jar 
  8.     cjs-datasource-demo 
  9.      
  10.      
  11.         org.springframework.boot 
  12.         spring-boot-starter-parent 
  13.         2.0.5.RELEASE 
  14.           
  15.      
  16.      
  17.         UTF-8 
  18.         UTF-8 
  19.         1.8 
  20.      
  21.      
  22.          
  23.             org.springframework.boot 
  24.             spring-boot-starter-aop 
  25.          
  26.          
  27.             org.springframework.boot 
  28.             spring-boot-starter-jdbc 
  29.          
  30.          
  31.             org.springframework.boot 
  32.             spring-boot-starter-web 
  33.          
  34.          
  35.             org.mybatis.spring.boot 
  36.             mybatis-spring-boot-starter 
  37.             1.3.2 
  38.          
  39.          
  40.             org.apache.commons 
  41.             commons-lang3 
  42.             3.8 
  43.          
  44.          
  45.             mysql 
  46.             mysql-connector-java 
  47.             runtime 
  48.          
  49.          
  50.             org.springframework.boot 
  51.             spring-boot-starter-test 
  52.             test 
  53.          
  54.      
  55.      
  56.          
  57.              
  58.                 org.springframework.boot 
  59.                 spring-boot-maven-plugin 
  60.              
  61.              
  62.          
  63.      

3.2. 数据源配置

application.yml 

 
 
 
 
  1. spring: 
  2.   datasource: 
  3.     master: 
  4.       jdbc-url: jdbc:mysql://192.168.102.31:3306/test 
  5.       username: root 
  6.       password: 123456 
  7.       driver-class-name: com.mysql.jdbc.Driver 
  8.     slave1: 
  9.       jdbc-url: jdbc:mysql://192.168.102.56:3306/test 
  10.       username: pig   # 只读账户 
  11.       password: 123456 
  12.       driver-class-name: com.mysql.jdbc.Driver 
  13.     slave2: 
  14.       jdbc-url: jdbc:mysql://192.168.102.36:3306/test 
  15.       username: pig   # 只读账户 
  16.       password: 123456 
  17.       driver-class-name: com.mysql.jdbc.Driver

多数据源配置

 
 
 
 
  1. package com.cjs.example.config; 
  2. import com.cjs.example.bean.MyRoutingDataSource; 
  3. import com.cjs.example.enums.DBTypeEnum; 
  4. import org.springframework.beans.factory.annotation.Qualifier; 
  5. import org.springframework.boot.context.properties.ConfigurationProperties; 
  6. import org.springframework.boot.jdbc.DataSourceBuilder; 
  7. import org.springframework.context.annotation.Bean; 
  8. import org.springframework.context.annotation.Configuration; 
  9. import javax.sql.DataSource; 
  10. import java.util.HashMap; 
  11. import java.util.Map; 
  12. /** 
  13.  * 关于数据源配置,参考SpringBoot官方文档第79章《Data Access》 
  14.  * 79. Data Access 
  15.  * 79.1 Configure a Custom DataSource 
  16.  * 79.2 Configure Two DataSources 
  17.  */ 
  18. @Configuration 
  19. public class DataSourceConfig { 
  20.     @Bean 
  21.     @ConfigurationProperties("spring.datasource.master") 
  22.     public DataSource masterDataSource() { 
  23.         return DataSourceBuilder.create().build(); 
  24.     } 
  25.     @Bean 
  26.     @ConfigurationProperties("spring.datasource.slave1") 
  27.     public DataSource slave1DataSource() { 
  28.         return DataSourceBuilder.create().build(); 
  29.     } 
  30.     @Bean 
  31.     @ConfigurationProperties("spring.datasource.slave2") 
  32.     public DataSource slave2DataSource() { 
  33.         return DataSourceBuilder.create().build(); 
  34.     } 
  35.     @Bean 
  36.     public DataSource myRoutingDataSource(@Qualifier("masterDataSource") DataSource masterDataSource, 
  37.                                           @Qualifier("slave1DataSource") DataSource slave1DataSource, 
  38.                                           @Qualifier("slave2DataSource") DataSource slave2DataSource) { 
  39.         Map targetDataSources = new HashMap<>(); 
  40.         targetDataSources.put(DBTypeEnum.MASTER, masterDataSource); 
  41.         targetDataSources.put(DBTypeEnum.SLAVE1, slave1DataSource); 
  42.         targetDataSources.put(DBTypeEnum.SLAVE2, slave2DataSource); 
  43.         MyRoutingDataSource myRoutingDataSource = new MyRoutingDataSource(); 
  44.         myRoutingDataSource.setDefaultTargetDataSource(masterDataSource); 
  45.         myRoutingDataSource.setTargetDataSources(targetDataSources); 
  46.         return myRoutingDataSource; 
  47.     } 
  48. }

这里,我们配置了4个数据源,1个master,2两个slave,1个路由数据源。前3个数据源都是为了生成第4个数据源,而且后续我们只用这最后一个路由数据源。

Spring Boot 最新基础教程和示例源码:https://github.com/javastacks/spring-boot-best-practice

MyBatis配置

 
 
 
 
  1. package com.cjs.example.config; 
  2. import org.apache.ibatis.session.SqlSessionFactory; 
  3. import org.mybatis.spring.SqlSessionFactoryBean; 
  4. import org.springframework.context.annotation.Bean; 
  5. import org.springframework.context.annotation.Configuration; 
  6. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
  7. import org.springframework.jdbc.datasource.DataSourceTransactionManager; 
  8. import org.springframework.transaction.PlatformTransactionManager; 
  9. import org.springframework.transaction.annotation.EnableTransactionManagement; 
  10. import javax.annotation.Resource; 
  11. import javax.sql.DataSource; 
  12. @EnableTransactionManagement 
  13. @Configuration 
  14. public class MyBatisConfig { 
  15.     @Resource(name = "myRoutingDataSource") 
  16.     private DataSource myRoutingDataSource; 
  17.     @Bean 
  18.     public SqlSessionFactory sqlSessionFactory() throws Exception { 
  19.         SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean(); 
  20.         sqlSessionFactoryBean.setDataSource(myRoutingDataSource); 
  21.         sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml")); 
  22.         return sqlSessionFactoryBean.getObject(); 
  23.     } 
  24.     @Bean 
  25.     public PlatformTransactionManager platformTransactionManager() { 
  26.         return new DataSourceTransactionManager(myRoutingDataSource); 
  27.     } 
  28. }

由于Spring容器中现在有4个数据源,所以我们需要为事务管理器和MyBatis手动指定一个明确的数据源。另外,Spring 系列面试题和答案全部整理好了,微信搜索Java技术栈,在后台发送:面试,可以在线阅读。

3.3. 设置路由key / 查找数据源

目标数据源就是那前3个这个我们是知道的,但是使用的时候是如果查找数据源的呢?

首先,我们定义一个枚举来代表这三个数据源

 
 
 
 
  1. package com.cjs.example.enums; 
  2. public enum DBTypeEnum { 
  3.     MASTER, SLAVE1, SLAVE2; 
  4. }

接下来,通过ThreadLocal将数据源设置到每个线程上下文中

 
 
 
 
  1. package com.cjs.example.bean; 
  2. import com.cjs.example.enums.DBTypeEnum; 
  3. import java.util.concurrent.atomic.AtomicInteger;
  4. public class DBContextHolder { 
  5.     private static final ThreadLocal contextHolder = new ThreadLocal<>(); 
  6.     private static final AtomicInteger counter = new AtomicInteger(-1); 
  7.     public static void set(DBTypeEnum dbType) { 
  8.         contextHolder.set(dbType); 
  9.     }
  10.     public static DBTypeEnum get() { 
  11.         return contextHolder.get(); 
  12.     } 
  13.     public static void master() { 
  14.         set(DBTypeEnum.MASTER); 
  15.         System.out.println("切换到master"); 
  16.     } 
  17.     public static void slave() {
  18.         //  轮询 
  19.         int index = counter.getAndIncrement() % 2; 
  20.         if (counter.get() > 9999) { 
  21.             counter.set(-1); 
  22.         } 
  23.         if (index == 0) { 
  24.             set(DBTypeEnum.SLAVE1); 
  25.             System.out.println("切换到slave1"); 
  26.         }else { 
  27.             set(DBTypeEnum.SLAVE2); 
  28.             System.out.println("切换到slave2"); 
  29.         } 
  30.     } 
  31. }

获取路由key

 
 
 
 
  1. package com.cjs.example.bean; 
  2. import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource; 
  3. import org.springframework.lang.Nullable; 
  4. public class MyRoutingDataSource extends AbstractRoutingDataSource { 
  5.     @Nullable 
  6.     @Override 
  7.     protected Object determineCurrentLookupKey() { 
  8.         return DBContextHolder.get(); 
  9.     } 
  10. }

设置路由key

默认情况下,所有的查询都走从库,插入/修改/删除走主库。我们通过方法名来区分操作类型(CRUD)

 
 
 
 
  1. package com.cjs.example.aop; 
  2. import com.cjs.example.bean.DBContextHolder; 
  3. import org.apache.commons.lang3.StringUtils; 
  4. import org.aspectj.lang.JoinPoint;
  5. import org.aspectj.lang.annotation.Aspect; 
  6. import org.aspectj.lang.annotation.Before; 
  7. import org.aspectj.lang.annotation.Pointcut; 
  8. import org.springframework.stereotype.Component; 
  9. @Aspect 
  10. @Component 
  11. public class DataSourceAop { 
  12.     @Pointcut("!@annotation(com.cjs.example.annotation.Master) " + 
  13.             "&& (execution(* com.cjs.example.service..*.select*(..)) " + 
  14.             "|| execution(* com.cjs.example.service..*.get*(..)))") 
  15.     public void readPointcut() { 
  16.     } 
  17.     @Pointcut("@annotation(com.cjs.example.annotation.Master) " + 
  18.             "|| execution(* com.cjs.example.service..*.insert*(..)) " + 
  19.             "|| execution(* com.cjs.example.service..*.add*(..)) " + 
  20.             "|| execution(* com.cjs.example.service..*.update*(..)) " +
  21.             "|| execution(* com.cjs.example.service..*.edit*(..)) " + 
  22.             "|| execution(* com.cjs.example.service..*.delete*(..)) " + 
  23.             "|| execution(* com.cjs.example.service..*.remove*(..))") 
  24.     public void writePointcut() { 
  25.     } 
  26.     @Before("readPointcut()") 
  27.     public void read() { 
  28.         DBContextHolder.slave(); 
  29.     } 
  30.     @Before("writePointcut()") 
  31.     public void write() { 
  32.         DBContextHolder.master(); 
  33.     } 
  34.     /** 
  35.      * 另一种写法:if...else...  判断哪些需要读从数据库,其余的走主数据库 
  36.      */ 
  37. //    @Before("execution(* com.cjs.example.service.impl.*.*(..))") 
  38. //    public void before(JoinPoint jp) { 
  39. //        String methodName = jp.getSignature().getName(); 
  40. // 
  41. //        if (StringUtils.startsWithAny(methodName, "get", "select", "find")) { 
  42. //            DBContextHolder.slave(); 
  43. //        }else { 
  44. //            DBContextHolder.master(); 
  45. //        } 
  46. //    } 
  47. }

有一般情况就有特殊情况,特殊情况是某些情况下我们需要强制读主库,针对这种情况,我们定义一个主键,用该注解标注的就读主库

 
 
 
 
  1. package com.cjs.example.annotation; 
  2. public @interface Master {
  3. }

例如,假设我们有一张表member

 
 
 
 
  1. package com.cjs.example.service.impl; 
  2. import com.cjs.example.annotation.Master; 
  3. import com.cjs.example.entity.Member; 
  4. import com.cjs.example.entity.MemberExample; 
  5. import com.cjs.example.mapper.MemberMapper; 
  6. import com.cjs.example.service.MemberService; 
  7. import org.springframework.beans.factory.annotation.Autowired; 
  8. import org.springframework.stereotype.Service; 
  9. import org.springframework.transaction.annotation.Transactional; 
  10. import java.util.List; 
  11. @Service 
  12. public class MemberServiceImpl implements MemberService {
  13.     @Autowired 
  14.     private MemberMapper memberMapper; 
  15.     @Transactional 
  16.     @Override 
  17.     public int insert(Member member) { 
  18.         return memberMapper.insert(member); 
  19.     }
  20.     @Master 
  21.     @Override 
  22.     public int save(Member member) { 
  23.         return memberMapper.insert(member); 
  24.     } 
  25.     @Override
  26.     public List selectAll() { 
  27.         return memberMapper.selectByExample(new MemberExample()); 
  28.     } 
  29.     @Master 
  30.     @Override 
  31.     public String getToken(String appId) { 
  32.         //  有些读操作必须读主数据库 
  33.         //  比如,获取微信access_token,因为高峰时期主从同步可能延迟 
  34.         //  这种情况下就必须强制从主数据读 
  35.         return null; 
  36.     } 
  37. }

4、测试 

 
 
 
 
  1. package com.cjs.example; 
  2. import com.cjs.example.entity.Member; 
  3. import com.cjs.example.service.MemberService; 
  4. import org.junit.Test; 
  5. import org.junit.runner.RunWith; 
  6. import org.springframework.beans.factory.annotation.Autowired; 
  7. import org.springframework.boot.test.context.SpringBootTest; 
  8. import org.springframework.test.context.junit4.SpringRunner; 
  9. @RunWith(SpringRunner.class) 
  10. @SpringBootTest 
  11. public class CjsDatasourceDemoApplicationTests { 
  12.     @Autowired 
  13.     private MemberService memberService; 
  14.     @Test 
  15.     public void testWrite() { 
  16.         Member member = new Member(); 
  17.         member.setName("zhangsan"); 
  18.         memberService.insert(member); 
  19.     } 
  20.     @Test 
  21.     public void testRead() { 
  22.         for (int i = 0; i < 4; i++) { 
  23.             memberService.selectAll(); 
  24.         } 
  25.     } 
  26.     @Test 
  27.     public void testSave() { 
  28.         Member member = new Member(); 
  29.         member.setName("wangwu"); 
  30.         memberService.save(member); 
  31.     } 
  32.     @Test 
  33.     public void testReadFromMaster() { 
  34.         memberService.getToken("1234"); 
  35.     } 
  36. }

查看控制台

5、工程结构

分享名称:SpringBoot+MyBatis+MySQL实现读写分离!
标题URL:http://www.mswzjz.cn/qtweb/news1/85701.html

攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能,是专注品牌与效果的网络营销公司;服务项目有等

广告

声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 贝锐智能