SpringBoot多數據源動態切換數據源

時間  2019-11-05
標籤 springboot 數據 動態 切換 欄目 Spring 简体版
原文   原文鏈接

一、配置多數據源前端

spring:
  datasource:
    master:
      password: erp_test@abc
      url: jdbc:mysql://127.0.0.1:3306/M201911010001?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&allowPublicKeyRetrieval=true
      driver-class-name: com.mysql.jdbc.Driver
      username: erp_test
      type: com.alibaba.druid.pool.DruidDataSource
      druid:
        initial-size: 5
        max-active: 150
        min-idle: 10
        max-wait: 6000
        web-stat-filter.enabled: true
        stat-view-servlet.enabled: true
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: SELECT 'x'
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        poolPreparedStatements: true
        maxPoolPreparedStatementPerConnectionSize: 20
        filters: stat,wall,log4j
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
        useGlobalDataSourceStat: true
    cluster:
    - key: slave1
      password: erp_test@abc
      url: jdbc:mysql://127.0.0.1:3306/M201911010002?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&allowPublicKeyRetrieval=true
      idle-timeout: 20000
      driver-class-name: com.mysql.jdbc.Driver
      username: erp_test
      type: com.alibaba.druid.pool.DruidDataSource
      druid:
        initial-size: 5
        max-active: 150
        min-idle: 10
        max-wait: 6000
        web-stat-filter.enabled: true
        stat-view-servlet.enabled: true
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: SELECT 'x'
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        poolPreparedStatements: true
        maxPoolPreparedStatementPerConnectionSize: 20
        filters: stat,wall,log4j
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
        useGlobalDataSourceStat: true
    - key: slave2
      password: erp_test@abc
      url: jdbc:mysql://127.0.0.1:3306/M201911010003?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&allowPublicKeyRetrieval=true
      idle-timeout: 20000
      driver-class-name: com.mysql.jdbc.Driver
      username: erp_test
      type: com.alibaba.druid.pool.DruidDataSource
      druid:
        initial-size: 5
        max-active: 150
        min-idle: 10
        max-wait: 6000
        web-stat-filter.enabled: true
        stat-view-servlet.enabled: true
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: SELECT 'x'
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        poolPreparedStatements: true
        maxPoolPreparedStatementPerConnectionSize: 20
        filters: stat,wall,log4j
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
        useGlobalDataSourceStat: true
View Code

在上面咱們配置了三個數據源，其中第一個做爲默認數據源也就是咱們的master數據源。主要是寫操做，那麼讀操做交給咱們的slave1跟slave2。
其中 master 數據源是必定要配置，做爲咱們的默認數據源；其次cluster集羣中，其餘的數據不配置也不會影響程序的運行（至關於單數據源），若是你想添加新的一個數據源 就在cluster下新增一個數據源便可，其中key爲必須項，用於數據源的惟一標識，以及接下來切換數據源的標識。

二、註冊數據源
在上面咱們已經配置了三個數據源，可是這是咱們自定義的配置，springboot是沒法給咱們自動配置，因此須要咱們本身註冊數據源.
那麼就要實現 EnvironmentAware 用於讀取上下文環境變量用於構建數據源，同時也須要實現 ImportBeanDefinitionRegistrar 接口註冊咱們構建的數據源。java

package com.erp.db;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.boot.context.properties.bind.Bindable;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.context.properties.source.ConfigurationPropertyName;
import org.springframework.boot.context.properties.source.ConfigurationPropertyNameAliases;
import org.springframework.boot.context.properties.source.ConfigurationPropertySource;
import org.springframework.boot.context.properties.source.MapConfigurationPropertySource;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotationMetadata;

import com.erp.config.DataSourceContext;
import com.zaxxer.hikari.HikariDataSource;

public class DynamicDataSourceRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {
    private static final Logger logger = LogManager.getLogger(DynamicDataSourceRegister.class);

    /**
     * 配置上下文（配置文件的獲取工具）
     */
    private Environment evn;

    /**
     * 別名
     */
    private final static ConfigurationPropertyNameAliases aliases = new ConfigurationPropertyNameAliases();

    /**
     * 因爲部分數據源配置不一樣，因此在此處添加別名，避免切換數據源出現某些參數沒法注入的狀況
     */
    static {
        aliases.addAliases("url", new String[]{"jdbc-url"});
        aliases.addAliases("username", new String[]{"user"});
    }

    /**
     * 存儲咱們註冊的數據源
     */
    private Map<String, DataSource> customDataSources = new HashMap<String, DataSource>();

    /**
     * 參數綁定工具 springboot2.0 新推出
     */
    private Binder binder;

    /**
     * ImportBeanDefinitionRegistrar接口的實現方法，經過該方法能夠按照本身的方式註冊bean
     *
     * @param annotationMetadata
     * @param beanDefinitionRegistry
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        // 獲取主數據源配置
        Map config, defauleDataSourceProperties;
        defauleDataSourceProperties = binder.bind("spring.datasource.master", Map.class).get();
        // 獲取數據源類型
        String typeStr = evn.getProperty("spring.datasource.master.type");
        // 獲取數據源類型
        Class<? extends DataSource> clazz = getDataSourceType(typeStr);
        // 綁定默認數據源參數 也就是主數據源
        DataSource consumerDatasource, defaultDatasource = bind(clazz, defauleDataSourceProperties);
        DataSourceContext.dataSourceIds.add("master");
        logger.info("註冊默認數據源成功");
        
        // 獲取其餘數據源配置
        List<Map> configs = binder.bind("spring.datasource.cluster", Bindable.listOf(Map.class)).get();
        // 遍歷從數據源
        for (int i = 0; i < configs.size(); i++) {
            config = configs.get(i);
            clazz = getDataSourceType((String) config.get("type"));
            defauleDataSourceProperties = config;
            // 綁定參數
            consumerDatasource = bind(clazz, defauleDataSourceProperties);
            // 獲取數據源的key，以便經過該key能夠定位到數據源
            String key = config.get("key").toString();
            customDataSources.put(key, consumerDatasource);
            // 數據源上下文，用於管理數據源與記錄已經註冊的數據源key
            DataSourceContext.dataSourceIds.add(key);
            logger.info("註冊數據源{}成功", key);
        }
        // bean定義類
        GenericBeanDefinition define = new GenericBeanDefinition();
        // 設置bean的類型，此處DynamicRoutingDataSource是繼承AbstractRoutingDataSource的實現類
        define.setBeanClass(MultiRouteDataSource.class);
        // 須要注入的參數
        MutablePropertyValues mpv = define.getPropertyValues();
        // 添加默認數據源，避免key不存在的狀況沒有數據源可用
        mpv.add("defaultTargetDataSource", defaultDatasource);
        // 添加其餘數據源
        mpv.add("targetDataSources", customDataSources);
        // 將該bean註冊爲datasource，不使用springboot自動生成的datasource
        beanDefinitionRegistry.registerBeanDefinition("datasource", define);
        logger.info("註冊數據源成功，一共註冊{}個數據源", customDataSources.keySet().size() + 1);
    }

    /**
     * 經過字符串獲取數據源class對象
     *
     * @param typeStr
     * @return
     */
    private Class<? extends DataSource> getDataSourceType(String typeStr) {
        Class<? extends DataSource> type;
        try {
            if (StringUtils.isNotBlank(typeStr)) {
                // 字符串不爲空則經過反射獲取class對象
                type = (Class<? extends DataSource>) Class.forName(typeStr);
            } else {
                // 默認爲hikariCP數據源，與springboot默認數據源保持一致
                type = HikariDataSource.class;
            }
            
            return type;
        } catch (Exception e) {
            //沒法經過反射獲取class對象的狀況則拋出異常，該狀況通常是寫錯了，因此這次拋出一個runtimeexception
            throw new IllegalArgumentException("can not resolve class with type: " + typeStr); 
        }
    }

    /**
     * 綁定參數，如下三個方法都是參考DataSourceBuilder的bind方法實現的，目的是儘可能保證咱們本身添加的數據源構造過程與springboot保持一致
     *
     * @param result
     * @param properties
     */
    private void bind(DataSource result, Map properties) {
        ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
        Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
        // 將參數綁定到對象
        binder.bind(ConfigurationPropertyName.EMPTY, Bindable.ofInstance(result));
    }

    private <T extends DataSource> T bind(Class<T> clazz, Map properties) {
        ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
        Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
        // 經過類型綁定參數並得到實例對象
        return binder.bind(ConfigurationPropertyName.EMPTY, Bindable.of(clazz)).get();
    }

    /**
     * @param clazz
     * @param sourcePath 參數路徑，對應配置文件中的值，如: spring.datasource
     * @param <T>
     * @return
     */
    private <T extends DataSource> T bind(Class<T> clazz, String sourcePath) {
        Map properties = binder.bind(sourcePath, Map.class).get();
        return bind(clazz, properties);
    }

    /**
     * EnvironmentAware接口的實現方法，經過aware的方式注入，此處是environment對象
     *
     * @param environment
     */
    @Override
    public void setEnvironment(Environment environment) {
        logger.info("開始註冊數據源");
        this.evn = environment;
        // 綁定配置器
        binder = Binder.get(evn);
    }
}

上面代碼須要注意的是在springboot2.x系列中用於綁定的工具類如RelaxedPropertyResolver已經沒法使用，如今使用Binder代替。上面代碼主要是讀取application中數據源的配置，先讀取spring.datasource.master構建默認數據源,而後在構建cluster中的數據源。mysql

在這裏註冊完數據源以後，咱們須要經過@import註解把咱們的數據源註冊器導入到spring中
在啓動類WebApplication.java加上以下註解@Import(DynamicDataSourceRegister.class)。
其中咱們用到了一個 DataSourceContext 中的靜態變量來保存咱們已經註冊成功的數據源的key,至此咱們的數據源註冊就已經完成了。

三、配置數據源上下文
咱們須要新建一個數據源上下文，用戶記錄當前線程使用的數據源的key是什麼，以及記錄全部註冊成功的數據源的key的集合。對於線程級別的私有變量，咱們首先ThreadLocal來實現。web

package com.erp.config;

import java.util.ArrayList;
import java.util.List;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * 數據源上下文
 * 
 * 數據源上下文的做用：用戶記錄當前線程使用的數據源的key是什麼，以及記錄全部註冊成功的數據源的key的集合。
 *
 * @author Lynch
 */
public class DataSourceContext {
    private static final Logger log = LogManager.getLogger(DataSourceContext.class);
    
    //線程級別的私有變量
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();
    
    //存儲已經註冊的數據源的key
    public static List<String> dataSourceIds = new ArrayList<>();

    public static void setRouterKey(String routerKey) {
        log.debug("切換至{}數據源", routerKey);
        contextHolder.set(routerKey);
    }

    public static String getRouterKey() {
        return contextHolder.get();
    }

    /**
     * 設置數據源以前必定要先移除
     * 
     * @author Lynch
     */
    public static void clearRouterKey() {
        contextHolder.remove();
    }

    /**
     * 判斷指定DataSrouce當前是否存在
     *
     * @param dataSourceId
     */
    public static boolean containsDataSource(String dataSourceId){
        return dataSourceIds.contains(dataSourceId);
    }

}

 

四、動態數據源路由
前面咱們以及新建了數據源上下文，用於存儲咱們當前線程的數據源key那麼怎麼通知spring用key當前的數據源呢，查閱資料可知，spring提供一個接口，名爲AbstractRoutingDataSource的抽象類，咱們只須要重寫determineCurrentLookupKey方法就能夠，這個方法看名字就知道，就是返回當前線程的數據源的key，那咱們只須要從咱們剛剛的數據源上下文中取出咱們的key便可，那麼具體代碼取下。spring

package com.erp.db;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

import com.erp.config.DataSourceContext;

/**
 * DataSource路由類
 * 
 * 重寫的函數決定了最後選擇的DataSource
 *
 * @author Lynch
 */
public class MultiRouteDataSource extends AbstractRoutingDataSource {
    
    @Override
    protected Object determineCurrentLookupKey() {
        // 經過綁定線程的數據源上下文實現多數據源的動態切換
        return DataSourceContext.getRouterKey();
    }
}

五、切換本身想要使用的數據源sql

public UserVO findUser(String username) {
    DataSourceContext.setDataSource("slave");
    UserVO userVO = userMapper.findByVO(username);
    System.out.println(userVO.getName());
    return null;
}

這種是在業務中使用代碼設置數據源的方式，也可使用AOP+註解的方式實現控制，還能夠前端頭部設置後端經過攔截器統一設置！apache

本文參考自此文後端

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程