请选择 进入手机版 | 继续访问电脑版
零一零零 门户 IT技术 Spring 查看内容

SpringBoot、AOP,动态数据源实现数据库读写分离

2020-9-22 07:54| 发布者: x0100| 查看: 167| 评论: 0

摘要: 环境部署 数据库:MySql 库数量:2个,一主一从 关于mysql的主从环境部署,可以参考: https://juejin.im/post/5dd13778e51d453da86c0e6f 开始项目 首先,毫无疑问,先开始搭建一个SpringBoot工程,然后在pom ...

环境部署

 

  • 数据库:MySql

  • 库数量:2个,一主一从

关于mysql的主从环境部署,可以参考:

https://juejin.im/post/5dd13778e51d453da86c0e6f

开始项目

首先,毫无疑问,先开始搭建一个SpringBoot工程,然后在pom文件中引入如下依赖:

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>com.alibaba</groupId>
  4.             <artifactId>druid-spring-boot-starter</artifactId>
  5.             <version>1.1.10</version>
  6.         </dependency>
  7.         <dependency>
  8.             <groupId>org.mybatis.spring.boot</groupId>
  9.             <artifactId>mybatis-spring-boot-starter</artifactId>
  10.             <version>1.3.2</version>
  11.         </dependency>
  12.         <dependency>
  13.             <groupId>tk.mybatis</groupId>
  14.             <artifactId>mapper-spring-boot-starter</artifactId>
  15.             <version>2.1.5</version>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>mysql</groupId>
  19.             <artifactId>mysql-connector-java</artifactId>
  20.             <version>8.0.16</version>
  21.         </dependency>
  22.         <!-- 动态数据源 所需依赖 ### start-->
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-jdbc</artifactId>
  26.             <scope>provided</scope>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-aop</artifactId>
  31.             <scope>provided</scope>
  32.         </dependency>
  33.         <!-- 动态数据源 所需依赖 ### end-->
  34.         <dependency>
  35.             <groupId>org.springframework.boot</groupId>
  36.             <artifactId>spring-boot-starter-web</artifactId>
  37.         </dependency>
  38.         <dependency>
  39.             <groupId>org.projectlombok</groupId>
  40.             <artifactId>lombok</artifactId>
  41.             <optional>true</optional>
  42.         </dependency>
  43.         <dependency>
  44.             <groupId>com.alibaba</groupId>
  45.             <artifactId>fastjson</artifactId>
  46.             <version>1.2.4</version>
  47.         </dependency>
  48.         <dependency>
  49.             <groupId>org.springframework.boot</groupId>
  50.             <artifactId>spring-boot-starter-test</artifactId>
  51.             <scope>test</scope>
  52.         </dependency>
  53.         <dependency>
  54.             <groupId>org.springframework.boot</groupId>
  55.             <artifactId>spring-boot-starter-data-jpa</artifactId>
  56.         </dependency>
  57.     </dependencies>

 

目录结构

引入基本的依赖后,整理一下目录结构,完成后的项目骨架大致如下:

建表

创建一张表user,在主库执行sql语句同时在从库生成对应的表数据

  1. DROP TABLE IF EXISTS `user`;
  2. CREATE TABLE `user` (
  3.   `user_id` bigint(20NOT NULL COMMENT '用户id',
  4.   `user_name` varchar(255DEFAULT '' COMMENT '用户名称',
  5.   `user_phone` varchar(50DEFAULT '' COMMENT '用户手机',
  6.   `address` varchar(255DEFAULT '' COMMENT '住址',
  7.   `weight` int(3NOT NULL DEFAULT '1' COMMENT '权重,大者优先',
  8.   `created_at` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  9.   `updated_at` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  10.   PRIMARY KEY (`user_id`)
  11. ENGINE=InnoDB DEFAULT CHARSET=utf8;
  12. INSERT INTO `user` VALUES ('1196978513958141952''测试1''18826334748''广州市海珠区''1''2019-11-20 10:28:51''2019-11-22 14:28:26');
  13. INSERT INTO `user` VALUES ('1196978513958141953''测试2''18826274230''广州市天河区''2''2019-11-20 10:29:37''2019-11-22 14:28:14');
  14. INSERT INTO `user` VALUES ('1196978513958141954''测试3''18826273900''广州市天河区''1''2019-11-20 10:30:19''2019-11-22 14:28:30');

 

主从数据源配置

application.yml,主要信息是主从库的数据源配置

搜索公众号程序员小乐回复关键字“offer”,获取算法面试题和答案。

  1. server:
  2.   port8001
  3. spring:
  4.   jackson:
  5.       date-format: yyyy-MM-dd HH:mm:ss
  6.       time-zone: GMT+8
  7.   datasource:
  8.     type: com.alibaba.druid.pool.DruidDataSource
  9.     driver-class-name: com.mysql.cj.jdbc.Driver
  10.     master:
  11.       urljdbc:mysql://127.0.0.1:3307/user?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false&useSSL=false&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true
  12.       username: root
  13.       password:
  14.     slave:
  15.       urljdbc:mysql://127.0.0.1:3308/user?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false&useSSL=false&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true
  16.       username: root
  17.       password:

因为有一主一从两个数据源,我们用枚举类来代替,方便我们使用时能对应

  1. @Getter
  2. public enum DynamicDataSourceEnum {
  3.     MASTER("master"),
  4.     SLAVE("slave");
  5.     private String dataSourceName;
  6.     DynamicDataSourceEnum(String dataSourceName) {
  7.         this.dataSourceName = dataSourceName;
  8.     }
  9. }

数据源配置信息类 DataSourceConfig,这里配置了两个数据源,masterDb和slaveDb

  1. @Configuration
  2. @MapperScan(basePackages = "com.xjt.proxy.mapper", sqlSessionTemplateRef = "sqlTemplate")
  3. public class DataSourceConfig {
  4.      // 主库
  5.       @Bean
  6.       @ConfigurationProperties(prefix = "spring.datasource.master")
  7.       public DataSource masterDb() {
  8.   return DruidDataSourceBuilder.create().build();
  9.       }
  10.     /**
  11.      * 从库
  12.      */
  13.     @Bean
  14.     @ConditionalOnProperty(prefix = "spring.datasource", name = "slave", matchIfMissing = true)
  15.     @ConfigurationProperties(prefix = "spring.datasource.slave")
  16.     public DataSource slaveDb() {
  17.         return DruidDataSourceBuilder.create().build();
  18.     }
  19.     /**
  20.      * 主从动态配置
  21.      */
  22.     @Bean
  23.     public DynamicDataSource dynamicDb(@Qualifier("masterDb") DataSource masterDataSource,
  24.         @Autowired(required = false) @Qualifier("slaveDb") DataSource slaveDataSource) {
  25.         DynamicDataSource dynamicDataSource = new DynamicDataSource();
  26.         Map<Object, Object> targetDataSources = new HashMap<>();
  27.         targetDataSources.put(DynamicDataSourceEnum.MASTER.getDataSourceName(), masterDataSource);
  28.         if (slaveDataSource != null) {
  29.             targetDataSources.put(DynamicDataSourceEnum.SLAVE.getDataSourceName(), slaveDataSource);
  30.         }
  31.         dynamicDataSource.setTargetDataSources(targetDataSources);
  32.         dynamicDataSource.setDefaultTargetDataSource(masterDataSource);
  33.         return dynamicDataSource;
  34.     }
  35.     @Bean
  36.     public SqlSessionFactory sessionFactory(@Qualifier("dynamicDb") DataSource dynamicDataSource) throws Exception {
  37.         SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  38.         bean.setMapperLocations(
  39.             new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/*Mapper.xml"));
  40.         bean.setDataSource(dynamicDataSource);
  41.         return bean.getObject();
  42.     }
  43.     @Bean
  44.     public SqlSessionTemplate sqlTemplate(@Qualifier("sessionFactory") SqlSessionFactory sqlSessionFactory) {
  45.         return new SqlSessionTemplate(sqlSessionFactory);
  46.     }
  47.     @Bean(name = "dataSourceTx")
  48.     public DataSourceTransactionManager dataSourceTx(@Qualifier("dynamicDb") DataSource dynamicDataSource) {
  49.         DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
  50.         dataSourceTransactionManager.setDataSource(dynamicDataSource);
  51.         return dataSourceTransactionManager;
  52.     }
  53. }

 

设置路由

设置路由的目的为了方便查找对应的数据源,我们可以用ThreadLocal保存数据源的信息到每个线程中,方便我们需要时获取

搜索公众号程序员小乐回复关键字“Java”,获取Java面试题和答案。

  1. public class DataSourceContextHolder {
  2.     private static final ThreadLocal<String> DYNAMIC_DATASOURCE_CONTEXT = new ThreadLocal<>();
  3.     public static void set(String datasourceType) {
  4.         DYNAMIC_DATASOURCE_CONTEXT.set(datasourceType);
  5.     }
  6.     public static String get() {
  7.         return DYNAMIC_DATASOURCE_CONTEXT.get();
  8.     }
  9.     public static void clear() {
  10.         DYNAMIC_DATASOURCE_CONTEXT.remove();
  11.     }
  12. }

获取路由

  1. public class DynamicDataSource extends AbstractRoutingDataSource {
  2.     @Override
  3.     protected Object determineCurrentLookupKey() {
  4.         return DataSourceContextHolder.get();
  5.     }
  6. }

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

数据源的注解

为了可以方便切换数据源,我们可以写一个注解,注解中包含数据源对应的枚举值,默认是主库,

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target(ElementType.METHOD)
  3. @Documented
  4. public @interface DataSourceSelector {
  5.     DynamicDataSourceEnum value() default DynamicDataSourceEnum.MASTER;
  6.     boolean clear() default true;
  7. }

 

aop切换数据源

到这里,aop终于可以现身出场了,这里我们定义一个aop类,对有注解的方法做切换数据源的操作,具体代码如下:

  1. @Slf4j
  2. @Aspect
  3. @Order(value = 1)
  4. @Component
  5. public class DataSourceContextAop {
  6.  @Around("@annotation(com.xjt.proxy.dynamicdatasource.DataSourceSelector)")
  7.   &nbs

鲜花

握手

雷人

路过

鸡蛋

最新评论


QQ|Archiver|手机版|小黑屋| 零一零零 ( 京ICP备20003964号 ) |网站地图

GMT+8, 2020-10-21 04:08 , Processed in 0.042114 second(s), 17 queries .

Powered by Discuz! X3.4

© 2001-2013 Comsenz Inc.

返回顶部