查看: 2050|回复: 0

[Java语言] Spring-Blog:个人博客(一)-Mybatis 读写分离

发表于 2018-2-3 08:00:05
概述:

2018,在平(tou)静(lan)了一段时间后,开始找点事情来做。这一次准备开发一个个人博客,在开发过程之中完善一下自己的技术。本系列博客只会提出一些比较有价值的技术思路,不会像写流水账一样记录开发过程。

  技术栈方面,会采用Spring Boot 2.0 作为底层框架,主要为了后续能够接入Spring Cloud 进行学习拓展。并且Spring Boot 2.0基于Spring5,也可以提前预习一些Spring5的新特性。后续技术会在相应博客中提出。

  项目GitHub地址:Spring-Blog
  

  介绍一下目录结构:

Spring-Blog(Parent 项目) Spring-Blog-common( Util 模块) Spring-Blog-business(Repository模块) Spring-Blog-api (Web 模块) Spring-Blog-webflux (基于Spring Boot 2.0 的 Web模块)

  为了让各位朋友能够更好理解这一模块的内容,演示代码将存放在Spring Boot 项目下:
 

 
  Github 地址:示例代码
  
  

1、DataSource

 
   在开始讲解前,我们需要先构建后我们的运行环境。Spring Boot 引入 Mybatis 的教程 可以参考 传送门 。这里我们不细述了,首先来看一下我们的目录结构:
  

  有使用过Spring Boot 的童鞋应该清楚,当我们在application.properties 配置好了我们的数据库连接信息后,Spring Boot 将会帮我们自动装载好DataSource。但如果我们需要进行读写分离操作是,如何配置自己的数据源,是我们必须掌握的。

  首先我们来看一下配置文件中的信息:

  1. spring.datasource.url=jdbc:mysql://localhost:3306/charles_blog2
  2. spring.datasource.username=root
  3. spring.datasource.password=root
  4. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  5. #别名扫描目录
  6. mybatis.type-aliases-package=com.jaycekon.demo.model
  7. #Mapper.xml扫描目录
  8. mybatis.mapper-locations=classpath:mybatis-mappers/*.xml
  9. #tkmapper 帮助工具
  10. mapper.mappers=com.jaycekon.demo.MyMapper
  11. mapper.not-empty=false
  12. mapper.identity=MYSQL
复制代码
1.1 DataSourceBuilder

 
 我们首先来看一下使用 DataSourceBuilder 来构建出DataSource:

  1. @Configuration
  2. @MapperScan("com.jaycekon.demo.mapper")
  3. @EnableTransactionManagement
  4. public class SpringJDBCDataSource {
  5. /**
  6. * 通过Spring JDBC 快速创建 DataSource
  7. * 参数格式
  8. * spring.datasource.master.jdbcurl=jdbc:mysql://localhost:3306/charles_blog
  9. * spring.datasource.master.username=root
  10. * spring.datasource.master.password=root
  11. * spring.datasource.master.driver-class-name=com.mysql.jdbc.Driver
  12. *
  13. * @return DataSource
  14. */
  15. @Bean
  16. @ConfigurationProperties(prefix = "spring.datasource.master")
  17. public DataSource dataSource() {
  18. return DataSourceBuilder.create().build();
  19. }
  20. }
复制代码

     从代码中我们可以看出,使用DataSourceBuilder 构建DataSource 的方法非常简单,但是需要注意的是:

DataSourceBuilder 只能自动识别配置文件中的 jdbcurl,username,password,driver-class-name等命名,因此我们需要在方法体上加上 @ ConfigurationProperties 注解。 数据库连接地址变量名需要使用 jdbcurl

数据库连接池使用 com.zaxxer.hikari.HikariDataSource
    

执行单元测试时,我们可以看到 DataSource 创建以及关闭的过程。

1.2 DruidDataSource

    除了使用上述的构建方法外,我们可以选择使用阿里提供的 Druid 数据库连接池创建 DataSource

  1. @Configuration
  2. @EnableTransactionManagement
  3. public class DruidDataSourceConfig {
  4. @Autowired
  5. private DataSourceProperties properties;
  6. @Bean
  7. public DataSource dataSoucre() throws Exception {
  8. DruidDataSource dataSource = new DruidDataSource();
  9. dataSource.setUrl(properties.getUrl());
  10. dataSource.setDriverClassName(properties.getDriverClassName());
  11. dataSource.setUsername(properties.getUsername());
  12. dataSource.setPassword(properties.getPassword());
  13. dataSource.setInitialSize(5);
  14. dataSource.setMinIdle(5);
  15. dataSource.setMaxActive(100);
  16. dataSource.setMaxWait(60000);
  17. dataSource.setTimeBetweenEvictionRunsMillis(60000);
  18. dataSource.setMinEvictableIdleTimeMillis(300000);
  19. dataSource.setValidationQuery("SELECT 'x'");
  20. dataSource.setTestWhileIdle(true);
  21. dataSource.setTestOnBorrow(false);
  22. dataSource.setTestOnReturn(false);
  23. dataSource.setPoolPreparedStatements(true);
  24. dataSource.setMaxPoolPreparedStatementPerConnectionSize(20);
  25. dataSource.setFilters("stat,wall");
  26. return dataSource;
  27. }
  28. }
复制代码

使用 DruidDataSource 作为数据库连接池可能看起来会比较麻烦,但是换一个角度来说,这个更加可控。我们可以通过 DataSourceProperties 来获取 application.properties 中的配置文件:

  1. spring.datasource.url=jdbc:mysql://localhost:3306/charles_blog2
  2. spring.datasource.username=root
  3. spring.datasource.password=root
  4. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
复制代码

需要注意的是,DataSourceProperties 读取的配置文件 前缀是 spring.datasource ,我们可以进入到 DataSourceProperties 的源码中观察:

  1. @ConfigurationProperties(prefix = "spring.datasource")
  2. public class DataSourceProperties
  3. implements BeanClassLoaderAware, EnvironmentAware, InitializingBean
复制代码

可以看到,在源码中已经默认标注了前缀的格式。

 除了使用 DataSourceProperties 来获取配置文件 我们还可以使用通用的环境变量读取类:
 

  1. @Autowired
  2. private Environment env;
  3. env.getProperty("spring.datasource.write")
复制代码
2、多数据源配置

 配置多数据源主要需要以下几个步骤:

2.1 DatabaseType 数据源名称

 这里直接使用枚举类型区分,读数据源和写数据源

  1. public enum DatabaseType {
  2. master("write"), slave("read");
  3. DatabaseType(String name) {
  4. this.name = name;
  5. }
  6. private String name;
  7. public String getName() {
  8. return name;
  9. }
  10. public void setName(String name) {
  11. this.name = name;
  12. }
  13. @Override
  14. public String toString() {
  15. return "DatabaseType{" +
  16. "name='" + name + '\'' +
  17. '}';
  18. }
  19. }
复制代码
2.2 DatabaseContextHolder

   该类主要用于记录当前线程使用的数据源,使用 ThreadLocal 进行记录数据

  1. public class DatabaseContextHolder {
  2. private static final ThreadLocal<DatabaseType> contextHolder = new ThreadLocal<>();
  3. public static void setDatabaseType(DatabaseType type) {
  4. contextHolder.set(type);
  5. }
  6. public static DatabaseType getDatabaseType() {
  7. return contextHolder.get();
  8. }
  9. }
复制代码
2.3 DynamicDataSource

   该类继承 AbstractRoutingDataSource 用于管理 我们的数据源,主要实现了 determineCurrentLookupKey 方法。 后续细述这个类是如何进行多数据源管理的。
   

  1. public class DynamicDataSource extends AbstractRoutingDataSource {
  2. @Nullable
  3. @Override
  4. protected Object determineCurrentLookupKey() {
  5. DatabaseType type = DatabaseContextHolder.getDatabaseType();
  6. logger.info("====================dataSource ==========" + type);
  7. return type;
  8. }
  9. }
复制代码
2.4 DataSourceConfig

     最后一步就是配置我们的数据源,将数据源放置到 DynamicDataSource 中:
     

  1. @Configuration
  2. @MapperScan("com.jaycekon.demo.mapper")
  3. @EnableTransactionManagement
  4. public class DataSourceConfig {
  5. @Autowired
  6. private DataSourceProperties properties;
  7. /**
  8. * 通过Spring JDBC 快速创建 DataSource
  9. * 参数格式
  10. * spring.datasource.master.jdbcurl=jdbc:mysql://localhost:3306/charles_blog
  11. * spring.datasource.master.username=root
  12. * spring.datasource.master.password=root
  13. * spring.datasource.master.driver-class-name=com.mysql.jdbc.Driver
  14. *
  15. * @return DataSource
  16. */
  17. @Bean(name = "masterDataSource")
  18. @Qualifier("masterDataSource")
  19. @ConfigurationProperties(prefix = "spring.datasource.master")
  20. public DataSource masterDataSource() {
  21. return DataSourceBuilder.create().build();
  22. }
  23. /**
  24. * 手动创建DruidDataSource,通过DataSourceProperties 读取配置
  25. * 参数格式
  26. * spring.datasource.url=jdbc:mysql://localhost:3306/charles_blog
  27. * spring.datasource.username=root
  28. * spring.datasource.password=root
  29. * spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  30. *
  31. * @return DataSource
  32. * @throws SQLException
  33. */
  34. @Bean(name = "slaveDataSource")
  35. @Qualifier("slaveDataSource")
  36. public DataSource slaveDataSource() throws SQLException {
  37. DruidDataSource dataSource = new DruidDataSource();
  38. dataSource.setUrl(properties.getUrl());
  39. dataSource.setDriverClassName(properties.getDriverClassName());
  40. dataSource.setUsername(properties.getUsername());
  41. dataSource.setPassword(properties.getPassword());
  42. dataSource.setInitialSize(5);
  43. dataSource.setMinIdle(5);
  44. dataSource.setMaxActive(100);
  45. dataSource.setMaxWait(60000);
  46. dataSource.setTimeBetweenEvictionRunsMillis(60000);
  47. dataSource.setMinEvictableIdleTimeMillis(300000);
  48. dataSource.setValidationQuery("SELECT 'x'");
  49. dataSource.setTestWhileIdle(true);
  50. dataSource.setTestOnBorrow(false);
  51. dataSource.setTestOnReturn(false);
  52. dataSource.setPoolPreparedStatements(true);
  53. dataSource.setMaxPoolPreparedStatementPerConnectionSize(20);
  54. dataSource.setFilters("stat,wall");
  55. return dataSource;
  56. }
  57. /**
  58. * 构造多数据源连接池
  59. * Master 数据源连接池采用 HikariDataSource
  60. * Slave 数据源连接池采用 DruidDataSource
  61. * @param master
  62. * @param slave
  63. * @return
  64. */
  65. @Bean
  66. @Primary
  67. public DynamicDataSource dataSource(@Qualifier("masterDataSource") DataSource master,
  68. @Qualifier("slaveDataSource") DataSource slave) {
  69. Map<Object, Object> targetDataSources = new HashMap<>();
  70. targetDataSources.put(DatabaseType.master, master);
  71. targetDataSources.put(DatabaseType.slave, slave);
  72. DynamicDataSource dataSource = new DynamicDataSource();
  73. dataSource.setTargetDataSources(targetDataSources);// 该方法是AbstractRoutingDataSource的方法
  74. dataSource.setDefaultTargetDataSource(slave);// 默认的datasource设置为myTestDbDataSourcereturn dataSource;
  75. }
  76. @Bean
  77. public SqlSessionFactory sqlSessionFactory(@Qualifier("masterDataSource") DataSource myTestDbDataSource,
  78. @Qualifier("slaveDataSource") DataSource myTestDb2DataSource) throws Exception {
  79. SqlSessionFactoryBean fb = new SqlSessionFactoryBean();
  80. fb.setDataSource(this.dataSource(myTestDbDataSource, myTestDb2DataSource));
  81. fb.setTypeAliasesPackage(env.getProperty("mybatis.type-aliases-package"));
  82. fb.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(env.getProperty("mybatis.mapper-locations")));
  83. return fb.getObject();
  84. }
  85. }
复制代码

   上述代码块比较长,我们来解析一下:

masterDataSourceslaveDataSource 主要是用来创建数据源的,这里分别使用了 hikaridatasource 和 druidDataSource 作为数据源 DynamicDataSource 方法体中,我们主要是将两个数据源都放到 DynamicDataSource 中进行统一管理 SqlSessionFactory 方法则是将所有数据源(DynamicDataSource )统一管理 2.5 UserMapperTest

   接下来我们来简单观察一下 DataSource 的创建过程:

   首先我们可以看到我们的两个数据源以及构建好了,分别使用的是HikariDataSourceDruidDataSource,然后我们会将两个数据源放入到 targetDataSource 中,并且这里讲我们的 slave 作为默认数据源 defaultTargetDataSource
   

然后到获取数据源这一块:

    主要是从 AbstractRoutingDataSource 这个类中的 determineTargetDataSource( ) 方法中进行判断,这里会调用到我们在 DynamicDataSource 中的方法, 去判断需要使用哪一个数据源。如果没有设置数据源,将采用默认数据源,就是我们刚才设置的DruidDataSource 数据源。
    

      在最后的代码运行结果中:

      我们可以看到确实是使用了我们设置的默认数据源。
      

3、读写分离

  在经历了千山万水后,终于来到我们的读写分离模块了,首先我们需要添加一些我们的配置信息:

  1. spring.datasource.read = get,select,count,list,query
  2. spring.datasource.write = add,create,update,delete,remove,insert
复制代码

这两个变量主要用于切面判断中,区分哪一些部分是需要使用 读数据源,哪些是需要使用写的。

3.1 DynamicDataSource 修改
  1. public class DynamicDataSource extends AbstractRoutingDataSource {
  2. static final Map<DatabaseType, List<String>> METHOD_TYPE_MAP = new HashMap<>();
  3. @Nullable
  4. @Override
  5. protected Object determineCurrentLookupKey() {
  6. DatabaseType type = DatabaseContextHolder.getDatabaseType();
  7. logger.info("====================dataSource ==========" + type);
  8. return type;
  9. }
  10. void setMethodType(DatabaseType type, String content) {
  11. List<String> list = Arrays.asList(content.split(","));
  12. METHOD_TYPE_MAP.put(type, list);
  13. }
  14. }
复制代码

 在这里我们需要添加一个Map 进行记录一些读写的前缀信息。

3.2 DataSourceConfig 修改

 在DataSourceConfig 中,我们再设置DynamicDataSource 的时候,将前缀信息设置进去。

  1. @Bean
  2. @Primary
  3. public DynamicDataSource dataSource(@Qualifier("masterDataSource") DataSource master,
  4. @Qualifier("slaveDataSource") DataSource slave) {
  5. Map<Object, Object> targetDataSources = new HashMap<>();
  6. targetDataSources.put(DatabaseType.master, master);
  7. targetDataSources.put(DatabaseType.slave, slave);
  8. DynamicDataSource dataSource = new DynamicDataSource();
  9. dataSource.setTargetDataSources(targetDataSources);// 该方法是AbstractRoutingDataSource的方法
  10. dataSource.setDefaultTargetDataSource(slave);// 默认的datasource设置为myTestDbDataSource
  11. String read = env.getProperty("spring.datasource.read");
  12. dataSource.setMethodType(DatabaseType.slave, read);
  13. String write = env.getProperty("spring.datasource.write");
  14. dataSource.setMethodType(DatabaseType.master, write);
  15. return dataSource;
  16. }
复制代码
3.3 DataSourceAspect

  在配置好读写的方法前缀后,我们需要配置一个切面,监听在进入Mapper 方法前将数据源设置好:

  主要的操作点在于 DatabaseContextHolder.setDatabaseType(type); 结合我们上面多数据源的获取数据源方法,这里就是我们设置读或写数据源的关键了。
  

  1. @Aspect
  2. @Component
  3. @EnableAspectJAutoProxy(proxyTargetClass = true)
  4. public class DataSourceAspect {
  5. private static Logger logger = LoggerFactory.getLogger(DataSourceAspect.class);
  6. @Pointcut("execution(* com.jaycekon.demo.mapper.*.*(..))")
  7. public void aspect() {
  8. }
  9. @Before("aspect()")
  10. public void before(JoinPoint point) {
  11. String className = point.getTarget().getClass().getName();
  12. String method = point.getSignature().getName();
  13. String args = StringUtils.join(point.getArgs(), ",");
  14. logger.info("className:{}, method:{}, args:{} ", className, method, args);
  15. try {
  16. for (DatabaseType type : DatabaseType.values()) {
  17. List<String> values = DynamicDataSource.METHOD_TYPE_MAP.get(type);
  18. for (String key : values) {
  19. if (method.startsWith(key)) {
  20. logger.info(">>{} 方法使用的数据源为:{}<<", method, key);
  21. DatabaseContextHolder.setDatabaseType(type);
  22. DatabaseType types = DatabaseContextHolder.getDatabaseType();
  23. logger.info(">>{}方法使用的数据源为:{}<<", method, types);
  24. }
  25. }
  26. }
  27. } catch (Exception e) {
  28. logger.error(e.getMessage(), e);
  29. }
  30. }
  31. }
复制代码
3.4 UserMapperTest

 方法启动后,先进入切面中,根据methodName 设置数据源类型。
 

然后进入到determineTargetDataSource 方法中 获取到数据源:

运行结果:

4、写在最后

  希望看完后觉得有帮助的朋友,帮博主到github 上面点个Start 或者 fork

  Spring-Blog 项目GitHub地址:Spring-Blog

  示例代码 Github 地址:示例代码



回复

使用道具 举报