<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
    <version>3.1.0</version>
</dependency>

spring:
  datasource:
    dynamic:
      primary: master #設(shè)置默認(rèn)的數(shù)據(jù)源或者數(shù)據(jù)源組,默認(rèn)值即為master
      strict: false #設(shè)置嚴(yán)格模式,默認(rèn)false不啟動(dòng). 啟動(dòng)后在未匹配到指定數(shù)據(jù)源時(shí)候回拋出異常,不啟動(dòng)會(huì)使用默認(rèn)數(shù)據(jù)源.
      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
          username: root
          password: 123456
          driver-class-name: com.gbase.jdbc.Driver

# 多主多從
spring:
  datasource:
    dynamic:
      datasource:
        master_1:
        master_2:
        slave_1: 
        slave_2: 
        slave_3:   

# 純粹多庫(kù)（記得設(shè)置primary）
spring:
  datasource:
    dynamic:
      datasource:
        db1:
        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");
  }
}

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.22</version>
</dependency>

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

spring:
  datasource: #數(shù)據(jù)庫(kù)鏈接相關(guān)配置
    dynamic:
      druid: #以下是全局默認(rèn)值，可以全局更改
        #監(jiān)控統(tǒng)計(jì)攔截的filters
        filters: stat
        #配置初始化大小/最小/最大
        initial-size: 1
        min-idle: 1
        max-active: 20
        #獲取連接等待超時(shí)時(shí)間
        max-wait: 60000
        #間隔多久進(jìn)行一次檢測(cè)，檢測(cè)需要關(guān)閉的空閑連接
        time-between-eviction-runs-millis: 60000
        #一個(gè)連接在池中最小生存的時(shí)間
        min-evictable-idle-time-millis: 300000
        validation-query: SELECT 'x'
        test-while-idle: true
        test-on-borrow: false
        test-on-return: false
        #打開PSCache，并指定每個(gè)連接上PSCache的大小。oracle設(shè)為true，mysql設(shè)為false。分庫(kù)分表較多推薦設(shè)置為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
      datasource:
        master:
          url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=GMT%2B8
          username: root
          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
          driver-class-name: com.gbase.jdbc.Driver
          druid: # 以下參數(shù)針對(duì)每個(gè)庫(kù)可以重新設(shè)置druid參數(shù)
            initial-size:
            validation-query: select 1 FROM DUAL #比如oracle就需要重新設(shè)置這個(gè)
            public-key: #（非全局參數(shù)）設(shè)置即表示啟用加密,底層會(huì)自動(dòng)幫你配置相關(guān)的連接參數(shù)和filter。

@Service
public class SchoolServiceImpl{
    public void addTeacherAndStudent() {
        teacherService.addTeacherWithTx("ss", 1);
        teacherMapper.addTeacher("test", 111);
        studentService.addStudentWithTx("tt", 2);
    }
}
@Service
@DS("teacher")
public class TeacherServiceImpl {
    public boolean addTeacherWithTx(String name, Integer age) {
        return teacherMapper.addTeacher(name, age);
    }
}
@Service
@DS("student")
public class StudentServiceImpl {
    public boolean addStudentWithTx(String name, Integer age) {
        return studentMapper.addStudent(name, age);
    }
}

/**
	 * 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()) {
				// 開啟一個(gè)新事務(wù)會(huì)獲取一個(gè)新的Connection，所以會(huì)調(diào)用DataSource接口的getConnection方法，從而切換數(shù)據(jù)源
				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);
			// 如果已經(jīng)開啟了事務(wù)，就從holder中獲取Connection
			con = txObject.getConnectionHolder().getConnection();
			…………
			}

@Transactional
public void addTeacherAndStudentWithTx() {
    teacherService.addTeacherWithTx("ss", 1);
    studentService.addStudentWithTx("tt", 2);
    throw new RuntimeException("test");
}

@Transactional
public void addTeacherAndStudentWithTx() {
	// 做了數(shù)據(jù)庫(kù)操作
	aaaDao.doSomethings(“test”);
    teacherService.addTeacherWithTx("ss", 1);
    studentService.addStudentWithTx("tt", 2);
    throw new RuntimeException("test");
}

 @Transaction
    public void insertDB1andDB2() {
        db1Service.insertOne();
        db2Service.insertOne();
        throw new RuntimeException("test");
    }

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.baomidou.dynamic.datasource.spring.boot.autoconfigure.DynamicDataSourceAutoConfiguration

@Slf4j
@Configuration
@AllArgsConstructor
// 以spring.datasource.dynamic為前綴讀取配置
@EnableConfigurationProperties(DynamicDataSourceProperties.class)
// 需要在spring boot的DataSource bean自動(dòng)配置之前注入我們的DataSource bean
@AutoConfigureBefore(DataSourceAutoConfiguration.class)
// 引入了Druid的autoConfig和各種數(shù)據(jù)源連接池的Creator
@Import(value = {DruidDynamicDataSourceConfiguration.class, DynamicDataSourceCreatorAutoConfiguration.class})
// 當(dāng)含有spring.datasource.dynamic配置的時(shí)候啟用這個(gè)autoConfig
@ConditionalOnProperty(prefix = DynamicDataSourceProperties.PREFIX, name = "enabled", havingValue = "true", matchIfMissing = true)
public class DynamicDataSourceAutoConfiguration {

    private final DynamicDataSourceProperties properties;

    /**
     * 多數(shù)據(jù)源加載接口，默認(rèn)從yml中讀取多數(shù)據(jù)源配置
     * @return DynamicDataSourceProvider
     */
    @Bean
    @ConditionalOnMissingBean
    public DynamicDataSourceProvider dynamicDataSourceProvider() {
        Map<String, DataSourceProperty> datasourceMap = properties.getDatasource();
        return new YmlDynamicDataSourceProvider(datasourceMap);
    }

    /**
     * 注冊(cè)自己的動(dòng)態(tài)多數(shù)據(jù)源DataSource
     * @param dynamicDataSourceProvider 各種數(shù)據(jù)源連接池建造者
     * @return DataSource
     */
    @Bean
    @ConditionalOnMissingBean
    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切面，對(duì)DS注解過(guò)的方法進(jìn)行增強(qiáng)，達(dá)到切換數(shù)據(jù)源的目的
     * @param dsProcessor 動(dòng)態(tài)參數(shù)解析數(shù)據(jù)源，如果數(shù)據(jù)源名稱以#開頭，就會(huì)進(jìn)入這個(gè)解析器鏈
     * @return advisor
     */
    @Bean
    @ConditionalOnMissingBean
    public DynamicDataSourceAnnotationAdvisor dynamicDatasourceAnnotationAdvisor(DsProcessor dsProcessor) {
        // aop方法攔截器在方法調(diào)用前后做操作
        DynamicDataSourceAnnotationInterceptor interceptor = new DynamicDataSourceAnnotationInterceptor();
        // 動(dòng)態(tài)參數(shù)解析器
        interceptor.setDsProcessor(dsProcessor);
        // 使用AbstractPointcutAdvisor將pointcut和advice連接構(gòu)成切面
        DynamicDataSourceAnnotationAdvisor advisor = new DynamicDataSourceAnnotationAdvisor(interceptor);
        advisor.setOrder(properties.getOrder());
        return advisor;
    }

    /**
     * 動(dòng)態(tài)參數(shù)解析器鏈
     * @return DsProcessor
     */
    @Bean
    @ConditionalOnMissingBean
    public DsProcessor dsProcessor() {
        DsHeaderProcessor headerProcessor = new DsHeaderProcessor();
        DsSessionProcessor sessionProcessor = new DsSessionProcessor();
        DsSpelExpressionProcessor spelExpressionProcessor = new DsSpelExpressionProcessor();
        // 順序header->session->spel 所有以#開頭的參數(shù)都會(huì)從參數(shù)中獲取數(shù)據(jù)源
        headerProcessor.setNextProcessor(sessionProcessor);
        sessionProcessor.setNextProcessor(spelExpressionProcessor);
        return headerProcessor;
    }

    /**
     * 提供不使用注解而使用正則或spel來(lái)切換數(shù)據(jù)源方案（實(shí)驗(yàn)性功能）
     * 如果想開啟這個(gè)功能得自己配置注入DynamicDataSourceConfigure Bean
     * @param dynamicDataSourceConfigure dynamicDataSourceConfigure
     * @param dsProcessor dsProcessor
     * @return advisor
     */
    @Bean
    @ConditionalOnBean(DynamicDataSourceConfigure.class)
    public DynamicDataSourceAdvisor dynamicAdvisor(DynamicDataSourceConfigure dynamicDataSourceConfigure, DsProcessor dsProcessor) {
        DynamicDataSourceAdvisor advisor = new DynamicDataSourceAdvisor(dynamicDataSourceConfigure.getMatchers());
        advisor.setDsProcessor(dsProcessor);
        advisor.setOrder(Ordered.HIGHEST_PRECEDENCE);
        return advisor;
    }
}

// 以spring.datasource.dynamic為前綴讀取配置
@EnableConfigurationProperties(DynamicDataSourceProperties.class)

@ConfigurationProperties(prefix = DynamicDataSourceProperties.PREFIX)
public class DynamicDataSourceProperties {

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

    /**
     * 必須設(shè)置默認(rèn)的庫(kù),默認(rèn)master
     */
    private String primary = "master";
    /**
     * 是否啟用嚴(yán)格模式,默認(rèn)不啟動(dòng). 嚴(yán)格模式下未匹配到數(shù)據(jù)源直接報(bào)錯(cuò), 非嚴(yán)格模式下則使用默認(rèn)數(shù)據(jù)源primary所設(shè)置的數(shù)據(jù)源
     */
    private Boolean strict = false;
    …………
      /**
     * Druid全局參數(shù)配置
     */
    @NestedConfigurationProperty
    private DruidConfig druid = new DruidConfig();
    /**
     * HikariCp全局參數(shù)配置
     */
    @NestedConfigurationProperty
    private HikariCpConfig hikari = new HikariCpConfig();
    …………
    }

@Slf4j
public class DynamicRoutingDataSource extends AbstractRoutingDataSource implements InitializingBean, DisposableBean {
    /**
     * 所有數(shù)據(jù)庫(kù)
     */
    private final Map<String, DataSource> dataSourceMap = new LinkedHashMap<>();
    /**
     * 分組數(shù)據(jù)庫(kù)
     */
    private final Map<String, DynamicGroupDataSource> groupDataSources = new ConcurrentHashMap<>();
	省略部分代碼…………

	/**
     * 添加數(shù)據(jù)源
     *
     * @param ds         數(shù)據(jù)源名稱
     * @param dataSource 數(shù)據(jù)源
     */
    public synchronized void addDataSource(String ds, DataSource dataSource) {
        // 如果數(shù)據(jù)源不存在則保存一個(gè)
        if (!dataSourceMap.containsKey(ds)) {
            // 包裝seata、p6spy插件
            dataSource = wrapDataSource(ds, dataSource);
            // 保存到所有數(shù)據(jù)源map
            dataSourceMap.put(ds, dataSource);
            // 對(duì)其進(jìn)行分組并保存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);
        }
        return dataSource;
    }
    // 添加分組數(shù)據(jù)源的方法
    private void addGroupDataSource(String ds, DataSource dataSource) {
        // 分組用_下劃線分割
        if (ds.contains(UNDERLINE)) {
            // 獲取組名
            String group = ds.split(UNDERLINE)[0];
            // 如果已存在組，則往里面添加數(shù)據(jù)源
            if (groupDataSources.containsKey(group)) {
                groupDataSources.get(group).addDatasource(dataSource);
            } else {
                try {
                    // 否則創(chuàng)建一個(gè)新的分組
                    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 {
        // 通過(guò)配置加載數(shù)據(jù)源
        Map<String, DataSource> dataSources = provider.loadDataSources();
        // 添加并分組數(shù)據(jù)源
        for (Map.Entry<String, DataSource> dsItem : dataSources.entrySet()) {
            addDataSource(dsItem.getKey(), dsItem.getValue());
        }
        // 檢測(cè)默認(rèn)數(shù)據(jù)源設(shè)置
        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);
        } else {
            throw new RuntimeException("dynamic-datasource Please check the setting of primary");
        }
    }
}

@Bean
    @ConditionalOnMissingBean
    public DynamicDataSourceProvider dynamicDataSourceProvider() {
        Map<String, DataSourceProperty> datasourceMap = properties.getDatasource();
        return new YmlDynamicDataSourceProvider(datasourceMap);
    }

@Slf4j
@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) {
        }
        try {
            Class.forName(HIKARI_DATASOURCE);
            hikariExists = true;
        } catch (ClassNotFoundException ignored) {
        }
    }
	…………
 	/**
     * 創(chuàng)建數(shù)據(jù)源
     *
     * @param dataSourceProperty 數(shù)據(jù)源信息
     * @return 數(shù)據(jù)源
     */
    public DataSource createDataSource(DataSourceProperty dataSourceProperty) {
        DataSource dataSource;
        //如果是jndi數(shù)據(jù)源
        String jndiName = dataSourceProperty.getJndiName();
        if (jndiName != null && !jndiName.isEmpty()) {
            dataSource = createJNDIDataSource(jndiName);
        } else {
            Class<? extends DataSource> type = dataSourceProperty.getType();
            // 連接池類型，如果不設(shè)置就自動(dòng)根據(jù)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);
            } else {
                dataSource = createBasicDataSource(dataSourceProperty);
            }
        }
        this.runScrip(dataSourceProperty, dataSource);
        return dataSource;
    }
    …………
   }

@Data
@AllArgsConstructor
public class HikariDataSourceCreator {

    private HikariCpConfig hikariCpConfig;

    public DataSource createDataSource(DataSourceProperty dataSourceProperty) {
        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);
    }
}

/**
     * AOP切面，對(duì)DS注解過(guò)的方法進(jìn)行增強(qiáng)，達(dá)到切換數(shù)據(jù)源的目的
     * @param dsProcessor 動(dòng)態(tài)參數(shù)解析數(shù)據(jù)源，如果數(shù)據(jù)源名稱以#開頭，就會(huì)進(jìn)入這個(gè)解析器鏈
     * @return advisor
     */
    @Bean
    @ConditionalOnMissingBean
    public DynamicDataSourceAnnotationAdvisor dynamicDatasourceAnnotationAdvisor(DsProcessor dsProcessor) {
        // aop方法攔截器在方法調(diào)用前后做操作
        DynamicDataSourceAnnotationInterceptor interceptor = new DynamicDataSourceAnnotationInterceptor();
        // 動(dòng)態(tài)參數(shù)解析器
        interceptor.setDsProcessor(dsProcessor);
        // 使用AbstractPointcutAdvisor將pointcut和advice連接構(gòu)成切面
        DynamicDataSourceAnnotationAdvisor advisor = new DynamicDataSourceAnnotationAdvisor(interceptor);
        advisor.setOrder(properties.getOrder());
        return advisor;
    }

    /**
     * 動(dòng)態(tài)參數(shù)解析器鏈
     * @return DsProcessor
     */
    @Bean
    @ConditionalOnMissingBean
    public DsProcessor dsProcessor() {
        DsHeaderProcessor headerProcessor = new DsHeaderProcessor();
        DsSessionProcessor sessionProcessor = new DsSessionProcessor();
        DsSpelExpressionProcessor spelExpressionProcessor = new DsSpelExpressionProcessor();
        // 順序header->session->spel 所有以#開頭的參數(shù)都會(huì)從參數(shù)中獲取數(shù)據(jù)源
        headerProcessor.setNextProcessor(sessionProcessor);
        sessionProcessor.setNextProcessor(spelExpressionProcessor);
        return headerProcessor;
    }

@Component
//聲明這是一個(gè)切面Bean
@Aspect
public class ServiceAspect {
    //配置切入點(diǎn),該方法無(wú)方法體,主要為方便同類中其他方法使用此處配置的切入點(diǎn)
    @Pointcut("execution(* com.xxx.aop.service..*(..))")
    public void aspect() {
    }

    /*
     * 配置前置通知,使用在方法aspect()上注冊(cè)的切入點(diǎn)
     * 同時(shí)接受JoinPoint切入點(diǎn)對(duì)象,可以沒(méi)有該參數(shù)
     */
    @Before("aspect()")
    public void before(JoinPoint joinPoint) {
    }

    //配置后置通知,使用在方法aspect()上注冊(cè)的切入點(diǎn)
    @After("aspect()")
    public void after(JoinPoint joinPoint) {
    }

    //配置環(huán)繞通知,使用在方法aspect()上注冊(cè)的切入點(diǎn)
    @Around("aspect()")
    public void around(JoinPoint joinPoint) {
    }

    //配置后置返回通知,使用在方法aspect()上注冊(cè)的切入點(diǎn)
    @AfterReturning("aspect()")
    public void afterReturn(JoinPoint joinPoint) {
    }

    //配置拋出異常后通知,使用在方法aspect()上注冊(cè)的切入點(diǎn)
    @AfterThrowing(pointcut = "aspect()", throwing = "ex")
    public void afterThrow(JoinPoint joinPoint, Exception ex) {
    }
}

public class DynamicDataSourceAnnotationAdvisor extends AbstractPointcutAdvisor implements
        BeanFactoryAware {

    // 通知
    private Advice advice;

    // 切入點(diǎn)
    private Pointcut pointcut;

    public DynamicDataSourceAnnotationAdvisor(@NonNull DynamicDataSourceAnnotationInterceptor dynamicDataSourceAnnotationInterceptor) {
        this.advice = dynamicDataSourceAnnotationInterceptor;
        this.pointcut = buildPointcut();
    }

    @Override
    public Pointcut getPointcut() {
        return this.pointcut;
    }

    @Override
    public Advice getAdvice() {
        return this.advice;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        if (this.advice instanceof BeanFactoryAware) {
            ((BeanFactoryAware) this.advice).setBeanFactory(beanFactory);
        }
    }

    private Pointcut buildPointcut() {
        //類級(jí)別
        Pointcut cpc = new AnnotationMatchingPointcut(DS.class, true);
        //方法級(jí)別
        Pointcut mpc = AnnotationMatchingPointcut.forMethodAnnotation(DS.class);
        //對(duì)于類和方法上都可以添加注解的情況
        //類上的注解,最終會(huì)將注解綁定到每個(gè)方法上
        return new ComposablePointcut(cpc).union(mpc);
    }
}

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;

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        try {
            // 這里把獲取到的數(shù)據(jù)源標(biāo)識(shí)如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注解的內(nèi)容
        String key = ds.value();
        //如果DS注解內(nèi)容是以#開頭解析動(dòng)態(tài)最終值否則直接返回
        return (!key.isEmpty() && key.startsWith(DYNAMIC_PREFIX)) ? dsProcessor.determineDatasource(invocation, key) : key;
    }
}

public final class DynamicDataSourceContextHolder {

    /**
     * 為什么要用鏈表存儲(chǔ)(準(zhǔn)確的是棧)
     * <pre>
     * 為了支持嵌套切換，如ABC三個(gè)service都是不同的數(shù)據(jù)源
     * 其中A的某個(gè)業(yè)務(wù)要調(diào)B的方法，B的方法需要調(diào)用C的方法。一級(jí)一級(jí)調(diào)用切換，形成了鏈。
     * 傳統(tǒng)的只設(shè)置當(dāng)前線程的方式不能滿足此業(yè)務(wù)需求，必須使用棧，后進(jìn)先出。
     * </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() {
    }

    /**
     * 獲得當(dāng)前線程數(shù)據(jù)源
     *
     * @return 數(shù)據(jù)源名稱
     */
    public static String peek() {
        return LOOKUP_KEY_HOLDER.get().peek();
    }

    /**
     * 設(shè)置當(dāng)前線程數(shù)據(jù)源
     * <p>
     * 如非必要不要手動(dòng)調(diào)用，調(diào)用后確保最終清除
     * </p>
     *
     * @param ds 數(shù)據(jù)源名稱
     */
    public static void push(String ds) {
        LOOKUP_KEY_HOLDER.get().push(StringUtils.isEmpty(ds) ? "" : ds);
    }

    /**
     * 清空當(dāng)前線程數(shù)據(jù)源
     * <p>
     * 如果當(dāng)前線程是連續(xù)切換數(shù)據(jù)源 只會(huì)移除掉當(dāng)前線程的數(shù)據(jù)源名稱
     * </p>
     */
    public static void poll() {
        Deque<String> deque = LOOKUP_KEY_HOLDER.get();
        deque.poll();
        if (deque.isEmpty()) {
            LOOKUP_KEY_HOLDER.remove();
        }
    }

    /**
     * 強(qiáng)制清空本地線程
     * <p>
     * 防止內(nèi)存泄漏，如手動(dòng)調(diào)用了push可調(diào)用此方法確保清除
     * </p>
     */
    public static void clear() {
        LOOKUP_KEY_HOLDER.remove();
    }
}

public abstract class AbstractRoutingDataSource extends AbstractDataSource {

    /**
     * 子類實(shí)現(xiàn)決定最終數(shù)據(jù)源
     *
     * @return 數(shù)據(jù)源
     */
    protected abstract DataSource determineDataSource();

    @Override
    public Connection getConnection() throws SQLException {
        return determineDataSource().getConnection();
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return determineDataSource().getConnection(username, password);
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T> T unwrap(Class<T> iface) throws SQLException {
        if (iface.isInstance(this)) {
            return (T) this;
        }
        return determineDataSource().unwrap(iface);
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return (iface.isInstance(this) || determineDataSource().isWrapperFor(iface));
    }
}

public class DynamicRoutingDataSource extends AbstractRoutingDataSource implements InitializingBean, DisposableBean {

    private static final String UNDERLINE = "_";
    /**
     * 所有數(shù)據(jù)庫(kù)
     */
    private final Map<String, DataSource> dataSourceMap = new LinkedHashMap<>();
    /**
     * 分組數(shù)據(jù)庫(kù)
     */
    private final Map<String, DynamicGroupDataSource> groupDataSources = new ConcurrentHashMap<>();
    }
    
    @Override
    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);
    }
     /**
     * 獲取數(shù)據(jù)源
     *
     * @param ds 數(shù)據(jù)源名稱
     * @return 數(shù)據(jù)源
     */
    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)) {
            log.debug("dynamic-datasource switch to the datasource named [{}]", ds);
            return dataSourceMap.get(ds);
        }
        if (strict) {
            throw new RuntimeException("dynamic-datasource could not find a datasource named" + 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();
        }

@Data
public class DynamicGroupDataSource {

    private String groupName;

    // 數(shù)據(jù)源切換策略
    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);
    }

    // 根據(jù)切換策略，決定一個(gè)數(shù)據(jù)源
    public DataSource determineDataSource() {
        return dynamicDataSourceStrategy.determineDataSource(dataSources);
    }

    public int size() {
        return dataSources.size();
    }
}

public class LoadBalanceDynamicDataSourceStrategy implements DynamicDataSourceStrategy {

    /**
     * 負(fù)載均衡計(jì)數(shù)器
     */
    private final AtomicInteger index = new AtomicInteger(0);

    @Override
    public DataSource determineDataSource(List<DataSource> dataSources) {
        return dataSources.get(Math.abs(index.getAndAdd(1) % dataSources.size()));
    }
}

public interface DynamicDataSourceProvider {
    /**
     * 加載所有數(shù)據(jù)源
     *
     * @return 所有數(shù)據(jù)源，key為數(shù)據(jù)源名稱
     */
    Map<String, DataSource> loadDataSources();
}

@Slf4j
public class DynamicRoutingDataSource extends AbstractRoutingDataSource implements InitializingBean, DisposableBean {
   /**
     * 所有數(shù)據(jù)庫(kù)
     */
    private final Map<String, DataSource> dataSourceMap = new LinkedHashMap<>();
    /**
     * 分組數(shù)據(jù)庫(kù)
     */
    private final Map<String, DynamicGroupDataSource> groupDataSources = new ConcurrentHashMap<>();
    …………
      /**
     * 獲取當(dāng)前所有的數(shù)據(jù)源
     *
     * @return 當(dāng)前所有數(shù)據(jù)源
     */
    public Map<String, DataSource> getCurrentDataSources() {
        return dataSourceMap;
    }

    /**
     * 獲取的當(dāng)前所有的分組數(shù)據(jù)源
     *
     * @return 當(dāng)前所有的分組數(shù)據(jù)源
     */
    public Map<String, DynamicGroupDataSource> getCurrentGroupDataSources() {
        return groupDataSources;
    }
      /**
     * 添加數(shù)據(jù)源
     *
     * @param ds         數(shù)據(jù)源名稱
     * @param dataSource 數(shù)據(jù)源
     */
    public synchronized void addDataSource(String ds, DataSource dataSource) {
        // 如果數(shù)據(jù)源不存在則保存一個(gè)
        if (!dataSourceMap.containsKey(ds)) {
            // 包裝seata、p6spy插件
            dataSource = wrapDataSource(ds, dataSource);
            // 保存
            dataSourceMap.put(ds, dataSource);
            // 對(duì)其進(jìn)行分組
            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);
        }
    }
    /**
     * 刪除數(shù)據(jù)源
     *
     * @param ds 數(shù)據(jù)源名稱
     */
    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);
        } else {
            log.warn("dynamic-datasource - could not find a database named [{}]", ds);
        }
    }
    …………
}

  @PostMapping("/add")
    @ApiOperation("通用添加數(shù)據(jù)源（推薦）")
    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("刪除數(shù)據(jù)源")
    public String remove(String name) {
        DynamicRoutingDataSource ds = (DynamicRoutingDataSource) dataSource;
        ds.removeDataSource(name);
        return "刪除成功";
    }