springboot 读写分离多个读库 druid监控

红太狼 2022-05-26 06:06 117阅读 0赞

1、修改mybatis.properties

\[java\]  [view plain][]   [copy][view plain]

1.  \# 主数据源，默认的  
2.  spring.datasource.driver-**class**\-name=com.mysql.jdbc.Driver  
3.  spring.datasource.url=jdbc:mysql://127.0.0.1:3306/db  
4.  spring.datasource.username=root  
5.  spring.datasource.password=123456  
6.    
7.  \# 初始化大小，最小，最大  
8.  spring.datasource.initialSize=5  
9.  spring.datasource.minIdle=5  
10. spring.datasource.maxActive=20  
11. \# 配置获取连接等待超时的时间  
12. spring.datasource.maxWait=60000  
13. \# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒  
14. spring.datasource.timeBetweenEvictionRunsMillis=60000  
15. \# 配置一个连接在池中最小生存的时间，单位是毫秒  
16. spring.datasource.minEvictableIdleTimeMillis=300000  
17. spring.datasource.validationQuery=SELECT 1 FROM DUAL  
18. spring.datasource.testWhileIdle=**true**  
19. spring.datasource.testOnBorrow=**false**  
20. spring.datasource.testOnReturn=**false**  
21. \# 打开PSCache，并且指定每个连接上PSCache的大小  
22. spring.datasource.poolPreparedStatements=**true**  
23. spring.datasource.maxPoolPreparedStatementPerConnectionSize=20  
24.   
25. \# 从数据源  
26. spring.slave.type=com.alibaba.druid.pool.DruidDataSource  
27. spring.slave.driver-**class**\-name=com.mysql.jdbc.Driver  
28. spring.slave.url=jdbc:mysql://127.0.0.1:3308/db  
29. spring.slave.username=root  
30. spring.slave.password=123456  
31. spring.slave.initialSize=5  
32. spring.slave.minIdle=5  
33. spring.slave.maxActive=20  
34. \# 配置获取连接等待超时的时间  
35. spring.slave.maxWait=60000  
36. \# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒  
37. spring.slave.timeBetweenEvictionRunsMillis=60000  
38. \# 配置一个连接在池中最小生存的时间，单位是毫秒  
39. spring.slave.minEvictableIdleTimeMillis=300000  
40. spring.slave.validationQuery=SELECT 1 FROM DUAL  
41. spring.slave.testWhileIdle=**true**  
42. spring.slave.testOnBorrow=**false**  
43. spring.slave.testOnReturn=**false**  
44. \# 打开PSCache，并且指定每个连接上PSCache的大小  
45. spring.slave.poolPreparedStatements=**true**  
46. spring.slave.maxPoolPreparedStatementPerConnectionSize=20  
47.   
48.   
49. spring.read2.type=com.alibaba.druid.pool.DruidDataSource  
50. spring.read2.driver-**class**\-name=com.mysql.jdbc.Driver  
51. spring.read2.url=jdbc:mysql://127.0.0.1:3309/db  
52. spring.read2.username=root  
53. spring.read2.password=123456  
54. spring.read2.initialSize=5  
55. spring.read2.minIdle=5  
56. spring.read2.maxActive=20  
57. \# 配置获取连接等待超时的时间  
58. spring.read2.maxWait=60000  
59. \# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒  
60. spring.read2.timeBetweenEvictionRunsMillis=60000  
61. \# 配置一个连接在池中最小生存的时间，单位是毫秒  
62. spring.read2.minEvictableIdleTimeMillis=300000  
63. spring.read2.validationQuery=SELECT 1 FROM DUAL  
64. spring.read2.testWhileIdle=**true**  
65. spring.read2.testOnBorrow=**false**  
66. spring.read2.testOnReturn=**false**  
67. \# 打开PSCache，并且指定每个连接上PSCache的大小  
68. spring.read2.poolPreparedStatements=**true**  
69. spring.read2.maxPoolPreparedStatementPerConnectionSize=20  
70.   
71. \# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙  
72. spring.datasource.filters=stat,wall,logback  
73. \# 通过connectProperties属性来打开mergeSql功能；慢SQL记录  
74. spring.datasource.connectionProperties=druid.stat.mergeSql=**true**;druid.stat.slowSqlMillis=5000  
75. \# 合并多个DruidDataSource的监控数据  
76. spring.datasource.useGlobalDataSourceStat=**true**  
77.   
78. \# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙  
79. spring.slave.filters=stat,wall,logback  
80. \# 通过connectProperties属性来打开mergeSql功能；慢SQL记录  
81. spring.slave.connectionProperties=druid.stat.mergeSql=**true**;druid.stat.slowSqlMillis=5000  
82. \# 合并多个DruidDataSource的监控数据  
83. spring.slave.useGlobalDataSourceStat=**true**  
84.   
85. \# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙  
86. spring.read2.filters=stat,wall,logback  
87. \# 通过connectProperties属性来打开mergeSql功能；慢SQL记录  
88. spring.read2.connectionProperties=druid.stat.mergeSql=**true**;druid.stat.slowSqlMillis=5000  
89. \# 合并多个DruidDataSource的监控数据  
90. spring.read2.useGlobalDataSourceStat=**true**

2、创建DataBaseConfiguration读取mybatis.properties配置文件

\[java\]  [view plain][]   [copy][view plain]

1.  **package** com.demo.mybatis;  
2.    
3.  **import** lombok.extern.slf4j.Slf4j;  
4.  **import** org.springframework.beans.factory.annotation.Value;  
5.  **import** org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;  
6.  **import** org.springframework.boot.context.properties.ConfigurationProperties;  
7.  **import** org.springframework.context.annotation.Bean;  
8.  **import** org.springframework.context.annotation.Configuration;  
9.  **import** org.springframework.context.annotation.Primary;  
10.   
11. **import** javax.sql.DataSource;  
12. **import** java.util.ArrayList;  
13. **import** java.util.List;  
14.   
15. /\*\* 
16.  \* Created by huguoju on 2016/12/29. 
17.  \* 数据库配置：解析properties文件 
18.  \*/  
19. @Slf4j  
20. @Configuration  
21. **public** **class** DataBaseConfiguration \{  
22.     @Value("$\{spring.datasource.type\}")  
23.     **private** Class<? **extends** DataSource> dataSourceType;  
24.   
25.     @Bean(name="writeDataSource", destroyMethod = "close", initMethod="init")  
26.     @Primary  
27.     @ConfigurationProperties(prefix = "spring.datasource",locations = "classpath:mybatis/mybatis.properties")  
28.     **public** DataSource writeDataSource() \{  
29.         log.info("-------------------- writeDataSource init ---------------------");  
30.         **return** DataSourceBuilder.create().type(dataSourceType).build();  
31.     \}  
32.     /\*\* 
33.      \* 有多少个从库就要配置多少个 
34.      \* @return 
35.      \*/  
36.     @Bean(name = "readDataSource1")  
37.     @ConfigurationProperties(prefix = "spring.slave",locations = "classpath:mybatis/mybatis.properties")  
38.     **public** DataSource readDataSourceOne()\{  
39.         log.info("-------------------- readDataSourceOne init ---------------------");  
40.         **return** DataSourceBuilder.create().type(dataSourceType).build();  
41.     \}  
42.   
43.     @Bean(name = "readDataSource2")  
44.     @ConfigurationProperties(prefix = "spring.read2",locations = "classpath:mybatis/mybatis.properties")  
45.     **public** DataSource readDataSourceTwo() \{  
46.         log.info("-------------------- readDataSourceTwo init ---------------------");  
47.         **return** DataSourceBuilder.create().type(dataSourceType).build();  
48.     \}  
49.     @Bean("readDataSources")  
50.     **public** List<DataSource> readDataSources()\{  
51.         List<DataSource> dataSources=**new** ArrayList<>();  
52.         dataSources.add(readDataSourceOne());  
53.         dataSources.add(readDataSourceTwo());  
54.         **return** dataSources;  
55.     \}  
56. \}

\[java\]  [view plain][]   [copy][view plain]

最新版本的springboot的@ConfigurationProperties去掉了locations属性，改用@PropertySource指定其他的配置文件，@PropertySource不能作用在方法上，要写在类上

添加引用：

import org.springframework.context.annotation.PropertySource;

\[java\]  [view plain][]   [copy][view plain]

1.  **package** com.demo.mybatis;  
2.    
3.  **import** lombok.extern.slf4j.Slf4j;  
4.  **import** org.springframework.beans.factory.annotation.Value;  
5.  **import** org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;  
6.  **import** org.springframework.boot.context.properties.ConfigurationProperties;  
7.  **import** org.springframework.context.annotation.Bean;  
8.  **import** org.springframework.context.annotation.Configuration;  
9.  **import** org.springframework.context.annotation.Primary;  
10. **import** org.springframework.context.annotation.PropertySource;  
11. **import** javax.sql.DataSource;  
12. **import** java.util.ArrayList;  
13. **import** java.util.List;  
14.   
15. /\*\* 
16.  \* Created by huguoju on 2016/12/29. 
17.  \* 数据库配置：解析properties文件 
18.  \*/  
19. @Slf4j  
20. @Configuration  
21. @PropertySource("classpath:mybatis/mybatis.properties")  
22. **public** **class** DataBaseConfiguration \{  
23.     @Value("$\{spring.datasource.type\}")  
24.     **private** Class<? **extends** DataSource> dataSourceType;  
25.   
26.     @Bean(name="writeDataSource", destroyMethod = "close", initMethod="init")  
27.     @Primary  
28.     @ConfigurationProperties(prefix = "spring.datasource")  
29.     **public** DataSource writeDataSource() \{  
30.         log.info("-------------------- writeDataSource init ---------------------");  
31.         **return** DataSourceBuilder.create().type(dataSourceType).build();  
32.     \}  
33.     /\*\* 
34.      \* 有多少个从库就要配置多少个 
35.      \* @return 
36.      \*/  
37.     @Bean(name = "readDataSource1")  
38.     @ConfigurationProperties(prefix = "spring.slave")  
39.     **public** DataSource readDataSourceOne()\{  
40.         log.info("-------------------- readDataSourceOne init ---------------------");  
41.         **return** DataSourceBuilder.create().type(dataSourceType).build();  
42.     \}  
43.   
44.     @Bean(name = "readDataSource2")  
45.     @ConfigurationProperties(prefix = "spring.read2")  
46.     **public** DataSource readDataSourceTwo() \{  
47.         log.info("-------------------- readDataSourceTwo init ---------------------");  
48.         **return** DataSourceBuilder.create().type(dataSourceType).build();  
49.     \}  
50.     @Bean("readDataSources")  
51.     **public** List<DataSource> readDataSources()\{  
52.         List<DataSource> dataSources=**new** ArrayList<>();  
53.         dataSources.add(readDataSourceOne());  
54.         dataSources.add(readDataSourceTwo());  
55.         **return** dataSources;  
56.     \}  
57. \}

3、创建DataSourceType，枚举区分读写库

\[java\]  [view plain][]   [copy][view plain]

1.  **package** com.demo.mybatis;  
2.    
3.  **import** lombok.Getter;  
4.    
5.  /\*\* 
6.   \* Created by huguoju on 2016/12/29. 
7.   \*/  
8.  **public** **enum** DataSourceType \{  
9.      read("read", "从库"),  
10.     write("write", "主库");  
11.     @Getter  
12.     **private** String type;  
13.     @Getter  
14.     **private** String name;  
15.   
16.     DataSourceType(String type, String name) \{  
17.         **this**.type = type;  
18.         **this**.name = name;  
19.     \}  
20. \}

4、创建DataSourceContextHolder，本地线程全局变量

\[java\]  [view plain][]   [copy][view plain]

1.  **package** com.demo.mybatis;  
2.    
3.  **import** lombok.extern.slf4j.Slf4j;  
4.    
5.  /\*\* 
6.   \* Created by huguoju on 2016/12/29. 
7.   \* 本地线程全局变量 
8.   \*/  
9.  @Slf4j  
10. **public** **class** DataSourceContextHolder  \{  
11.     **private** **static** **final** ThreadLocal<String> local = **new** ThreadLocal<String>();  
12.   
13.     **public** **static** ThreadLocal<String> getLocal() \{  
14.         **return** local;  
15.     \}  
16.   
17.     /\*\* 
18.      \* 读可能是多个库 
19.      \*/  
20.     **public** **static** **void** read() \{  
21.   
22.         local.set(DataSourceType.read.getType());  
23.     \}  
24.   
25.     /\*\* 
26.      \* 写只有一个库 
27.      \*/  
28.     **public** **static** **void** write() \{  
29.         log.debug("writewritewrite");  
30.         local.set(DataSourceType.write.getType());  
31.     \}  
32.   
33.     **public** **static** String getJdbcType() \{  
34.         **return** local.get();  
35.     \}  
36. \}

5、创建MyAbstractRoutingDataSource，多数据源切换

\[java\]  [view plain][]   [copy][view plain]

1.  **package** com.demo.mybatis;  
2.    
3.  **import** org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;  
4.    
5.  **import** java.util.concurrent.atomic.AtomicInteger;  
6.    
7.  /\*\* 
8.   \* Created by huguoju on 2016/12/29. 
9.   \* 多数据源切换 
10.  \*/  
11. **public** **class** MyAbstractRoutingDataSource **extends** AbstractRoutingDataSource \{  
12.     **private** **final** **int** dataSourceNumber;  
13.     **private** AtomicInteger count = **new** AtomicInteger(0);  
14.   
15.     **public** MyAbstractRoutingDataSource(**int** dataSourceNumber) \{  
16.         **this**.dataSourceNumber = dataSourceNumber;  
17.     \}  
18.   
19.     @Override  
20.     **protected** Object determineCurrentLookupKey() \{  
21.         String typeKey = DataSourceContextHolder.getJdbcType();  
22.         **if** (typeKey.equals(DataSourceType.write.getType()))  
23.             **return** DataSourceType.write.getType();  
24.         // 读 简单负载均衡  
25.         **int** number = count.getAndAdd(1);  
26.         **int** lookupKey = number % dataSourceNumber;  
27.         **return** **new** Integer(lookupKey);  
28.     \}  
29. \}

6、创建MybatisConfiguration或者将MyBatisConfig修改，配置mybatis

\[java\]  [view plain][]   [copy][view plain]

1.  **package** com.demo.mybatis;  
2.    
3.  **import** lombok.extern.slf4j.Slf4j;  
4.  **import** org.apache.ibatis.session.SqlSessionFactory;  
5.  **import** org.mybatis.spring.SqlSessionFactoryBean;  
6.  **import** org.mybatis.spring.annotation.MapperScan;  
7.  **import** org.springframework.beans.factory.annotation.Value;  
8.  **import** org.springframework.boot.autoconfigure.condition.ConditionalOnClass;  
9.  **import** org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;  
10. **import** org.springframework.context.annotation.\*;  
11. **import** org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;  
12. **import** org.springframework.transaction.annotation.EnableTransactionManagement;  
13.   
14. **import** javax.annotation.Resource;  
15. **import** javax.sql.DataSource;  
16. **import** java.util.HashMap;  
17. **import** java.util.List;  
18. **import** java.util.Map;  
19.   
20. /\*\* 
21.  \* Created by huguoju on 2016/12/28. 
22.  \* 配置mybatis 
23.  \*/  
24. @Slf4j  
25. @Configuration  
26. @ConditionalOnClass(\{EnableTransactionManagement.**class**\})  
27. @Import(\{ DataBaseConfiguration.**class**\})  
28. @MapperScan(basePackages=\{ "com.demo.mapper"\})  
29. **public** **class** MybatisConfiguration \{  
30.     @Value("$\{spring.datasource.type\}")  
31.     **private** Class<? **extends** DataSource> dataSourceType;  
32.   
33.     @Value("$\{datasource.readSize\}")  
34.     **private** String dataSourceSize;  
35.     @Resource(name = "writeDataSource")  
36.     **private** DataSource dataSource;  
37.     @Resource(name = "readDataSources")  
38.     **private** List<DataSource> readDataSources;  
39.   
40.     @Bean  
41.     @ConditionalOnMissingBean  
42.     **public** SqlSessionFactory sqlSessionFactory() **throws** Exception \{  
43.         SqlSessionFactoryBean sqlSessionFactoryBean = **new** SqlSessionFactoryBean();  
44.         sqlSessionFactoryBean.setDataSource(roundRobinDataSouceProxy());  
45.         sqlSessionFactoryBean.setTypeAliasesPackage("com.demo.model");  
46.         sqlSessionFactoryBean.getObject().getConfiguration().setMapUnderscoreToCamelCase(**true**);  
47.         **return** sqlSessionFactoryBean.getObject();  
48.     \}  
49.     /\*\* 
50.      \* 有多少个数据源就要配置多少个bean 
51.      \* @return 
52.      \*/  
53.     @Bean  
54.     **public** AbstractRoutingDataSource roundRobinDataSouceProxy() \{  
55.         **int** size = Integer.parseInt(dataSourceSize);  
56.         MyAbstractRoutingDataSource proxy = **new** MyAbstractRoutingDataSource(size);  
57.         Map<Object, Object> targetDataSources = **new** HashMap<Object, Object>();  
58.         // DataSource writeDataSource = SpringContextHolder.getBean("writeDataSource");  
59.         // 写  
60.         targetDataSources.put(DataSourceType.write.getType(),dataSource);  
61.         // targetDataSources.put(DataSourceType.read.getType(),readDataSource);  
62.         //多个读数据库时  
63.         **for** (**int** i = 0; i < size; i++) \{  
64.             targetDataSources.put(i, readDataSources.get(i));  
65.         \}  
66.         proxy.setDefaultTargetDataSource(dataSource);  
67.         proxy.setTargetDataSources(targetDataSources);  
68.         **return** proxy;  
69.     \}  
70. \}

7、创建DataSourceTransactionManager，自定义事物

\[java\]  [view plain][]   [copy][view plain]

1.  **package** com.demo.mybatis;  
2.    
3.  **import** lombok.extern.slf4j.Slf4j;  
4.  **import** org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;  
5.  **import** org.springframework.context.annotation.Bean;  
6.  **import** org.springframework.context.annotation.Configuration;  
7.  **import** org.springframework.transaction.annotation.EnableTransactionManagement;  
8.    
9.  **import** javax.annotation.Resource;  
10. **import** javax.sql.DataSource;  
11.   
12. /\*\* 
13.  \* 自定义事务 
14.  \* Created by huguoju on 2016/12/29. 
15.  \*/  
16. @Configuration  
17. @EnableTransactionManagement  
18. @Slf4j  
19. **public** **class** DataSourceTransactionManager **extends** DataSourceTransactionManagerAutoConfiguration \{  
20.     /\*\* 
21.      \* 自定义事务 
22.      \* MyBatis自动参与到spring事务管理中，无需额外配置，只要org.mybatis.spring.SqlSessionFactoryBean引用的数据源与DataSourceTransactionManager引用的数据源一致即可，否则事务管理会不起作用。 
23.      \* @return 
24.      \*/  
25.     @Resource(name = "writeDataSource")  
26.     **private** DataSource dataSource;  
27.     @Bean(name = "transactionManager")  
28.     **public** org.springframework.jdbc.datasource.DataSourceTransactionManager transactionManagers() \{  
29.         log.info("-------------------- transactionManager init ---------------------");  
30.         **return** **new** org.springframework.jdbc.datasource.DataSourceTransactionManager(dataSource);  
31.     \}  
32. \}

8、创建DataSourceAop,切换数据源

\[java\]  [view plain][]   [copy][view plain]

1.  **package** com.demo.mybatis;  
2.    
3.  **import** lombok.extern.slf4j.Slf4j;  
4.  **import** org.aspectj.lang.annotation.Aspect;  
5.  **import** org.aspectj.lang.annotation.Before;  
6.  **import** org.springframework.stereotype.Component;  
7.    
8.  /\*\* 
9.   \* Created by huguoju on 2016/12/29. 
10.  \* 拦截设置本地线程变量 
11.  \*/  
12. @Aspect  
13. @Component  
14. @Slf4j  
15. **public** **class** DataSourceAop \{  
16.     @Before("execution(\* com.demo.mapper..\*.select\*(..)) || execution(\* com.demo.mapper..\*.get\*(..))")  
17.     **public** **void** setReadDataSourceType() \{  
18.         DataSourceContextHolder.read();  
19.         log.info("dataSource切换到：Read");  
20.     \}  
21.   
22.     @Before("execution(\* com.demo.mapper..\*.insert\*(..)) || execution(\* com.demo.mapper..\*.update\*(..))")  
23.     **public** **void** setWriteDataSourceType() \{  
24.         DataSourceContextHolder.write();  
25.         log.info("dataSource切换到：write");  
26.     \}  
27. \}

以上就完成了，测试类省略了，测试类只要一个select和insert的sql语句就可以，在DataSourceAop的切换方法里打断点，就可以看出来切换数据了，

druid监控全部库， 只要设置useGlobalDataSourceStat=true就可以了。

[view plain]: https://blog.csdn.net/u011493599/article/details/53930394#