SpringBoot读写分离组件开发详解

环境：springboot2.2.6RELEASE

创新互联是专业的老城网站建设公司，老城接单;提供成都网站设计、网站制作,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行老城网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

实现目标：一写多读，读可以任意配置多个，默认都是从写库中进行操作，只有符合条件的方法(指定的目标方法或者标有指定注解的方法才会从读库中操作)。独立打成一个jar包放入本地仓库。

实现原理：通过aop。

1.pom.xml配置文件

 
 
 
 
    
  
  
  
  
  1.  
    2. 
  
  
  
  
  2.             org.springframework.boot 
    3. 
  
  
  
  
  3.             spring-boot-starter 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.             org.springframework.boot 
    7. 
  
  
  
  
  7.             spring-boot-starter-data-jpa 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.             org.springframework.boot 
    11. 
  
  
  
  
  11.             spring-boot-configuration-processor 
    12. 
  
  
  
  
  12.             true 
    13. 
  
  
  
  
  13.  
    14.

 2.application.yml配置文件

 
 
 
 
    
  
  
  
  
  1. pack: 
    2. 
  
  
  
  
  2.   datasource: 
    3. 
  
  
  
  
  3.     pointcut: execution(public * net.greatsoft.service.base.*.*(..)) || execution(public * net.greatsoft.service.xxx.*.*(..)) 
    4. 
  
  
  
  
  4.     master: 
    5. 
  
  
  
  
  5.       driverClassName: oracle.jdbc.driver.OracleDriver 
    6. 
  
  
  
  
  6.       jdbcUrl: jdbc:oracle:thin:@10.100.102.113:1521/orcl 
    7. 
  
  
  
  
  7.       username: test 
    8. 
  
  
  
  
  8.       password: test 
    9. 
  
  
  
  
  9.       minimumIdle: 10 
    10. 
  
  
  
  
  10.       maximumPoolSize: 200 
    11. 
  
  
  
  
  11.       autoCommit: true 
    12. 
  
  
  
  
  12.       idleTimeout: 30000 
    13. 
  
  
  
  
  13.       poolName: MbookHikariCP 
    14. 
  
  
  
  
  14.       maxLifetime: 1800000 
    15. 
  
  
  
  
  15.       connectionTimeout: 30000 
    16. 
  
  
  
  
  16.       connectionTestQuery: SELECT 1 FROM DUAL   
    17. 
  
  
  
  
  17.     slaves: 
    18. 
  
  
  
  
  18.       - driverClassName: oracle.jdbc.driver.OracleDriver 
    19. 
  
  
  
  
  19.         jdbcUrl: jdbc:oracle:thin:@10.100.102.113:1521/orcl 
    20. 
  
  
  
  
  20.         username: dc 
    21. 
  
  
  
  
  21.         password: dc 
    22. 
  
  
  
  
  22.         minimumIdle: 10 
    23. 
  
  
  
  
  23.         maximumPoolSize: 200 
    24. 
  
  
  
  
  24.         autoCommit: true 
    25. 
  
  
  
  
  25.         idleTimeout: 30000 
    26. 
  
  
  
  
  26.         poolName: MbookHikariCP 
    27. 
  
  
  
  
  27.         maxLifetime: 1800000 
    28. 
  
  
  
  
  28.         connectionTimeout: 30000 
    29. 
  
  
  
  
  29.         connectionTestQuery: SELECT 1 FROM DUAL 
    30. 
  
  
  
  
  30.       - driverClassName: oracle.jdbc.driver.OracleDriver 
    31. 
  
  
  
  
  31.         jdbcUrl: jdbc:oracle:thin:@10.100.102.113:1521/orcl 
    32. 
  
  
  
  
  32.         username: empi 
    33. 
  
  
  
  
  33.         password: empi 
    34. 
  
  
  
  
  34.         minimumIdle: 10 
    35. 
  
  
  
  
  35.         maximumPoolSize: 200 
    36. 
  
  
  
  
  36.         autoCommit: true 
    37. 
  
  
  
  
  37.         idleTimeout: 30000 
    38. 
  
  
  
  
  38.         poolName: MbookHikariCP 
    39. 
  
  
  
  
  39.         maxLifetime: 1800000 
    40. 
  
  
  
  
  40.         connectionTimeout: 30000 
    41. 
  
  
  
  
  41.         connectionTestQuery: SELECT 1 FROM DUAL 
    42.

 pointcut：定义切点，那些方法是需要拦截(从读库中操作)。

master：写库配置。

slaves：读库配置(List集合)。

3.属性配置类

 
 
 
 
    
  
  
  
  
  1. @Component 
    2. 
  
  
  
  
  2. @ConfigurationProperties(prefix = "pack.datasource") 
    3. 
  
  
  
  
  3. public class RWDataSourceProperties { 
    4. 
  
  
  
  
  4.      
    5. 
  
  
  
  
  5.     private String pointcut ; 
    6. 
  
  
  
  
  6.     private HikariConfig master ; 
    7. 
  
  
  
  
  7.     private List slaves = new ArrayList<>(); 
    8. 
  
  
  
  
  8.      
    9. 
  
  
  
  
  9. } 
    10.

 4.读写配置类

 
 
 
 
    
  
  
  
  
  1. public class RWConfig  { 
    2. 
  
  
  
  
  2.      
    3. 
  
  
  
  
  3.     private static Logger logger = LoggerFactory.getLogger(RWConfig.class) ; 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.     @Bean 
    6. 
  
  
  
  
  6.     public HikariDataSource masterDataSource(RWDataSourceProperties rwDataSourceProperties) { 
    7. 
  
  
  
  
  7.         return new HikariDataSource(rwDataSourceProperties.getMaster()) ; 
    8. 
  
  
  
  
  8.     } 
    9. 
  
  
  
  
  9.      
    10. 
  
  
  
  
  10.     @Bean 
    11. 
  
  
  
  
  11.     public List slaveDataSources(RWDataSourceProperties rwDataSourceProperties) { 
    12. 
  
  
  
  
  12.         List lists = new ArrayList<>() ; 
    13. 
  
  
  
  
  13.         for(HikariConfig config : rwDataSourceProperties.getSlaves()) { 
    14. 
  
  
  
  
  14.             lists.add(new HikariDataSource(config)) ; 
    15. 
  
  
  
  
  15.         } 
    16. 
  
  
  
  
  16.         return lists ; 
    17. 
  
  
  
  
  17.     } 
    18. 
  
  
  
  
  18.      
    19. 
  
  
  
  
  19.     @Bean 
    20. 
  
  
  
  
  20.   @Primary 
    21. 
  
  
  
  
  21.     @DependsOn({"masterDataSource", "slaveDataSources"}) 
    22. 
  
  
  
  
  22.     public AbstractRoutingDataSource routingDataSource(@Qualifier("masterDataSource")DataSource masterDataSource, 
    23. 
  
  
  
  
  23.             @Qualifier("slaveDataSources")List slaveDataSources) { 
    24. 
  
  
  
  
  24.         BaseRoutingDataSource ds = new BaseRoutingDataSource() ; 
    25. 
  
  
  
  
  25.         Map targetDataSources = new HashMap<>(2) ; 
    26. 
  
  
  
  
  26.         targetDataSources.put("master", masterDataSource) ; 
    27. 
  
  
  
  
  27.         for (int i = 0; i < slaveDataSources.size(); i++) { 
    28. 
  
  
  
  
  28.             targetDataSources.put("slave-" + i, slaveDataSources.get(i)) ; 
    29. 
  
  
  
  
  29.         } 
    30. 
  
  
  
  
  30.         ds.setDefaultTargetDataSource(masterDataSource) ; 
    31. 
  
  
  
  
  31.         ds.setTargetDataSources(targetDataSources) ; 
    32. 
  
  
  
  
  32.         return ds ; 
    33. 
  
  
  
  
  33.     } 
    34. 
  
  
  
  
  34.      
    35. 
  
  
  
  
  35. } 
    36.

 5.数据源路由

 
 
 
 
    
  
  
  
  
  1. public class BaseRoutingDataSource extends AbstractRoutingDataSource { 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     @Resource 
    4. 
  
  
  
  
  4.     private DataSourceHolder holder; 
    5. 
  
  
  
  
  5.      
    6. 
  
  
  
  
  6.     @Override 
    7. 
  
  
  
  
  7.     protected Object determineCurrentLookupKey() { 
    8. 
  
  
  
  
  8.         return holder.get() ; 
    9. 
  
  
  
  
  9.     } 
    10. 
  
  
  
  
  10.      
    11. 
  
  
  
  
  11. } 
    12. 
 
 
 
 

 
 
 
 
    
  
  
  
  
  1. public class DataSourceHolder { 
    2. 
  
  
  
  
  2.      
    3. 
  
  
  
  
  3.     private ThreadLocal context = new ThreadLocal() { 
    4. 
  
  
  
  
  4.         @Override 
    5. 
  
  
  
  
  5.         protected Integer initialValue() { 
    6. 
  
  
  
  
  6.             return 0 ; 
    7. 
  
  
  
  
  7.         } 
    8. 
  
  
  
  
  8.     }; 
    9. 
  
  
  
  
  9.      
    10. 
  
  
  
  
  10.     @Resource 
    11. 
  
  
  
  
  11.     private BaseSlaveLoad slaveLoad ; 
    12. 
  
  
  
  
  12.      
    13. 
  
  
  
  
  13.     public String get() { 
    14. 
  
  
  
  
  14.         Integer type = context.get() ; 
    15. 
  
  
  
  
  15.         return type == null || type == 0 ? "master" : "slave-" + slaveLoad.load() ; 
    16. 
  
  
  
  
  16.     } 
    17. 
  
  
  
  
  17.      
    18. 
  
  
  
  
  18.     public void set(Integer type) { 
    19. 
  
  
  
  
  19.         context.set(type) ; 
    20. 
  
  
  
  
  20.     } 
    21. 
  
  
  
  
  21.      
    22. 
  
  
  
  
  22. } 
    23.

 通过aop动态设置context的内容值，0为从写库中操作，其它的都在读库中操作。

BaseSlaveLoad类为到底从那个读库中选取的一个算法类，默认实现使用的是轮询算法。

 
 
 
 
    
  
  
  
  
  1. public interface BaseSlaveLoad { 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     int load() ; 
    4. 
  
  
  
  
  4.      
    5. 
  
  
  
  
  5. } 
    6. 
 
 
 
 

 
 
 
 
    
  
  
  
  
  1. public abstract class AbstractSlaveLoad implements BaseSlaveLoad { 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     @Resource 
    4. 
  
  
  
  
  4.     protected List slaveDataSources ; 
    5. 
  
  
  
  
  5.      
    6. 
  
  
  
  
  6. } 
    7.

 这里定义一个抽象类注入了读库列表，所有的实现类从该类中继承即可。

 
 
 
 
    
  
  
  
  
  1. public class PollingLoad extends AbstractSlaveLoad { 
    2. 
  
  
  
  
  2.      
    3. 
  
  
  
  
  3.     private int index = 0 ; 
    4. 
  
  
  
  
  4.     private int size = 1 ; 
    5. 
  
  
  
  
  5.      
    6. 
  
  
  
  
  6.     @PostConstruct 
    7. 
  
  
  
  
  7.     public void init() { 
    8. 
  
  
  
  
  8.         size = slaveDataSources.size() ; 
    9. 
  
  
  
  
  9.     } 
    10. 
  
  
  
  
  10.      
    11. 
  
  
  
  
  11.     @Override 
    12. 
  
  
  
  
  12.     public int load() { 
    13. 
  
  
  
  
  13.         int n = index ; 
    14. 
  
  
  
  
  14.         synchronized (this) { 
    15. 
  
  
  
  
  15.             index = (++index) % size ; 
    16. 
  
  
  
  
  16.         } 
    17. 
  
  
  
  
  17.         return n ; 
    18. 
  
  
  
  
  18.     } 
    19. 
  
  
  
  
  19.      
    20. 
  
  
  
  
  20. } 
    21.

 配置成Bean

 
 
 
 
    
  
  
  
  
  1. @Bean 
    2. 
  
  
  
  
  2.     @ConditionalOnMissingBean 
    3. 
  
  
  
  
  3.     public BaseSlaveLoad slaveLoad() { 
    4. 
  
  
  
  
  4.         return new PollingLoad() ; 
    5. 
  
  
  
  
  5.     } 
    6. 
  
  
  
  
  6.      
    7. 
  
  
  
  
  7.     @Bean 
    8. 
  
  
  
  
  8.     public DataSourceHolder dataSourceHolder() { 
    9. 
  
  
  
  
  9.         return new DataSourceHolder() ; 
    10. 
  
  
  
  
  10.     } 
    11.

 6.数据源AOP

 
 
 
 
    
  
  
  
  
  1. public class DataSourceAspect implements MethodInterceptor { 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     private DataSourceHolder holder ; 
    4. 
  
  
  
  
  4.      
    5. 
  
  
  
  
  5.     public DataSourceAspect(DataSourceHolder holder) { 
    6. 
  
  
  
  
  6.         this.holder = holder ; 
    7. 
  
  
  
  
  7.     } 
    8. 
  
  
  
  
  8.      
    9. 
  
  
  
  
  9.     @Override 
    10. 
  
  
  
  
  10.     public Object invoke(MethodInvocation invocation) throws Throwable { 
    11. 
  
  
  
  
  11.         Method method = invocation.getMethod() ; 
    12. 
  
  
  
  
  12.         String methodName = method.getName() ; 
    13. 
  
  
  
  
  13.         SlaveDB slaveDB = method.getAnnotation(SlaveDB.class) ; 
    14. 
  
  
  
  
  14.         if (slaveDB == null) { 
    15. 
  
  
  
  
  15.             slaveDB = method.getDeclaringClass().getAnnotation(SlaveDB.class) ; 
    16. 
  
  
  
  
  16.         } 
    17. 
  
  
  
  
  17.         if (methodName.startsWith("find")  
    18. 
  
  
  
  
  18.                 || methodName.startsWith("get") 
    19. 
  
  
  
  
  19.                 || methodName.startsWith("query") 
    20. 
  
  
  
  
  20.                 || methodName.startsWith("select") 
    21. 
  
  
  
  
  21.                 || methodName.startsWith("list") 
    22. 
  
  
  
  
  22.                 || slaveDB != null) { 
    23. 
  
  
  
  
  23.             holder.set(1) ; 
    24. 
  
  
  
  
  24.         } else { 
    25. 
  
  
  
  
  25.             holder.set(0) ; 
    26. 
  
  
  
  
  26.         } 
    27. 
  
  
  
  
  27.         return invocation.proceed(); 
    28. 
  
  
  
  
  28.     } 
    29. 
  
  
  
  
  29.  
    30. 
  
  
  
  
  30. } 
    31.

 应该切点需要动态配置，所以这里采用spring aop的方式来配置

 
 
 
 
    
  
  
  
  
  1. @Bean 
    2. 
  
  
  
  
  2.     public AspectJExpressionPointcutAdvisor logAdvisor(RWDataSourceProperties props, DataSourceHolder holder) { 
    3. 
  
  
  
  
  3.         AspectJExpressionPointcutAdvisor advisor = new AspectJExpressionPointcutAdvisor() ; 
    4. 
  
  
  
  
  4.         logger.info("执行表达式：{}", props.getPointcut()) ; 
    5. 
  
  
  
  
  5.         advisor.setExpression(props.getPointcut()) ; 
    6. 
  
  
  
  
  6.         advisor.setAdvice(new DataSourceAspect(holder)) ; 
    7. 
  
  
  
  
  7.         return advisor ; 
    8. 
  
  
  
  
  8.     } 
    9.

 7.Enable开启功能

 
 
 
 
    
  
  
  
  
  1. public class RWImportSelector implements ImportSelector { 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     @Override 
    4. 
  
  
  
  
  4.     public String[] selectImports(AnnotationMetadata importingClassMetadata) { 
    5. 
  
  
  
  
  5.         return new String[] {RWConfig.class.getName()} ; 
    6. 
  
  
  
  
  6.     } 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8. } 
    9.

 这里的RWConfig为我们上面的配置类

 
 
 
 
    
  
  
  
  
  1. @Retention(RetentionPolicy.RUNTIME) 
    2. 
  
  
  
  
  2. @Target(ElementType.TYPE) 
    3. 
  
  
  
  
  3. @Documented 
    4. 
  
  
  
  
  4. @Import({RWImportSelector.class}) 
    5. 
  
  
  
  
  5. public @interface EnableRW { 
    6. 
  
  
  
  
  6. } 
    7. 
 
 
 
 

 
 
 
 
    
  
  
  
  
  1. @Documented 
    2. 
  
  
  
  
  2. @Retention(RUNTIME) 
    3. 
  
  
  
  
  3. @Target({ TYPE, METHOD }) 
    4. 
  
  
  
  
  4. public @interface SlaveDB { 
    5. 
  
  
  
  
  5. } 
    6.

 有@SlaveDB的注解方法会类都会从读库中操作。

到此读写分离组件开发完成。

8.打包安装到本地仓库

 
 
 
 
    
  
  
  
  
  1. mvn install -Dmaven.test.skip=true 
    2.

9.新建base-web项目

引入依赖

 
 
 
 
    
  
  
  
  
  1.  
    2. 
  
  
  
  
  2.             com.pack 
    3. 
  
  
  
  
  3.             xg-component-rw 
    4. 
  
  
  
  
  4.             1.0.0 
    5. 
  
  
  
  
  5.  
    6.

 启动类添加注解开启读写分离功能

 
 
 
 
    
  
  
  
  
  1. @SpringBootApplication 
    2. 
  
  
  
  
  2. @EnableRW 
    3. 
  
  
  
  
  3. public class BaseWebApplication { 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.     public static void main(String[] args) { 
    6. 
  
  
  
  
  6.         SpringApplication.run(BaseWebApplication.class, args); 
    7. 
  
  
  
  
  7.     } 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. } 
    10.

 测试：

第一次查询：

第二次查询：

为了区别两个从库设置不同的数据

这里是写库

完毕！！！

文章名称：SpringBoot读写分离组件开发详解
当前链接：http://www.shufengxianlan.com/qtweb/news36/497736.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

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

猜你还喜欢下面的内容

企业建站知识

同城分类信息

成都免费建网站　　 　营销型网站建设　　 　成都网站安全运维　　 　成都画册制作　　 　德阳服务器托管　　 　绵竹网站建设　　 　响应式网站　　 　眉山主机托管　　 　重庆水土三线托管　　 　成都网站制作　　 　证企宝　　 　成都主机租用　　 　温岭熙道网站　　 　域名ssl证书　　 　网站域名　　 　成都服装定制　　 　南充网站制作　　 　川银永信　　 　视频运营　　 　腾讯云免备案主机