目录
1:使用动态数据源的初衷
2:导入所需要的jar
3:在bootstrap.yml(application.properteis)或者application.yml中写入配置
4:定义DynamicDataSource类,用来动态连接数据源
5:定义DynamicDataSourceConfig,数据源的配置类
6:写一个用来切换数据源的注解类DS
7:写一个AOP类DynamicDataSourceAspect,用来控制数据源切换
1:使用动态数据源的初衷
是能在应用层做到读写分离,即在程序代码中控制不同的查询方法去连接不同的库。除了这种方法以外,数据库中间件也是个不错的选择,它的优点是数据库集群对应用来说只暴露为单库,不需要切换数据源的代码逻辑。
思路:从动态数据源工具中获取到DataSource标示,根据标示获取DataSrouce对象。在Spring容器中,这一点其实更好实现。原理就是在DB访问之前,切换数据源。
***我们通过自定义注解 + AOP的方式实现数据源动态切换。
2:导入所需要的jar
mysql
mysql-connector-java
com.alibaba
druid-spring-boot-starter
1.1.9
3:在bootstrap.yml(application.properteis)或者application.yml中写入配置
# 数据源配置
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driverClassName: com.mysql.cj.jdbc.Driver
druid:
center:
username: root
password: root
url: jdbc:mysql://127.0.0.1:3306/test1?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8&allowMultiQueries=true&allowPublicKeyRetrieval=true
duanguo:
username: root
password: root
url: jdbc:mysql://127.0.0.1:3306/test2?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8&allowMultiQueries=true&allowPublicKeyRetrieval=true
4:定义DynamicDataSource类,用来动态连接数据源
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import javax.sql.DataSource;
import java.util.Map;
public class DynamicDataSource extends AbstractRoutingDataSource {
public static final Logger log= LoggerFactory.getLogger(DynamicDataSource.class);
//用来装载需要使用的数据源的线程名(即即将调用的数据源线程名变量)
private static final ThreadLocal contextHolder = new ThreadLocal<>();
public DynamicDataSource(DataSource defaultDataSource, Map
5:定义DynamicDataSourceConfig,数据源的配置类
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.spring.cloud.api.util.DynamicDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class DynamicDataSourceConfig {
@Bean
@ConfigurationProperties(prefix = "spring.datasource.druid.center") // application.yml中对应属性的前缀
public DataSource dataSource1() {
return DruidDataSourceBuilder.create().build();
}
@Bean
@ConfigurationProperties(prefix = "spring.datasource.druid.duanguo") // application.yml中对应属性的前缀
public DataSource dataSource2() {
return DruidDataSourceBuilder.create().build();
}
@Bean
@Primary
public DynamicDataSource dataSource() {
Map
6:写一个用来切换数据源的注解类DS
import java.lang.annotation.*;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({
ElementType.METHOD
})
public @interface DS {
//设置默认数据源
String value() default "centerDS";
}
7:写一个AOP类DynamicDataSourceAspect,用来控制数据源切换
import com.spring.cloud.api.annotation.DS;
import com.spring.cloud.api.util.DynamicDataSource;
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.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
@Aspect
@Component
public class DynamicDataSourceAspect {
@Before("@annotation(com.spring.cloud.api.annotation.DS)")
public void beforeSwitchDS(JoinPoint point){
//获得当前访问的class
Class> className = point.getTarget().getClass();
//获得访问的方法名
String methodName = point.getSignature().getName();
//得到方法的参数的类型
Class[] argClass = ((MethodSignature)point.getSignature()).getParameterTypes();
//默认数据源
String dataSource = "centerDS";
try {
// 得到访问的方法对象
Method method = className.getMethod(methodName, argClass);
// 判断是否存在@DS注解
if (method.isAnnotationPresent(DS.class)) {
DS annotation = method.getAnnotation(DS.class);
// 取出注解中的数据源名
dataSource = annotation.value();
}
} catch (Exception e) {
e.printStackTrace();
}
// 切换数据源
DynamicDataSource.setDataSource(dataSource);
}
//接口调用结束,即清除本地数据源线程变量,使其换回到默认数据源
@After("@annotation(com.spring.cloud.api.annotation.DS)")
public void afterSwitchDS(JoinPoint point){
DynamicDataSource.clearDataSource();
}
}
8:关闭springboot自带的数据源配置,导入自定义的数据配置(可以不用,这里这是为了提前加载配置类)
import com.joolun.cloud.center.api.config.DataSourceConfig;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.context.annotation.Import;
@Import({DataSourceConfig.class}) //可以不用写,这里作用只是提前导入此配置
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class}) //关闭springboot自带的数据源配置
public class ApiApplication {
public static void main(String[] args) {
SpringApplication.run(ApiApplication.class, args);
}
}
# 数据源配置
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driverClassName: com.mysql.cj.jdbc.Driver
druid:
center:
username: root
password: root
url: jdbc:mysql://127.0.0.1:3306/test1?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8&allowMultiQueries=true&allowPublicKeyRetrieval=true
duanguo:
username: root
password: root
url: jdbc:mysql://127.0.0.1:3306/test2?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8&allowMultiQueries=true&allowPublicKeyRetrieval=true
4:定义DynamicDataSource类,用来动态连接数据源
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import javax.sql.DataSource;
import java.util.Map;
public class DynamicDataSource extends AbstractRoutingDataSource {
public static final Logger log= LoggerFactory.getLogger(DynamicDataSource.class);
//用来装载需要使用的数据源的线程名(即即将调用的数据源线程名变量)
private static final ThreadLocal contextHolder = new ThreadLocal<>();
public DynamicDataSource(DataSource defaultDataSource, Map
5:定义DynamicDataSourceConfig,数据源的配置类
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.spring.cloud.api.util.DynamicDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class DynamicDataSourceConfig {
@Bean
@ConfigurationProperties(prefix = "spring.datasource.druid.center") // application.yml中对应属性的前缀
public DataSource dataSource1() {
return DruidDataSourceBuilder.create().build();
}
@Bean
@ConfigurationProperties(prefix = "spring.datasource.druid.duanguo") // application.yml中对应属性的前缀
public DataSource dataSource2() {
return DruidDataSourceBuilder.create().build();
}
@Bean
@Primary
public DynamicDataSource dataSource() {
Map
6:写一个用来切换数据源的注解类DS
import java.lang.annotation.*;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({
ElementType.METHOD
})
public @interface DS {
//设置默认数据源
String value() default "centerDS";
}
7:写一个AOP类DynamicDataSourceAspect,用来控制数据源切换
import com.spring.cloud.api.annotation.DS;
import com.spring.cloud.api.util.DynamicDataSource;
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.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
@Aspect
@Component
public class DynamicDataSourceAspect {
@Before("@annotation(com.spring.cloud.api.annotation.DS)")
public void beforeSwitchDS(JoinPoint point){
//获得当前访问的class
Class> className = point.getTarget().getClass();
//获得访问的方法名
String methodName = point.getSignature().getName();
//得到方法的参数的类型
Class[] argClass = ((MethodSignature)point.getSignature()).getParameterTypes();
//默认数据源
String dataSource = "centerDS";
try {
// 得到访问的方法对象
Method method = className.getMethod(methodName, argClass);
// 判断是否存在@DS注解
if (method.isAnnotationPresent(DS.class)) {
DS annotation = method.getAnnotation(DS.class);
// 取出注解中的数据源名
dataSource = annotation.value();
}
} catch (Exception e) {
e.printStackTrace();
}
// 切换数据源
DynamicDataSource.setDataSource(dataSource);
}
//接口调用结束,即清除本地数据源线程变量,使其换回到默认数据源
@After("@annotation(com.spring.cloud.api.annotation.DS)")
public void afterSwitchDS(JoinPoint point){
DynamicDataSource.clearDataSource();
}
}
8:关闭springboot自带的数据源配置,导入自定义的数据配置(可以不用,这里这是为了提前加载配置类)
import com.joolun.cloud.center.api.config.DataSourceConfig;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.context.annotation.Import;
@Import({DataSourceConfig.class}) //可以不用写,这里作用只是提前导入此配置
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class}) //关闭springboot自带的数据源配置
public class ApiApplication {
public static void main(String[] args) {
SpringApplication.run(ApiApplication.class, args);
}
}
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.spring.cloud.api.util.DynamicDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class DynamicDataSourceConfig {
@Bean
@ConfigurationProperties(prefix = "spring.datasource.druid.center") // application.yml中对应属性的前缀
public DataSource dataSource1() {
return DruidDataSourceBuilder.create().build();
}
@Bean
@ConfigurationProperties(prefix = "spring.datasource.druid.duanguo") // application.yml中对应属性的前缀
public DataSource dataSource2() {
return DruidDataSourceBuilder.create().build();
}
@Bean
@Primary
public DynamicDataSource dataSource() {
Map
6:写一个用来切换数据源的注解类DS
import java.lang.annotation.*;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({
ElementType.METHOD
})
public @interface DS {
//设置默认数据源
String value() default "centerDS";
}
7:写一个AOP类DynamicDataSourceAspect,用来控制数据源切换
import com.spring.cloud.api.annotation.DS;
import com.spring.cloud.api.util.DynamicDataSource;
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.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
@Aspect
@Component
public class DynamicDataSourceAspect {
@Before("@annotation(com.spring.cloud.api.annotation.DS)")
public void beforeSwitchDS(JoinPoint point){
//获得当前访问的class
Class> className = point.getTarget().getClass();
//获得访问的方法名
String methodName = point.getSignature().getName();
//得到方法的参数的类型
Class[] argClass = ((MethodSignature)point.getSignature()).getParameterTypes();
//默认数据源
String dataSource = "centerDS";
try {
// 得到访问的方法对象
Method method = className.getMethod(methodName, argClass);
// 判断是否存在@DS注解
if (method.isAnnotationPresent(DS.class)) {
DS annotation = method.getAnnotation(DS.class);
// 取出注解中的数据源名
dataSource = annotation.value();
}
} catch (Exception e) {
e.printStackTrace();
}
// 切换数据源
DynamicDataSource.setDataSource(dataSource);
}
//接口调用结束,即清除本地数据源线程变量,使其换回到默认数据源
@After("@annotation(com.spring.cloud.api.annotation.DS)")
public void afterSwitchDS(JoinPoint point){
DynamicDataSource.clearDataSource();
}
}
8:关闭springboot自带的数据源配置,导入自定义的数据配置(可以不用,这里这是为了提前加载配置类)
import com.joolun.cloud.center.api.config.DataSourceConfig;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.context.annotation.Import;
@Import({DataSourceConfig.class}) //可以不用写,这里作用只是提前导入此配置
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class}) //关闭springboot自带的数据源配置
public class ApiApplication {
public static void main(String[] args) {
SpringApplication.run(ApiApplication.class, args);
}
}
import com.spring.cloud.api.annotation.DS;
import com.spring.cloud.api.util.DynamicDataSource;
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.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
@Aspect
@Component
public class DynamicDataSourceAspect {
@Before("@annotation(com.spring.cloud.api.annotation.DS)")
public void beforeSwitchDS(JoinPoint point){
//获得当前访问的class
Class> className = point.getTarget().getClass();
//获得访问的方法名
String methodName = point.getSignature().getName();
//得到方法的参数的类型
Class[] argClass = ((MethodSignature)point.getSignature()).getParameterTypes();
//默认数据源
String dataSource = "centerDS";
try {
// 得到访问的方法对象
Method method = className.getMethod(methodName, argClass);
// 判断是否存在@DS注解
if (method.isAnnotationPresent(DS.class)) {
DS annotation = method.getAnnotation(DS.class);
// 取出注解中的数据源名
dataSource = annotation.value();
}
} catch (Exception e) {
e.printStackTrace();
}
// 切换数据源
DynamicDataSource.setDataSource(dataSource);
}
//接口调用结束,即清除本地数据源线程变量,使其换回到默认数据源
@After("@annotation(com.spring.cloud.api.annotation.DS)")
public void afterSwitchDS(JoinPoint point){
DynamicDataSource.clearDataSource();
}
}
8:关闭springboot自带的数据源配置,导入自定义的数据配置(可以不用,这里这是为了提前加载配置类)
import com.joolun.cloud.center.api.config.DataSourceConfig;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.context.annotation.Import;
@Import({DataSourceConfig.class}) //可以不用写,这里作用只是提前导入此配置
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class}) //关闭springboot自带的数据源配置
public class ApiApplication {
public static void main(String[] args) {
SpringApplication.run(ApiApplication.class, args);
}
}
9:使用
import com.spring.cloud.api.annotation.DS;
import com.spring.cloud.api.util.DynamicDataSource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/hello")
public class HelloController {
@DS("duanguoDS") //不写,则使用默认数据源
@GetMapping("/test")
public String test(){
return DynamicDataSource.getDataSource();
}
@GetMapping("/test1")
public String test1(){
return DynamicDataSource.getDataSource();
}
}



