使用dynamic-datasource-spring-boot-starter做多資料源及源碼分析

多資料源系列

1、spring boot2.0 +Mybatis + druid搭建一個最簡單的多資料源

2、利用Spring的AbstractRoutingDataSource做多資料源動态切換

3、使用dynamic-datasource-spring-boot-starter做多資料源及源碼分析

文章目錄

簡介

實操

基本使用

內建druid連接配接池

service嵌套

為什麼切換資料源不生效或事務不生效？

源碼分析

整體結構

自動配置怎麼實作的

如何內建衆多連接配接池的

DS注解如何被攔截處理的

多資料源動态切換及如何管理多資料源

資料組的負載均衡怎麼做的

如何自定義資料配置來源

如何動态增減資料源

總結

前兩篇部落格介紹了用基本的方式做多資料源，可以應對一般的情況，但是遇到一些複雜的情況就需要擴充下功能了，比如：動态增減資料源、資料源分組，純粹多庫 讀寫分離 一主多從、從其他資料庫或者配置中心讀取資料源等等。其實就算沒有這些需求，使用這個實作多資料源也比之前使用AbstractRoutingDataSource要便捷的多

dynamic-datasource-spring-boot-starter 是一個基于springboot的快速內建多資料源的啟動器。

github: https://github.com/baomidou/dynamic-datasource-spring-boot-starter

文檔： https://github.com/baomidou/dynamic-datasource-spring-boot-starter/wiki

它跟mybatis-plus是一個生态圈裡的，很容易內建mybatis-plus

特性：

資料源分組，适用于多種場景 純粹多庫 讀寫分離 一主多從 混合模式。

内置敏感參數加密和啟動初始化表結構schema資料庫database。

提供對Druid，Mybatis-Plus，P6sy，Jndi的快速內建。

簡化Druid和HikariCp配置，提供全局參數配置。

提供自定義資料源來源接口(預設使用yml或properties配置)。

提供項目啟動後增減資料源方案。

提供Mybatis環境下的 純讀寫分離 方案。

使用spel動态參數解析資料源，如從session，header或參數中擷取資料源。（多租戶架構神器）

提供多層資料源嵌套切換。（ServiceA >>> ServiceB >>> ServiceC，每個Service都是不同的資料源）

提供 不使用注解 而 使用 正則 或 spel 來切換資料源方案（實驗性功能）。

基于seata的分布式事務支援。

先把坐标丢出來

<dependency>

<groupId>com.baomidou</groupId>

<artifactId>dynamic-datasource-spring-boot-starter</artifactId>

<version>3.1.0</version>

</dependency>

下面抽幾個用的比較多的應用場景介紹

使用方法很簡潔，分兩步走

一：通過yml配置好資料源

二：service層裡面在想要切換資料源的方法上加上@DS注解就行了，也可以加在整個service層上，方法上的注解優先于類上注解

spring:

datasource:

dynamic:

primary: master #設定預設的資料源或者資料源組,預設值即為master

strict: false #設定嚴格模式,預設false不啟動. 啟動後在未比對到指定資料源時候回抛出異常,不啟動會使用預設資料源.

datasource:

master:

url: jdbc:mysql://127.0.0.1:3306/dynamic

username: root

password: 123456

driver-class-name: com.mysql.jdbc.Driver

db1:

url: jdbc:gbase://127.0.0.1:5258/dynamic

driver-class-name: com.gbase.jdbc.Driver

這就是兩個不同資料源的配置，接下來寫service代碼就行了

# 多主多從

master_1:

master_2:

slave_1:

slave_2:

slave_3:

如果是多主多從，那麼就用資料組名稱_xxx，下劃線前面的就是資料組名稱，相同組名稱的資料源會放在一個組下。切換資料源時，可以指定具體資料源名稱，也可以指定組名然後會自動采用負載均衡算法切換

# 純粹多庫（記得設定primary）

db2:

db3:

db4:

db5:

純粹多庫，就一個一個往上加就行了

@Service

@DS("master")

public class UserServiceImpl implements UserService {

@Autowired

private JdbcTemplate jdbcTemplate;

public List<Map<String, Object>> selectAll() {

return jdbcTemplate.queryForList("select * from user");

}

@Override

@DS("db1")

public List<Map<String, Object>> selectByCondition() {

return jdbcTemplate.queryForList("select * from user where age >10");

}

注解 結果

沒有@DS 預設資料源

@DS(“dsName”) dsName可以為組名也可以為具體某個庫的名稱

通過日志可以發現我們配置的多資料源已經被初始化了，如果切換資料源也會看到列印日子的

是不是很便捷，這是官方的例子

<groupId>com.alibaba</groupId>

<artifactId>druid-spring-boot-starter</artifactId>

<version>1.1.22</version>

首先引入依賴

autoconfigure:

exclude: com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure

再排除掉druid原生的自動配置

datasource: #資料庫連結相關配置

druid: #以下是全局預設值，可以全局更改

#監控統計攔截的filters

filters: stat

#配置初始化大小/最小/最大

initial-size: 1

min-idle: 1

max-active: 20

#擷取連接配接等待逾時時間

max-wait: 60000

#間隔多久進行一次檢測，檢測需要關閉的空閑連接配接

time-between-eviction-runs-millis: 60000

#一個連接配接在池中最小生存的時間

min-evictable-idle-time-millis: 300000

validation-query: SELECT 'x'

test-while-idle: true

test-on-borrow: false

test-on-return: false

#打開PSCache，并指定每個連接配接上PSCache的大小。oracle設為true，mysql設為false。分庫分表較多推薦設定為false

pool-prepared-statements: false

max-pool-prepared-statement-per-connection-size: 20

stat:

merge-sql: true

log-slow-sql: true

slow-sql-millis: 2000

primary: master

url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=GMT%2B8

password: root

driver-class-name: com.mysql.cj.jdbc.Driver

gbase1:

url: jdbc:gbase://127.0.0.1:5258/test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false&useSSL=false&zeroDateTimeBehavior=convertToNull

username: gbase

password: gbase

druid: # 以下參數針對每個庫可以重新設定druid參數

initial-size:

validation-query: select 1 FROM DUAL #比如oracle就需要重新設定這個

public-key: #（非全局參數）設定即表示啟用加密,底層會自動幫你配置相關的連接配接參數和filter。

配置好了就可以了，切換資料源的用法和上面的一樣的，打@DS(“db1”)注解到service類或方法上就行了

詳細配置參考這個配置類com.baomidou.dynamic.datasource.spring.boot.autoconfigure.DynamicDataSourceProperties

這個就是特性的第九條：提供多層資料源嵌套切換。（ServiceA >>> ServiceB >>> ServiceC，每個Service都是不同的資料源）

借用源碼中的demo：實作SchoolService >>> studentService、teacherService

public class SchoolServiceImpl{

public void addTeacherAndStudent() {

teacherService.addTeacherWithTx("ss", 1);

teacherMapper.addTeacher("test", 111);

studentService.addStudentWithTx("tt", 2);

}

@DS("teacher")

public class TeacherServiceImpl {

public boolean addTeacherWithTx(String name, Integer age) {

return teacherMapper.addTeacher(name, age);

@DS("student")

public class StudentServiceImpl {

public boolean addStudentWithTx(String name, Integer age) {

return studentMapper.addStudent(name, age);

這個addTeacherAndStudent調用資料源切換就是primary ->teacher->primary->student->primary

關于其他demo可以看官方wiki，裡面寫了很多用法，這裡就不贅述了，重點在于學習原理。。。

這種問題常見于上一節service嵌套，比如serviceA -> serviceB、serviceC，serviceA

加上@Transaction

簡單來說：嵌套資料源的service中，如果操作了多個資料源，不能在最外層加上@Transaction開啟事務，否則切換資料源不生效，因為這屬于分布式事務了，需要用seata方案解決，如果是單個資料源(不需要切換資料源)可以用@Transaction開啟事務，保證每個資料源自己的完整性

下面來粗略的分析加事務不生效的原因：

它這個切換資料源的原理就是實作了DataSource接口，實作了getConnection方法，隻要在service中開啟事務，service中對其他資料源操作隻會使用開啟事務的資料源，因為開啟事務資料源會被緩存下來，可以在DataSourceTransactionManager的doBegin方法中看見那個txObject，如果在一個事務内，就會複用Connection，是以切換不了資料源

/**

* This implementation sets the isolation level but ignores the timeout.

*/

@Override

protected void doBegin(Object transaction, TransactionDefinition definition) {

DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;

Connection con = null;

try {

if (!txObject.hasConnectionHolder() ||

txObject.getConnectionHolder().isSynchronizedWithTransaction()) {

// 開啟一個新事務會擷取一個新的Connection，是以會調用DataSource接口的getConnection方法，進而切換資料源

Connection newCon = obtainDataSource().getConnection();

if (logger.isDebugEnabled()) {

logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");

}

txObject.setConnectionHolder(new ConnectionHolder(newCon), true);

}

txObject.getConnectionHolder().setSynchronizedWithTransaction(true);

// 如果已經開啟了事務，就從holder中擷取Connection

con = txObject.getConnectionHolder().getConnection();

…………

多資料源事務嵌套

看上面源碼，說是新起一個事務才會重新擷取Connection，才會成功切換資料源，那我在每個資料源的service方法上都加上@Transaction呢？（涉及spring事務傳播行為）

這裡做個小實驗，還是上面的例子，serviceA ->(嵌套) serviceB、serviceC，serviceA

加上@Transaction，現在給serviceB和serviceC的方法上也加上@Transaction，就是所有service裡被調用的方法都打上@Transaction注解

@Transactional

public void addTeacherAndStudentWithTx() {

teacherService.addTeacherWithTx("ss", 1);

studentService.addStudentWithTx("tt", 2);

throw new RuntimeException("test");

類似這樣，裡面兩個service也都加上了@Transaction

實際上這樣資料源也不會切換，因為預設事務傳播級别為required，父子service屬于同一事物是以就會用同一Connection。而這裡是多資料源，如果把事務傳播方式改成require_new給子service起新事物，可以切換資料源，他們都是獨立的事務了，然後父service復原不會導緻子service復原（詳見spring事務傳播），這樣保證了每個單獨的資料源的資料完整性，如果要保證所有資料源的完整性，那就用seata分布式事務架構

// 做了資料庫操作

aaaDao.doSomethings(“test”);

關于事務嵌套，還有一種情況就是在外部service裡面做DB1的一些操作，然後再調用DB2、DB3的service，再想保證DB1的事務，就需要在外部service上加@Transaction，如果想讓裡面的service正常切換資料源，根據事務傳播行為，設定為propagation = Propagation.REQUIRES_NEW就可以了，裡面的也能正常切換資料源了，因為它們是獨立的事務

補充：關于@Transaction操作多資料源事務的問題

@Transaction

public void insertDB1andDB2() {

db1Service.insertOne();

db2Service.insertOne();

throw new RuntimeException("test");

類似于上面這種操作，我們通過注入多個DataSource、DataSourceTransactionManager、SqlSessionFactory、SqlSessionTemplate這四種Bean的方式來實作多資料源(最頂上第一篇部落格提到的方式)，然後在外部又加上了@Transaction想實作事務

我試過在中間抛異常檢視能不能正常復原，結果發現隻會有一個資料源的事務生效，點開@Transaction注解，發現裡面有個transactionManager屬性，這個就是指定之前聲明的transactionManager Bean，我們預設了DB1的transactionManager為@Primary，是以這時DB2的事務就不會生效，因為用的是DB1的TransactionManager。因為@Transactional隻能指定一個事務管理器，并且注解不允許重複，是以就隻能使用一個資料源的事務管理器了。如果DB2中的更新失敗,我想復原DB1和DB2以進行復原，可以使用ChainedTransactionManager來解決，它可以最後盡最大努力復原事務

源碼基于3.1.1版本(20200522)

由于篇幅限制，隻截了重點代碼，如果需要看完整代碼可以去github拉，或者點選下載下傳dynamic-datasource-spring-boot-starter.zip

拿到代碼要找到入手點，這裡帶着問題閱讀代碼

一般一個starter的最好入手點就是自動配置類，在 META-INF/spring.factories檔案中指定自動配置類入口

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\

com.baomidou.dynamic.datasource.spring.boot.autoconfigure.DynamicDataSourceAutoConfiguration

1

2

在spring.factories中看到有這個自動配置

是以從核心自動配置類DynamicDataSourceAutoConfiguration入手

可以認為這就是程式的Main入口

@Slf4j

@Configuration

@AllArgsConstructor

// 以spring.datasource.dynamic為字首讀取配置

@EnableConfigurationProperties(DynamicDataSourceProperties.class)

// 需要在spring boot的DataSource bean自動配置之前注入我們的DataSource bean

@AutoConfigureBefore(DataSourceAutoConfiguration.class)

// 引入了Druid的autoConfig和各種資料源連接配接池的Creator

@Import(value = {DruidDynamicDataSourceConfiguration.class, DynamicDataSourceCreatorAutoConfiguration.class})

// 當含有spring.datasource.dynamic配置的時候啟用這個autoConfig

@ConditionalOnProperty(prefix = DynamicDataSourceProperties.PREFIX, name = "enabled", havingValue = "true", matchIfMissing = true)

public class DynamicDataSourceAutoConfiguration {

private final DynamicDataSourceProperties properties;

/**

* 多資料源加載接口，預設從yml中讀取多資料源配置

* @return DynamicDataSourceProvider

*/

@Bean

@ConditionalOnMissingBean

public DynamicDataSourceProvider dynamicDataSourceProvider() {

Map<String, DataSourceProperty> datasourceMap = properties.getDatasource();

return new YmlDynamicDataSourceProvider(datasourceMap);

* 注冊自己的動态多資料源DataSource

* @param dynamicDataSourceProvider 各種資料源連接配接池建造者

* @return DataSource

public DataSource dataSource(DynamicDataSourceProvider dynamicDataSourceProvider) {

DynamicRoutingDataSource dataSource = new DynamicRoutingDataSource();

dataSource.setPrimary(properties.getPrimary());

dataSource.setStrict(properties.getStrict());

dataSource.setStrategy(properties.getStrategy());

dataSource.setProvider(dynamicDataSourceProvider);

dataSource.setP6spy(properties.getP6spy());

dataSource.setSeata(properties.getSeata());

return dataSource;

* AOP切面，對DS注解過的方法進行增強，達到切換資料源的目的

* @param dsProcessor 動态參數解析資料源，如果資料源名稱以#開頭，就會進入這個解析器鍊

* @return advisor

public DynamicDataSourceAnnotationAdvisor dynamicDatasourceAnnotationAdvisor(DsProcessor dsProcessor) {

// aop方法攔截器在方法調用前後做操作

DynamicDataSourceAnnotationInterceptor interceptor = new DynamicDataSourceAnnotationInterceptor();

// 動态參數解析器

interceptor.setDsProcessor(dsProcessor);

// 使用AbstractPointcutAdvisor将pointcut和advice連接配接構成切面

DynamicDataSourceAnnotationAdvisor advisor = new DynamicDataSourceAnnotationAdvisor(interceptor);

advisor.setOrder(properties.getOrder());

return advisor;

* 動态參數解析器鍊

* @return DsProcessor

public DsProcessor dsProcessor() {

DsHeaderProcessor headerProcessor = new DsHeaderProcessor();

DsSessionProcessor sessionProcessor = new DsSessionProcessor();

DsSpelExpressionProcessor spelExpressionProcessor = new DsSpelExpressionProcessor();

// 順序header->session->spel 所有以#開頭的參數都會從參數中擷取資料源

headerProcessor.setNextProcessor(sessionProcessor);

sessionProcessor.setNextProcessor(spelExpressionProcessor);

return headerProcessor;

* 提供不使用注解而使用正則或spel來切換資料源方案（實驗性功能）

* 如果想開啟這個功能得自己配置注入DynamicDataSourceConfigure Bean

* @param dynamicDataSourceConfigure dynamicDataSourceConfigure

* @param dsProcessor dsProcessor

@ConditionalOnBean(DynamicDataSourceConfigure.class)

public DynamicDataSourceAdvisor dynamicAdvisor(DynamicDataSourceConfigure dynamicDataSourceConfigure, DsProcessor dsProcessor) {

DynamicDataSourceAdvisor advisor = new DynamicDataSourceAdvisor(dynamicDataSourceConfigure.getMatchers());

advisor.setDsProcessor(dsProcessor);

advisor.setOrder(Ordered.HIGHEST_PRECEDENCE);

這裡自動配置的五個Bean都是非常重要的，後面會一一涉及到

這裡說說自動配置，主要就是上面自動配置類的幾個注解，都寫了注釋，其中重要的是這個注解：

@EnableConfigurationProperties：使使用 @ConfigurationProperties 注解的類生效，主要是用來把properties或者yml配置檔案轉化為bean來使用的，這個在實際使用中非常實用

@ConfigurationProperties(prefix = DynamicDataSourceProperties.PREFIX)

public class DynamicDataSourceProperties {

public static final String PREFIX = "spring.datasource.dynamic";

public static final String HEALTH = PREFIX + ".health";

* 必須設定預設的庫,預設master

private String primary = "master";

* 是否啟用嚴格模式,預設不啟動. 嚴格模式下未比對到資料源直接報錯, 非嚴格模式下則使用預設資料源primary所設定的資料源

private Boolean strict = false;

…………

/**

* Druid全局參數配置

@NestedConfigurationProperty

private DruidConfig druid = new DruidConfig();

* HikariCp全局參數配置

private HikariCpConfig hikari = new HikariCpConfig();

可以發現之前我們在spring.datasource.dynamic配置的東西都會注入到這個配置Bean中，需要注意的是使用了@NestedConfigurationProperty嵌套了其他的配置類，如果搞不清楚配置項是啥，就直接看看DynamicDataSourceProperties這個類就清楚了

比如說DruidConfig，這個DruidConfig是自定義的一個配置類，不是Druid裡面的，它下面有個toProperties方法，為了實作yml配置中每個dataSource下面的durid可以獨立配置(不配置就使用全局配置的)，根據全局配置和獨立配置結合轉換為Properties，然後在DruidDataSourceCreator類中根據這個配置建立druid連接配接池

關于內建連接配接池配置在上面已經提到過了，就是DynamicDataSourceProperties配置類下，但是如何通過這些配置生成真正的資料源連接配接池呢，讓我們來看creator包

看名字就知道支援哪幾種資料源

在自動配置中，配置DataSource的時候，new了一個DynamicRoutingDataSource，而它實作了InitializingBean接口，在bean初始化時候做一些操作

public class DynamicRoutingDataSource extends AbstractRoutingDataSource implements InitializingBean, DisposableBean {

* 所有資料庫

private final Map<String, DataSource> dataSourceMap = new LinkedHashMap<>();

* 分組資料庫

private final Map<String, DynamicGroupDataSource> groupDataSources = new ConcurrentHashMap<>();

省略部分代碼…………

* 添加資料源

*

* @param ds 資料源名稱

* @param dataSource 資料源

public synchronized void addDataSource(String ds, DataSource dataSource) {

// 如果資料源不存在則儲存一個

if (!dataSourceMap.containsKey(ds)) {

// 包裝seata、p6spy插件

dataSource = wrapDataSource(ds, dataSource);

// 儲存到所有資料源map

dataSourceMap.put(ds, dataSource);

// 對其進行分組并儲存map

this.addGroupDataSource(ds, dataSource);

log.info("dynamic-datasource - load a datasource named [{}] success", ds);

} else {

log.warn("dynamic-datasource - load a datasource named [{}] failed, because it already exist", ds);

}

// 包裝seata、p6spy插件的方法

private DataSource wrapDataSource(String ds, DataSource dataSource) {

if (p6spy) {

dataSource = new P6DataSource(dataSource);

log.debug("dynamic-datasource [{}] wrap p6spy plugin", ds);

if (seata) {

dataSource = new DataSourceProxy(dataSource);

log.debug("dynamic-datasource [{}] wrap seata plugin", ds);

// 添加分組資料源的方法

private void addGroupDataSource(String ds, DataSource dataSource) {

// 分組用_下劃線分割

if (ds.contains(UNDERLINE)) {

// 擷取組名

String group = ds.split(UNDERLINE)[0];

// 如果已存在組，則往裡面添加資料源

if (groupDataSources.containsKey(group)) {

groupDataSources.get(group).addDatasource(dataSource);

} else {

try {

// 否則建立一個新的分組

DynamicGroupDataSource groupDatasource = new DynamicGroupDataSource(group, strategy.newInstance());

groupDatasource.addDatasource(dataSource);

groupDataSources.put(group, groupDatasource);

} catch (Exception e) {

log.error("dynamic-datasource - add the datasource named [{}] error", ds, e);

dataSourceMap.remove(ds);

}

}

@Override

public void afterPropertiesSet() throws Exception {

// 通過配置加載資料源

Map<String, DataSource> dataSources = provider.loadDataSources();

// 添加并分組資料源

for (Map.Entry<String, DataSource> dsItem : dataSources.entrySet()) {

addDataSource(dsItem.getKey(), dsItem.getValue());

// 檢測預設資料源設定

if (groupDataSources.containsKey(primary)) {

log.info("dynamic-datasource initial loaded [{}] datasource,primary group datasource named [{}]", dataSources.size(), primary);

} else if (dataSourceMap.containsKey(primary)) {

log.info("dynamic-datasource initial loaded [{}] datasource,primary datasource named [{}]", dataSources.size(), primary);

throw new RuntimeException("dynamic-datasource Please check the setting of primary");

這個類就是核心的動态資料源元件，它将DataSource維護在map裡，這裡重點看如何建立資料源連接配接池

它所做的操作就是初始化時從provider擷取建立好的資料源map，然後解析這個map對其分組，來看看這個provider裡面是如何建立這個map的

在自動配置中，注入的是這個bean，就是通過yml讀取配置檔案的(後面還有通過jdbc讀取配置檔案)，重點不在這裡，這是後面要提到的

通過跟蹤provider.loadDataSources();發現在createDataSourceMap方法中調用的是dataSourceCreator.createDataSource(dataSourceProperty)

@Setter

public class DataSourceCreator {

/**

* 是否存在druid

private static Boolean druidExists = false;

* 是否存在hikari

private static Boolean hikariExists = false;

static {

try {

Class.forName(DRUID_DATASOURCE);

druidExists = true;

log.debug("dynamic-datasource detect druid,Please Notice \n " +

"https://github.com/baomidou/dynamic-datasource-spring-boot-starter/wiki/Integration-With-Druid");

} catch (ClassNotFoundException ignored) {

Class.forName(HIKARI_DATASOURCE);

hikariExists = true;

…………

/**

* 建立資料源

* @param dataSourceProperty 資料源資訊

* @return 資料源

public DataSource createDataSource(DataSourceProperty dataSourceProperty) {

DataSource dataSource;

//如果是jndi資料源

String jndiName = dataSourceProperty.getJndiName();

if (jndiName != null && !jndiName.isEmpty()) {

dataSource = createJNDIDataSource(jndiName);

Class<? extends DataSource> type = dataSourceProperty.getType();

// 連接配接池類型，如果不設定就自動根據Druid > HikariCp的順序查找

if (type == null) {

if (druidExists) {

dataSource = createDruidDataSource(dataSourceProperty);

} else if (hikariExists) {

dataSource = createHikariDataSource(dataSourceProperty);

} else {

dataSource = createBasicDataSource(dataSourceProperty);

} else if (DRUID_DATASOURCE.equals(type.getName())) {

dataSource = createDruidDataSource(dataSourceProperty);

} else if (HIKARI_DATASOURCE.equals(type.getName())) {

dataSource = createHikariDataSource(dataSourceProperty);

dataSource = createBasicDataSource(dataSourceProperty);

this.runScrip(dataSourceProperty, dataSource);

}

重點就在這裡，根據配置中的type或連接配接池的class來判斷該建立哪種連接配接池

@Data

public class HikariDataSourceCreator {

private HikariCpConfig hikariCpConfig;

HikariConfig config = dataSourceProperty.getHikari().toHikariConfig(hikariCpConfig);

config.setUsername(dataSourceProperty.getUsername());

config.setPassword(dataSourceProperty.getPassword());

config.setJdbcUrl(dataSourceProperty.getUrl());

config.setDriverClassName(dataSourceProperty.getDriverClassName());

config.setPoolName(dataSourceProperty.getPoolName());

return new HikariDataSource(config);

比如說建立hikari連接配接池，就在這個creator中建立了真正的hikari連接配接池，建立完後放在dataSourceMap維護起來

注解攔截處理離不開AOP，是以這裡介紹代碼中如何使用AOP的

還是從這個自動配置類入手，發現注入了一個DynamicDataSourceAnnotationAdvisor bean，它是一個advisor

閱讀這個advisor之前，這裡多提一點AOP相關的

在 Spring AOP 中，有 3 個常用的概念，Advices 、 Pointcut 、 Advisor ，解釋如下：

Advices ：表示一個 method 執行前或執行後的動作。

Pointcut ：表示根據 method 的名字或者正規表達式等方式去攔截一個 method 。

Advisor ： Advice 和 Pointcut 組成的獨立的單元，并且能夠傳給 proxy factory 對象。

@Component

//聲明這是一個切面Bean

@Aspect

public class ServiceAspect {

//配置切入點,該方法無方法體,主要為友善同類中其他方法使用此處配置的切入點

@Pointcut("execution(* com.xxx.aop.service..*(..))")

public void aspect() {

/*

* 配置前置通知,使用在方法aspect()上注冊的切入點

* 同時接受JoinPoint切入點對象,可以沒有該參數

@Before("aspect()")

public void before(JoinPoint joinPoint) {

//配置後置通知,使用在方法aspect()上注冊的切入點

@After("aspect()")

public void after(JoinPoint joinPoint) {

//配置環繞通知,使用在方法aspect()上注冊的切入點

@Around("aspect()")

public void around(JoinPoint joinPoint) {

//配置後置傳回通知,使用在方法aspect()上注冊的切入點

@AfterReturning("aspect()")

public void afterReturn(JoinPoint joinPoint) {

//配置抛出異常後通知,使用在方法aspect()上注冊的切入點

@AfterThrowing(pointcut = "aspect()", throwing = "ex")

public void afterThrow(JoinPoint joinPoint, Exception ex) {

我們平常可能使用這種AspectJ注解多一點，通過@Aspect注解的方式來聲明切面，spring會通過我們的AspectJ注解（比如@Pointcut、@Before） 動态的生成各個Advisor。

Spring還提供了另一種切面-顧問（Advisor），其可以完成更為複雜的切面織入功能，我們可以通過直接繼承AbstractPointcutAdvisor來提供切面邏輯。

它們最終都會生成對應的Advisor執行個體

而這裡就是使用了繼承AbstractPointcutAdvisor的方式來實作切面的

其中最重要的就是getAdvice和getPointcut方法，可以簡單的認為advisor=advice+pointcut

public class DynamicDataSourceAnnotationAdvisor extends AbstractPointcutAdvisor implements

BeanFactoryAware {

// 通知

private Advice advice;

// 切入點

private Pointcut pointcut;

public DynamicDataSourceAnnotationAdvisor(@NonNull DynamicDataSourceAnnotationInterceptor dynamicDataSourceAnnotationInterceptor) {

this.advice = dynamicDataSourceAnnotationInterceptor;

this.pointcut = buildPointcut();

@Override

public Pointcut getPointcut() {

return this.pointcut;

public Advice getAdvice() {

return this.advice;

public void setBeanFactory(BeanFactory beanFactory) throws BeansException {

if (this.advice instanceof BeanFactoryAware) {

((BeanFactoryAware) this.advice).setBeanFactory(beanFactory);

private Pointcut buildPointcut() {

//類級别

Pointcut cpc = new AnnotationMatchingPointcut(DS.class, true);

//方法級别

Pointcut mpc = AnnotationMatchingPointcut.forMethodAnnotation(DS.class);

//對于類和方法上都可以添加注解的情況

//類上的注解,最終會将注解綁定到每個方法上

return new ComposablePointcut(cpc).union(mpc);

現在再來看@DS注解的advisor實作，在buildPointcut方法裡攔截了被@DS注解的方法或類，并且使用ComposablePointcut組合切入點，可以實作方法優先級大于類優先級的特性

發現advice是通過構造方法傳來的，是DynamicDataSourceAnnotationInterceptor，現在來看看這個

public class DynamicDataSourceAnnotationInterceptor implements MethodInterceptor {

* The identification of SPEL.

private static final String DYNAMIC_PREFIX = "#";

private static final DataSourceClassResolver RESOLVER = new DataSourceClassResolver();

@Setter

private DsProcessor dsProcessor;

public Object invoke(MethodInvocation invocation) throws Throwable {

// 這裡把擷取到的資料源辨別如master存入本地線程

DynamicDataSourceContextHolder.push(determineDatasource(invocation));

return invocation.proceed();

} finally {

DynamicDataSourceContextHolder.poll();

private String determineDatasource(MethodInvocation invocation) throws Throwable {

//獲得DS注解的方法

Method method = invocation.getMethod();

DS ds = method.isAnnotationPresent(DS.class) ? method.getAnnotation(DS.class)

: AnnotationUtils.findAnnotation(RESOLVER.targetClass(invocation), DS.class);

//獲得DS注解的内容

String key = ds.value();

//如果DS注解内容是以#開頭解析動态最終值否則直接傳回

return (!key.isEmpty() && key.startsWith(DYNAMIC_PREFIX)) ? dsProcessor.determineDatasource(invocation, key) : key;

這是它的advice通知，也可以說是方法攔截器，在要切換資料源的方法前，将切換的資料源放入了holder裡，方法執行完後在finally中釋放掉，也就是在這裡做了目前資料源的切換。下面的determineDatasource決定資料源的方法中判斷了以#開頭解析動态參數資料源，這個功能就是特性中說的使用spel動态參數解析資料源，如從session，header或參數中擷取資料源。

剩下的還有個DynamicDataSourceAdvisor，這個功能是特性八的提供不使用注解而使用正則或spel來切換資料源方案（實驗性功能），這裡就不介紹這塊了

在上一節AOP實作裡面的MethodInterceptor裡，在方法前後調用了DynamicDataSourceContextHolder.push()和poll()，這個holder類似于前一篇部落格使用AbstractRoutingDataSource做多資料源動态切換用的holder，隻是這裡做了點改造

public final class DynamicDataSourceContextHolder {

* 為什麼要用連結清單存儲(準确的是棧)

* <pre>

* 為了支援嵌套切換，如ABC三個service都是不同的資料源

* 其中A的某個業務要調B的方法，B的方法需要調用C的方法。一級一級調用切換，形成了鍊。

* 傳統的隻設定目前線程的方式不能滿足此業務需求，必須使用棧，後進先出。

* </pre>

private static final ThreadLocal<Deque<String>> LOOKUP_KEY_HOLDER = new NamedThreadLocal<Deque<String>>("dynamic-datasource") {

@Override

protected Deque<String> initialValue() {

return new ArrayDeque<>();

};

private DynamicDataSourceContextHolder() {

* 獲得目前線程資料源

* @return 資料源名稱

public static String peek() {

return LOOKUP_KEY_HOLDER.get().peek();

* 設定目前線程資料源

* <p>

* 如非必要不要手動調用，調用後確定最終清除

* </p>

* @param ds 資料源名稱

public static void push(String ds) {

LOOKUP_KEY_HOLDER.get().push(StringUtils.isEmpty(ds) ? "" : ds);

* 清空目前線程資料源

* 如果目前線程是連續切換資料源 隻會移除掉目前線程的資料源名稱

public static void poll() {

Deque<String> deque = LOOKUP_KEY_HOLDER.get();

deque.poll();

if (deque.isEmpty()) {

LOOKUP_KEY_HOLDER.remove();

* 強制清空本地線程

* 防止記憶體洩漏，如手動調用了push可調用此方法確定清除

public static void clear() {

LOOKUP_KEY_HOLDER.remove();

它使用了棧這個資料結構目前資料源，使用了ArrayDeque這個線程不安全的雙端隊列容器來實作棧功能，它作為棧性能比Stack好，現在不推薦用老容器

用棧的話，嵌套過程中push，出去就pop，實作了這個嵌套調用service的業務需求

現在來看切換資料源的核心類

在之前做動态資料源切換的時候，我們利用Spring的AbstractRoutingDataSource做多資料源動态切換，它實作了DataSource接口，重寫了getConnection方法

在這裡切換資料源原理也是如此，它自己寫了一個AbstractRoutingDataSource類，不是spring的那個，現在來看看這個類

public abstract class AbstractRoutingDataSource extends AbstractDataSource {

* 子類實作決定最終資料源

protected abstract DataSource determineDataSource();

public Connection getConnection() throws SQLException {

return determineDataSource().getConnection();

public Connection getConnection(String username, String password) throws SQLException {

return determineDataSource().getConnection(username, password);

@SuppressWarnings("unchecked")

public <T> T unwrap(Class<T> iface) throws SQLException {

if (iface.isInstance(this)) {

return (T) this;

return determineDataSource().unwrap(iface);

public boolean isWrapperFor(Class<?> iface) throws SQLException {

return (iface.isInstance(this) || determineDataSource().isWrapperFor(iface));

可以發現也是實作了DataSource接口的getConnection方法，現在來看下子類如何實作determineDataSource方法的

private static final String UNDERLINE = "_";

public DataSource determineDataSource() {

return getDataSource(DynamicDataSourceContextHolder.peek());

private DataSource determinePrimaryDataSource() {

log.debug("dynamic-datasource switch to the primary datasource");

return groupDataSources.containsKey(primary) ? groupDataSources.get(primary).determineDataSource() : dataSourceMap.get(primary);

/**

* 擷取資料源

public DataSource getDataSource(String ds) {

if (StringUtils.isEmpty(ds)) {

return determinePrimaryDataSource();

} else if (!groupDataSources.isEmpty() && groupDataSources.containsKey(ds)) {

log.debug("dynamic-datasource switch to the datasource named [{}]", ds);

return groupDataSources.get(ds).determineDataSource();

} else if (dataSourceMap.containsKey(ds)) {

return dataSourceMap.get(ds);

if (strict) {

throw new RuntimeException("dynamic-datasource could not find a datasource named" + ds);

return determinePrimaryDataSource();

之前creator生成的資料源連接配接池放入map維護後，現在擷取資料源就是從map中取就行了，可以發現這裡資料組優先于單資料源

在上一節中，DynamicRoutingDataSource的getDataSource方法裡

else if (!groupDataSources.isEmpty() && groupDataSources.containsKey(ds)) {

如果資料組不為空并且DS注解寫的資料組名，那麼就會在資料組中選取一個資料源，調用的determineDataSource方法

public class DynamicGroupDataSource {

private String groupName;

// 資料源切換政策

private DynamicDataSourceStrategy dynamicDataSourceStrategy;

private List<DataSource> dataSources = new LinkedList<>();

public DynamicGroupDataSource(String groupName, DynamicDataSourceStrategy dynamicDataSourceStrategy) {

this.groupName = groupName;

this.dynamicDataSourceStrategy = dynamicDataSourceStrategy;

public void addDatasource(DataSource dataSource) {

dataSources.add(dataSource);

public void removeDatasource(DataSource dataSource) {

dataSources.remove(dataSource);

// 根據切換政策，決定一個資料源

return dynamicDataSourceStrategy.determineDataSource(dataSources);

public int size() {

return dataSources.size();

} 

這是資料組的DataSource，裡面根據政策模式來決定一個資料源，目前實作的就兩種，随機和輪詢，預設的是輪詢，在DynamicDataSourceProperties屬性中寫了預設值，也可以通過配置檔案配置

public class LoadBalanceDynamicDataSourceStrategy implements DynamicDataSourceStrategy {

* 負載均衡計數器

private final AtomicInteger index = new AtomicInteger(0);

public DataSource determineDataSource(List<DataSource> dataSources) {

return dataSources.get(Math.abs(index.getAndAdd(1) % dataSources.size()));

這是一個簡單的輪詢負載均衡，我們可以通過自己的業務需求，新增一個政策類來實作新的負載均衡算法

預設是從yml中讀取資料源配置的(YmlDynamicDataSourceProvider)，實際業務中，我們可能遇到從其他地方擷取配置來建立資料源，比如從資料庫、配置中心、mq等等

想自定義資料來源可以自定義一個provider實作DynamicDataSourceProvider接口并繼承AbstractDataSourceProvider類就行了

public interface DynamicDataSourceProvider {

* 加載所有資料源

* @return 所有資料源，key為資料源名稱

Map<String, DataSource> loadDataSources();

如果想通過jdbc擷取資料源，它這裡有個抽象類AbstractJdbcDataSourceProvider，需要實作它的executeStmt方法，就是從其他資料庫查詢出這些資訊，url、username、password等等(就是我們在yml配置的那些資訊)，然後拼接成一個配置對象DataSourceProperty傳回出去調用createDataSourceMap方法就行了

這個也是實際中很實用的功能，它的實作還是通過DynamicRoutingDataSource這個核心動态資料源元件來做的

/**

* 擷取目前所有的資料源

* @return 目前所有資料源

public Map<String, DataSource> getCurrentDataSources() {

return dataSourceMap;

* 擷取的目前所有的分組資料源

* @return 目前所有的分組資料源

public Map<String, DynamicGroupDataSource> getCurrentGroupDataSources() {

return groupDataSources;

// 儲存

// 對其進行分組

* 删除資料源

public synchronized void removeDataSource(String ds) {

if (!StringUtils.hasText(ds)) {

throw new RuntimeException("remove parameter could not be empty");

if (primary.equals(ds)) {

throw new RuntimeException("could not remove primary datasource");

if (dataSourceMap.containsKey(ds)) {

DataSource dataSource = dataSourceMap.get(ds);

try {

closeDataSource(ds, dataSource);

} catch (Exception e) {

throw new RuntimeException("dynamic-datasource - remove the database named " + ds + " failed", e);

dataSourceMap.remove(ds);

if (ds.contains(UNDERLINE)) {

String group = ds.split(UNDERLINE)[0];

if (groupDataSources.containsKey(group)) {

groupDataSources.get(group).removeDatasource(dataSource);

log.info("dynamic-datasource - remove the database named [{}] success", ds);

log.warn("dynamic-datasource - could not find a database named [{}]", ds);

可以發現它預留了相關接口給開發者，可友善的添加删除資料庫

添加資料源我們需要做的就是：

1、注入DynamicRoutingDataSource和DataSourceCreator

2、通過資料源配置(url、username、password等)建構一個DataSourceProperty對象

3、再通過dataSourceCreator根據配置建構一個真實的DataSource

4、最後調用DynamicRoutingDataSource的addDataSource方法添加這個DataSource就行了

同理，删除資料源：

1、注入DynamicRoutingDataSource

2、調用DynamicRoutingDataSource的removeDataSource方法

@PostMapping("/add")

@ApiOperation("通用添加資料源（推薦）")

public Set<String> add(@Validated @RequestBody DataSourceDTO dto) {

DataSourceProperty dataSourceProperty = new DataSourceProperty();

BeanUtils.copyProperties(dto, dataSourceProperty);

DynamicRoutingDataSource ds = (DynamicRoutingDataSource) dataSource;

DataSource dataSource = dataSourceCreator.createDataSource(dataSourceProperty);

ds.addDataSource(dto.getPollName(), dataSource);

return ds.getCurrentDataSources().keySet();

@DeleteMapping

@ApiOperation("删除資料源")

public String remove(String name) {

ds.removeDataSource(name);

return "删除成功";

} 

通過閱讀這塊源碼，涉及到了一些spring aop、spring事務管理、spring boot自動配置等