乐趣区

关于java:手把手教你玩多数据源动态切换

为了进步利用的可靠性,多数据源当初也很常见,数据库能够搭建双 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)
@Component
public 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);
    }
}
  1. 首先,咱们在 dsPc() 办法上定义了切点,咱们拦挡下所有带有 @DataSource 注解的办法,同时因为该注解也能够加在类上,如果该注解加在类上,就示意类中的所有办法都应用该数据源。
  2. 接下来咱们定义了一个盘绕告诉,首先依据以后的切点,调用 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 容器中,如下:

@Configuration
public 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:

@Mapper
public interface UserMapper {@Select("select count(*) from user")
    Integer count();}

一个很简略的数据库查问操作。

再来一个 service:

@Service
public class UserService {

    @Autowired
    UserMapper userMapper;

    @DataSource("master")
    public Integer master() {return userMapper.count();
    }

    @DataSource("slave")
    public Integer slave() {return userMapper.count();
    }
}

通过 @DataSource 注解来指定具体操作的数据源,如果没有应用该注解指定,默认就应用 master 数据源。

最初去单元测试中测一下,如下:

@SpringBootTest
class 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,获取本文源码下载链接。

退出移动版