springboot2.x整合mybatis-plus,mysql實現多數據源

怎麼新建springboot項目我在這裏就不介紹了，首先我們先來看一下需要引入哪些主要的jar

1：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 https://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.7.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>dome</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>dome</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <druid.version>1.1.2</druid.version>
        <mysql-connector.version>8.0.7-dmr</mysql-connector.version>
        <mybatis-plus.version>2.1.8</mybatis-plus.version>
        <mybatisplus-spring-boot-starter.version>1.0.5</mybatisplus-spring-boot-starter.version>
        <redis-clien.version>2.9.0</redis-clien.version>
        <fast-json.version>1.2.45</fast-json.version>
        <lombok.version>1.18.8</lombok.version>
    </properties>

    <dependencies>
        
        <!--web支持-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--AOP-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <!--Mysql Start-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-connector.version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <!--Mysql End-->


        <!-- MyBatis plus增強和springboot的集成 Start-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatisplus-spring-boot-starter</artifactId>
            <version>${mybatisplus-spring-boot-starter.version}</version>
        </dependency>
        <!-- 分頁插件 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.5</version>
        </dependency>
        <!-- MyBatis plus增強和springboot的集成 End-->


        <!-- mp自動代碼生成 Start-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.0.7.1</version>
        </dependency>

        <!-- velocity 模板引擎, 默認 -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.0</version>
        </dependency>

        <!-- freemarker 模板引擎 -->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.23</version>
        </dependency>
        <!-- beetl 模板引擎 -->
        <dependency>
            <groupId>com.ibeetl</groupId>
            <artifactId>beetl</artifactId>
            <version>2.2.5</version>
        </dependency>
        <!-- mp自動代碼生成 END-->

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest-all</artifactId>
            <version>1.3</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>
        <!--redis Start-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>${redis-clien.version}</version>
        </dependency>
        <!--redis END-->

        <!--FastJson-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fast-json.version}</version>
        </dependency>

    </dependencies>

    <build>
        <!--MAVEN PACK-->
        <defaultGoal>compile</defaultGoal>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.1</version>
                <configuration>
                    <!--<proc>none</proc>-->
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.20</version>
                <configuration>
                    <skip>true</skip>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                </executions>
            </plugin>
        </plugins>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>

</project>

2：application.yml

#自定義配置
example:
  muti-datasource-open: true #是否開啓多數據源(true/false)
  redis-multi-open: false

#spring配置
spring:
  profiles:
    active: dev
#端口
server:
  port: 8987
  
---
#主數據源
spring:
  profiles: dev
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/expo0917?serverTimezone=UTC&useSSL=false&autoReconnect=true&tinyInt1isBit=false&useUnicode=true&characterEncoding=utf8
    username: root
    password: root

#數據源 biz
biz:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/xm001dev?serverTimezone=UTC&useSSL=false&autoReconnect=true&tinyInt1isBit=false&useUnicode=true&characterEncoding=utf8
    username: root
    password: root

logging:
  level:
    ROOT: INFO
    com:
      example: DEBUG
  file: D:/logs/app.log
  
---
#mybatis-plus配置
mybatis-plus:
  mapper-locations: classpath*:com/example/dome/common/dao/repository/mapping/*.xml
  typeAliasesPackage: >
    com.example.dome.common.dao.entity
  global-config:
    id-type: 0  # 0:數據庫ID自增   1:用戶輸入id  2:全局唯一id(IdWorker)  3:全局唯一ID(uuid)
    db-column-underline: false
    refresh-mapper: true
  configuration:
    map-underscore-to-camel-case: true
    cache-enabled: true #配置的緩存的全局開關
    lazyLoadingEnabled: true #延時加載的開關
    multipleResultSetsEnabled: true #開啓的話，延時加載一個屬性時會加載該對象全部屬性，否則按需加載屬性

logging:
  level:
    org.springframework.web.servlet: ERROR

---
#Redis
spring:
  redis:
    host: 192.168.11.200
    porl: 6379
    database: 0
    password:
    timeout: 6000ms
    jedis:
      pool:
        max-active: 1000    # 連接池最大連接數（使用負值表示沒有限制）
        max-wait: -1ms    # 連接池最大阻塞等待時間（使用負值表示沒有限制）
        max-idle: 10      # 連接池中的最大空閒連接
        min-idle: 5       # 連接池中的最小空閒連接
  cache:
    type: none

關於yml裏面的自定義配置內容提示可以參考：https://blog.csdn.net/qq_34805041/article/details/100103980

 

3：Druid數據連接池配置

package com.example.dome.config.properties;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.util.JdbcConstants;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.sql.SQLException;

/**
 * @Time 2019/8/28 18:54
 * @Author GuiPing.Xu
 * @Version 1.0.0
 * @Explain  <p>數據庫數據源配置</p>
 *  <p>說明:這個類中包含了許多默認配置,若這些配置符合您的情況,您可以不用管,若不符合,建議不要修改本類,建議直接在"application.yml"中配置即可</p>
 */
@Component
@ConfigurationProperties(prefix = "spring.datasource")
public class    DruidProperties {

    private String url;

    private String username;

    private String password;

    private String driverClassName = "com.mysql.cj.jdbc.Driver";

    private Integer initialSize = 10;

    private Integer minIdle = 3;

    private Integer maxActive = 60;

    private Integer maxWait = 60000;

    private Boolean removeAbandoned = true;

    private Integer removeAbandonedTimeout = 180;

    private Integer timeBetweenEvictionRunsMillis = 60000;

    private Integer minEvictableIdleTimeMillis = 300000;

    private String validationQuery = "SELECT 'x'";

    private Boolean testWhileIdle = true;

    private Boolean testOnBorrow = false;

    private Boolean testOnReturn = false;

    private Boolean poolPreparedStatements = true;

    private Integer maxPoolPreparedStatementPerConnectionSize = 50;

    private String filters = "stat";

    public void config(DruidDataSource dataSource) {
        dataSource.setDbType(JdbcConstants.MYSQL);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driverClassName);
        // 定義初始連接數
        dataSource.setInitialSize(initialSize);
        // 最小空閒
        dataSource.setMinIdle(minIdle);
        // 定義最大連接數
        dataSource.setMaxActive(maxActive);
        // 獲取連接等待超時的時間
        dataSource.setMaxWait(maxWait);
        // 超過時間限制是否回收
        dataSource.setRemoveAbandoned(removeAbandoned);
        // 超過時間限制多長
        dataSource.setRemoveAbandonedTimeout(removeAbandonedTimeout);

        // 配置間隔多久才進行一次檢測，檢測需要關閉的空閒連接，單位是毫秒
        dataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        // 配置一個連接在池中最小生存的時間，單位是毫秒
        dataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        // 用來檢測連接是否有效的sql，要求是一個查詢語句
        dataSource.setValidationQuery(validationQuery);
        // 申請連接的時候檢測
        dataSource.setTestWhileIdle(testWhileIdle);
        // 申請連接時執行validationQuery檢測連接是否有效，配置爲true會降低性能
        dataSource.setTestOnBorrow(testOnBorrow);
        // 歸還連接時執行validationQuery檢測連接是否有效，配置爲true會降低性能
        dataSource.setTestOnReturn(testOnReturn);
        // 打開PSCache，並且指定每個連接上PSCache的大小
        dataSource.setPoolPreparedStatements(poolPreparedStatements);
        dataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        // 屬性類型是字符串，通過別名的方式配置擴展插件，常用的插件有：
        // 監控統計用的filter:stat
        // 日誌用的filter:log4j
        // 防禦SQL注入的filter:wall
        try {
            dataSource.setFilters(filters);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public Integer getInitialSize() {
        return initialSize;
    }

    public void setInitialSize(Integer initialSize) {
        this.initialSize = initialSize;
    }

    public Integer getMinIdle() {
        return minIdle;
    }

    public void setMinIdle(Integer minIdle) {
        this.minIdle = minIdle;
    }

    public Integer getMaxActive() {
        return maxActive;
    }

    public void setMaxActive(Integer maxActive) {
        this.maxActive = maxActive;
    }

    public Integer getMaxWait() {
        return maxWait;
    }

    public void setMaxWait(Integer maxWait) {
        this.maxWait = maxWait;
    }

    public Integer getTimeBetweenEvictionRunsMillis() {
        return timeBetweenEvictionRunsMillis;
    }

    public void setTimeBetweenEvictionRunsMillis(Integer timeBetweenEvictionRunsMillis) {
        this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    }

    public Integer getMinEvictableIdleTimeMillis() {
        return minEvictableIdleTimeMillis;
    }

    public void setMinEvictableIdleTimeMillis(Integer minEvictableIdleTimeMillis) {
        this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
    }

    public String getValidationQuery() {
        return validationQuery;
    }

    public void setValidationQuery(String validationQuery) {
        this.validationQuery = validationQuery;
    }

    public Boolean getTestWhileIdle() {
        return testWhileIdle;
    }

    public void setTestWhileIdle(Boolean testWhileIdle) {
        this.testWhileIdle = testWhileIdle;
    }

    public Boolean getTestOnBorrow() {
        return testOnBorrow;
    }

    public void setTestOnBorrow(Boolean testOnBorrow) {
        this.testOnBorrow = testOnBorrow;
    }

    public Boolean getTestOnReturn() {
        return testOnReturn;
    }

    public void setTestOnReturn(Boolean testOnReturn) {
        this.testOnReturn = testOnReturn;
    }

    public Boolean getPoolPreparedStatements() {
        return poolPreparedStatements;
    }

    public void setPoolPreparedStatements(Boolean poolPreparedStatements) {
        this.poolPreparedStatements = poolPreparedStatements;
    }

    public Integer getMaxPoolPreparedStatementPerConnectionSize() {
        return maxPoolPreparedStatementPerConnectionSize;
    }

    public void setMaxPoolPreparedStatementPerConnectionSize(Integer maxPoolPreparedStatementPerConnectionSize) {
        this.maxPoolPreparedStatementPerConnectionSize = maxPoolPreparedStatementPerConnectionSize;
    }

    public String getFilters() {
        return filters;
    }

    public void setFilters(String filters) {
        this.filters = filters;
    }

    public Boolean getRemoveAbandoned() {
        return removeAbandoned;
    }

    public void setRemoveAbandoned(Boolean removeAbandoned) {
        this.removeAbandoned = removeAbandoned;
    }

    public Integer getRemoveAbandonedTimeout() {
        return removeAbandonedTimeout;
    }

    public void setRemoveAbandonedTimeout(Integer removeAbandonedTimeout) {
        this.removeAbandonedTimeout = removeAbandonedTimeout;
    }

}

4：自定義註解類,用來使用在service方法上指定改方法要使用的數據源

package com.example.dome.common.annotion;

import java.lang.annotation.*;

/**
 *  @Time 2019/8/27 18:40
 *  @Author GuiPing.Xu
 *  @Version 1.0.0
 *  @Explain 自定義註解類
 *
 * java 四大元註解作用
 * 1.@Target ：用於描述註解的使用範圍，也就是說使用了@Target去定義一個註解，
 *             那麼可以決定定義好的註解能用在什麼地方
 *             1.CONSTRUCTOR:用於描述構造器
 * 　　　　     2.FIELD:用於描述域
 * 　　　　     3.LOCAL_VARIABLE:用於描述局部變量
 * 　　　　     4.METHOD:用於描述方法
 * 　　　　     5.PACKAGE:用於描述包
 * 　　　　     6.PARAMETER:用於描述參數
 * 　　　　     7.TYPE:用於描述類、接口(包括註解類型) 或enum聲明
 * 2.@Retention：用於描述註解的生命週期，也就是說這個註解在什麼範圍內有效，
 *               註解的生命週期和三個階段有關：源代碼階段、CLASS文件中有效、運行時有效，
 *               故其取值也就三個值，分別代表着三個階段
 *               1、RetentionPolicy.SOURCE：註解只保留在源文件，當Java文件編譯成class文件的時候，註解被遺棄；
 *               2、RetentionPolicy.CLASS：註解被保留到class文件，但jvm加載class文件時候被遺棄，這是默認的生命週期；
 *               3、RetentionPolicy.RUNTIME：註解不僅被保存到class文件中，jvm加載class文件之後，仍然存在；
 * 3.@Documented：表示該註解是否可以生成到 API文檔中。在該註解使用後，如果導出API文檔，
 *                會將該註解相關的信息可以被例如javadoc此類的工具文檔化。
 *                注意：Documented是一個標記註解，沒有成員。
 * 4.@Inherited：使用@Inherited定義的註解具備繼承性
 *              假設一個註解在定義時，使用了@Inherited，然後該註解在一個類上使用，如果這個類有子類，
 *              那麼通過反射我們可以從類的子類上獲取到同樣的註解、
 */
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DataSource {
    String name() default "";
}

5：定義多數據源枚舉常量類

package com.example.dome.common.mutidatesource;

/**
 * @Time 2019/8/27 18:40
 * @Author GuiPing.Xu
 * @Version 1.0.0
 * @Explain 多數據源的常量類
 */
public interface DSEnum {
    /**
     * 核心數據庫
     */
    String DATA_SOURCE_CORE="dataSourceCore";

    /**
     * 其他業務數據庫
     */
    String DATA_SOURCE_BIZ="dataSourceBiz";

}

6：配置DataSource上下文，用來存儲當前線程的數據源

package com.example.dome.common.mutidatesource;

/**
 * @Time 2019/8/27 18:45
 * @Author GuiPing.Xu
 * @Version 1.0.0
 * @Explain dataSource的上下文 用來存儲當前線程的數據源類型
 */
public class DataSourceContextHolder {
    private static final  ThreadLocal<String> contextHolder=new ThreadLocal<String>();

    /**
     * @param dataSourceType 數據庫類型
     * @Description: 設置數據源類型
     */
    public static void setDataSourceType(String dataSourceType) {
        contextHolder.set(dataSourceType);
    }

    /**
     * @Description: 獲取數據源類型
     */
    public static String getDataSourceType() {
        return contextHolder.get();
    }

    /**
     * @Description: 清除數據源類型
     */
    public static void clearDataSourceType() {
        contextHolder.remove();
    }

}

7：定義動態數據源

package com.example.dome.common.mutidatesource;


/**
 * @Time 2019/8/27 18:48
 * @Author GuiPing.Xu
 * @Version 1.0.0
 * @Explain 動態數據源
 */
public class AbstractRoutingDataSource extends org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSourceType();
    }
}

8：最核心最重要的AOP類

package com.example.dome.common.aop;

import com.example.dome.common.annotion.DataSource;
import com.example.dome.common.mutidatesource.DSEnum;
import com.example.dome.common.mutidatesource.DataSourceContextHolder;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @Time 2019/8/28 11:43
 * @Author GuiPing.Xu
 * @Version 1.0.0
 * @Explain AOP切面類
 *
 */
@Aspect
@Component
@ConditionalOnProperty(prefix = "example",name = "muti-datasource-open",havingValue = "true")
public class    MultiSourceExAop implements Ordered {

    Logger logger= LoggerFactory.getLogger(this.getClass());

    /**
     * 定義一個Annotation 類型的切點,當spring 掃描到自定義註解@DataSource,進入該切點
     */
    @Pointcut(value = "@annotation(com.example.dome.common.annotion.DataSource)")
    private void cut() {

    }

    /**
     * 可以同時在所攔截cut()方法的前後執行一段邏輯
     * @param point
     * @return
     * @throws Throwable
     */
    @Around("cut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {

        Signature signature = point.getSignature();
        MethodSignature methodSignature = null;
        if (!(signature instanceof MethodSignature)) {
            throw new IllegalArgumentException("該註解只能用於方法");
        }
        methodSignature = (MethodSignature) signature;

        Object target = point.getTarget();
        Method currentMethod = target.getClass().getMethod(methodSignature.getName(), methodSignature.getParameterTypes());

        DataSource datasource = currentMethod.getAnnotation(DataSource.class);
        if (datasource != null) {
            DataSourceContextHolder.setDataSourceType(datasource.name());
            logger.debug("設置數據源爲：" + datasource.name());
        } else {
            DataSourceContextHolder.setDataSourceType(DSEnum.DATA_SOURCE_CORE);
            logger.debug("設置數據源爲：dataSourceCore");
        }
        try {
            return point.proceed();
        } finally {
            logger.debug("清空數據源信息！");
            DataSourceContextHolder.clearDataSourceType();
        }
    }

    /**
     * AOP事務順序  AOP的順序要早於spring的事務
     * @return
     */ 
    @Override
    public int getOrder() {
        return 1;
    }
}

配置信息類

package com.example.dome.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.example.dome.common.mutidatesource.AbstractRoutingDataSource;
import com.example.dome.common.mutidatesource.DSEnum;
import com.example.dome.config.properties.DruidProperties;
import com.example.dome.config.properties.MutiDataSourceProperties;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import java.sql.SQLException;
import java.util.HashMap;

/**
 * @Time 2019/8/28 15:33
 * @Author GuiPing.Xu
 * @Version 1.0.0
 * @Explain
 */
@Configuration
@EnableTransactionManagement(order = 2)
@MapperScan(basePackages = {"com.example.dome.common.mapper"})
public class MybatisPlusConfig {
    @Autowired
    DruidProperties druidProperties;
    @Autowired
    MutiDataSourceProperties mutiDataSourceProperties;

    /**
     * 核心數據源
     */
    private DruidDataSource coreDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        druidProperties.config(dataSource);
        return dataSource;
    }

    /**
     * 另一個數據源
     */
    private DruidDataSource bizDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        druidProperties.config(dataSource);
        mutiDataSourceProperties.config(dataSource);
        return dataSource;
    }

    /**
     * 單數據源連接池配置  通過@ConditionalOnProperty來控制Configuration是否生效
     */
    @Bean
    @ConditionalOnProperty(prefix = "example", name = "muti-datasource-open", havingValue = "false")
    public DruidDataSource singleDatasource() {
        return coreDataSource();
    }

    /**
     * 多數據源連接池配置
     */
    @Bean
    @ConditionalOnProperty(prefix = "example", name = "muti-datasource-open", havingValue = "true")
    public AbstractRoutingDataSource mutiDataSource() {

        DruidDataSource coreDataSource = coreDataSource();
        DruidDataSource bizDataSource = bizDataSource();
        try {
            coreDataSource.init();
            bizDataSource.init();
        } catch (SQLException sql) {
            sql.printStackTrace();
        }

        AbstractRoutingDataSource dynamicDataSource = new AbstractRoutingDataSource();
        HashMap<Object, Object> hashMap = new HashMap<>();
        hashMap.put(DSEnum.DATA_SOURCE_CORE, coreDataSource);
        hashMap.put(DSEnum.DATA_SOURCE_BIZ, bizDataSource);
        dynamicDataSource.setTargetDataSources(hashMap);
        dynamicDataSource.setDefaultTargetDataSource(coreDataSource);
        return dynamicDataSource;
    }
}

GitHub源代碼地址：https://github.com/xuguipinga/springBootStudy/tree/master/multipleDataSources

本人也是第一次寫，其中有一些代碼也是借鑑一些大牛的，如有什麼不合理的地方，希望可以指出來，多多交流，學習