springboot多数据源相关：使用多个自定义注解完成切换数据源，根据指定条件切换数据源，将多个数据源的结果集合并
使用多个自定义注解完成切换数据源，根据指定条件切换数据源，将多个数据源的结果集合并
package com.api.config.aspect;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import com.api.config.annotation.DataSource;
import com.api.config.annotation.DataSourceMulti;
import com.api.config.dynamic.DynamicDataSourceContextHolder;
import com.api.config.enums.DataSourceType;
/**
* 数据切面，用于代理三种不同的数据集成
* @author
*
*/
@Order(1)
@Aspect
@Component
public class DataSourceAspect {
@Pointcut("@annotation(com.api.config.annotation.DataSource)")
public void dataSourcePointcut() {
}
@Pointcut("@annotation(com.api.config.annotation.DataSourceMulti)")
public void dataSourceMultiPointcut() {
}
@Pointcut("@annotation(com.api.config.annotation.DataSourceChange)")
public void dataSourceChangePointcut() {
}
/**
* 切换数据源的功能
* @Author K75022761
* @Date 下午4:50:54 2023年5月24日
* @param point
*/
@Around("dataSourcePointcut()")
public Object switchDataSource(ProceedingJoinPoint point) throws Throwable {
MethodSignature signature = (MethodSignature) point.getSignature();
DataSource dataSource = signature.getMethod().getAnnotation(DataSource.class);
if (dataSource != null) {
String dataSourceName = dataSource.value().name();
DynamicDataSourceContextHolder.setDataSourceType(dataSourceName);
}
Object proceed = point.proceed();
DynamicDataSourceContextHolder.clearDataSourceType();
return proceed;
}
/**
* 切换数据源获取所有数据并返回
* @Author
* @Date 下午4:51:32 2023年5月24日
* @param point
* @return
* @throws Throwable
*/
@SuppressWarnings("unchecked")
@Around("dataSourceMultiPointcut()")
public Object executeMulti(ProceedingJoinPoint point) throws Throwable {
MethodSignature signature = (MethodSignature) point.getSignature();
DataSourceMulti dataSourceMulti = signature.getMethod().getAnnotation(DataSourceMulti.class);
if (dataSourceMulti != null) {
List<Object> result = new ArrayList<>();
Method method = signature.getMethod();
if (method != null) {
Object[] args = point.getArgs();
Annotation[] annotations = method.getAnnotations();
for (Annotation annotation : annotations) {
if (annotation instanceof DataSourceMulti) {
DataSourceMulti dataSource = (DataSourceMulti) annotation;
DataSourceType[] value = dataSource.value();
for (int j = 0; j < value.length; j++) {
DynamicDataSourceContextHolder.setDataSourceType(value[j].name());
result.addAll((List<Object>) method.invoke(point.getTarget(), args));
}
}
}
}
return result;
}
return point.proceed();
}
/**
* 依据SN或者其他条件动态切换数据源
* @Author
* @Date 下午4:51:44 2023年5月24日
* @param point
* @return
* @throws Throwable
*/
@Around("dataSourceChangePointcut()")
public Object dataSourceChange(ProceedingJoinPoint point) throws Throwable {
Object[] args = point.getArgs();
//TODO add 获取source表内容
DataSourceType d = getDataSourceType(args);
DynamicDataSourceContextHolder.setDataSourceType(d.name());
Object proceed = point.proceed();
DynamicDataSourceContextHolder.clearDataSourceType();
return proceed;
}
private DataSourceType getDataSourceType(Object[] args) {
// TODO Auto-generated method stub
return DataSourceType.IFAS;
}
}
若依的数据源切换类
package com.api.config.dynamic;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 数据源切换处理
*
* @author ruoyi
*/
public class DynamicDataSourceContextHolder
{
public static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);
/**
* 使用ThreadLocal维护变量，ThreadLocal为每个使用该变量的线程提供独立的变量副本，
* 所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
*/
private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();
/**
* 设置数据源的变量
*/
public static void setDataSourceType(String dsType)
{
log.info("切换到{}数据源", dsType);
CONTEXT_HOLDER.set(dsType);
}
/**
* 获得数据源的变量
*/
public static String getDataSourceType()
{
return CONTEXT_HOLDER.get();
}
/**
* 清空数据源变量
*/
public static void clearDataSourceType()
{
CONTEXT_HOLDER.remove();
}
}
自定义注解，基本上只是改个类名，总共三个
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface DataSource {
String value() default "";
}
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface DataSourceChange {
String value() default "";
}
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface DataSourceMulti {
String value() default "";
}
动态数据源类
package com.api.config.dynamic;
import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.annotation.Order;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import com.api.config.enums.DataSourceType;
//import com.api.config.interceptor.ReplaceSqlInterceptor;//参见上一篇博文
import com.api.utils.SpringUtils;
@Order(1)
@Configuration
@MapperScan(basePackages = {"com.api.dao.*"})
public class DynamicDataSourceConfig {
class DynamicDataSource extends AbstractRoutingDataSource
{
public final Logger log = LoggerFactory.getLogger(DynamicDataSource.class);
public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources)
{
super.setDefaultTargetDataSource(defaultTargetDataSource);
super.setTargetDataSources(targetDataSources);
super.afterPropertiesSet();
}
@Override
protected Object determineCurrentLookupKey()
{
log.info("使用{}数据源", DynamicDataSourceContextHolder.getDataSourceType());
return DynamicDataSourceContextHolder.getDataSourceType();
}
}
@Autowired
ReplaceSqlInterceptor replaceSqlInterceptor;
@Bean(name = "dynamicDataSource")
@Primary
public DynamicDataSource dataSource() {
Map<Object, Object> targetDataSources = new HashMap<>();
DataSource dataSource1 = SpringUtils.getBean("db1DataSource");
targetDataSources.put(DataSourceType.DB1.name(), dataSource1);
DataSource dataSource2 = SpringUtils.getBean("db2DataSource");
targetDataSources.put(DataSourceType.DB2.name(), dataSource2);
return new DynamicDataSource(dataSource1, targetDataSources);
}
@Bean("dynamicSqlSessionFactory")
@Autowired
@Primary
public SqlSessionFactory sqlSessionFactory(DynamicDataSource dynamicDataSource) throws Exception {
SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
sessionFactory.setDataSource(dataSource());
// PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
// sessionFactory.setMapperLocations(resolver.getResources("classpath*:mapping/*.xml"));
//增加插件，不用的话删掉
//Interceptor[] plugins = new Interceptor[]{replaceSqlInterceptor};
//sessionFactory.setPlugins(plugins);
return sessionFactory.getObject();
}
@Primary
@Bean
public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("dynamicSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
return new SqlSessionTemplate(sqlSessionFactory);
}
@Bean("dynamicTransactionManager")
@Autowired
@Primary
public DataSourceTransactionManager transactionManager(DynamicDataSource dynamicDataSource) {
return new DataSourceTransactionManager(dynamicDataSource);
}
}
若依工具类
package com.api.utils;
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
* spring工具类 方便在非spring管理环境中获取bean
*
* @author ruoyi
*/
@Component
public final class SpringUtils implements BeanFactoryPostProcessor, ApplicationContextAware
{
/** Spring应用上下文环境 */
private static ConfigurableListableBeanFactory beanFactory;
private static ApplicationContext applicationContext;
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
{
SpringUtils.beanFactory = beanFactory;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
{
SpringUtils.applicationContext = applicationContext;
}
/**
* 获取对象
*
* @param name
* @return Object 一个以所给名字注册的bean的实例
* @throws org.springframework.beans.BeansException
*
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(String name) throws BeansException
{
return (T) beanFactory.getBean(name);
}
/**
* 获取类型为requiredType的对象
*
* @param clz
* @return
* @throws org.springframework.beans.BeansException
*
*/
public static <T> T getBean(Class<T> clz) throws BeansException
{
T result = (T) beanFactory.getBean(clz);
return result;
}
/**
* 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
*
* @param name
* @return boolean
*/
public static boolean containsBean(String name)
{
return beanFactory.containsBean(name);
}
/**
* 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
*
* @param name
* @return boolean
* @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
*
*/
public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
{
return beanFactory.isSingleton(name);
}
/**
* @param name
* @return Class 注册对象的类型
* @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
*
*/
public static Class<?> getType(String name) throws NoSuchBeanDefinitionException
{
return beanFactory.getType(name);
}
/**
* 如果给定的bean名字在bean定义中有别名，则返回这些别名
*
* @param name
* @return
* @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
*
*/
public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
{
return beanFactory.getAliases(name);
}
/**
* 获取aop代理对象
*
* @param invoker
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T getAopProxy(T invoker)
{
return (T) AopContext.currentProxy();
}
/**
* 获取当前的环境配置，无配置返回null
*
* @return 当前的环境配置
*/
public static String[] getActiveProfiles()
{
return applicationContext.getEnvironment().getActiveProfiles();
}
/**
* 获取当前的环境配置，当有多个环境配置时，只获取第一个
*
* @return 当前的环境配置
*/
public static String getActiveProfile()
{
final String[] activeProfiles = getActiveProfiles();
return activeProfiles.length>0 ? activeProfiles[0] : null;
}
}