3.Spring Boot之多数据源动态切换数据源AOP
一、引入依赖
<!--Begin aop+注解 增强拦截-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
<version>2.4.2</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.9.6</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>
</dependency>
<!--End aop+注解 增强拦截-->
二、配置多数据源
首先我们需要在我们的的application.yml配置我们的三个数据源
server:
port: 8989
spring:
datasource:
demo:
driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
url: jdbc:sqlserver://192.168.110.31:1433;DatabaseName=Demo
username: sa
password: Qlled.123456
type: com.zaxxer.hikari.HikariDataSource
cluster:
- key: demo2
driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
url: jdbc:sqlserver://192.168.110.31:1433;DatabaseName=Demo2
username: sa
password: Qlled.123456
type: com.zaxxer.hikari.HikariDataSource
- key: demo3
driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
url: jdbc:sqlserver://192.168.110.31:1433;DatabaseName=Demo3
username: sa
password: Qlled.123456
type: com.zaxxer.hikari.HikariDataSource
mybatis:
mapper-locations: classpath:/mybatis/mapper/*.xml
config-location: classpath:/mybatis/config/mybatis-config.xml
logging:
config: classpath:log4j2.xml
在上面我们配置了三个数据，其中master数据源是一定要配置的，作为我们的默认数据源，其次cluster集群中，其他的数据不配置也不会影响程序运行，如果你想添加新的一个数据源 就在cluster下新增一个数据源即可，其中key为必须项，用于数据源的唯一标识，以及接下来切换数据源的标识。
三、注册数据源
在上面我们已经配置了三个数据源，但是这是我们自定义的配置，springboot是无法给我们自动配置，所以需要我们自己注册数据源.
那么就要实现 EnvironmentAware用于读取上下文环境变量用于构建数据源，同时也需要实现 ImportBeanDefinitionRegistrar接口注册我们构建的数据源，具体代码如下
lql.demo2.register.DynamicDataSourceRegister
package lql.demo2.register;
import com.zaxxer.hikari.HikariDataSource;
import lql.demo2.config.DynamicDataSourceContextHolder;
import lql.demo2.config.DynamicRoutingDataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.boot.context.properties.bind.Bindable;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.context.properties.source.ConfigurationPropertyName;
import org.springframework.boot.context.properties.source.ConfigurationPropertyNameAliases;
import org.springframework.boot.context.properties.source.ConfigurationPropertySource;
import org.springframework.boot.context.properties.source.MapConfigurationPropertySource;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.util.StringUtils;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* #多数据源#
* Created by QiuLiang.Liu
* on 2021-03-18 10:29
* 动态数据源注册
* 实现 ImportBeanDefinitionRegistrar 实现数据源注册
* 实现 EnvironmentAware 用于读取application.yml配置
*/
public class DynamicDataSourceRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware {
private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceRegister.class);
/**
* 配置上下文（也可以理解为配置文件的获取工具）
*/
private Environment evn;
/**
* 别名
*/
private final static ConfigurationPropertyNameAliases aliases = new ConfigurationPropertyNameAliases();
/**
* 由于部分数据源配置不同，所以在此处添加别名，避免切换数据源出现某些参数无法注入的情况
*/
static {
aliases.addAliases("url", new String[]{"jdbc-url"});
aliases.addAliases("username", new String[]{"user"});
}
/**
* 存储我们注册的数据源
*/
private Map<String, DataSource> customDataSources = new HashMap<String, DataSource>();
/**
* 参数绑定工具 springboot2.0新推出
*/
private Binder binder;
/**
* ImportBeanDefinitionRegistrar接口的实现方法，通过该方法可以按照自己的方式注册bean
*
* @param annotationMetadata
* @param beanDefinitionRegistry
*/
@Override
public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
// 获取所有数据源配置
Map config, defauleDataSourceProperties;
defauleDataSourceProperties = binder.bind("spring.datasource.demo", Map.class).get();
// 获取数据源类型
String typeStr = evn.getProperty("spring.datasource.demo.type");
// 获取数据源类型
Class<? extends DataSource> clazz = getDataSourceType(typeStr);
// 绑定默认数据源参数 也就是主数据源
DataSource consumerDatasource, defaultDatasource = bind(clazz, defauleDataSourceProperties);
DynamicDataSourceContextHolder.dataSourceIds.add("demo");
logger.info("注册默认数据源成功");
// 获取其他数据源配置
List<Map> configs = binder.bind("spring.datasource.cluster", Bindable.listOf(Map.class)).get();
// 遍历从数据源
for (int i = 0; i < configs.size(); i++) {
config = configs.get(i);
clazz = getDataSourceType((String) config.get("type"));
defauleDataSourceProperties = config;
// 绑定参数
consumerDatasource = bind(clazz, defauleDataSourceProperties);
// 获取数据源的key，以便通过该key可以定位到数据源
String key = config.get("key").toString();
customDataSources.put(key, consumerDatasource);
// 数据源上下文，用于管理数据源与记录已经注册的数据源key
DynamicDataSourceContextHolder.dataSourceIds.add(key);
logger.info("注册数据源{}成功", key);
}
// bean定义类
GenericBeanDefinition define = new GenericBeanDefinition();
// 设置bean的类型，此处DynamicRoutingDataSource是继承AbstractRoutingDataSource的实现类
define.setBeanClass(DynamicRoutingDataSource.class);
// 需要注入的参数
MutablePropertyValues mpv = define.getPropertyValues();
// 添加默认数据源，避免key不存在的情况没有数据源可用
mpv.add("defaultTargetDataSource", defaultDatasource);
// 添加其他数据源
mpv.add("targetDataSources", customDataSources);
// 将该bean注册为datasource，不使用springboot自动生成的datasource
beanDefinitionRegistry.registerBeanDefinition("datasource", define);
logger.info("注册数据源成功，一共注册{}个数据源", customDataSources.keySet().size() + 1);
}
/**
* 通过字符串获取数据源class对象
*
* @param typeStr
* @return
*/
private Class<? extends DataSource> getDataSourceType(String typeStr) {
Class<? extends DataSource> type;
try {
if (StringUtils.hasLength(typeStr)) {
// 字符串不为空则通过反射获取class对象
type = (Class<? extends DataSource>) Class.forName(typeStr);
} else {
// 默认为hikariCP数据源，与springboot默认数据源保持一致
type = HikariDataSource.class;
}
return type;
} catch (Exception e) {
throw new IllegalArgumentException("can not resolve class with type: " + typeStr); //无法通过反射获取class对象的情况则抛出异常，该情况一般是写错了，所以此次抛出一个runtimeexception
}
}
/**
* 绑定参数，以下三个方法都是参考DataSourceBuilder的bind方法实现的，目的是尽量保证我们自己添加的数据源构造过程与springboot保持一致
*
* @param result
* @param properties
*/
private void bind(DataSource result, Map properties) {
ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
// 将参数绑定到对象
binder.bind(ConfigurationPropertyName.EMPTY, Bindable.ofInstance(result));
}
private <T extends DataSource> T bind(Class<T> clazz, Map properties) {
ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
// 通过类型绑定参数并获得实例对象
return binder.bind(ConfigurationPropertyName.EMPTY, Bindable.of(clazz)).get();
}
/**
* @param clazz
* @param sourcePath 参数路径，对应配置文件中的值，如: spring.datasource
* @param <T>
* @return
*/
private <T extends DataSource> T bind(Class<T> clazz, String sourcePath) {
Map properties = binder.bind(sourcePath, Map.class).get();
return bind(clazz, properties);
}
/**
* EnvironmentAware接口的实现方法，通过aware的方式注入，此处是environment对象
*
* @param environment
*/
@Override
public void setEnvironment(Environment environment) {
logger.info("开始注册数据源");
this.evn = environment;
// 绑定配置器
binder = Binder.get(evn);
}
}
上面代码需要注意的是在springboot2.x系列中用于绑定的工具类如RelaxedPropertyResolver已经无法使用，现在使用Binder代替。上面代码主要是读取application中数据源的配置，先读取spring.datasource.demo构建默认数据源,然后在构建cluster中的数据源。
在这里注册完数据源之后，我们需要通过@import注解把我们的数据源注册器导入到spring中 在启动类Demo2Application.java加上如下注解@Import(DynamicDataSourceRegister.class)。
其中我们用到了一个DynamicDataSourceContextHolder 中的静态变量来保存我们已经注册成功的数据源的key,至此我们的数据源注册就已经完成了。
四、配置数据源上下文
我们需要新建一个数据源上下文，用户记录当前线程使用的数据源的key是什么，以及记录所有注册成功的数据源的key的集合。对于线程级别的私有变量，我们用ThreadLocal来实现，具体代码如下
lql.demo2..config.DynamicDataSourceContextHolder
package lql.demo2.config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.List;
/**
* #多数据源#
* Created by QiuLiang.Liu
* on 2021-03-18 10:35
* @Description: 数据源上下文
*/
public class DynamicDataSourceContextHolder {
private static Logger logger = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);
/**
* 存储已经注册的数据源的key
*/
public static List<String> dataSourceIds = new ArrayList<>();
/**
* 线程级别的私有变量
*/
private static final ThreadLocal<String> HOLDER = new ThreadLocal<>();
public static String getDataSourceRouterKey () {
String tmp = HOLDER.get();
return HOLDER.get();
}
public static void setDataSourceRouterKey (String dataSourceRouterKey) {
logger.info("切换至{}数据源", dataSourceRouterKey);
HOLDER.set(dataSourceRouterKey);
}
/**
* 设置数据源之前一定要先移除
*/
public static void removeDataSourceRouterKey () {
HOLDER.remove();
}
/**
* 判断指定DataSrouce当前是否存在
*
* @param dataSourceId
* @return
*/
public static boolean containsDataSource(String dataSourceId){
return dataSourceIds.contains(dataSourceId);
}
}
五、动态数据源路由
前面我们以及新建了数据源上下文，用于存储我们当前线程的数据源key那么怎么通知spring用key当前的数据源呢，查阅资料可知，spring提供一个接口，名为AbstractRoutingDataSource的抽象类，我们只需要重写determineCurrentLookupKey方法就可以，这个方法看名字就知道，就是返回当前线程的数据源的key，那我们只需要从我们刚刚的数据源上下文中取出我们的key即可，具体代码如下
lql.demo2.config.DynamicRoutingDataSource
package lql.demo2.config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
/**
* #多数据源#
* Created by QiuLiang.Liu
* on 2021-03-18 10:38
* @Description: 动态数据源路由配置
*/
public class DynamicRoutingDataSource extends AbstractRoutingDataSource {
private static Logger logger = LoggerFactory.getLogger(DynamicRoutingDataSource.class);
@Override
protected Object determineCurrentLookupKey() {
String dataSourceName = DynamicDataSourceContextHolder.getDataSourceRouterKey();
logger.info("当前数据源是：{}", dataSourceName);
return DynamicDataSourceContextHolder.getDataSourceRouterKey();
}
}
六、通过aop+注解实现动态数据源的切换
现在spring也已经知道通过key来取对应的数据源，我们现在只需要实现给对应的类或者方法设置他们的数据源的key，并且保存在数据源上下文中即可。这里我们采用注解来设置数据源，通过aop拦截并且保存到数据源上下中。
我们新建一个标识数据源的注解@DataSource，具体代码如下
lql.demo2.annotation.DataSource
package lql.demo2.annotation;
import org.springframework.stereotype.Component;
import java.lang.annotation.*;
/**
* #多数据源#
* Created by QiuLiang.Liu
* on 2021-03-18 10:41
* 切换数据注解 可以用于类或者方法级别 方法级别优先级 > 类级别
*/
@Target({ElementType.METHOD, ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface DataSource {
String value() default "demo"; //该值即key值
}
其中他的默认值是demo,因为我们默认数据源的key也是demo。也就是说如果你直接用注解，而不指定value的话，那么默认就使用demo默认数据源。
然后我们新建一个aop类来拦截，具体代码如下
lql.demo2.aop.DynamicDataSourceAspect
package lql.demo2.aop;
import lql.demo2.annotation.DataSource;
import lql.demo2.config.DynamicDataSourceContextHolder;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
/**
*Created by QiuLiang.Liu
*on 2021-03-19 10:33
*/
@Aspect
@Component
public class DynamicDataSourceAspect {
private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);
/**
* 对指定注解，进行横切，创建一个横切的对象方法
*
*/
//@Pointcut("@annotation(lql.demo2.annotation.DataSource)")
//public void annotationPoint(){};
@Before("@annotation(ds)")
public void changeDataSource(JoinPoint point, DataSource ds) throws Throwable {
String dsId = ds.value();
if (DynamicDataSourceContextHolder.dataSourceIds.contains(dsId)) {
logger.debug("Use DataSource :{} >", dsId, point.getSignature());
DynamicDataSourceContextHolder.setDataSourceRouterKey(dsId);
} else {
logger.info("数据源[{}]不存在，使用默认数据源 >{}", dsId, point.getSignature());
}
}
@After("@annotation(ds)")
public void restoreDataSource(JoinPoint point, DataSource ds) {
logger.debug("Revert DataSource : " + ds.value() + " > " + point.getSignature());
DynamicDataSourceContextHolder.removeDataSourceRouterKey();
}
}
通过aop拦截，获取注解上面的value的值key，然后取判断我们注册的keys集合中是否有这个key,如果没有，则使用默认数据源，如果有，则设置上下文中当前数据源的key为注解的value。
七、测试
最后我们在对应的方法上面加上注解来测试一下即可
我们在UserMapper.java上面加上注解，并且进行测试。
package lql.demo2.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import lql.demo2.annotation.DataSource;
import lql.demo2.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;
/**
* Created by QiuLiang.Liu
* on 2021-02-03 16:17
*/
public interface UserMapper extends BaseMapper<User> {
@DataSource //默认数据源
@Select("select * from T_User")
List<User> getAll();
@DataSource("demo2") //数据源demo2
@Select("select * from T_User where UserId = #{UserId}")
User getById(@Param("UserId") String userId);
}
编写测试类
package lql.demo2.controller;
import lql.demo2.common.Result;
import lql.demo2.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* Created by QiuLiang.Liu
* on 2021-02-03 17:30
*/
@RestController
@RequestMapping("/User")
public class UserController {
private static final Logger log = LoggerFactory.getLogger(UserController.class);
@Autowired
private UserService userService;
//数据源demo
@GetMapping("getAll")
public Result getAll() {
log.info("获取所有User...Begin...");
try {
return Result.isOk().data(userService.getAll());
} catch (Exception e) {
return Result.isFail(e);
}
}
//数据源demo2
@GetMapping("getById")
public Result getById(String userId) {
log.info("获取UserId='"+userId+"'...Begin...");
//DynamicDataSourceContextHolder.setDataSourceRouterKey("demo2");
try {
return Result.isOk().data(userService.getById(userId));
} catch (Exception e) {
return Result.isFail(e);
}
}
}
首先测试getAll方法，查询demo数据
再测试getById方法
日志提示数据源能够切换，能够分别查询demo和demo2的数据。
那么至此我们的多数据源动态数据源就完成了。
主要的思路就是
- 配置文件中配置多个数据源
- 启动类注册动态数据源
- 在需要的方法上使用注解指定数据源
代码见 3.SpringBoot之多数据源动态切换数据源.zip
原文参考 https://blog.csdn.net/xp541130126/article/details/81739760
浙公网安备 33010602011771号