spring实现动态数据源（多数据源），可用于读写分离，对代码无入侵

适用场景：
1、一个项目需要从多个不同的数据库获取数据，不想创建多个项目的情况。
2、为了充分运用数据库集群中从库的性能，在从库建立只读链接，通过程序实现读写分离。

思路：
1、通过自定义注解指定程序要访问的数据库。
2、操作数据库的时候根据指定的数据库动态分配数据源（数据库连接）。

步骤：
1、创建自定义注解@DynamicDataSource，可用于方法上，用来指定该方法用到的数据库。
2、通过AOP将指定的数据源放入到ThreadLocal中。
3、通过实现org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource的determineCurrentLookupKey()来动态分配数据源。

代码如下：

    <!-- 如果依赖不存在 引入依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>xxx</version>
    </dependency>

参考配置

# 示例一：单数据源配置
# database start
spring.datasource.name=dataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/dev_master?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&autoReconnect=true&failOverReadOnly=false&maxReconnects=10
spring.datasource.username=username
spring.datasource.password=password
# datebase end

# 示例二：多数据源配置
# database start
# 开启动态数据源配置
dynamic.datasource.enable=true
# 动态数据源名称 第一个为默认数据源
dynamic.datasource.name=master,slave
# 动态数据源配置
dynamic.datasource.master.driver-class-name=com.mysql.jdbc.Driver
dynamic.datasource.master.url=jdbc:mysql://127.0.0.1:3306/dev_master
dynamic.datasource.master.username=username
dynamic.datasource.master.password=password
dynamic.datasource.slave.driver-class-name=com.mysql.jdbc.Driver
dynamic.datasource.slave.url=jdbc:mysql://127.0.0.1:3306/dev_slave
dynamic.datasource.slave.username=username
dynamic.datasource.slave.password=password
# 其他参数
dynamic.datasource.slave.readOnly=true
# datebase end

package common.dynamic.datasource;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 动态数据源
 *
 * @date 2022/6/16 14:39
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface DynamicDataSource {
    String value() default "master";
}

package common.dynamic.datasource;

/**
 * 数据源key
 *
 * @date 2022/6/16 15:16
 */
public interface DynamicDataSourceKey {

    public static final String MASTER = "master";

    public static final String SLAVE = "slave";

}

package common.dynamic.datasource;

/**
 * 动态数据源
 *
 * @date 2022/6/16 13:36
 */
public class DynamicDataSourceKeyHolder {

    private static ThreadLocal<String> DATA_SOURCE_KEY_HOLDER = new ThreadLocal<>();

    public static void setDataSourceKey(String dataSourceKey){
        DATA_SOURCE_KEY_HOLDER.set(dataSourceKey);
    }

    public static String getDataSourceKey(){
        String dataSourceKey = DATA_SOURCE_KEY_HOLDER.get();
        return dataSourceKey;
    }

    public static void clear(){
        DATA_SOURCE_KEY_HOLDER.remove();
    }

}

package common.dynamic.datasource;

import com.jd.fastjson.JSON;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

/**
 * 根据注解切换数据源
 *
 * @date 2022/6/16 14:13
 */
@Aspect
@Component
public class DynamicDataSourceAspect {

    private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);

    @Around(value = "@annotation(DynamicDataSource) && @annotation(dynamicDataSource)", argNames = "joinPoint, dynamicDataSource")
    Object aroundAdvice(ProceedingJoinPoint joinPoint, DynamicDataSource dynamicDataSource) throws Throwable {
        logger.debug("进入了切面: {}", JSON.toJSONString(dynamicDataSource));
        try {
            DynamicDataSourceKeyHolder.setDataSourceKey(dynamicDataSource.value());
            return joinPoint.proceed();
        } catch (Throwable throwable){
            logger.error("", throwable);
            throw throwable;
        } finally {
            DynamicDataSourceKeyHolder.clear();
        }
    }

}

package common.dynamic.datasource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * 动态数据源路由
 *
 * @date 2022/6/16 13:36
 */
public class RoutingDynamicDataSource extends AbstractRoutingDataSource {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     * 路由策略
     * 如果返回null会使用默认数据源
     * @return
     */
    @Override
    protected Object determineCurrentLookupKey() {
        String dataSourceKey = DynamicDataSourceKeyHolder.getDataSourceKey();
        logger.debug("dataSourceKey:{}", dataSourceKey);
        return dataSourceKey;
    }

}

package common.dynamic.datasource.config;

import common.dynamic.datasource.RoutingDynamicDataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.boot.context.properties.bind.BindResult;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.context.properties.source.ConfigurationPropertySource;
import org.springframework.boot.context.properties.source.ConfigurationPropertySources;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.validation.DataBinder;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * 配置数据源
 *
 * @date 2022/6/16 18:37
 */
@Configuration
public class DynamicDataSourceConfig implements EnvironmentAware {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     * 默认数据源类型
     */
    private String defaultDataSourceType = "com.zaxxer.hikari.HikariDataSource";

    /**
     * 数据源
     */
    private DataSource dataSource;

    /**
     * 动态数据源map
     */
    private Map dynamicDatasourceMap = new HashMap<>();


    @Override
    public void setEnvironment(Environment environment) {
        // 获取数据源配置
        Properties dynamicDatasourceProperties = this.getPropertiesByPrefix(environment, "dynamic.datasource");
        String enable = dynamicDatasourceProperties.getProperty("enable", "false");
        if(enable.trim().equals("true")){
            // 开启动态数据源
            RoutingDynamicDataSource routingDynamicDataSource = new RoutingDynamicDataSource();
            String names = dynamicDatasourceProperties.getProperty("name");
            String[] nameArray = names.split(",");
            for (int i = 0; i < nameArray.length; i++) {
                // 构建动态数据源
                logger.info("构建数据源：dynamic.datasource.{}", nameArray[i]);
                Properties subDatasourceProperties = this.getPropertiesByPrefix(environment, "dynamic.datasource." + nameArray[i]);
                DataSource subDataSource = buildDataSource(subDatasourceProperties);
                if(i == 0){
                    if(subDataSource == null){
                        throw new IllegalArgumentException(String.format("默认数据源:%s 配置失败", nameArray[i]));
                    }
                    routingDynamicDataSource.setDefaultTargetDataSource(subDataSource);
                }
                if(subDataSource == null){
                    logger.error("数据源:{} 配置失败", nameArray[i]);
                } else {
                    this.dynamicDatasourceMap.put(nameArray[i], subDataSource);
                }
            }
            routingDynamicDataSource.setTargetDataSources(this.dynamicDatasourceMap);
            this.dataSource = routingDynamicDataSource;
        } else {
            // 不开启动态数据源
            logger.info("构建数据源：spring.datasource");
            Properties springDatasourceProperties = this.getPropertiesByPrefix(environment, "spring.datasource");
            DataSource springDataSource = buildDataSource(springDatasourceProperties);
            this.dataSource = springDataSource;
        }
    }

    /**
     * 根据前缀获取配置
     * @param environment
     * @param proPrefix
     * @return
     */
    private Properties getPropertiesByPrefix(Environment environment, String proPrefix){
        Iterable<ConfigurationPropertySource> sources = ConfigurationPropertySources.get(environment);
        Binder binder = new Binder(sources);
        BindResult<Properties> bindResult = binder.bind(proPrefix, Properties.class);
        if(bindResult.isBound()){
            return bindResult.get();
        }
        return new Properties();
    }

    /**
     * 构建数据源
     * @param properties
     * @return
     */
    private DataSource buildDataSource(Properties properties){
        try {
            String driverClassName = properties.getProperty("driver-class-name");
            String url = properties.getProperty("url");
            String username = properties.getProperty("username");
            String password = properties.getProperty("password");
            // 参数校验
            if(driverClassName == null || "".equals(driverClassName)){
                throw new IllegalArgumentException("没有配置：driver-class-name");
            }
            if(url == null || "".equals(url)){
                throw new IllegalArgumentException("没有配置：url");
            }
            if(username == null || "".equals(username)){
                throw new IllegalArgumentException("没有配置：username");
            }
            if(password == null || "".equals(password)){
                throw new IllegalArgumentException("没有配置：password");
            }
            String type = properties.getProperty("type");
            if(type == null || "".equals(type.trim())){
                // 默认数据源类型
                type = this.defaultDataSourceType;
            }
            Class dataSourceType = Class.forName(type);
            DataSource buildDataSource = DataSourceBuilder.create().type(dataSourceType).driverClassName(driverClassName).url(url).username(username).password(password).build();
            // 补充数据源属性
            DataBinder dataBinder = new DataBinder(buildDataSource);
            dataBinder.bind(new MutablePropertyValues(properties));
            return buildDataSource;
        } catch (Exception e){
            e.printStackTrace();
            logger.error("构建数据源失败", e);
        }
        return null;
    }

    @Bean(value = "dataSource")
    DataSource dataSource(){
        DataSource dataSource = this.dataSource;
        return dataSource;
    }

}

import static common.dynamic.datasource.DynamicDataSourceKey.SLAVE;
    
    // 展示部分代码
    
    @RequestMapping("/demo")
    @DynamicDataSource(SLAVE) // 指定要访问的数据库
    public ApiResult demo(){
        // 访问数据库
        return ApiResult.success();
    }