采用spring 提供的AbstractRoutingDataSource抽象类来实习，
总体是根据用户端的请求参数，使用aop拦截请求后，动态加载配置数据库中存储的用户数据源配置信息，从而实现用户的动态数据源修改。
1.编写AbstractRoutingDataSource的子类，通过函数determineCurrentLookupKey()实现用户自定义设置参数后，加载对应的数据源，实际上就是一个map，key为用户参数，value为datasource。
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
public class DynamicDataSource extends AbstractRoutingDataSource {
/**
* ThreadLocal 用于提供线程局部变量，在多线程环境可以保证各个线程里的变量独立于其它线程里的变量。
* 也就是说 ThreadLocal 可以为每个线程创建一个【单独的变量副本】，相当于线程的 private static 类型变量。
*/
private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();
/**
* 决定使用哪个数据源之前需要把多个数据源的信息以及默认数据源信息配置好
*
* @param defaultTargetDataSource 默认数据源
* @param targetDataSources 目标数据源
*/
public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
super.setDefaultTargetDataSource(defaultTargetDataSource);
super.setTargetDataSources(targetDataSources);
super.afterPropertiesSet();
}
@Override
protected Object determineCurrentLookupKey() {
logger.info("当前的数据源是====" + getDataSource() == null ? "default" : getDataSource());
return getDataSource();
}
public static void setDataSource(String dataSource) {
CONTEXT_HOLDER.set(dataSource);
}
public static String getDataSource() {
return CONTEXT_HOLDER.get();
}
public static void clearDataSource() {
CONTEXT_HOLDER.remove();
}
}
2.加载上面的实现类,此处加载的是yml文件中配置的默认数据源，在该数据源中存储着用户的数据源配置信息。
import com.zaxxer.hikari.HikariDataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.util.StringUtils;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 实现 EnvironmentAware 用于读取application.yml配置
*/
@Configuration
public class DynamicDataSourceRegister implements EnvironmentAware {
private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceRegister.class);
/**
* 别名
*/
private final static ConfigurationPropertyNameAliases aliases = new ConfigurationPropertyNameAliases();
/**
* 由于部分数据源配置不同，所以在此处添加别名，避免切换数据源出现某些参数无法注入的情况
*/
static {
aliases.addAliases("url", new String[]{"url"});
aliases.addAliases("username", new String[]{"username"});
}
/**
* 配置上下文（也可以理解为配置文件的获取工具）
*/
private Environment evn;
/**
* 参数绑定工具 springboot2.0新推出
*/
private Binder binder;
@Bean("dynamicDataSource")
public DynamicDataSource registerBeanDefinitions() {
Map<Object, Object> targetDataSources = new HashMap<>();
// 获取所有数据源配置
Map config, defauleDataSourceProperties;
defauleDataSourceProperties = binder.bind("spring.datasource", Map.class).get();
// 获取数据源类型
String typeStr = evn.getProperty("spring.datasource.type");
// 获取数据源类型
Class<? extends DataSource> clazz = getDataSourceType(typeStr);
// 绑定默认数据源参数 也就是主数据源
DataSource consumerDatasource, defaultDatasource = bind(clazz, defauleDataSourceProperties);
targetDataSources.put("default", defaultDatasource);
logger.info("注册默认数据源成功");
/*// 获取其他数据源配置
List<Map> configs = binder.bind("spring.datasource.druid.tenant", Bindable.listOf(Map.class)).get();
// 遍历从数据源
for (int i = 0; i < configs.size(); i++) {
config = configs.get(i);
defauleDataSourceProperties = config;
// 绑定参数
consumerDatasource = bind(clazz, defauleDataSourceProperties);
// 获取数据源的key，以便通过该key可以定位到数据源
String key = config.get("key").toString();
targetDataSources.put(key, consumerDatasource);
logger.info("注册数据源{}成功", key);
}*/
return new DynamicDataSource(defaultDatasource, targetDataSources);
}
/**
* 通过字符串获取数据源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) {
//无法通过反射获取class对象的情况则抛出异常，该情况一般是写错了，所以此次抛出一个runtimeexception
throw new IllegalArgumentException("can not resolve class with type: " + typeStr);
}
}
/**
* 绑定参数，以下三个方法都是参考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();
}
/**
* EnvironmentAware接口的实现方法，通过aware的方式注入，此处是environment对象
*
* @param environment
*/
@Override
public void setEnvironment(Environment environment) {
this.evn = environment;
// 绑定配置器
binder = Binder.get(evn);
}
}
3.编写Aop 拦截请求,前置拦截请求参数，获取spring单例的动态数据源配置，根据用户参数去修改targetDataSources，默认的数据源还是会一直存在。当一个请求完成，清除了key之后，下次请求进入，当调用数据库的时候，获取数据源会调用到DynamicDataSource.determineCurrentLookupKey()，此方法此时返回的将是个null，然后当返回的key是null，会返回默认的数据源，也就是之前配置的存放用户数据源配置信息的数据源，获取用户的数据源配置，修改数据源配置，执行业务操作。
@Before("controllerMethod()")
private void controllerBefore(JoinPoint joinPoint) throws Exception {
String key = String.valueOf(joinPoint.getArgs()[0]);
if (log.isDebugEnabled()) {
log.debug("Before controller method [{}], args = [{}]", joinPoint.getSignature().toString(), GcmsWebJsonUtil.toJson(joinPoint.getArgs()));
}
// 获取单例的DynamicDataSource
DynamicDataSource dds = (DynamicDataSource) GcmsSpringUtil.getBean("dynamicDataSource");
// 数据库中根据key查询新的datasource配置
Map<String, Object> stringObjectMap = dataSourceService.selectAllProperty(key);
Map<Object, Object> map = new HashMap<>();
// 构建新的datasource与key绑定
map.put(key, DruidDataSourceFactory.createDataSource(stringObjectMap));
// 设置目标数据源
dds.setTargetDataSources(map);
// 刷新数据源原有列表
dds.afterPropertiesSet();
// 设置当前目标数据源
DynamicDataSource.setDataSource(key);
log.debug("set datasource is " + key);
}
@After("controllerMethod()")
private void controllerAfter(JoinPoint joinPoint) {
if (log.isDebugEnabled()) {
log.debug("After controller method [{}], args = [{}]", joinPoint.getSignature().toString(), GcmsWebJsonUtil.toJson(joinPoint.getArgs()));
}
log.debug("clean datasource==== " + DynamicDataSource.getDataSource());
// 清空用户信息
DynamicDataSource.clearDataSource();
log.debug("clean datasource finished");
}
这样整个动态的修改就完成了。
网友评论