适用场景:
1、一个项目需要从多个不同的数据库获取数据,不想创建多个项目的情况。
2、为了充分运用数据库集群中从库的性能,在从库建立只读链接,通过程序实现读写分离。
思路:
1、通过自定义注解指定程序要访问的数据库。
2、操作数据库的时候根据指定的数据库动态分配数据源(数据库连接)。
步骤:
1、创建自定义注解@DynamicDataSource
,可用于方法上,用来指定该方法用到的数据库。
2、通过AOP将指定的数据源放入到ThreadLocal中。
3、通过实现org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource
的determineCurrentLookupKey()
来动态分配数据源。
代码如下:
<!-- 如果依赖不存在 引入依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>xxx</version>
</dependency>
参考配置
# 示例一:单数据源配置
# database start
spring.datasource.name=dataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/dev_master?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&autoReconnect=true&failOverReadOnly=false&maxReconnects=10
spring.datasource.username=username
spring.datasource.password=password
# datebase end
# 示例二:多数据源配置
# database start
# 开启动态数据源配置
dynamic.datasource.enable=true
# 动态数据源名称 第一个为默认数据源
dynamic.datasource.name=master,slave
# 动态数据源配置
dynamic.datasource.master.driver-class-name=com.mysql.jdbc.Driver
dynamic.datasource.master.url=jdbc:mysql://127.0.0.1:3306/dev_master
dynamic.datasource.master.username=username
dynamic.datasource.master.password=password
dynamic.datasource.slave.driver-class-name=com.mysql.jdbc.Driver
dynamic.datasource.slave.url=jdbc:mysql://127.0.0.1:3306/dev_slave
dynamic.datasource.slave.username=username
dynamic.datasource.slave.password=password
# 其他参数
dynamic.datasource.slave.readOnly=true
# datebase end
package common.dynamic.datasource;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 动态数据源
*
* @date 2022/6/16 14:39
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface DynamicDataSource {
String value() default "master";
}
package common.dynamic.datasource;
/**
* 数据源key
*
* @date 2022/6/16 15:16
*/
public interface DynamicDataSourceKey {
public static final String MASTER = "master";
public static final String SLAVE = "slave";
}
package common.dynamic.datasource;
/**
* 动态数据源
*
* @date 2022/6/16 13:36
*/
public class DynamicDataSourceKeyHolder {
private static ThreadLocal<String> DATA_SOURCE_KEY_HOLDER = new ThreadLocal<>();
public static void setDataSourceKey(String dataSourceKey){
DATA_SOURCE_KEY_HOLDER.set(dataSourceKey);
}
public static String getDataSourceKey(){
String dataSourceKey = DATA_SOURCE_KEY_HOLDER.get();
return dataSourceKey;
}
public static void clear(){
DATA_SOURCE_KEY_HOLDER.remove();
}
}
package common.dynamic.datasource;
import com.jd.fastjson.JSON;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
/**
* 根据注解切换数据源
*
* @date 2022/6/16 14:13
*/
@Aspect
@Component
public class DynamicDataSourceAspect {
private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);
@Around(value = "@annotation(DynamicDataSource) && @annotation(dynamicDataSource)", argNames = "joinPoint, dynamicDataSource")
Object aroundAdvice(ProceedingJoinPoint joinPoint, DynamicDataSource dynamicDataSource) throws Throwable {
logger.debug("进入了切面: {}", JSON.toJSONString(dynamicDataSource));
try {
DynamicDataSourceKeyHolder.setDataSourceKey(dynamicDataSource.value());
return joinPoint.proceed();
} catch (Throwable throwable){
logger.error("", throwable);
throw throwable;
} finally {
DynamicDataSourceKeyHolder.clear();
}
}
}
package common.dynamic.datasource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
/**
* 动态数据源路由
*
* @date 2022/6/16 13:36
*/
public class RoutingDynamicDataSource extends AbstractRoutingDataSource {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
/**
* 路由策略
* 如果返回null会使用默认数据源
* @return
*/
@Override
protected Object determineCurrentLookupKey() {
String dataSourceKey = DynamicDataSourceKeyHolder.getDataSourceKey();
logger.debug("dataSourceKey:{}", dataSourceKey);
return dataSourceKey;
}
}
package common.dynamic.datasource.config;
import common.dynamic.datasource.RoutingDynamicDataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.boot.context.properties.bind.BindResult;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.context.properties.source.ConfigurationPropertySource;
import org.springframework.boot.context.properties.source.ConfigurationPropertySources;
import org.springframework.boot.jdbc.DataSourceBuilder;
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.validation.DataBinder;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
* 配置数据源
*
* @date 2022/6/16 18:37
*/
@Configuration
public class DynamicDataSourceConfig implements EnvironmentAware {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
/**
* 默认数据源类型
*/
private String defaultDataSourceType = "com.zaxxer.hikari.HikariDataSource";
/**
* 数据源
*/
private DataSource dataSource;
/**
* 动态数据源map
*/
private Map dynamicDatasourceMap = new HashMap<>();
@Override
public void setEnvironment(Environment environment) {
// 获取数据源配置
Properties dynamicDatasourceProperties = this.getPropertiesByPrefix(environment, "dynamic.datasource");
String enable = dynamicDatasourceProperties.getProperty("enable", "false");
if(enable.trim().equals("true")){
// 开启动态数据源
RoutingDynamicDataSource routingDynamicDataSource = new RoutingDynamicDataSource();
String names = dynamicDatasourceProperties.getProperty("name");
String[] nameArray = names.split(",");
for (int i = 0; i < nameArray.length; i++) {
// 构建动态数据源
logger.info("构建数据源:dynamic.datasource.{}", nameArray[i]);
Properties subDatasourceProperties = this.getPropertiesByPrefix(environment, "dynamic.datasource." + nameArray[i]);
DataSource subDataSource = buildDataSource(subDatasourceProperties);
if(i == 0){
if(subDataSource == null){
throw new IllegalArgumentException(String.format("默认数据源:%s 配置失败", nameArray[i]));
}
routingDynamicDataSource.setDefaultTargetDataSource(subDataSource);
}
if(subDataSource == null){
logger.error("数据源:{} 配置失败", nameArray[i]);
} else {
this.dynamicDatasourceMap.put(nameArray[i], subDataSource);
}
}
routingDynamicDataSource.setTargetDataSources(this.dynamicDatasourceMap);
this.dataSource = routingDynamicDataSource;
} else {
// 不开启动态数据源
logger.info("构建数据源:spring.datasource");
Properties springDatasourceProperties = this.getPropertiesByPrefix(environment, "spring.datasource");
DataSource springDataSource = buildDataSource(springDatasourceProperties);
this.dataSource = springDataSource;
}
}
/**
* 根据前缀获取配置
* @param environment
* @param proPrefix
* @return
*/
private Properties getPropertiesByPrefix(Environment environment, String proPrefix){
Iterable<ConfigurationPropertySource> sources = ConfigurationPropertySources.get(environment);
Binder binder = new Binder(sources);
BindResult<Properties> bindResult = binder.bind(proPrefix, Properties.class);
if(bindResult.isBound()){
return bindResult.get();
}
return new Properties();
}
/**
* 构建数据源
* @param properties
* @return
*/
private DataSource buildDataSource(Properties properties){
try {
String driverClassName = properties.getProperty("driver-class-name");
String url = properties.getProperty("url");
String username = properties.getProperty("username");
String password = properties.getProperty("password");
// 参数校验
if(driverClassName == null || "".equals(driverClassName)){
throw new IllegalArgumentException("没有配置:driver-class-name");
}
if(url == null || "".equals(url)){
throw new IllegalArgumentException("没有配置:url");
}
if(username == null || "".equals(username)){
throw new IllegalArgumentException("没有配置:username");
}
if(password == null || "".equals(password)){
throw new IllegalArgumentException("没有配置:password");
}
String type = properties.getProperty("type");
if(type == null || "".equals(type.trim())){
// 默认数据源类型
type = this.defaultDataSourceType;
}
Class dataSourceType = Class.forName(type);
DataSource buildDataSource = DataSourceBuilder.create().type(dataSourceType).driverClassName(driverClassName).url(url).username(username).password(password).build();
// 补充数据源属性
DataBinder dataBinder = new DataBinder(buildDataSource);
dataBinder.bind(new MutablePropertyValues(properties));
return buildDataSource;
} catch (Exception e){
e.printStackTrace();
logger.error("构建数据源失败", e);
}
return null;
}
@Bean(value = "dataSource")
DataSource dataSource(){
DataSource dataSource = this.dataSource;
return dataSource;
}
}
import static common.dynamic.datasource.DynamicDataSourceKey.SLAVE;
// 展示部分代码
@RequestMapping("/demo")
@DynamicDataSource(SLAVE) // 指定要访问的数据库
public ApiResult demo(){
// 访问数据库
return ApiResult.success();
}