綜合概述

在很多具體應用場景中，我們需要用到動態資料來源的情況，比如多租戶的場景，系統登入時需要根據使用者資訊切換到使用者對應的資料庫。又比如業務A要訪問A資料庫，業務B要訪問B資料庫等，都可以使用動態資料來源方案進行解決。接下來，我們就來講解如何實現動態資料來源，以及在過程中剖析動態資料來源背後的實現原理。

實現案例

本教程案例基於 Spring Boot + Mybatis + MySQL 實現。

生成專案模板

為方便我們初始化專案，Spring Boot給我們提供一個專案模板生成網站。

1.  開啟瀏覽器，訪問：https://start.spring.io/

2.  根據頁面提示，選擇構建工具，開發語言，專案資訊等。

3.  點選 Generate the project，生成專案模板，生成之後會將壓縮包下載到本地。

4.  使用IDE匯入專案，我這裡使用Eclipse，通過匯入Maven專案的方式匯入。

建立資料庫表

這裡使用MySQL資料庫，版本是8.0.16，在專案根目錄下新建db目錄，然後在其中編寫一個數據庫指令碼檔案。

在MySQL資料庫新建一個master，slave資料庫，然後在此資料庫中執行下面的指令碼建立專案使用者表和使用者資料。

指令碼檔案

SQL指令碼內容

springboot.sql

-- ----------------------------
-- Table structure for sys_user
-- ----------------------------
DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '編號',
  `name` varchar(50) NOT NULL COMMENT '使用者名稱',
  `nick_name` varchar(150) DEFAULT NULL COMMENT '暱稱',
  `avatar` varchar(150) DEFAULT NULL COMMENT '頭像',
  `password` varchar(100) DEFAULT NULL COMMENT '密碼',
  `salt` varchar(40) DEFAULT NULL COMMENT '加密鹽',
  `email` varchar(100) DEFAULT NULL COMMENT '郵箱',
  `mobile` varchar(100) DEFAULT NULL COMMENT '手機號',
  `status` tinyint(4) DEFAULT NULL COMMENT '狀態  0：禁用   1：正常',
  `dept_id` bigint(20) DEFAULT NULL COMMENT '機構ID',
  `create_by` varchar(50) DEFAULT NULL COMMENT '建立人',
  `create_time` datetime DEFAULT NULL COMMENT '建立時間',
  `last_update_by` varchar(50) DEFAULT NULL COMMENT '更新人',
  `last_update_time` datetime DEFAULT NULL COMMENT '更新時間',
  `del_flag` tinyint(4) DEFAULT '0' COMMENT '是否刪除  -1：已刪除  0：正常',
  PRIMARY KEY (`id`),
  UNIQUE KEY `name` (`name`)
) ENGINE=InnoDB AUTO_INCREMENT=34 DEFAULT CHARSET=utf8 COMMENT='使用者管理';

-- ----------------------------
-- Records of sys_user
-- ----------------------------
INSERT INTO `sys_user` VALUES ('1', 'admin', '管理員', null, 'bd1718f058d8a02468134432b8656a86', 'YzcmCZNvbXocrsz9dm8e', '[email protected]', '13612345678', '1', '4', 'admin', '2018-08-14 11:11:11', 'admin', '2018-08-14 11:11:11', '0');
INSERT INTO `sys_user` VALUES ('2', 'liubei', '劉備', null, 'fd80ebd493a655608dc893a9f897d845', 'YzcmCZNvbXocrsz9dm8e', '[email protected]', '13889700023', '1', '7', 'admin', '2018-09-23 19:43:00', 'admin', '2019-01-10 11:41:13', '0');
INSERT INTO `sys_user` VALUES ('3', 'zhaoyun', '趙雲', null, 'fd80ebd493a655608dc893a9f897d845', 'YzcmCZNvbXocrsz9dm8e', '[email protected]', '13889700023', '1', '7', 'admin', '2018-09-23 19:43:44', 'admin', '2018-09-23 19:43:52', '0');
INSERT INTO `sys_user` VALUES ('4', 'zhugeliang', '諸葛亮', null, 'fd80ebd493a655608dc893a9f897d845', 'YzcmCZNvbXocrsz9dm8e', '[email protected]', '13889700023', '7', '11', 'admin', '2018-09-23 19:44:23', 'admin', '2018-09-23 19:44:29', '0');
INSERT INTO `sys_user` VALUES ('5', 'caocao', '曹操', null, 'fd80ebd493a655608dc893a9f897d845', 'YzcmCZNvbXocrsz9dm8e', '[email protected]', '13889700023', '1', '8', 'admin', '2018-09-23 19:45:32', 'admin', '2019-01-10 17:59:14', '0');
INSERT INTO `sys_user` VALUES ('6', 'dianwei', '典韋', null, 'fd80ebd493a655608dc893a9f897d845', 'YzcmCZNvbXocrsz9dm8e', '[email protected]', '13889700023', '1', '10', 'admin', '2018-09-23 19:45:48', 'admin', '2018-09-23 19:45:57', '0');
INSERT INTO `sys_user` VALUES ('7', 'xiahoudun', '夏侯惇', null, 'fd80ebd493a655608dc893a9f897d845', 'YzcmCZNvbXocrsz9dm8e', '[email protected]', '13889700023', '1', '8', 'admin', '2018-09-23 19:46:09', 'admin', '2018-09-23 19:46:17', '0');
INSERT INTO `sys_user` VALUES ('8', 'xunyu', '荀彧', null, 'fd80ebd493a655608dc893a9f897d845', 'YzcmCZNvbXocrsz9dm8e', '[email protected]', '13889700023', '1', '10', 'admin', '2018-09-23 19:46:38', 'admin', '2018-11-04 15:33:17', '0');
INSERT INTO `sys_user` VALUES ('9', 'sunquan', '孫權', null, 'fd80ebd493a655608dc893a9f897d845', 'YzcmCZNvbXocrsz9dm8e', '[email protected]', '13889700023', '1', '10', 'admin', '2018-09-23 19:46:54', 'admin', '2018-09-23 19:47:03', '0');
INSERT INTO `sys_user` VALUES ('0', 'zhouyu', '周瑜', null, 'fd80ebd493a655608dc893a9f897d845', 'YzcmCZNvbXocrsz9dm8e', '[email protected]', '13889700023', '1', '11', 'admin', '2018-09-23 19:47:28', 'admin', '2018-09-23 19:48:04', '0');
INSERT INTO `sys_user` VALUES ('11', 'luxun', '陸遜', null, 'fd80ebd493a655608dc893a9f897d845', 'YzcmCZNvbXocrsz9dm8e', '[email protected]', '13889700023', '1', '11', 'admin', '2018-09-23 19:47:44', 'admin', '2018-09-23 19:47:58', '0');
INSERT INTO `sys_user` VALUES ('12', 'huanggai', '黃蓋', null, 'fd80ebd493a655608dc893a9f897d845', 'YzcmCZNvbXocrsz9dm8e', '[email protected]', '13889700023', '1', '11', 'admin', '2018-09-23 19:48:38', 'admin', '2018-09-23 19:49:02', '0');

新增相關依賴

需要新增Spring Boot，Spring Aop，Mybatis，MySQL，Swagger相關依賴。Swagger方便用來測試介面。

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.louis.springboot</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

     <dependencies>
        <!-- spring boot -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- spring aop -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- swagger -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
        <!-- 打包時拷貝MyBatis的對映檔案 -->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/sqlmap/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>  
                <directory>src/main/resources</directory>  
                    <includes> 
                        <include>**/*.*</include>  
                    </includes> 
                    <filtering>true</filtering>  
            </resource> 
        </resources>
    </build>

</project>

新增相關配置

修改配置檔案，新增兩個資料來源，可以是同一個主機地址的兩個資料庫master，slave，也可是兩個不同主機的地址，根據實際情況配置。

application.yml

server:
  port: 8080
spring:
  datasource:
    master:
      driver-class-name: com.mysql.cj.jdbc.Driver
      type: com.zaxxer.hikari.HikariDataSource
      jdbcUrl: jdbc:mysql://127.0.0.1:3306/master?useUnicode=true&zeroDateTimeBehavior=convertToNull&autoReconnect=true&characterEncoding=utf-8
      username: root
      password: 123456
    slave:
      driver-class-name: com.mysql.cj.jdbc.Driver
      type: com.zaxxer.hikari.HikariDataSource
      jdbcUrl: jdbc:mysql://127.0.0.1:3306/slave?useUnicode=true&zeroDateTimeBehavior=convertToNull&autoReconnect=true&characterEncoding=utf-8
      username: root
      password: 123456

Swagger配置類

在config包中新增一個swagger 配置類，在工程下新建 config 包並新增一個 SwaggerConfig 配置類。

SwaggerConfig.java

package com.louis.springboot.demo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any()).build();
    }

    private ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("SpringBoot API Doc")
                .description("This is a restful api document of Spring Boot.")
                .version("1.0")
                .build();
    }

}

修改啟動類

啟動類新增 exclude = {DataSourceAutoConfiguration.class}， 以禁用資料來源預設自動配置。

資料來源預設自動配置會讀取 spring.datasource.* 的屬性建立資料來源，所以要禁用以進行定製。

@ComponentScan(basePackages = "com.louis.springboot") 是掃描範圍，都知道不用多說。

DemoApplication.java

package com.louis.springboot.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})    // 禁用資料來源自動配置
@ComponentScan(basePackages = "com.louis.springboot")
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

資料來源配置類

建立一個數據源配置類，主要做以下幾件事情：

1. 配置 dao，model，xml mapper檔案的掃描路徑。

2. 注入資料來源配置屬性，建立master、slave資料來源。

3. 建立一個動態資料來源，並裝入master、slave資料來源。

4. 將動態資料來源設定到SQL會話工廠和事務管理器。

如此，當進行資料庫操作時，就會通過我們建立的動態資料來源去獲取要操作的資料來源了。

package com.louis.springboot.demo.config;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
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 org.springframework.transaction.PlatformTransactionManager;
import com.louis.springboot.demo.config.dds.DynamicDataSource;

@Configuration
@MapperScan(basePackages = {"com.louis.**.dao"}) // 掃描DAO
public class MybatisConfig {

    @Bean("master")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource master() {
        return DataSourceBuilder.create().build();
    }

    @Bean("slave")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slave() {
        return DataSourceBuilder.create().build();
    }

    @Bean("dynamicDataSource")
    public DataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map<Object, Object> dataSourceMap = new HashMap<>(2);
        dataSourceMap.put("master", master());
        dataSourceMap.put("slave", slave());
        // 將 master 資料來源作為預設指定的資料來源
        dynamicDataSource.setDefaultDataSource(master());
        // 將 master 和 slave 資料來源作為指定的資料來源
        dynamicDataSource.setDataSources(dataSourceMap);
        return dynamicDataSource;
    }

    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean() throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        // 配置資料來源，此處配置為關鍵配置，如果沒有將 dynamicDataSource作為資料來源則不能實現切換
        sessionFactory.setDataSource(dynamicDataSource());
        sessionFactory.setTypeAliasesPackage("com.louis.**.model");    // 掃描Model
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sessionFactory.setMapperLocations(resolver.getResources("classpath*:**/sqlmap/*.xml"));    // 掃描對映檔案
        return sessionFactory;
    }

    @Bean
    public PlatformTransactionManager transactionManager() {
        // 配置事務管理, 使用事務時在方法頭部新增@Transactional註解即可
        return new DataSourceTransactionManager(dynamicDataSource());
    }
}

動態資料來源類

我們上一步把這個動態資料來源設定到了SQL會話工廠和事務管理器，這樣在操作資料庫時就會通過動態資料來源類來獲取要操作的資料來源了。

動態資料來源類集成了Spring提供的AbstractRoutingDataSource類，AbstractRoutingDataSource 中獲取資料來源的方法就是 determineTargetDataSource，而此方法又通過 determineCurrentLookupKey 方法獲取查詢資料來源的key。

所以如果我們需要動態切換資料來源，就可以通過以下兩種方式定製：

1. 覆寫 determineCurrentLookupKey 方法

通過覆寫 determineCurrentLookupKey 方法，從一個自定義的 DynamicDataSourceContextHolder.getDataSourceKey() 獲取資料來源key值，這樣在我們想動態切換資料來源的時候，只要通過  DynamicDataSourceContextHolder.setDataSourceKey(key)  的方式就可以動態改變資料來源了。這種方式要求在獲取資料來源之前，要先初始化各個資料來源到 DynamicDataSource 中，我們案例就是採用這種方式實現的，所以在 MybatisConfig 中把master和slave資料來源都事先初始化到DynamicDataSource 中。

2. 可以通過覆寫 determineTargetDataSource，因為資料來源就是在這個方法建立並返回的，所以這種方式就比較自由了，支援到任何你希望的地方讀取資料來源資訊，只要最終返回一個 DataSource 的實現類即可。比如你可以到資料庫、本地檔案、網路介面等方式讀取到資料來源資訊然後返回相應的資料來源物件就可以了。

DynamicDataSource.java

package com.louis.springboot.demo.config.dds;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * 動態資料來源實現類
 * @author Louis
 * @date Jun 17, 2019
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    
    
    /**
     * 如果不希望資料來源在啟動配置時就載入好，可以定製這個方法，從任何你希望的地方讀取並返回資料來源
     * 比如從資料庫、檔案、外部介面等讀取資料來源資訊，並最終返回一個DataSource實現類物件即可
     */
    @Override
    protected DataSource determineTargetDataSource() {
        return super.determineTargetDataSource();
    }
    
    /**
     * 如果希望所有資料來源在啟動配置時就載入好，這裡通過設定資料來源Key值來切換資料，定製這個方法
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceKey();
    }
    
    /**
     * 設定預設資料來源
     * @param defaultDataSource
     */
    public void setDefaultDataSource(Object defaultDataSource) {
        super.setDefaultTargetDataSource(defaultDataSource);
    }
    
    /**
     * 設定資料來源
     * @param dataSources
     */
    public void setDataSources(Map<Object, Object> dataSources) {
        super.setTargetDataSources(dataSources);
        // 將資料來源的 key 放到資料來源上下文的 key 集合中，用於切換時判斷資料來源是否有效
        DynamicDataSourceContextHolder.addDataSourceKeys(dataSources.keySet());
    }
}

資料來源上下文

動態資料來源的切換主要是通過呼叫這個類的方法來完成的。在任何想要進行切換資料來源的時候都可以通過呼叫這個類的方法實現切換。比如系統登入時，根據使用者資訊呼叫這個類的資料來源切換方法切換到使用者對應的資料庫。

主要方法介紹：

1. 切換資料來源

在任何想要進行切換資料來源的時候都可以通過呼叫這個類的方法實現切換。

/**
 * 切換資料來源
 * @param key
 */
public static void setDataSourceKey(String key) {
    contextHolder.set(key);
}

2. 重置資料來源

將資料來源重置回預設的資料來源。預設資料來源通過 DynamicDataSource.setDefaultDataSource(ds) 進行設定。

/**
 * 重置資料來源
 */
public static void clearDataSourceKey() {
    contextHolder.remove();
}

3. 獲取當前資料來源key

/**
 * 獲取資料來源
 * @return
 */
public static String getDataSourceKey() {
    return contextHolder.get();
}

完整程式碼如下

DynamicDataSourceContextHolder.java

package com.louis.springboot.demo.config.dds;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * 動態資料來源上下文
 * @author Louis
 * @date Jun 17, 2019
 */
public class DynamicDataSourceContextHolder {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>() {
        /**
         * 將 master 資料來源的 key作為預設資料來源的 key
         */
        @Override
        protected String initialValue() {
            return "master";
        }
    };


    /**
     * 資料來源的 key集合，用於切換時判斷資料來源是否存在
     */
    public static List<Object> dataSourceKeys = new ArrayList<>();

    /**
     * 切換資料來源
     * @param key
     */
    public static void setDataSourceKey(String key) {
        contextHolder.set(key);
    }

    /**
     * 獲取資料來源
     * @return
     */
    public static String getDataSourceKey() {
        return contextHolder.get();
    }

    /**
     * 重置資料來源
     */
    public static void clearDataSourceKey() {
        contextHolder.remove();
    }

    /**
     * 判斷是否包含資料來源
     * @param key 資料來源key
     * @return
     */
    public static boolean containDataSourceKey(String key) {
        return dataSourceKeys.contains(key);
    }
    
    /**
     * 新增資料來源keys
     * @param keys
     * @return
     */
    public static boolean addDataSourceKeys(Collection<? extends Object> keys) {
        return dataSourceKeys.addAll(keys);
    }
}

註解式資料來源

到這裡，在任何想要動態切換資料來源的時候，只要呼叫  DynamicDataSourceContextHolder.setDataSourceKey(key)  就可以完成了。

接下來我們實現通過註解的方式來進行資料來源的切換，原理就是添加註解（如@DataSource(value="master")），然後實現註解切面進行資料來源切換。

建立一個動態資料來源註解，擁有一個value值，用於標識要切換的資料來源的key。

DataSource.java

package com.louis.springboot.demo.config.dds;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 動態資料來源註解
 * @author Louis
 * @date Jun 17, 2019
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
    
    /**
     * 資料來源key值
     * @return
     */
    String value();
    
}

建立一個AOP切面，攔截帶 @DataSource 註解的方法，在方法執行前切換至目標資料來源，執行完成後恢復到預設資料來源。

DynamicDataSourceAspect.java

package com.louis.springboot.demo.config.dds;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 動態資料來源切換處理器
 * @author Louis
 * @date Jun 17, 2019
 */
@Aspect
@Order(-1)  // 該切面應當先於 @Transactional 執行
@Component
public class DynamicDataSourceAspect {
    
    /**
     * 切換資料來源
     * @param point
     * @param dataSource
     */
    @Before("@annotation(dataSource))")
    public void switchDataSource(JoinPoint point, DataSource dataSource) {
        if (!DynamicDataSourceContextHolder.containDataSourceKey(dataSource.value())) {
            System.out.println("DataSource [{}] doesn't exist, use default DataSource [{}] " + dataSource.value());
        } else {
            // 切換資料來源
            DynamicDataSourceContextHolder.setDataSourceKey(dataSource.value());
            System.out.println("Switch DataSource to [" + DynamicDataSourceContextHolder.getDataSourceKey()
                + "] in Method [" + point.getSignature() + "]");
        }
    }

    /**
     * 重置資料來源
     * @param point
     * @param dataSource
     */
    @After("@annotation(dataSource))")
    public void restoreDataSource(JoinPoint point, DataSource dataSource) {
        // 將資料來源置為預設資料來源
        DynamicDataSourceContextHolder.clearDataSourceKey();
        System.out.println("Restore DataSource to [" + DynamicDataSourceContextHolder.getDataSourceKey() 
            + "] in Method [" + point.getSignature() + "]");
    }
}

到這裡，動態資料來源相關的處理程式碼就完成了。

編寫使用者業務程式碼

由於手動編寫MyBatis的Model、DAO、XML對映檔案比較繁瑣，通常都會通過一些生成工具來生成。MyBatis官方也提供了生成工具（MyBaits Generator），另外還有一些基於官方基礎上改進的第三方工具，比如MyBatis Plus就是國內提供的一款非常優秀的開源工具，網上相關教程比較多，這裡就不再贅述了。

這裡提供一些資料作為參考。

Mybatis Generator 官網：http://www.mybatis.org/generator/index.html

Mybatis Generator 教程：https://blog.csdn.net/testcs_dn/article/details/77881776

MyBatis Plus 官網: http://mp.baomidou.com/#/

MyBatis Plus 官網: http://mp.baomidou.com/#/quick-start

程式碼生成好之後，分別將MODEL、DAO、XML對映檔案拷貝到相應的包裡。

生成的使用者類程式碼如下面所示。

SysUser.java

package com.louis.springboot.demo.model;

import java.util.Date;

public class SysUser {
    private Long id;

    private String name;

    private String nickName;

    private String avatar;

    private String password;

    private String salt;

    private String email;

    private String mobile;

    private Byte status;

    private Long deptId;

    private String createBy;

    private Date createTime;

    private String lastUpdateBy;

    private Date lastUpdateTime;

    private Byte delFlag;

    // 省略setter和getter
}

接下來在SysUserMapper中新增一個查詢全部的方法。

SysUserMapper.java

package com.louis.springboot.demo.dao;

import java.util.List;

import com.louis.springboot.demo.model.SysUser;

public interface SysUserMapper {
    int deleteByPrimaryKey(Long id);

    int insert(SysUser record);

    int insertSelective(SysUser record);

    SysUser selectByPrimaryKey(Long id);

    int updateByPrimaryKeySelective(SysUser record);

    int updateByPrimaryKey(SysUser record);
    

    /**
     * 查詢全部使用者
     * @return
     */
    List<SysUser> selectAll();
}

然後在SysUserMapper.xml中實現查詢全部方法的SQL語句。

SysUserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.louis.springboot.demo.dao.SysUserMapper">
  <resultMap id="BaseResultMap" type="com.louis.springboot.demo.model.SysUser">
    <id column="id" jdbcType="BIGINT" property="id" />
    <result column="name" jdbcType="VARCHAR" property="name" />
    <result column="nick_name" jdbcType="VARCHAR" property="nickName" />
    <result column="avatar" jdbcType="VARCHAR" property="avatar" />
    <result column="password" jdbcType="VARCHAR" property="password" />
    <result column="salt" jdbcType="VARCHAR" property="salt" />
    <result column="email" jdbcType="VARCHAR" property="email" />
    <result column="mobile" jdbcType="VARCHAR" property="mobile" />
    <result column="status" jdbcType="TINYINT" property="status" />
    <result column="dept_id" jdbcType="BIGINT" property="deptId" />
    <result column="create_by" jdbcType="VARCHAR" property="createBy" />
    <result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
    <result column="last_update_by" jdbcType="VARCHAR" property="lastUpdateBy" />
    <result column="last_update_time" jdbcType="TIMESTAMP" property="lastUpdateTime" />
    <result column="del_flag" jdbcType="TINYINT" property="delFlag" />
  </resultMap>
  <sql id="Base_Column_List">
    id, name, nick_name, avatar, password, salt, email, mobile, status, dept_id, create_by, 
    create_time, last_update_by, last_update_time, del_flag
  </sql>
  <select id="selectByPrimaryKey" parameterType="java.lang.Long" resultMap="BaseResultMap">
    select 
    <include refid="Base_Column_List" />
    from sys_user
    where id = #{id,jdbcType=BIGINT}
  </select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Long">
    delete from sys_user
    where id = #{id,jdbcType=BIGINT}
  </delete>
  <insert id="insert" parameterType="com.louis.springboot.demo.model.SysUser">
    insert into sys_user (id, name, nick_name, 
      avatar, password, salt, 
      email, mobile, status, 
      dept_id, create_by, create_time, 
      last_update_by, last_update_time, del_flag
      )
    values (#{id,jdbcType=BIGINT}, #{name,jdbcType=VARCHAR}, #{nickName,jdbcType=VARCHAR}, 
      #{avatar,jdbcType=VARCHAR}, #{password,jdbcType=VARCHAR}, #{salt,jdbcType=VARCHAR}, 
      #{email,jdbcType=VARCHAR}, #{mobile,jdbcType=VARCHAR}, #{status,jdbcType=TINYINT}, 
      #{deptId,jdbcType=BIGINT}, #{createBy,jdbcType=VARCHAR}, #{createTime,jdbcType=TIMESTAMP}, 
      #{lastUpdateBy,jdbcType=VARCHAR}, #{lastUpdateTime,jdbcType=TIMESTAMP}, #{delFlag,jdbcType=TINYINT}
      )
  </insert>
  <insert id="insertSelective" parameterType="com.louis.springboot.demo.model.SysUser">
    insert into sys_user
    <trim prefix="(" suffix=")" suffixOverrides=",">
      <if test="id != null">
        id,
      </if>
      <if test="name != null">
        name,
      </if>
      <if test="nickName != null">
        nick_name,
      </if>
      <if test="avatar != null">
        avatar,
      </if>
      <if test="password != null">
        password,
      </if>
      <if test="salt != null">
        salt,
      </if>
      <if test="email != null">
        email,
      </if>
      <if test="mobile != null">
        mobile,
      </if>
      <if test="status != null">
        status,
      </if>
      <if test="deptId != null">
        dept_id,
      </if>
      <if test="createBy != null">
        create_by,
      </if>
      <if test="createTime != null">
        create_time,
      </if>
      <if test="lastUpdateBy != null">
        last_update_by,
      </if>
      <if test="lastUpdateTime != null">
        last_update_time,
      </if>
      <if test="delFlag != null">
        del_flag,
      </if>
    </trim>
    <trim prefix="values (" suffix=")" suffixOverrides=",">
      <if test="id != null">
        #{id,jdbcType=BIGINT},
      </if>
      <if test="name != null">
        #{name,jdbcType=VARCHAR},
      </if>
      <if test="nickName != null">
        #{nickName,jdbcType=VARCHAR},
      </if>
      <if test="avatar != null">
        #{avatar,jdbcType=VARCHAR},
      </if>
      <if test="password != null">
        #{password,jdbcType=VARCHAR},
      </if>
      <if test="salt != null">
        #{salt,jdbcType=VARCHAR},
      </if>
      <if test="email != null">
        #{email,jdbcType=VARCHAR},
      </if>
      <if test="mobile != null">
        #{mobile,jdbcType=VARCHAR},
      </if>
      <if test="status != null">
        #{status,jdbcType=TINYINT},
      </if>
      <if test="deptId != null">
        #{deptId,jdbcType=BIGINT},
      </if>
      <if test="createBy != null">
        #{createBy,jdbcType=VARCHAR},
      </if>
      <if test="createTime != null">
        #{createTime,jdbcType=TIMESTAMP},
      </if>
      <if test="lastUpdateBy != null">
        #{lastUpdateBy,jdbcType=VARCHAR},
      </if>
      <if test="lastUpdateTime != null">
        #{lastUpdateTime,jdbcType=TIMESTAMP},
      </if>
      <if test="delFlag != null">
        #{delFlag,jdbcType=TINYINT},
      </if>
    </trim>
  </insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.louis.springboot.demo.model.SysUser">
    update sys_user
    <set>
      <if test="name != null">
        name = #{name,jdbcType=VARCHAR},
      </if>
      <if test="nickName != null">
        nick_name = #{nickName,jdbcType=VARCHAR},
      </if>
      <if test="avatar != null">
        avatar = #{avatar,jdbcType=VARCHAR},
      </if>
      <if test="password != null">
        password = #{password,jdbcType=VARCHAR},
      </if>
      <if test="salt != null">
        salt = #{salt,jdbcType=VARCHAR},
      </if>
      <if test="email != null">
        email = #{email,jdbcType=VARCHAR},
      </if>
      <if test="mobile != null">
        mobile = #{mobile,jdbcType=VARCHAR},
      </if>
      <if test="status != null">
        status = #{status,jdbcType=TINYINT},
      </if>
      <if test="deptId != null">
        dept_id = #{deptId,jdbcType=BIGINT},
      </if>
      <if test="createBy != null">
        create_by = #{createBy,jdbcType=VARCHAR},
      </if>
      <if test="createTime != null">
        create_time = #{createTime,jdbcType=TIMESTAMP},
      </if>
      <if test="lastUpdateBy != null">
        last_update_by = #{lastUpdateBy,jdbcType=VARCHAR},
      </if>
      <if test="lastUpdateTime != null">
        last_update_time = #{lastUpdateTime,jdbcType=TIMESTAMP},
      </if>
      <if test="delFlag != null">
        del_flag = #{delFlag,jdbcType=TINYINT},
      </if>
    </set>
    where id = #{id,jdbcType=BIGINT}
  </update>
  <update id="updateByPrimaryKey" parameterType="com.louis.springboot.demo.model.SysUser">
    update sys_user
    set name = #{name,jdbcType=VARCHAR},
      nick_name = #{nickName,jdbcType=VARCHAR},
      avatar = #{avatar,jdbcType=VARCHAR},
      password = #{password,jdbcType=VARCHAR},
      salt = #{salt,jdbcType=VARCHAR},
      email = #{email,jdbcType=VARCHAR},
      mobile = #{mobile,jdbcType=VARCHAR},
      status = #{status,jdbcType=TINYINT},
      dept_id = #{deptId,jdbcType=BIGINT},
      create_by = #{createBy,jdbcType=VARCHAR},
      create_time = #{createTime,jdbcType=TIMESTAMP},
      last_update_by = #{lastUpdateBy,jdbcType=VARCHAR},
      last_update_time = #{lastUpdateTime,jdbcType=TIMESTAMP},
      del_flag = #{delFlag,jdbcType=TINYINT}
    where id = #{id,jdbcType=BIGINT}
  </update>
  
  <select id="selectAll" resultMap="BaseResultMap">
    select 
    <include refid="Base_Column_List" />
    from sys_user
  </select>
</mapper>

接著編寫一個服務介面，新增一個查詢全部的方法。

SysUserService.java

package com.louis.springboot.demo.service;
import java.util.List;

import com.louis.springboot.demo.model.SysUser;

public interface SysUserService {

    /**
     * 查詢所有使用者
     * @return
     */
    List<SysUser> findAll();

}

繼續編寫服務實現類，並通過呼叫DAO來完成查詢方法。

package com.louis.springboot.demo.service.impl;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.louis.springboot.demo.dao.SysUserMapper;
import com.louis.springboot.demo.model.SysUser;
import com.louis.springboot.demo.service.SysUserService;

@Service
public class SysUserServiceImpl implements SysUserService {
    
    @Autowired
    private SysUserMapper sysUserMapper;
    
    @Override
    public List<SysUser> findAll() {
        return sysUserMapper.selectAll();
    }
}

最後編寫一個控制器，包含兩個查詢方法，分別註解 master 和 slave 資料來源。

SysUserController.java

package com.louis.springboot.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.louis.springboot.demo.config.dds.DataSource;
import com.louis.springboot.demo.service.SysUserService;

/**
 * 使用者控制器
 * @author Louis
 * @date Jun 17, 2019
 */
@RestController
@RequestMapping("user")
public class SysUserController {

    @Autowired
    private SysUserService sysUserService;
    
    
    @DataSource(value="master")
    @PostMapping(value="/findAll")
    public Object findAll() {
        return sysUserService.findAll();
    }
    
    @DataSource(value="slave")
    @PostMapping(value="/findAll2")
    public Object findAll2() {
        return sysUserService.findAll();
    }

}

到這裡，相關程式碼就完成了，接下來，我們來測試一下介面。

編譯測試執行

1.  右鍵專案 -> Run as -> Maven install，開始執行Maven構建，第一次會下載Maven依賴，可能需要點時間，如果出現如下資訊，就說明專案編譯打包成功了。

2.  右鍵檔案 DemoApplication.java -> Run as -> Java Application，開始啟動應用，當出現如下資訊的時候，就說明應用啟動成功了，預設啟動埠是8080。

3.  開啟瀏覽器，訪問：http://localhost:8080/swagger-ui.html，進入swagger介面文件介面。

為了區分master和slave的資料，我們把slave資料庫的管理員記錄的暱稱修改為超級管理員。

然後我們首先測試findAll介面，最終返回結果如下，管理員記錄暱稱為“管理員“，說明查詢的是master資料庫。

接著我們測試findAll2介面，最終返回結果如下，可以看到管理員記錄暱稱為“超級管理員“，說明查詢的是slave資料庫。

流程分析

現在我們來整體分析一下動態資料來源的實現流程，整個過程大概是這樣的。

首先，我們在配置檔案中配置了我們需要的兩個資料來源，當然你也可以配多個。

application.yml

server:
  port: 8080
spring:
  datasource:
    master:
      driver-class-name: com.mysql.cj.jdbc.Driver
      type: com.zaxxer.hikari.HikariDataSource
      jdbcUrl: jdbc:mysql://127.0.0.1:3306/master?useUnicode=true&zeroDateTimeBehavior=convertToNull&autoReconnect=true&characterEncoding=utf-8
      username: root
      password: 123456
    slave:
      driver-class-name: com.mysql.cj.jdbc.Driver
      type: com.zaxxer.hikari.HikariDataSource
      jdbcUrl: jdbc:mysql://127.0.0.1:3306/slave?useUnicode=true&zeroDateTimeBehavior=convertToNull&autoReconnect=true&characterEncoding=utf-8
      username: root
      password: 123456

然後我們在MybatisConfig配置類中，載入了我們的資料來源，並通過dynamicDataSource.setDataSources(dataSourceMap)將我們的資料來源裡邊儲存起來。

MybatisConfig.java

@Configuration
@MapperScan(basePackages = {"com.louis.**.dao"}) // 掃描DAO
public class MybatisConfig {

    @Bean("master")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource master() {
        return DataSourceBuilder.create().build();
    }

    @Bean("slave")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slave() {
        return DataSourceBuilder.create().build();
    }

    @Bean("dynamicDataSource")
    public DataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map<Object, Object> dataSourceMap = new HashMap<>(2);
        dataSourceMap.put("master", master());
        dataSourceMap.put("slave", slave());
        // 將 master 資料來源作為預設指定的資料來源
        dynamicDataSource.setDefaultDataSource(master());
        // 將 master 和 slave 資料來源作為指定的資料來源
        dynamicDataSource.setDataSources(dataSourceMap);
        return dynamicDataSource;
    }

    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean() throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        // 配置資料來源，此處配置為關鍵配置，如果沒有將 dynamicDataSource作為資料來源則不能實現切換
        sessionFactory.setDataSource(dynamicDataSource());
        sessionFactory.setTypeAliasesPackage("com.louis.**.model");    // 掃描Model
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sessionFactory.setMapperLocations(resolver.getResources("classpath*:**/sqlmap/*.xml"));    // 掃描對映檔案
        return sessionFactory;
    }

    @Bean
    public PlatformTransactionManager transactionManager() {
        // 配置事務管理, 使用事務時在方法頭部新增@Transactional註解即可
        return new DataSourceTransactionManager(dynamicDataSource());
    }
}

其實在使用了AbstractRoutingDataSource之後，程式碼執行資料庫操作時，是通過AbstractRoutingDataSource的determineTargetDataSource方法來獲取要訪問的資料來源的，而determineTargetDataSource又會通過determineCurrentLookupKey來獲取資料來源key，然後根據這個key去查詢資料來源。所以這裡就衍生了兩種動態切換資料來源的方法，一種是直接覆蓋determineTargetDataSource方法，返回自己需要的資料來源，或者通過覆蓋determineCurrentLookupKey來獲取自定義的key，然後通過key去獲取資料來源。我們這裡就採用第二種方法，並且我們把key儲存到上下文中，通過DynamicDataSourceContextHolder來設定和獲取，這樣，只要我們在需要的時候呼叫DynamicDataSourceContextHolder的設定方法動態改變key值，就可以達到動態讀取資料來源的目的了。

DynamicDataSource.java

public class DynamicDataSource extends AbstractRoutingDataSource {
    
    
    /**
     * 如果不希望資料來源在啟動配置時就載入好，可以定製這個方法，從任何你希望的地方讀取並返回資料來源
     * 比如從資料庫、檔案、外部介面等讀取資料來源資訊，並最終返回一個DataSource實現類物件即可
     */
    @Override
    protected DataSource determineTargetDataSource() {
        return super.determineTargetDataSource();
    }
    
    /**
     * 如果希望所有資料來源在啟動配置時就載入好，這裡通過設定資料來源Key值來切換資料，定製這個方法
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceKey();
    }
    
    /**
     * 設定預設資料來源
     * @param defaultDataSource
     */
    public void setDefaultDataSource(Object defaultDataSource) {
        super.setDefaultTargetDataSource(defaultDataSource);
    }
    
    /**
     * 設定資料來源
     * @param dataSources
     */
    public void setDataSources(Map<Object, Object> dataSources) {
        super.setTargetDataSources(dataSources);
        // 將資料來源的 key 放到資料來源上下文的 key 集合中，用於切換時判斷資料來源是否有效
        DynamicDataSourceContextHolder.addDataSourceKeys(dataSources.keySet());
    }
}

通過上面講解我們已經知道只要在需要切換資料來源的時候通過DynamicDataSourceContextHolder設定一下key值就可以了，那麼如何可以實現指定不同方法可以不同資料庫呢，我們這裡添加了一個名為DataSource的註解，只要在需要制定資料來源的方法上加上@DataSource(value="資料來源名稱")就可以了。如我們的SysUserController分別指定了findAll訪問master資料來源，findAll2訪問slave資料來源。

SysUserController.java

@RestController
@RequestMapping("user")
public class SysUserController {

    @Autowired
    private SysUserService sysUserService;
    
    
    @DataSource(value="master")
    @PostMapping(value="/findAll")
    public Object findAll() {
        return sysUserService.findAll();
    }
    
    @DataSource(value="slave")
    @PostMapping(value="/findAll2")
    public Object findAll2() {
        return sysUserService.findAll();
    }

}

之所以加了資料來源註解就能使用資料來源切換，是因為我們通過Spring AOP實現了一個DynamicDataSourceAspect切面，這個切面能夠在新增有資料來源註解的方法執行的時候，先行把資料來源切換到註解提供的目標資料來源，並且如果有需要的話，在資料訪問執行完畢後清理和切換回先前的資料來源。

DynamicDataSourceAspect.java

@Aspect
@Order(-1)  // 該切面應當先於 @Transactional 執行
@Component
public class DynamicDataSourceAspect {
    
    /**
     * 切換資料來源
     * @param point
     * @param dataSource
     */
    @Before("@annotation(dataSource))")
    public void switchDataSource(JoinPoint point, DataSource dataSource) {
        if (!DynamicDataSourceContextHolder.containDataSourceKey(dataSource.value())) {
            System.out.println("DataSource [{}] doesn't exist, use default DataSource [{}] " + dataSource.value());
        } else {
            // 切換資料來源
            DynamicDataSourceContextHolder.setDataSourceKey(dataSource.value());
            System.out.println("Switch DataSource to [" + DynamicDataSourceContextHolder.getDataSourceKey()
                + "] in Method [" + point.getSignature() + "]");
        }
    }

    /**
     * 重置資料來源
     * @param point
     * @param dataSource
     */
    @After("@annotation(dataSource))")
    public void restoreDataSource(JoinPoint point, DataSource dataSource) {
        // 將資料來源置為預設資料來源
        DynamicDataSourceContextHolder.clearDataSourceKey();
        System.out.println("Restore DataSource to [" + DynamicDataSourceContextHolder.getDataSourceKey() 
            + "] in Method [" + point.getSignature() + "]");
    }
}

參考資料

MyBatis 官網：http://www.mybatis.org/mybatis-3/zh/index.html

MyBatis Generator 官網：http://www.mybatis.org/generator/index.html

MyBatis Plus 官網: http://mp.baomidou.com/#/quick-start

相關導航

Spring Boot：快速入門教程

Spring Boot：整合Swagger文件

Spring Boot：整合MyBatis框架

Spring Boot：實現MyBatis分頁

Spring Boot：整合Druid資料來源

Spring Boot：實現MyBatis動態資料來源

Spring Boot：實現MyBatis動態建立表

原始碼下載

碼雲：https://gitee.com/liuge1988/spring-boot-demo.git

作者：朝雨憶輕塵
出處：https://www.cnblogs.com/xifengxiaoma/ 
版權所有，歡迎轉載，轉載請註明原文作者及出