spring boot 多數據源動態切換

介紹

版本說明

spring boot版本：2.0.2.RELEASE
數據源：druid
數據庫：mysql
ORM映射：MyBatis，JPA（Hibernate）

需求說明

因爲需要在同一個項目中連接多個數據庫，而且後期可能還回繼續新增新的數據庫連接。所以除了實現多數據源之外，還需要實現多個數據源之間動態的進行切換。多數據源的話，聲明出來就好了，動態切換就需要用到AbstractRoutingDataSource跟AOP切面來實現。在示例中只實現數據源切換不實現AOP。關於AOP的部分結合自己的業務來寫就好了。

POM

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.0</version>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

配置文件

# 數據源相關配置
ds:
  # 數據庫1
  basic:
    datasource:
      url: jdbc:mysql://192.168.31.203:3306/ktwlsoft_framework_basic_pl?useUnicode=true&characterEncoding=utf8&useSSL=false&useAffectedRows=true&serverTimezone=GMT
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
  # 數據庫2
  base:
    datasource:
      url: jdbc:mysql://192.168.31.203:3306/tensquare_base?useUnicode=true&characterEncoding=utf8&useSSL=false&useAffectedRows=true&serverTimezone=GMT
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
  # 數據庫3
  article:
    datasource:
      url: jdbc:mysql://192.168.31.203:3306/tensquare_article?useUnicode=true&characterEncoding=utf8&useSSL=false&useAffectedRows=true&serverTimezone=GMT
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
  # 數據庫4
  friend:
    datasource:
      url: jdbc:mysql://192.168.31.203:3306/tensquare_friend?useUnicode=true&characterEncoding=utf8&useSSL=false&useAffectedRows=true&serverTimezone=GMT
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
  # 連接池配置
  datasource:
    initial_size: 20
    min_idle: 20
    max_active: 200
    max_wait: 60000
    time_between_eviction_runs_millis: 60000
    min_evictable_idle_time_millis: 300000
    test_while_idle: true
    test_on_borrow: false
    test_on_return: false
    pool_prepared_statements: true
    max_pool_prepared_statement_per_connection_size: 20


# JPA 相關配置
spring:
  jpa:
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
    show-sql: true
# mybatis 打印sql
logging:
  level:
    com.hzw.mapper : debug

數據源的代碼實現

自定義數據源切換類

/**
 * 自定義數據源切換類
 */
public class DatabaseContextHolder {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();

    public static void setDBKey(String dataSourceKey) {
        contextHolder.set(dataSourceKey);
    }

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

    public static void clearDBKey() {
        contextHolder.remove();
    }
}

動態數據源

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

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

/**
 * 動態數據源
 *
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    private static DynamicDataSource instance;
    private static byte[] lock=new byte[0];
    private static Map<Object,Object> dataSourceMap=new HashMap<Object, Object>();

    @Override
    public void setTargetDataSources(Map<Object, Object> targetDataSources) {
        super.setTargetDataSources(targetDataSources);
        dataSourceMap.putAll(targetDataSources);
        // 必須添加該句，否則新添加數據源無法識別到
        super.afterPropertiesSet();
    }

    public Map<Object, Object> getDataSourceMap() {
        return dataSourceMap;
    }

    @Override
    protected Object determineCurrentLookupKey() {
        String dbKey = DatabaseContextHolder.getDBKey();
        return dbKey;
    }

    private DynamicDataSource() {}

    public static synchronized DynamicDataSource getInstance(){
        if(instance==null){
            synchronized (lock){
                if(instance==null){
                    instance=new DynamicDataSource();
                }
            }
        }
        return instance;
    }

}

數據源KEY

/**
 * 數據庫數據源名稱
 */
public class DbUtil {

    /**數據庫basic**/
    public static final String DB_BASIC = "ds_basic";
    /**數據庫base**/
    public static final String DB_BASE = "ds_base";
    /**數據庫article**/
    public static final String DB_ARTICLE = "ds_article";
    /**數據庫friend**/
    public static final String DB_FRIEND = "ds_friend";

}

數據源配置

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import com.hzw.util.DbUtil;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

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

/**
 * 數據源配置
 */
@Configuration
// 掃描 Mapper 接口並容器管理
@MapperScan(basePackages = DatasourceConfig.PACKAGE, sqlSessionFactoryRef = "sqlSessionFactory")
public class DatasourceConfig {
    // mapper掃描
    static final String PACKAGE = "com.hzw.mapper";
    static final String MAPPER_LOCATION = "classpath:mapper/*.xml";

    @Value("${ds.basic.datasource.url}")
    private String urlBasic;
    @Value("${ds.basic.datasource.username}")
    private String userBasic;
    @Value("${ds.basic.datasource.password}")
    private String passwordBasic;
    @Value("${ds.basic.datasource.driver-class-name}")
    private String driverClassBasic;

    @Value("${ds.base.datasource.url}")
    private String urlBase;
    @Value("${ds.base.datasource.username}")
    private String userBase;
    @Value("${ds.base.datasource.password}")
    private String passwordBase;
    @Value("${ds.base.datasource.driver-class-name}")
    private String driverClassBase;

    @Value("${ds.article.datasource.url}")
    private String urlArticle;
    @Value("${ds.article.datasource.username}")
    private String userArticle;
    @Value("${ds.article.datasource.password}")
    private String passwordArticle;
    @Value("${ds.article.datasource.driver-class-name}")
    private String driverClassArticle;

    @Value("${ds.friend.datasource.url}")
    private String urlFriend;
    @Value("${ds.friend.datasource.username}")
    private String userFriend;
    @Value("${ds.friend.datasource.password}")
    private String passwordFriend;
    @Value("${ds.friend.datasource.driver-class-name}")
    private String driverClassFriend;

    @Value("${ds.datasource.max_active}")
    private Integer maxActive;
    @Value("${ds.datasource.min_idle}")
    private Integer minIdle;
    @Value("${ds.datasource.initial_size}")
    private Integer initialSize;
    @Value("${ds.datasource.max_wait}")
    private Long maxWait;
    @Value("${ds.datasource.time_between_eviction_runs_millis}")
    private Long timeBetweenEvictionRunsMillis;
    @Value("${ds.datasource.min_evictable_idle_time_millis}")
    private Long minEvictableIdleTimeMillis;
    @Value("${ds.datasource.test_while_idle}")
    private Boolean testWhileIdle;
    @Value("${ds.datasource.test_while_idle}")
    private Boolean testOnBorrow;
    @Value("${ds.datasource.test_on_borrow}")
    private Boolean testOnReturn;

    @Bean(name = "dynamicDataSource")
    @Primary
    public DynamicDataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = DynamicDataSource.getInstance();

        // basic數據源
        DruidDataSource dataSourceBasic = initDataSource(driverClassBasic,urlBasic,userBasic,passwordBasic);
        // base數據源
        DruidDataSource dataSourceBase = initDataSource(driverClassBase,urlBase,userBase,passwordBase);
        // article數據源
        DruidDataSource dataSourceArticle = initDataSource(driverClassArticle,urlArticle,userArticle,passwordArticle);
        // friend數據源
        DruidDataSource dataSourceFriend = initDataSource(driverClassFriend,urlFriend,userFriend,passwordFriend);

        Map<Object,Object> map = new HashMap<>();
        map.put(DbUtil.DB_BASIC, dataSourceBasic);
        map.put(DbUtil.DB_BASE, dataSourceBase);
        map.put(DbUtil.DB_ARTICLE, dataSourceArticle);
        map.put(DbUtil.DB_FRIEND, dataSourceFriend);

        dynamicDataSource.setTargetDataSources(map);
        // 默認數據源
        dynamicDataSource.setDefaultTargetDataSource(dataSourceBasic);
        return dynamicDataSource;
    }

    /**
     * 初始數據源
     * @param driver    驅動
     * @param url       數據庫連接
     * @param username  用戶名
     * @param password  密碼
     * @return
     */
    public DruidDataSource initDataSource(String driver,String url,String username,String password){
        //jdbc配置
        DruidDataSource rdataSource = new DruidDataSource();
        rdataSource.setDriverClassName(driver);
        rdataSource.setUrl(url);
        rdataSource.setUsername(username);
        rdataSource.setPassword(password);
        setPool(rdataSource);
        return rdataSource;
    }

    /**
     * 連接池配置
     * @param rdataSource
     */
    private void setPool(DruidDataSource rdataSource){
        //連接池配置
        rdataSource.setMaxActive(maxActive);
        rdataSource.setMinIdle(minIdle);
        rdataSource.setInitialSize(initialSize);
        rdataSource.setMaxWait(maxWait);
        rdataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        rdataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        rdataSource.setTestWhileIdle(testWhileIdle);
        rdataSource.setTestOnBorrow(testOnBorrow);
        rdataSource.setTestOnReturn(testOnReturn);
        rdataSource.setValidationQuery("SELECT 'x'");
        rdataSource.setPoolPreparedStatements(true);
        rdataSource.setMaxPoolPreparedStatementPerConnectionSize(20);
        try {
            rdataSource.setFilters("stat");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Bean(name = "transactionManager")
    @Primary
    public DataSourceTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dynamicDataSource());
    }

    @Bean(name = "sqlSessionFactory")
    @Primary
    public SqlSessionFactory sqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dynamicDataSource)
            throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dynamicDataSource);
        sessionFactory.setTypeAliasesPackage("com.hzw.model");
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(DatasourceConfig.MAPPER_LOCATION));
        return sessionFactory.getObject();
    }


    @Bean
    public ServletRegistrationBean druidServlet() {
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean();
        servletRegistrationBean.setServlet(new StatViewServlet());
        servletRegistrationBean.addUrlMappings("/druid/*");
        Map<String, String> initParameters = new HashMap<String, String>();
        // 用戶名
        initParameters.put("loginUsername", "admin");
        // 密碼
        initParameters.put("loginPassword", "admin");
        // 禁用HTML頁面上的“Reset All”功能
        initParameters.put("resetEnable", "false");
        // IP白名單 (沒有配置或者爲空，則允許所有訪問)
        initParameters.put("allow", "");
        servletRegistrationBean.setInitParameters(initParameters);
        return servletRegistrationBean;
    }

    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new WebStatFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        return filterRegistrationBean;
    }

}

如此這般，多數據源，動態切換的功能就有了，那麼下面來驗證是否成功。

驗證

啓動類

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 啓動類
 */
@SpringBootApplication
public class Application{
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

下面可以寫幾個mybatis的例子跟JPA(Hibernate)的例子，保證我們的mybatis跟JPA都是可用的，數據源都是可以切換成功的。這裏就不具體寫了，只把在service層怎麼來動態切換的代碼貼出來

article數據庫

@Override
    public List<Channel> findChannel() {
        // 指定數據源
        DatabaseContextHolder.setDBKey(DbUtil.DB_ARTICLE);
        return channelRepository.findAll();
    }

base數據庫

@Override
    public List<City> findCity() {
        // 指定數據源
        DatabaseContextHolder.setDBKey(DbUtil.DB_BASE);
        return cityMapper.findCity();
    }

basic數據庫

@Override
    public List<Users> findUser() {
        // 指定數據源
        DatabaseContextHolder.setDBKey(DbUtil.DB_BASIC);
        return usersMapper.findUser();
    }

這裏是在代碼中手動指定當前方法使用的數據庫，我們可以根據自己的業務來進行改造

場景一

需求是不同的用戶，根據區域或其他屬性來進行分庫，某些用戶訪問某個數據庫。
這種場景，只需要在用戶登錄的時候就把用戶能訪問的數據庫存儲起來，在AOP中獲取當前用戶能訪問的數據庫並調用DatabaseContextHolder.setDBKey()方法來設置。AOP的切面可以定義到service或者是action層。

場景二

需求是指定的某個AOP切面能訪問某個數據庫。
這種場景就更簡單了，只需要在切面中去設置就行了

結語

我們的場景是根據不同的用戶來進行數據庫的動態切換，本來想的是可以在線上新增數據庫連接並且能夠切換。目前只實現了在項目中把數據源全部配置出來，然後動態切換，後面在慢慢實現動態新增的事情吧。

參考鏈接

參考鏈接1
參考鏈接2

源碼地址

碼雲——源代碼地址