sp展ingboot mysql_springboot-配置多数据源（AOP实现）（HikariCP + MybatisPlus + mysql + SqlServer）...

场景：

springboot项目，默认使用HikariCP连接池 + MybatisPlus持久层框架 + mysql数据库等一套流程，现需求需去第三方sqlserver数据库拉取数据，直连数据库，不走接口，因此，需把项目改造成 多数据源结构，以实现动态切换数据源。

使用docker 安装mysql + sqlserver 数据库 进行测试

实现示例：

0.pom.xml

1 <?xml version="1.0" encoding="UTF-8"?>

2

3 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

4 4.0.0

5

6 com.mumu

7 springboot-mumu

8 1.0-SNAPSHOT

9

10 mumu-web

11

12

13

14

15 org.springframework.boot

16 spring-boot-starter-web

17

18

19

20 org.springframework.boot

21 spring-boot-starter-aop

22

23

24

25 mysql

26 mysql-connector-java

27 runtime

28

29

30

31 com.microsoft.sqlserver

32 mssql-jdbc

33 runtime

34

35

36

37 com.baomidou

38 mybatis-plus-boot-starter

39 3.0.5

40

41

42

43

44

45

46

47 org.springframework.boot

48 spring-boot-maven-plugin

49

50

51

52

53

1.配置文件

server:

port:9587spring:

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:1234567890slave:

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 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 packagecom.mumu.common.datasources;2

3 importorg.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;4

5 importjava.util.Map;6

7 /**

8 * @Description 动态数据源实现类9 * @Author Created by Mumu10 * @Date on 2019/11/2511 */

12 public class DynamicDataSource extendsAbstractRoutingDataSource {13 /**

14 * 如果希望所有数据源在启动配置时就加载好，这里通过设置数据源Key值来切换数据，定制这个方法15 */

16 @Override17 protectedObject determineCurrentLookupKey() {18 returnDynamicDataSourceContextHolder.getDataSourceKey();19 }20

21 /**

22 * 设置默认数据源23 *@paramdefaultDataSource24 */

25 public voidsetDefaultDataSource(Object defaultDataSource) {26 super.setDefaultTargetDataSource(defaultDataSource);27 }28

29 /**

30 * 设置数据源31 *@paramdataSources32 */

33 public void setDataSources(MapdataSources) {34 super.setTargetDataSources(dataSources);35 //将数据源的 key 放到数据源上下文的 key 集合中，用于切换时判断数据源是否有效36 //DynamicDataSourceContextHolder.addDataSourceKeys(dataSources.keySet());

37 }38 }

4.动态数据源上下文

动态数据源的切换主要是通过调用这个类的方法来完成的

1 packagecom.mumu.common.datasources;2

3 /**

4 * @Description 动态数据源上下文5 * @Author Created by Mumu6 * @Date on 2019/11/257 */

8 public classDynamicDataSourceContextHolder {9 private static final ThreadLocal contextHolder = new ThreadLocal() {10 /**

11 * 将 master 数据源的 key作为默认数据源的 key12 */

13 @Override14 protectedString initialValue() {15 returnDataSourceNames.FIRST;16 }17 };18

19 /**

20 * 获取数据源21 *@return

22 */

23 public staticString getDataSourceKey() {24 returncontextHolder.get();25 }26

27 /**

28 * 切换数据源29 *@paramkey30 */

31 public static voidsetDataSourceKey(String key) {32 contextHolder.set(key);33 }34

35 /**

36 * 重置数据源37 */

38 public static voidclearDataSourceKey() {39 contextHolder.remove();40 }41

42

43 }

5.动态数据源注解

1 packagecom.mumu.common.datasources.annotation;2

3 import java.lang.annotation.*;4

5 /**

6 * @Description 动态数据源注解7 * @Author Created by Mumu8 * @Date on 2019/11/259 */

10 @Target({ElementType.TYPE, ElementType.METHOD})11 @Retention(RetentionPolicy.RUNTIME)12 @Documented13 public @interfaceDataSource {14 /**

15 * 数据源key值16 *17 *@return

18 */

19 String name() default "";20 }

6.动态数据源切换处理器

创建一个AOP切面，拦截带 @DataSource 注解的方法，在方法执行前切换至目标数据源，执行完成后恢复到默认数据源。

1 packagecom.mumu.common.datasources.aspect;2

3 importcom.mumu.common.datasources.DataSourceNames;4 importcom.mumu.common.datasources.DynamicDataSourceContextHolder;5 importcom.mumu.common.datasources.annotation.DataSource;6 importlombok.extern.slf4j.Slf4j;7 importorg.aspectj.lang.ProceedingJoinPoint;8 importorg.aspectj.lang.annotation.Around;9 importorg.aspectj.lang.annotation.Aspect;10 importorg.aspectj.lang.annotation.Pointcut;11 importorg.aspectj.lang.reflect.MethodSignature;12 importorg.springframework.core.annotation.Order;13 importorg.springframework.stereotype.Component;14

15 importjava.lang.reflect.Method;16

17 /**

18 * @Description 动态数据源切换处理器19 * @Author Created by Mumu20 * @Date on 2019/11/2521 */

22 @Aspect23 @Component24 @Slf4j25 @Order(-1)//该切面应当先于 @Transactional 执行

26 public classDynamicDataSourceAspect {27 @Pointcut("@annotation(com.mumu.common.datasources.annotation.DataSource)")28 public voiddataSourcePointCut() {29

30 }31

32 @Around("dataSourcePointCut()")33 public Object around(ProceedingJoinPoint point) throwsThrowable {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 returnpoint.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 packagecom.mumu.service.impl;2

3 importcom.mumu.common.datasources.DataSourceNames;4 importcom.mumu.common.datasources.annotation.DataSource;5 importcom.mumu.model.AddressBook;6 importcom.mumu.persistence.mapper.AddressBookMapper;7 importcom.mumu.service.AddressBookService;8 importorg.springframework.beans.factory.annotation.Autowired;9 importorg.springframework.stereotype.Service;10

11 /**

12 * @Description13 * @Author Created by Mumu14 * @Date on 2019/11/2515 */

16 @Service17 public class AddressBookServiceImpl implementsAddressBookService {18 @Autowired19 privateAddressBookMapper addressBookMapper;20

21 @Override22 publicAddressBook queryById(Integer bookId){23 AddressBook addressBook =addressBookMapper.queryById(bookId);24 returnaddressBook;25 }26 }

动态切换sqlserver数据源(slave) 通过@DataSource(name = DataSourceNames.SECOND)完成

1 packagecom.mumu.service.impl;2

3 importcom.mumu.common.datasources.DataSourceNames;4 importcom.mumu.common.datasources.annotation.DataSource;5 importcom.mumu.model.Inventory;6 importcom.mumu.persistence.mapper.InventoryMapper;7 importcom.mumu.service.InventoryService;8 importorg.springframework.beans.factory.annotation.Autowired;9 importorg.springframework.stereotype.Service;10

11 /**

12 * @Description13 * @Author Created by Mumu14 * @Date on 2019/11/2515 */

16 @Service17 public class InventoryServiceImpl implementsInventoryService {18 @Autowired19 privateInventoryMapper inventoryMapper;20 @Override21 @DataSource(name =DataSourceNames.SECOND)22 publicInventory queryById(Integer id){23 returninventoryMapper.queryById(id);24 };25 }

8.遇到的问题

多数据源注入、循环依赖问题

自定义sqlSessionFactory时，用错mybatis/mybatis-plus的类，导致对应的mybatis全局配置文件未生效

敬请期待...