为了进步利用的可靠性，多数据源当初也很常见，数据库能够搭建双 M 构造，这个松哥之前也发文和大家分享过如何搭建双 M 构造的主从备份？，那么 Java 代码里该如何操作多数据源呢？
我在 19 年的时候写过几篇文章教大家配置 JdbcTemplate、MyBatis 以及 JPA 中的多数据源（公众号江南一点雨后盾回复 666 有相干的材料），不过那几篇文章的整体思路都是弄多个 Dao 层实例，而后手动抉择用哪个实例，这样总感觉不太不便。
MyBatis-Plus 也提供了相应的工具，感兴趣的小伙伴能够自行尝试。
明天我想率领小伙伴们，利用 AOP 的思维，本人来写一个简略的多数据源切换工具。
1. 准备常识
想要自定义动静数据源切换，得先理解一个类 AbstractRoutingDataSource：
AbstractRoutingDataSource 是在 Spring2.0.1 中引入的（留神是 Spring2.0.1 不是 Spring Boot2.0.1，所以这其实也算是 Spring 一个十分古老的个性了）, 该类充当了 DataSource 的路由中介，它可能在运行时, 依据某种 key 值来动静切换到真正的 DataSource 上。
大抵的用法就是你提前准备好各种数据源，存入到一个 Map 中，Map 的 key 就是这个数据源的名字，Map 的 value 就是这个具体的数据源，而后再把这个 Map 配置到 AbstractRoutingDataSource 中，最初，每次执行数据库查问的时候，拿一个 key 进去，AbstractRoutingDataSource 会找到具体的数据源去执行这次数据库操作。
大抵思路就是这样。
接下来咱们就来看看怎么玩。
2. 创立我的项目
首先咱们创立一个 Spring Boot 我的项目，引入 Web、MyBatis 以及 MySQL 依赖，我的项目创立胜利之后，再手动退出 Druid 和 AOP 依赖，如下：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId></dependency><dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</artifactId> <version>1.2.9</version></dependency>这块呢其实没啥好说的，都是惯例操作。
3. 配置文件
接下来咱们创立一个 application-druid.yaml 用来配置咱们的数据源信息，如下：
# 数据源配置spring: datasource: type: com.alibaba.druid.pool.DruidDataSource driverClassName: com.mysql.cj.jdbc.Driver ds: # 主库数据源，默认 master 不能变 master: url: jdbc:mysql://127.0.0.1:3306/test08?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=Asia/Shanghai username: root password: 123 # 从库数据源 slave: url: jdbc:mysql://127.0.0.1:3306/test07?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&serverTimezone=Asia/Shanghai username: root password: 123 # 初始连接数 initialSize: 5 # 最小连接池数量 minIdle: 10 # 最大连接池数量 maxActive: 20 # 配置获取连贯期待超时的工夫 maxWait: 60000 # 配置距离多久才进行一次检测，检测须要敞开的闲暇连贯，单位是毫秒 timeBetweenEvictionRunsMillis: 60000 # 配置一个连贯在池中最小生存的工夫，单位是毫秒 minEvictableIdleTimeMillis: 300000 # 配置一个连贯在池中最大生存的工夫，单位是毫秒 maxEvictableIdleTimeMillis: 900000 # 配置检测连贯是否无效 validationQuery: SELECT 1 FROM DUAL testWhileIdle: true testOnBorrow: false testOnReturn: false druid: webStatFilter: enabled: true statViewServlet: enabled: true # 设置白名单，不填则容许所有拜访 allow: url-pattern: /druid/* # 控制台治理用户名和明码 login-username: javaboy login-password: 123456 filter: stat: enabled: true # 慢SQL记录 log-slow-sql: true slow-sql-millis: 1000 merge-sql: true wall: config: multi-statement-allow: true都是 Druid 的惯例配置，也没啥好说的，惟一须要留神的是咱们整个配置文件的格局。ds 里边配置咱们的所有数据源，每个数据源都有一个名字，master 是默认数据源的名字，不可批改，其余数据源都能够自定义名字。最初面咱们还配置了 Druid 的监控性能，如果小伙伴们还不懂 Druid 的监控性能，能够查看Spring Boot 如何监控 SQL 运行状况？。
不过小伙伴们晓得，YAML 配置不像 properties 配置能够通过 @PropertySource 注解加载自定义的配置文件，YAML 配置没有相似的加载机制。不过工具是死的人是活的，咱们能够利用 Spring Boot 的 profile 机制来加载这个自定义的 application-druid.yaml 配置文件，具体做法就是在 application.yaml 中加一行配置，如下：
spring: profiles: active: druid接下来咱们还须要提供一个配置类，将这个配置文件的内容加载到配置类中，如下：
@ConfigurationProperties(prefix = "spring.datasource")public class DruidProperties { private int initialSize; private int minIdle; private int maxActive; private int maxWait; private int timeBetweenEvictionRunsMillis; private int minEvictableIdleTimeMillis; private int maxEvictableIdleTimeMillis; private String validationQuery; private boolean testWhileIdle; private boolean testOnBorrow; private boolean testOnReturn; private Map<String, Map<String, String>> ds; public DruidDataSource dataSource(DruidDataSource datasource) { /** 配置初始化大小、最小、最大 */ datasource.setInitialSize(initialSize); datasource.setMaxActive(maxActive); datasource.setMinIdle(minIdle); /** 配置获取连贯期待超时的工夫 */ datasource.setMaxWait(maxWait); /** 配置距离多久才进行一次检测，检测须要敞开的闲暇连贯，单位是毫秒 */ datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis); /** 配置一个连贯在池中最小、最大生存的工夫，单位是毫秒 */ datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis); datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis); /** * 用来检测连贯是否无效的sql，要求是一个查问语句，罕用select 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。 */ datasource.setValidationQuery(validationQuery); /** 倡议配置为true，不影响性能，并且保障安全性。申请连贯的时候检测，如果闲暇工夫大于timeBetweenEvictionRunsMillis，执行validationQuery检测连贯是否无效。 */ datasource.setTestWhileIdle(testWhileIdle); /** 申请连贯时执行validationQuery检测连贯是否无效，做了这个配置会升高性能。 */ datasource.setTestOnBorrow(testOnBorrow); /** 偿还连贯时执行validationQuery检测连贯是否无效，做了这个配置会升高性能。 */ datasource.setTestOnReturn(testOnReturn); return datasource; } public int getInitialSize() { return initialSize; } public void setInitialSize(int initialSize) { this.initialSize = initialSize; } public int getMinIdle() { return minIdle; } public void setMinIdle(int minIdle) { this.minIdle = minIdle; } public int getMaxActive() { return maxActive; } public void setMaxActive(int maxActive) { this.maxActive = maxActive; } public int getMaxWait() { return maxWait; } public void setMaxWait(int maxWait) { this.maxWait = maxWait; } public int getTimeBetweenEvictionRunsMillis() { return timeBetweenEvictionRunsMillis; } public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis) { this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis; } public int getMinEvictableIdleTimeMillis() { return minEvictableIdleTimeMillis; } public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis) { this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis; } public int getMaxEvictableIdleTimeMillis() { return maxEvictableIdleTimeMillis; } public void setMaxEvictableIdleTimeMillis(int maxEvictableIdleTimeMillis) { this.maxEvictableIdleTimeMillis = maxEvictableIdleTimeMillis; } public String getValidationQuery() { return validationQuery; } public void setValidationQuery(String validationQuery) { this.validationQuery = validationQuery; } public boolean isTestWhileIdle() { return testWhileIdle; } public void setTestWhileIdle(boolean testWhileIdle) { this.testWhileIdle = testWhileIdle; } public boolean isTestOnBorrow() { return testOnBorrow; } public void setTestOnBorrow(boolean testOnBorrow) { this.testOnBorrow = testOnBorrow; } public boolean isTestOnReturn() { return testOnReturn; } public void setTestOnReturn(boolean testOnReturn) { this.testOnReturn = testOnReturn; } public Map<String, Map<String, String>> getDs() { return ds; } public void setDs(Map<String, Map<String, String>> ds) { this.ds = ds; }}这个配置类没啥好说的，咱们配置的多个数据源我将之读取到了一个名为 ds 的 Map 中，未来就依据这个 Map 中的数据来结构数据源。
4. 加载数据源
接下来咱们要依据配置文件来加载数据源。加载形式如下：
public interface DynamicDataSourceProvider { String DEFAULT_DATASOURCE = "master"; /** * 加载所有的数据源 * @return */ Map<String, DataSource> loadDataSources();}@Configuration@EnableConfigurationProperties(DruidProperties.class)public class YamlDynamicDataSourceProvider implements DynamicDataSourceProvider { @Autowired DruidProperties druidProperties; @Override public Map<String, DataSource> loadDataSources() { Map<String, DataSource> ds = new HashMap<>(druidProperties.getDs().size()); try { Map<String, Map<String, String>> map = druidProperties.getDs(); Set<String> keySet = map.keySet(); for (String s : keySet) { DruidDataSource dataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(map.get(s)); ds.put(s, druidProperties.dataSource(dataSource)); } } catch (Exception e) { e.printStackTrace(); } return ds; }}加载的外围工作在 YamlDynamicDataSourceProvider 类中实现的。该类中有一个 loadDataSources 办法示意读取所有的数据源对象。数据源的相干属性都在 druidProperties 对象中，咱们先依据根本的数据库连贯信息创立一个 DataSource 对象，而后再调用 druidProperties#dataSource 办法为这些数据源连接池配置其余的属性（最大连接数、最小闲暇数等），最初，以 key-value 的模式将数据源存入一个 Map 汇合中，每一个数据源的 key 就是你在 YAML 中配置的数据源名称。
5. 数据源切换
对于以后数据库操作应用哪个数据源？咱们有很多种不同的设置计划，当然最为省事的方法是把以后应用的数据源信息存入到 ThreadLocal 中，ThreadLocal 的特点，简略说就是在哪个线程中存入的数据，在哪个线程能力取出来，换一个线程就取不进去了，这样能够确保多线程环境下的数据安全。
先来一个简略的工具类，如下：
public class DynamicDataSourceContextHolder { public static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class); /** * 应用ThreadLocal保护变量，ThreadLocal为每个应用该变量的线程提供独立的变量正本， * 所以每一个线程都能够独立地扭转本人的正本，而不会影响其它线程所对应的正本。 */ private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>(); /** * 设置数据源的变量 */ public static void setDataSourceType(String dsType) { log.info("切换到{}数据源", dsType); CONTEXT_HOLDER.set(dsType); } /** * 取得数据源的变量 */ public static String getDataSourceType() { return CONTEXT_HOLDER.get(); } /** * 清空数据源变量 */ public static void clearDataSourceType() { CONTEXT_HOLDER.remove(); }}接下来咱们自定义一个注解用来标记以后的数据源，如下：
@Retention(RetentionPolicy.RUNTIME)@Target({ElementType.METHOD, ElementType.TYPE})public @interface DataSource { String dataSourceName() default DynamicDataSourceProvider.DEFAULT_DATASOURCE; @AliasFor("dataSourceName") String value() default DynamicDataSourceProvider.DEFAULT_DATASOURCE;}这个注解未来加在 Service 层的办法上，应用该注解的时候，须要指定一个数据源名称，不指定的话，默认就应用 master 作为数据源。
咱们还须要通过 AOP 来解析以后的自定义注解，如下：
@Aspect@Order(1)@Componentpublic class DataSourceAspect { @Pointcut("@annotation(org.javaboy.demo.annotation.DataSource)" + "|| @within(org.javaboy.demo.annotation.DataSource)") public void dsPc() { } @Around("dsPc()") public Object around(ProceedingJoinPoint point) throws Throwable { DataSource dataSource = getDataSource(point); if (Objects.nonNull(dataSource)) { DynamicDataSourceContextHolder.setDataSourceType(dataSource.dataSourceName()); } try { return point.proceed(); } finally { // 销毁数据源 在执行办法之后 DynamicDataSourceContextHolder.clearDataSourceType(); } } /** * 获取须要切换的数据源 */ public DataSource getDataSource(ProceedingJoinPoint point) { MethodSignature signature = (MethodSignature) point.getSignature(); DataSource dataSource = AnnotationUtils.findAnnotation(signature.getMethod(), DataSource.class); if (Objects.nonNull(dataSource)) { return dataSource; } return AnnotationUtils.findAnnotation(signature.getDeclaringType(), DataSource.class); }}- 首先，咱们在 dsPc() 办法上定义了切点，咱们拦挡下所有带有
@DataSource注解的办法，同时因为该注解也能够加在类上，如果该注解加在类上，就示意类中的所有办法都应用该数据源。 - 接下来咱们定义了一个盘绕告诉，首先依据以后的切点，调用 getDataSource 办法获取到
@DataSource注解，这个注解可能来自办法上也可能来自类上，办法上的优先级高于类上的优先级。如果拿到的注解不为空，则咱们在 DynamicDataSourceContextHolder 中设置以后的数据源名称，设置实现后进行办法的调用；如果拿到的注解为空，那么就间接进行办法的调用，不再设置数据源了（未来会主动应用默认的数据源）。最初记得办法调用实现后，从 ThreadLocal 中移除数据源。
6. 定义动静数据源
接下来咱们来自定义一个动静数据源：
public class DynamicDataSource extends AbstractRoutingDataSource { DynamicDataSourceProvider dynamicDataSourceProvider; public DynamicDataSource(DynamicDataSourceProvider dynamicDataSourceProvider) { this.dynamicDataSourceProvider = dynamicDataSourceProvider; Map<Object, Object> targetDataSources = new HashMap<>(dynamicDataSourceProvider.loadDataSources()); super.setTargetDataSources(targetDataSources); super.setDefaultTargetDataSource(dynamicDataSourceProvider.loadDataSources().get(DynamicDataSourceProvider.DEFAULT_DATASOURCE)); super.afterPropertiesSet(); } @Override protected Object determineCurrentLookupKey() { String dataSourceType = DynamicDataSourceContextHolder.getDataSourceType(); return dataSourceType; }}这就是咱们文章结尾所说的 AbstractRoutingDataSource 了，该类有一个办法名为 determineCurrentLookupKey，当须要应用数据源的时候，零碎会主动调用该办法，获取以后数据源的标记，如 master 或者 slave 或者其余，拿到标记之后，就能够据此获取到一个数据源了。
当咱们配置 DynamicDataSource 的时候，须要配置两个要害的参数，一个是 setTargetDataSources，这个就是以后所有的数据源，把以后所有的数据源都通知给 AbstractRoutingDataSource，这些数据源都是 key-value 的模式（未来依据 determineCurrentLookupKey 办法返回的 key 就能够获取到具体的数据源了）；另一个办法是 setDefaultTargetDataSource，这个就是默认的数据源，当咱们执行一个数据库操作的时候，如果没有指定数据源（例如 Service 层的办法没有加 @DataSource 注解），那么默认就应用这个数据源。
最初，再将这个 bean 注册到 Spring 容器中，如下：
@Configurationpublic class DruidAutoConfiguration { @Autowired DynamicDataSourceProvider dynamicDataSourceProvider; @Bean DynamicDataSource dynamicDataSource() { return new DynamicDataSource(dynamicDataSourceProvider); } /** * 去除数据源监控页面的广告 * * @param properties * @return */ @Bean @ConditionalOnProperty(name = "spring.datasource.druid.statViewServlet.enabled", havingValue = "true") public FilterRegistrationBean removeDruidFilterRegistrationBean(DruidStatProperties properties) { // 获取web监控页面的参数 DruidStatProperties.StatViewServlet config = properties.getStatViewServlet(); // 提取common.js的配置门路 String pattern = config.getUrlPattern() != null ? config.getUrlPattern() : "/druid/*"; String commonJsPattern = pattern.replaceAll("\\*", "js/common.js"); // 创立filter进行过滤 Filter filter = new Filter() { @Override public void init(javax.servlet.FilterConfig filterConfig) throws ServletException { } @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { String text = Utils.readFromResource("support/http/resources/js/common.js"); text = text.replace("this.buildFooter();", ""); response.getWriter().write(text); } @Override public void destroy() { } }; FilterRegistrationBean registrationBean = new FilterRegistrationBean(); registrationBean.setFilter(filter); registrationBean.addUrlPatterns(commonJsPattern); return registrationBean; }}上面，咱们还配置了一个过滤器，这个过滤器的目标是去除 Druid 监控页面的阿里广告，具体原理参考Spring Boot 如何监控 SQL 运行状况？一文。
7. 测试
好啦，功败垂成，咱们再来测试一下，写一个 UserMapper：
@Mapperpublic interface UserMapper { @Select("select count(*) from user") Integer count();}一个很简略的数据库查问操作。
再来一个 service：
@Servicepublic class UserService { @Autowired UserMapper userMapper; @DataSource("master") public Integer master() { return userMapper.count(); } @DataSource("slave") public Integer slave() { return userMapper.count(); }}通过 @DataSource 注解来指定具体操作的数据源，如果没有应用该注解指定，默认就应用 master 数据源。
最初去单元测试中测一下，如下：
@SpringBootTestclass DynamicDatasourceDemoApplicationTests { @Autowired UserService userService; @Test void contextLoads() { System.out.println("userService.master() = " + userService.master()); System.out.println("userService.slave() = " + userService.slave()); }}因为我这里 master 和 slave 别离对应了不同的库，这里查问会展现出不同的后果。
8. 小结
知其然知其所以然！
好啦，公众号江南一点雨后盾回复 dynamic_datasource，获取本文源码下载链接。