SpringBoot实现数据源动态切换的最佳姿势_Java

在介绍动态数据源之前，我们先一起来看看多数据源在 spring boot 中的实现方式。

1.1数据库准备

创建两个库，分别是db_test_1和db_test_2。db_test_1数据库中创建一张用户表，脚本如下：

db_test_2数据库中创建另一张账户表，脚本如下：

1.2工程环境准备

pom.xml中添加相关的依赖包，示例如下：

<!--spring boot核心-->
<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter</artifactid>
</dependency>
<!--spring boot 测试-->
<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-test</artifactid>
    <scope>test</scope>
</dependency>
<!--mysql 驱动-->
<dependency>
    <groupid>mysql</groupid>
    <artifactid>mysql-connector-java</artifactid>
</dependency>
<!-- druid -->
<dependency>
    <groupid>com.alibaba</groupid>
    <artifactid>druid-spring-boot-starter</artifactid>
    <version>1.1.10</version>
</dependency>
<!--mybatis-->
<dependency>
    <groupid>org.mybatis.spring.boot</groupid>
    <artifactid>mybatis-spring-boot-starter</artifactid>
    <version>2.0.0</version>
</dependency>
<!--aspectj 注解代理-->
<dependency>
    <groupid>org.aspectj</groupid>
    <artifactid>aspectjweaver</artifactid>
</dependency>

1.3编写多数据源

创建动态数据源服务类

首先，创建一个dynamicdatasource类，并继承abstractroutingdatasource抽象类，同时重写determinecurrentlookupkey()方法，代码示例如下：

创建动态数据源缓存类

创建一个datasourcecontextholder类，用于缓存数据源，同时需要确保线程环境下安全

package com.example.dynamic.datasource.config;
 
publicclass datasourcecontextholder {
 
    /**
     * 设置线程独立变量，用于存储数据源唯一标记
     */
    privatestaticfinal threadlocal<string> datasource_holder = new threadlocal<>();
 
    /**
     * 设置数据源
     * @param datasourcename 数据源名称
     */
    public static void set(string datasourcename){
        datasource_holder.set(datasourcename);
    }
 
    /**
     * 获取当前线程的数据源
     * @return 数据源名称
     */
    public static string get(){
        return datasource_holder.get();
    }
 
    /**
     * 删除当前数据源
     */
    public static void remove(){
        datasource_holder.remove();
    }
 
}

创建动态数据源配置类

接着，创建一个datasourceconfig配置类，设置动态数据源相关的参数，并注入到 bean 工厂，代码示例如下：

package com.example.dynamic.datasource.config;
 
@configuration
publicclass datasourceconfig {
 
    @bean(name = "db1")
    @configurationproperties(prefix = "spring.datasource.db1.druid")
    public datasource db1(){
        return druiddatasourcebuilder.create().build();
    }
 
    @bean(name = "db2")
    @configurationproperties(prefix = "spring.datasource.db2.druid")
    public datasource db2(){
        return druiddatasourcebuilder.create().build();
    }
 
    @bean
    @primary
    public dynamicdatasource createdynamicdatasource(){
        // 配置数据源集合，其中key代表数据源名称，datasourcecontextholder中缓存的就是这个key
        map<object,object> datasourcemap = new hashmap<>();
        datasourcemap.put("db1",db1());
        datasourcemap.put("db2",db2());
 
        // 注入动态数据源到bean工厂
        dynamicdatasource dynamicdatasource = new dynamicdatasource();
        // 设置默认数据源
        dynamicdatasource.setdefaulttargetdatasource(db1());
        // 设置动态数据源集
        dynamicdatasource.settargetdatasources(datasourcemap);
        return dynamicdatasource;
    }
}

编写相关配置变量

根据上面的配置变量，我们还需要在application.properties文件中添加相关的数据源变量，内容如下：

排除自动装配数据源

需要在注解@springbootapplication类上排除自动装配数据源配置，内容如下：

1.4利用切面代理类设置数据源

在上文中，我们采用的是手动方式来设置数据源，在实际的业务开发中，我们通常会采用切面代理类来设置数据源，以便简化代码复杂度。

创建数据源注解

首先，定义一个数据源注解来实现数据源的切换，同时配置一个默认的数据源名称，代码示例如下：

package com.example.dynamic.datasource.config.aop;
 
@target({elementtype.method, elementtype.type})
@retention(retentionpolicy.runtime)
@documented
public @interface dbsource {
 
    /**
     * 数据源key值
     * @return
     */
    string value() default "db1";
}

编写数据源代理类

接着，基于@dbsource注解，创建一个 aop 代理类，所有配置该注解的方法都会被前后拦截，代码示例如下：

package com.example.dynamic.datasource.config.aop;
 
@order(1)
@aspect
@component
publicclass dbsourceaspect {
 
    privatestaticfinal logger logger = loggerfactory.getlogger(dbsourceaspect.class);
 
 
    @pointcut("@annotation(com.example.dynamic.datasource.config.aop.dbsource)")
    public void dynamicdatasource(){}
 
    @around("dynamicdatasource()")
    public object datasourcearound(proceedingjoinpoint point) throws throwable {
        // 获取要切换的数据源名称
        methodsignature methodsignature = (methodsignature)point.getsignature();
        method method = methodsignature.getmethod();
        dbsource dbsource = method.getannotation(dbsource.class);
        logger.info("select datasource:" + dbsource.value());
        datasourcecontextholder.set(dbsource.value());
        try {
            return point.proceed();
        } finally {
            datasourcecontextholder.remove();
        }
    }
}

使用注解切换数据源

最后，在需要的方法上配置相关的数据源注解即可。

@service
public class userinfoservice {
 
    @autowired
    private userinfomapper userinfomapper;
 
    @transactional
    @dbsource(value = "db1")
    public void add(userinfo entity){
        userinfomapper.insert(entity);
    }
}

账户服务类，代码示例如下：

@service
public class accountinfoservice {
 
    @autowired
    private accountinfomapper accountinfomapper;
 
    @transactional
    @dbsource(value = "db2")
    public void add(accountinfo entity){
        accountinfomapper.insert(entity);
    }
}

采用 aop 代理的方式来切换数据源，业务实现上会更加的灵活。

在上文中，我们介绍了多数据源的配置实现方式，这种配置方式有一个不好的地方在于：配置文件都是写死的。

能不能改成动态的加载数据源呢，下面我们一起来看看相关的具体实现方式

2.1数据库准备

首先，我们需要准备一张数据源配置表。新建一个test_db数据库，然后在数据库中创建一张数据源配置表，脚本如下：

create table`tb_db_info` (
`id`int(11) unsignednotnull auto_increment,
`db_name`varchar(50) defaultnull,
`db_url`varchar(200) defaultnull,
`driver_class_name`varchar(100) defaultnull,
`username`varchar(80) defaultnull,
`password`varchar(80) defaultnull,
  primary key (`id`)
) engine=innodb auto_increment=3defaultcharset=utf8mb4;

最后，初始化两条数据，方便后续数据源的查询。

2.2修改全局配置文件

我们还是以上文介绍的工程为例，把之前自定义的配置参数删除掉，重新基于 spring boot 约定的配置方式，添加相关的数据源参数，内容如下：

# 配置默认数据源
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.driver

2.3编写相关的服务类

基于数据库中tb_db_info表，编写相关的查询逻辑，代码示例如下：

package com.example.dynamic.datasource.entity;
 
publicclass dbinfo {
 
    /**
     * 主键id
     */
    private integer id;
 
    /**
     * 数据库key，即保存map中的key
     */
    private string dbname;
 
    /**
     * 数据库地址
     */
    private string dburl;
 
    /**
     * 数据库驱动
     */
    private string driverclassname;
 
    /**
     * 数据库用户名
     */
    private string username;
 
    /**
     * 数据库密码
     */
    private string password;
 
    // set、get方法等...
}

public interface dbinfomapper {
 
    list<dbinfo> findall();
}

<?xml version="1.0" encoding="utf-8" ?>
<!doctype mapper
        public "-//mybatis.org//dtd mapper 3.0//en"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.dynamic.datasource.mapper.dbinfomapper">
 
    <select id="findall" resulttype="com.example.dynamic.datasource.entity.dbinfo">
        select
        id
        ,db_name as dbname
        ,db_url as dburl
        ,driver_class_name as driverclassname
        ,username
        ,password
        from tb_db_info
        order by id
    </select>
</mapper>

2.4修改动态数据源服务类

对dynamicdatasource类进行一些调整，代码如下：

public class dynamicdatasource extends abstractroutingdatasource {
 
    @override
    protected object determinecurrentlookupkey() {
        return datasourcecontextholder.get();
    }
 
    /**
     * 重新加载数据源集合
     * @param dblist
     */
    public void loaddatasources(list<dbinfo> dblist){
        try {
            map<object, object> targetdatasourcemap = new hashmap<>();
            for (dbinfo source : dblist) {
                // 初始化数据源
                druiddatasource datasource = new druiddatasource();
                datasource.setdriverclassname(source.getdriverclassname());
                datasource.seturl(source.getdburl());
                datasource.setusername(source.getusername());
                datasource.setpassword(source.getpassword());
                datasource.setinitialsize(1);
                datasource.setminidle(1);
                datasource.setmaxactive(5);
                datasource.settestwhileidle(true);
                datasource.settestonborrow(true);
                datasource.setvalidationquery("select 1 ");
                datasource.init();
                targetdatasourcemap.put(source.getdbname(), datasource);
            }
            super.settargetdatasources(targetdatasourcemap);
            // 重新初始化resolveddatasources对象
            super.afterpropertiesset();
        } catch (exception e){
            e.printstacktrace();
        }
    }
}

2.5修改动态数据源配置类

对datasourceconfig类也需要进行一些调整，通过 spring boot 默认的数据源配置类初始化一个数据源实例对象，代码如下：

@configuration
publicclass datasourceconfig {
 
    @autowired
    private datasourceproperties basicproperties;
 
    /**
     * 注入动态数据源
     * @param datasource
     * @return
     */
    @bean
    @primary
    public dynamicdatasource dynamicdatasource(){
        // 获取初始数据源
        datasource defaultdatasource = basicproperties.initializedatasourcebuilder().build();
 
        map<object,object> targetdatasources = new hashmap<>();
        targetdatasources.put("defaultdatasource", defaultdatasource);
        // 注入动态数据源
        dynamicdatasource dynamicdatasource = new dynamicdatasource();
        // 设置默认数据源
        dynamicdatasource.setdefaulttargetdatasource(defaultdatasource);
        // 设置动态数据源集
        dynamicdatasource.settargetdatasources(targetdatasources);
        return dynamicdatasource;
    }
}