使用dynamic datasource springboot starter實現多數據源及源碼分析

 更新時間:2021年09月10日 11:55:27   作者:0x2015  
這篇文章主要介紹了使用dynamic-datasource-spring-boot-starter做多數據源及源碼分析,本文給大家介紹的非常詳細,對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下

簡介

前兩篇博客介紹了用基本的方式做多數據源,可以應對一般的情況,但是遇到一些復雜的情況就需要擴展下功能了,比如:動態增減數據源、數據源分組,純粹多庫 讀寫分離 一主多從、從其他數據庫或者配置中心讀取數據源等等。其實就算沒有這些需求,使用這個實現多數據源也比之前使用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

特性:

  1. 數據源分組,適用于多種場景 純粹多庫 讀寫分離 一主多從 混合模式。
  2. 內置敏感參數加密和啟動初始化表結構schema數據庫database。
  3. 提供對Druid,Mybatis-Plus,P6sy,Jndi的快速集成。
  4. 簡化Druid和HikariCp配置,提供全局參數配置。
  5. 提供自定義數據源來源接口(默認使用yml或properties配置)。
  6. 提供項目啟動后增減數據源方案。
  7. 提供Mybatis環境下的 純讀寫分離 方案。
  8. 使用spel動態參數解析數據源,如從session,header或參數中獲取數據源。(多租戶架構神器)
  9. 提供多層數據源嵌套切換。(ServiceA >>> ServiceB >>> ServiceC,每個Service都是不同的數據源)
  10. 提供 不使用注解 而 使用 正則 或 spel 來切換數據源方案(實驗性功能)。
  11. 基于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
          username: root
          password: 123456
          driver-class-name: com.gbase.jdbc.Driver

這就是兩個不同數據源的配置,接下來寫service代碼就行了

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

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

# 純粹多庫(記得設置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");
  }
}

注解 結果
沒有@DS 默認數據源
@DS(“dsName”) dsName可以為組名也可以為具體某個庫的名稱

在這里插入圖片描述

通過日志可以發現我們配置的多數據源已經被初始化了,如果切換數據源也會看到打印日子的
是不是很便捷,這是官方的例子

集成druid連接池

<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

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

spring:
  datasource: #數據庫鏈接相關配置
    dynamic:
      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
      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: # 以下參數針對每個庫可以重新設置druid參數
            initial-size:
            validation-query: select 1 FROM DUAL #比如oracle就需要重新設置這個
            public-key: #(非全局參數)設置即表示啟用加密,底層會自動幫你配置相關的連接參數和filter。

配置好了就可以了,切換數據源的用法和上面的一樣的,打@DS(“db1”)注解到service類或方法上就行了
詳細配置參考這個配置類com.baomidou.dynamic.datasource.spring.boot.autoconfigure.DynamicDataSourceProperties

service嵌套

這個就是特性的第九條:提供多層數據源嵌套切換。(ServiceA >>> ServiceB >>> ServiceC,每個Service都是不同的數據源)
借用源碼中的demo:實現SchoolService >>> studentService、teacherService

@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);
    }
}

這個addTeacherAndStudent調用數據源切換就是primary ->teacher->primary->student->primary

在這里插入圖片描述

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

為什么切換數據源不生效或事務不生效?

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

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

下面來粗略的分析加事務不生效的原因:
它這個切換數據源的原理就是實現了DataSource接口,實現了getConnection方法,只要在service中開啟事務,service中對其他數據源操作只會使用開啟事務的數據源,因為開啟事務數據源會被緩存下來,可以在DataSourceTransactionManagerdoBegin方法中看見那個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分布式事務框架

@Transactional
public void addTeacherAndStudentWithTx() {
	// 做了數據庫操作
	aaaDao.doSomethings(“test”);
    teacherService.addTeacherWithTx("ss", 1);
    studentService.addStudentWithTx("tt", 2);
    throw new RuntimeException("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

在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
     */
    @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切面,對DS注解過的方法進行增強,達到切換數據源的目的
     * @param dsProcessor 動態參數解析數據源,如果數據源名稱以#開頭,就會進入這個解析器鏈
     * @return advisor
     */
    @Bean
    @ConditionalOnMissingBean
    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
     */
    @Bean
    @ConditionalOnMissingBean
    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
     * @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;
    }
}

這里自動配置的五個Bean都是非常重要的,后面會一一涉及到

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

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

@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全局參數配置
     */
    @NestedConfigurationProperty
    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初始化時候做一些操作

@Slf4j
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);
        }
        return dataSource;
    }
    // 添加分組數據源的方法
    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);
        } else {
            throw new RuntimeException("dynamic-datasource Please check the setting of primary");
        }
    }
}

這個類就是核心的動態數據源組件,它將DataSource維護在map里,這里重點看如何創建數據源連接池
它所做的操作就是初始化時從provider獲取創建好的數據源map,然后解析這個map對其分組,來看看這個provider里面是如何創建這個map的

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

在自動配置中,注入的是這個bean,就是通過yml讀取配置文件的(后面還有通過jdbc讀取配置文件),重點不在這里,這是后面要提到的
通過跟蹤provider.loadDataSources();發現在createDataSourceMap方法中調用的是dataSourceCreator.createDataSource(dataSourceProperty)

@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) {
        }
    }
	…………
 	/**
     * 創建數據源
     *
     * @param dataSourceProperty 數據源信息
     * @return 數據源
     */
    public DataSource createDataSource(DataSourceProperty dataSourceProperty) {
        DataSource dataSource;
        //如果是jndi數據源
        String jndiName = dataSourceProperty.getJndiName();
        if (jndiName != null && !jndiName.isEmpty()) {
            dataSource = createJNDIDataSource(jndiName);
        } else {
            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);
            } else {
                dataSource = createBasicDataSource(dataSourceProperty);
            }
        }
        this.runScrip(dataSourceProperty, dataSource);
        return dataSource;
    }
    …………
   }

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

@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);
    }
}

比如說創建hikari連接池,就在這個creator中創建了真正的hikari連接池,創建完后放在dataSourceMap維護起來

DS注解如何被攔截處理的

注解攔截處理離不開AOP,所以這里介紹代碼中如何使用AOP的

在這里插入圖片描述

/**
     * AOP切面,對DS注解過的方法進行增強,達到切換數據源的目的
     * @param dsProcessor 動態參數解析數據源,如果數據源名稱以#開頭,就會進入這個解析器鏈
     * @return advisor
     */
    @Bean
    @ConditionalOnMissingBean
    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
     */
    @Bean
    @ConditionalOnMissingBean
    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;
    }

還是從這個自動配置類入手,發現注入了一個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的方式來實現切面的

在這里插入圖片描述

其中最重要的就是getAdvicegetPointcut方法,可以簡單的認為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;
    }

    @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() {
        //類級別
        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;

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        try {
            // 這里把獲取到的數據源標識如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);
    }

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

    /**
     * 強制清空本地線程
     * <p>
     * 防止內存泄漏,如手動調用了push可調用此方法確保清除
     * </p>
     */
    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 {

    /**
     * 子類實現決定最終數據源
     *
     * @return 數據源
     */
    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));
    }
}

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

public class DynamicRoutingDataSource extends AbstractRoutingDataSource implements InitializingBean, DisposableBean {

    private static final String UNDERLINE = "_";
    /**
     * 所有數據庫
     */
    private final Map<String, DataSource> dataSourceMap = new LinkedHashMap<>();
    /**
     * 分組數據庫
     */
    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);
    }
     /**
     * 獲取數據源
     *
     * @param ds 數據源名稱
     * @return 數據源
     */
    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();
    }
    …………
    }

之前creator生成的數據源連接池放入map維護后,現在獲取數據源就是從map中取就行了,可以發現這里數據組優先于單數據源

數據組的負載均衡怎么做的

在上一節中,DynamicRoutingDataSource的getDataSource方法里

else if (!groupDataSources.isEmpty() && groupDataSources.containsKey(ds)) {
            log.debug("dynamic-datasource switch to the datasource named [{}]", ds);
            return groupDataSources.get(ds).determineDataSource();
        }

如果數據組不為空并且DS注解寫的數據組名,那么就會在數據組中選取一個數據源,調用的determineDataSource方法

@Data
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);
    }

    // 根據切換策略,決定一個數據源
    public DataSource determineDataSource() {
        return dynamicDataSourceStrategy.determineDataSource(dataSources);
    }

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

這是數據組的DataSource,里面根據策略模式來決定一個數據源,目前實現的就兩種,隨機和輪詢,默認的是輪詢,在DynamicDataSourceProperties屬性中寫了默認值,也可以通過配置文件配置

public class LoadBalanceDynamicDataSourceStrategy implements DynamicDataSourceStrategy {

    /**
     * 負載均衡計數器
     */
    private final AtomicInteger index = new AtomicInteger(0);

    @Override
    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這個核心動態數據源組件來做的

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

    /**
     * 獲取的當前所有的分組數據源
     *
     * @return 當前所有的分組數據源
     */
    public Map<String, DynamicGroupDataSource> getCurrentGroupDataSources() {
        return groupDataSources;
    }
      /**
     * 添加數據源
     *
     * @param ds         數據源名稱
     * @param dataSource 數據源
     */
    public synchronized void addDataSource(String ds, DataSource dataSource) {
        // 如果數據源不存在則保存一個
        if (!dataSourceMap.containsKey(ds)) {
            // 包裝seata、p6spy插件
            dataSource = wrapDataSource(ds, dataSource);
            // 保存
            dataSourceMap.put(ds, dataSource);
            // 對其進行分組
            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);
        }
    }
    /**
     * 刪除數據源
     *
     * @param ds 數據源名稱
     */
    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);
        }
    }
    …………
}

可以發現它預留了相關接口給開發者,可方便的添加刪除數據庫

添加數據源我們需要做的就是:
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) {
        DynamicRoutingDataSource ds = (DynamicRoutingDataSource) dataSource;
        ds.removeDataSource(name);
        return "刪除成功";
    }

總結

通過閱讀這塊源碼,涉及到了一些spring aop、spring事務管理、spring boot自動配置等等,可以更加熟悉使用spring的這些擴展點、api等,還可以根據業務需求去擴展這個starter

到此這篇關于使用dynamic-datasource-spring-boot-starter做多數據源及源碼分析的文章就介紹到這了,更多相關dynamic-datasource-spring-boot-starter多數據源內容請搜索腳本之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持腳本之家!

相關文章

  • Java實現Floyd算法求最短路徑

    Java實現Floyd算法求最短路徑

    這篇文章主要為大家詳細介紹了Java實現Floyd算法求最短路徑,具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2018-01-01
  • Java 使用Axis調用WebService的示例代碼

    Java 使用Axis調用WebService的示例代碼

    這篇文章主要介紹了Java 使用Axis調用WebService的示例代碼,幫助大家更好的理解和使用Java,感興趣的朋友可以了解下
    2020-09-09
  • SpringMVC Cron定時器Demo常見問題解決方案

    SpringMVC Cron定時器Demo常見問題解決方案

    這篇文章主要介紹了SpringMVC Cron定時器Demo常見問題解決方案,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
    2020-11-11
  • 使用Rhino讓java執行javascript的方法實例

    使用Rhino讓java執行javascript的方法實例

    這篇文章主要介紹了java使用Rhino執行javascript的方法,Rhino由Mozilla開發,是 JavaScript 一種基于Java的實現
    2013-12-12
  • springboot整合mybatis實現簡單的一對多級聯查詢功能

    springboot整合mybatis實現簡單的一對多級聯查詢功能

    這篇文章主要介紹了springboot整合mybatis實現簡單的一對多級聯查詢功能,分步驟通過實例代碼給大家介紹的非常詳細,對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下
    2021-08-08
  • Java中鎖的分類與使用方法

    Java中鎖的分類與使用方法

    這篇文章主要給大家介紹了關于Java中鎖分類與使用的相關資料,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
    2021-04-04
  • springboot自定義stater啟動流程

    springboot自定義stater啟動流程

    這篇文章主要介紹了springboot自定義stater啟動流程,本文給大家介紹的非常詳細,具有一定的參考借鑒價值,需要的朋友可以參考下
    2019-12-12
  • java中equals和等號(==)的區別淺談

    java中equals和等號(==)的區別淺談

    java中equals和等號(==)的區別淺談,需要的朋友可以參考一下
    2013-05-05
  • Java實現Excel批量導入數據

    Java實現Excel批量導入數據

    這篇文章主要為大家詳細介紹了Java實現Excel批量導入數據,文中示例代碼介紹的非常詳細,具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2020-08-08
  • Spring Boot使用Thymeleaf + Gradle構建war到Tomcat

    Spring Boot使用Thymeleaf + Gradle構建war到Tomcat

    今天小編就為大家分享一篇關于Spring Boot使用Thymeleaf + Gradle構建war到Tomcat,小編覺得內容挺不錯的,現在分享給大家,具有很好的參考價值,需要的朋友一起跟隨小編來看看吧
    2018-12-12

最新評論

精品国内自产拍在线观看