Spring Boot动态数据源切换

淡淡的烟草味﹌ 2023-06-03 07:00 18阅读 0赞

在实际开发过程中,可能有这样的情况,一个项目涉及到多个数据库.有的数据需要插入这个数据库,而有的数据需要插入到另一个数据库里面.所以接下来,就来教大家怎么用最简单的方式来实现这一需求.

我们将会用Spring里面的AOP设计来实现这一逻辑.通过把注解添加在方法上(DAO方法上)来实现数据源的动态切换.简单来说就是当前方法操作的是哪个数据源,我们就需要在方法上添加注解标识使用哪个数据源.

我们注意到在Spring2.0.1中引入了AbstractRoutingDataSource,该类充当了DataSource的路由中介,能有在运行时,根据某种key值来动态切换到真正的DataSource上.AbstractRoutingDataSource就是我们实现数据源动态切换的关键部分.

接下来,为了加深大家的理解,我们通过一个简单的例子一步一步来实现这一过程.假设现在,我们有这样一个需求.项目里面需要到三个数据源(三个数据库).

# 一 数据源枚举 #

我们用一个枚举来表示这三个数据源.每个枚举表示一个数据源,三个数据源,三个枚举.如下:

public enum EDataSourceType {
    
        /**
         * 【基础】数据库数据源名称
         */
        BASIC,
    
        /**
         * 【历史】数据库数据源名称
         */
        HISTORY,
    
        /**
         * 【统计】数据库数据源名称
         */
        STATIS
    }

# 二 数据源配置 #

三个数据源肯定都有各自的url地址,所以配置文件(application.yml)配置如下:

spring:
      application:
        name: table-shard
      datasource:
        name: mysql_test
        type: com.alibaba.druid.pool.DruidDataSource
        druid:
          # 多数据源
          basic:  #数据源 -- 基础数据库
            url: jdbc:mysql://127.0.0.1:3306/basicdb?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=GMT%2B8
            username: root
            password: 123456
          history:  #数据源 -- 历史数据库
            url: jdbc:mysql://127.0.0.1:3306/historydb?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=GMT%2B8
            username: root
            password: 123456
          statis:  #数据源 -- 统计数据库
            url: jdbc:mysql://127.0.0.1:3306/statisdb?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=GMT%2B8
            username: root
            password: 123456
          filters: stat
          driver-class-name: com.mysql.cj.jdbc.Driver
          initial-size: 1
          min-idle: 1
          max-active: 20
          max-wait: 60000
          time-between-eviction-runs-millis: 60000
          min-evictable-idle-time-millis: 300000
          validation-query: SELECT 'x'
          test-while-idle: true
          test-on-borrow: false
          test-on-return: false
          pool-prepared-statements: false
          max-pool-prepared-statement-per-connection-size: 20

> 注意三个数据源的配置

# 三 数据源(DataSource)路由的实现 #

AbstractRoutingDataSource是DataSource的路由中介的处理器.也是我们实现数据源动切换最关键的部分.我们自定义DynamicRoutingDataSource类继承AbstractRoutingDataSource加入数据源切换的逻辑.

在运行过程中Spring会调用AbstractRoutingDataSource.determineCurrentLookupKey()方法动态获取到需要的数据源.DynamicRoutingDataSource构造函数需要两个参数一个是默认的数据源,另一个是多数据源map.key是数据源标识也就是我们上面的数据源枚举EDataSourceType,value是DataSource(每个数据源对应的DataSource我们会在配置文件里面添加进来).这样在运行(AOP)的时候我们只需要调用setDataSource()方法指定到我们需要的数据源上就可以了.

/**
     * @name: DynamicRoutingDataSource
     * @author: tuacy.
     * @date: 2019/6/24.
     * @version: 1.0
     * @Description: 动态数据源设置，每次访问之前设置，访问完成之后在清空
     * (AbstractRoutingDataSource相当于数据源路由中介,能有在运行时, 根据某种key值来动态切换到真正的DataSource上)
     */
    public class DynamicRoutingDataSource extends AbstractRoutingDataSource {
    
        private static final ThreadLocal<EDataSourceType> contextHolder = new ThreadLocal<>();
    
        /**
         * 构造函数
         *
         * @param defaultTargetDataSource 默认的数据源
         * @param targetDataSources       多数据源每个key对应一个数据源
         */
        public DynamicRoutingDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
            // 设置默认数据源
            super.setDefaultTargetDataSource(defaultTargetDataSource);
            // 设置多数据源. key value的形式
            super.setTargetDataSources(targetDataSources);
            super.afterPropertiesSet();
        }
    
        /**
         * 多数据源对应的key, 会通过这个key找到我们需要的数据源
         */
        @Override
        protected Object determineCurrentLookupKey() {
            return getDataSource();
        }
    
        /**
         * 设置使用哪个数据源
         *
         * @param dataSource 数据源对应的名字
         */
        public static void setDataSource(EDataSourceType dataSource) {
            contextHolder.set(dataSource);
        }
    
        /**
         * 获取数据源对应的名字
         * @return 数据源对应的名字
         */
        public static EDataSourceType getDataSource() {
            return contextHolder.get();
        }
    
        /**
         * 清空掉
         */
        public static void clearDataSource() {
            contextHolder.remove();
        }
    
    }

# 四 配置 #

## 4.1 DynamicDataSourceConfig配置 ##

把我们自定义的DynamicRoutingDataSource类注入到IOC容器里面去.特别注意DynamicRoutingDataSource类的构造函需要两个参数一个是默认的数据源,一个是多数据源map.注意map key是数据源标识(我们定义的数据源枚举EDataSourceType),value是每个数据源对应的DataSource(url,password等配置信息).

public class DynamicDataSourceConfig {
    
        /**
         * 基础数据库   application.yml spring.datasource.druid.basic配置信息
         *
         * @return DataSource
         */
        @Bean(name = "basicDataSource")
        @ConfigurationProperties("spring.datasource.druid.basic")
        public DataSource basicDataSource() {
            return new DruidDataSource();
        }
    
        /**
         * 历史数据库  application.yml spring.datasource.druid.history配置信息
         *
         * @return DataSource
         */
        @Bean(name = "historyDataSource")
        @ConfigurationProperties("spring.datasource.druid.history")
        public DataSource historyDataSource() {
            return new DruidDataSource();
        }
    
        /**
         * 统计数据库  application.yml  spring.datasource.druid.statis配置信息
         *
         * @return DataSource
         */
        @Bean(name = "statisDataSource")
        @ConfigurationProperties("spring.datasource.druid.statis")
        public DataSource statisDataSource() {
            return new DruidDataSource();
        }
    
        /**
         * 我们我们自定义的数据源DynamicRoutingDataSource添加到Spring容器里面去
         *
         * @param basicDataSource   基础数据库
         * @param historyDataSource 历史数据库
         * @param statisDataSource  统计数据库
         */
        @Bean
        @Primary
        public DynamicRoutingDataSource dataSource(DataSource basicDataSource, DataSource historyDataSource, DataSource statisDataSource) {
            Map<Object, Object> targetDataSources = Maps.newHashMapWithExpectedSize(3);
            // 每个key对应一个数据源
            targetDataSources.put(EDataSourceType.BASIC, basicDataSource);
            targetDataSources.put(EDataSourceType.HISTORY, historyDataSource);
            targetDataSources.put(EDataSourceType.STATIS, statisDataSource);
            return new DynamicRoutingDataSource(basicDataSource, targetDataSources);
        }
    
    }

## 4.2 启动类上的配置 ##

在启动类上添加.过滤掉DataSourceAutoConfiguration配置,进入我们的配置DynamicDataSourceConfig.就是把默认的数据源配置替换成我们自定义的数据源配置.

@SpringBootApplication(exclude = {
            DataSourceAutoConfiguration.class
    })
    @Import({DynamicDataSourceConfig.class})

# 五 AOP #

AOP的实现部分就是在运行的时候去调用DynamicRoutingDataSource.setDataSource().我们把AOP注解添加在方法上,在进入方法之前我们先调用DynamicRoutingDataSource.setDataSource()来设置我们需要的数据源.实现逻辑如下.

@Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface DataSourceAnnotation {
    
        /**
         * 数据源类型
         * @return 数据源类型
         */
        EDataSourceType sourceType();
    }

@Aspect
    @Component
    @Order(value = 1)
    public class DataSourceAspect {
    
        /**
         * 所有添加了DataSourceAnnotation的方法都进入切面
         */
        @Pointcut("@annotation(com.tuacy.tableshard.tableextend.multisource.DataSourceAnnotation)")
        public void dataSourcePointCut() {
        }
    
        @Around("dataSourcePointCut()")
        public Object around(ProceedingJoinPoint point) throws Throwable {
            MethodSignature signature = (MethodSignature) point.getSignature();
            Method method = signature.getMethod();
    
            // 在执行方法之前设置使用哪个数据源
            DataSourceAnnotation ds = method.getAnnotation(DataSourceAnnotation.class);
            if (ds == null) {
                DynamicRoutingDataSource.setDataSource(EDataSourceType.BASIC);
            } else {
                DynamicRoutingDataSource.setDataSource(ds.sourceType());
            }
    
            try {
                return point.proceed();
            } finally {
                DynamicRoutingDataSource.clearDataSource();
            }
        }
    }

# 六 使用 #

使用很简单,就是在DAO对应的方法上添加@DataSourceAnnotation注解来指定数据源.这样这个DAO方法里面使用到的数据源就是我们指定的数据源.

/**
         * DataSourceAnnotation 用于指定数据源,放到统计数据库里面
         */
        @Override
        @DataSourceAnnotation(sourceType = EDataSourceType.STATIS)
        @Transactional(rollbackFor = Exception.class)
        public int insertItem(AccHour item) {
            return accHourMapper.insertItem(item);
        }

--------------------

上述动态数据源的切换整个逻辑我们就已经全部实现了,很简单的.主要就是AbstractRoutingDataSource以及AOP的使用.更加详细的代码可以看下 [https://github.com/tuacy/java-study/tree/master/tableshard][https_github.com_tuacy_java-study_tree_master_tableshard]

[https_github.com_tuacy_java-study_tree_master_tableshard]: https://github.com/tuacy/java-study/tree/master/tableshard