springboot-配置多數據源（AOP實現）（HikariCP + MybatisPlus + mysql + SqlServer）

本文轉載自查看原文 2019-11-19 23:19 298 多數據源/ Java-SpringBoot系列/ springboot

場景：

springboot項目，默認使用HikariCP連接池 + MybatisPlus持久層框架 + mysql數據庫等一套流程，現需求需去第三方sqlserver數據庫拉取數據，直連數據庫，不走接口，因此，需把項目改造成多數據源結構，以實現動態切換數據源。

使用docker 安裝mysql + sqlserver 數據庫進行測試

實現示例：

0.pom.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 4     <modelVersion>4.0.0</modelVersion>
 5     <parent>
 6         <groupId>com.mumu</groupId>
 7         <artifactId>springboot-mumu</artifactId>
 8         <version>1.0-SNAPSHOT</version>
 9     </parent>
10     <artifactId>mumu-web</artifactId>
11 
12     <dependencies>
13         <!-- web -->
14         <dependency>
15             <groupId>org.springframework.boot</groupId>
16             <artifactId>spring-boot-starter-web</artifactId>
17         </dependency>
18         <!-- aop -->
19         <dependency>
20             <groupId>org.springframework.boot</groupId>
21             <artifactId>spring-boot-starter-aop</artifactId>
22         </dependency>
23         <!-- mysql -->
24         <dependency>
25             <groupId>mysql</groupId>
26             <artifactId>mysql-connector-java</artifactId>
27             <scope>runtime</scope>
28         </dependency>
29         <!-- sqlserver -->
30         <dependency>
31             <groupId>com.microsoft.sqlserver</groupId>
32             <artifactId>mssql-jdbc</artifactId>
33             <scope>runtime</scope>
34         </dependency>
35         <!-- mybatis-plus -->
36         <dependency>
37             <groupId>com.baomidou</groupId>
38             <artifactId>mybatis-plus-boot-starter</artifactId>
39             <version>3.0.5</version>
40         </dependency>
41 
42     </dependencies>
43 
44     <build>
45         <plugins>
46             <plugin>
47                 <groupId>org.springframework.boot</groupId>
48                 <artifactId>spring-boot-maven-plugin</artifactId>
49             </plugin>
50         </plugins>
51     </build>
52 
53 </project>

1.配置文件

server:
  port: 9587
spring:
  datasource:
    hikari:
      master:
        driverClassName: com.mysql.cj.jdbc.Driver
        jdbcUrl: jdbc:mysql://127.0.0.1:3306/d_credit?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8
        username: root
        password: 1234567890
      slave:
        driverClassName: com.microsoft.sqlserver.jdbc.SQLServerDriver
        jdbcUrl: jdbc:sqlserver://127.0.0.1:1433;DatabaseName=TestDB
        username: SA
        password: <1234567890@Passw0rd>

#mybatis-plus
mybatis-plus:
  type-aliases-package: com.mumu.model
  mapper-locations: classpath:/mapper/**/*.xml
  configuration:
    jdbc-type-for-null: null
    map-underscore-to-camel-case: true
    cache-enabled: false
  global-config:
    db-config:
      id-type: auto
      field-strategy: not_empty

2.數據源配置類

注意：！！！！！

1.使用mybatis的全局配置文件這里工廠bean使用SqlSessionFactoryBean

使用mybatis-plus的全局配置這里工廠bean使用MybatisSqlSessionFactoryBean

否則 mybatis對應的全局配置不會生效

2.@Primary用在DataSourceBuilder.create().build()構建的DataSource方法上，不能放到構建動態數據源方法上，否則會有循環依賴的問題

package com.mumu.common.config;

import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import com.mumu.common.datasources.DataSourceNames;
import com.mumu.common.datasources.DynamicDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
import javax.xml.crypto.Data;
import java.util.HashMap;
import java.util.Map;

/**
 * @Description
 * @Author Created by Mumu
 * @Date on 2019/11/25
 */
@Configuration
@EnableTransactionManagement
@MapperScan("com.mumu.*.mapper")
public class DataSourceConfig {

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

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


    @Bean(name = "dynamicDataSource")
    public DataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map<Object, Object> dataSourceMap = new HashMap<>(2);
        dataSourceMap.put(DataSourceNames.FIRST, master());
        dataSourceMap.put(DataSourceNames.SECOND, slave());
        /// 將 master 數據源作為默認指定的數據源
        dynamicDataSource.setDefaultDataSource(master());
        // 將 master 和 slave 數據源作為指定的數據源
        dynamicDataSource.setDataSources(dataSourceMap);
        return dynamicDataSource;
    }

    @Bean("sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory() throws Exception {
//        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean(); // 使用mybatis的全局配置文件
        //使用mybatisplus的工程bean，mybatis-plus的全局配置文件才會生效
        MybatisSqlSessionFactoryBean sqlSessionFactoryBean = new MybatisSqlSessionFactoryBean();
        // 配置數據源，此處配置為關鍵配置，如果沒有將 dynamicDataSource作為數據源則不能實現切換
        sqlSessionFactoryBean.setDataSource(dynamicDataSource());
        // 掃描model
        sqlSessionFactoryBean.setTypeAliasesPackage("com.mumu.model");
        // 掃描映射文件
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:/mapper/**/*Mapper.xml"));
        return sqlSessionFactoryBean.getObject();
    }
}

3.動態數據源類

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

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

所以如果我們需要動態切換數據源，就可以通過以下兩種方式定制：

1. 覆寫 determineCurrentLookupKey 方法

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

2. 可以通過覆寫 determineTargetDataSource，因為數據源就是在這個方法創建並返回的，所以這種方式就比較自由了，支持到任何你希望的地方讀取數據源信息，只要最終返回一個 DataSource 的實現類即可。比如你可以到數據庫、本地文件、網絡接口等方式讀取到數據源信息然后返回相應的數據源對象就可以了。

 1 package com.mumu.common.datasources;
 2 
 3 import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
 4 
 5 import java.util.Map;
 6 
 7 /**
 8  * @Description 動態數據源實現類
 9  * @Author Created by Mumu
10  * @Date on 2019/11/25
11  */
12 public class DynamicDataSource extends AbstractRoutingDataSource {
13     /**
14      * 如果希望所有數據源在啟動配置時就加載好，這里通過設置數據源Key值來切換數據，定制這個方法
15      */
16     @Override
17     protected Object determineCurrentLookupKey() {
18         return DynamicDataSourceContextHolder.getDataSourceKey();
19     }
20 
21     /**
22      * 設置默認數據源
23      * @param defaultDataSource
24      */
25     public void setDefaultDataSource(Object defaultDataSource) {
26         super.setDefaultTargetDataSource(defaultDataSource);
27     }
28 
29     /**
30      * 設置數據源
31      * @param dataSources
32      */
33     public void setDataSources(Map<Object, Object> dataSources) {
34         super.setTargetDataSources(dataSources);
35         // 將數據源的 key 放到數據源上下文的 key 集合中，用於切換時判斷數據源是否有效
36 //        DynamicDataSourceContextHolder.addDataSourceKeys(dataSources.keySet());
37     }
38 }

4.動態數據源上下文

動態數據源的切換主要是通過調用這個類的方法來完成的

 1 package com.mumu.common.datasources;
 2 
 3 /**
 4  * @Description 動態數據源上下文
 5  * @Author Created by Mumu
 6  * @Date on 2019/11/25
 7  */
 8 public class DynamicDataSourceContextHolder {
 9     private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>() {
10         /**
11          * 將 master 數據源的 key作為默認數據源的 key
12          */
13         @Override
14         protected String initialValue() {
15             return DataSourceNames.FIRST;
16         }
17     };
18 
19     /**
20      * 獲取數據源
21      * @return
22      */
23     public static String getDataSourceKey() {
24         return contextHolder.get();
25     }
26 
27     /**
28      * 切換數據源
29      * @param key
30      */
31     public static void setDataSourceKey(String key) {
32         contextHolder.set(key);
33     }
34 
35     /**
36      * 重置數據源
37      */
38     public static void clearDataSourceKey() {
39         contextHolder.remove();
40     }
41 
42 
43 }

5.動態數據源注解

 1 package com.mumu.common.datasources.annotation;
 2 
 3 import java.lang.annotation.*;
 4 
 5 /**
 6  * @Description 動態數據源注解
 7  * @Author Created by Mumu
 8  * @Date on 2019/11/25
 9  */
10 @Target({ElementType.TYPE, ElementType.METHOD})
11 @Retention(RetentionPolicy.RUNTIME)
12 @Documented
13 public @interface DataSource {
14     /**
15      * 數據源key值
16      *
17      * @return
18      */
19     String name() default "";
20 }

6.動態數據源切換處理器

創建一個AOP切面，攔截帶 @DataSource 注解的方法，在方法執行前切換至目標數據源，執行完成后恢復到默認數據源。

 1 package com.mumu.common.datasources.aspect;
 2 
 3 import com.mumu.common.datasources.DataSourceNames;
 4 import com.mumu.common.datasources.DynamicDataSourceContextHolder;
 5 import com.mumu.common.datasources.annotation.DataSource;
 6 import lombok.extern.slf4j.Slf4j;
 7 import org.aspectj.lang.ProceedingJoinPoint;
 8 import org.aspectj.lang.annotation.Around;
 9 import org.aspectj.lang.annotation.Aspect;
10 import org.aspectj.lang.annotation.Pointcut;
11 import org.aspectj.lang.reflect.MethodSignature;
12 import org.springframework.core.annotation.Order;
13 import org.springframework.stereotype.Component;
14 
15 import java.lang.reflect.Method;
16 
17 /**
18  * @Description 動態數據源切換處理器
19  * @Author Created by Mumu
20  * @Date on 2019/11/25
21  */
22 @Aspect
23 @Component
24 @Slf4j
25 @Order(-1)// 該切面應當先於 @Transactional 執行
26 public class DynamicDataSourceAspect {
27     @Pointcut("@annotation(com.mumu.common.datasources.annotation.DataSource)")
28     public void dataSourcePointCut() {
29 
30     }
31 
32     @Around("dataSourcePointCut()")
33     public Object around(ProceedingJoinPoint point) throws Throwable {
34         MethodSignature signature = (MethodSignature) point.getSignature();
35         Method method = signature.getMethod();
36 
37         DataSource ds = method.getAnnotation(DataSource.class);
38         if (ds == null) {
39             DynamicDataSourceContextHolder.setDataSourceKey(DataSourceNames.FIRST);
40             log.info("set datasource is " + DataSourceNames.FIRST);
41         } else {
42             // 切換數據源
43             DynamicDataSourceContextHolder.setDataSourceKey(ds.name());
44             log.info("Switch DataSource to【{}】in Method【{}】", DynamicDataSourceContextHolder.getDataSourceKey(), signature);
45         }
46 
47         try {
48             return point.proceed();
49         } finally {
50             // 將數據源置為默認數據源
51             DynamicDataSourceContextHolder.clearDataSourceKey();
52             log.info("Restore DataSource to【{}】in Method【{}】", DynamicDataSourceContextHolder.getDataSourceKey(), signature);
53         }
54     }
55 }

7.測試

默認操作mysql數據源（master），不做特殊處理

 1 package com.mumu.service.impl;
 2 
 3 import com.mumu.common.datasources.DataSourceNames;
 4 import com.mumu.common.datasources.annotation.DataSource;
 5 import com.mumu.model.AddressBook;
 6 import com.mumu.persistence.mapper.AddressBookMapper;
 7 import com.mumu.service.AddressBookService;
 8 import org.springframework.beans.factory.annotation.Autowired;
 9 import org.springframework.stereotype.Service;
10 
11 /**
12  * @Description
13  * @Author Created by Mumu
14  * @Date on 2019/11/25
15  */
16 @Service
17 public class AddressBookServiceImpl implements AddressBookService {
18     @Autowired
19     private AddressBookMapper addressBookMapper;
20 
21     @Override
22     public AddressBook  queryById(Integer bookId){
23         AddressBook addressBook = addressBookMapper.queryById(bookId);
24         return addressBook;
25     }
26 }

動態切換sqlserver數據源（slave）通過@DataSource(name = DataSourceNames.SECOND)完成

 1 package com.mumu.service.impl;
 2 
 3 import com.mumu.common.datasources.DataSourceNames;
 4 import com.mumu.common.datasources.annotation.DataSource;
 5 import com.mumu.model.Inventory;
 6 import com.mumu.persistence.mapper.InventoryMapper;
 7 import com.mumu.service.InventoryService;
 8 import org.springframework.beans.factory.annotation.Autowired;
 9 import org.springframework.stereotype.Service;
10 
11 /**
12  * @Description
13  * @Author Created by Mumu
14  * @Date on 2019/11/25
15  */
16 @Service
17 public class InventoryServiceImpl implements InventoryService {
18     @Autowired
19     private InventoryMapper inventoryMapper;
20     @Override
21     @DataSource(name = DataSourceNames.SECOND)
22     public Inventory queryById(Integer id){
23         return inventoryMapper.queryById(id);
24     };
25 }

8.遇到的問題

多數據源注入、循環依賴問題

自定義sqlSessionFactory時，用錯mybatis/mybatis-plus的類，導致對應的mybatis全局配置文件未生效

敬請期待...

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 SpringBoot-技術專區-Mybatisplus多數據源 java springboot 配置多數據源 mysql sqlserver springboot整合mybatisplus配置多數據源-hikari HikariCP配置詳解+多數據源 HikariCP配置詳解+多數據源 SpringBoot項目配置Mysql多數據源 SpringBoot配置多數據源Mysql+Sqlite SpringBoot 多數據源配置 Springboot多數據源配置 SpringBoot多數據源配置