SpringBoot利用自定义注解实现多数据源

自定义多数据源

SpringBoot利用自定义注解实现多数据源，前置知识：注解、Aop、SpringBoot整合Mybaits

1、搭建工程

创建一个SpringBoot工程，并引入依赖

	<dependencies>
	<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<!-- 解析多数据源注解 -->
	<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-aop</artifactId>
	</dependency>
	<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-starter</artifactId>
	<version>2.3.0</version>
	</dependency>
	<dependency>
	<groupId>com.mysql</groupId>
	<artifactId>mysql-connector-j</artifactId>
	<scope>runtime</scope>
	</dependency>
	<!-- https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter -->
	<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid-spring-boot-starter</artifactId>
	<version>1.2.18</version>
	</dependency>
	<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-test</artifactId>
	<scope>test</scope>
	</dependency>
	</dependencies>

2、定义多数据源注解

	/**
	* 1、定义多数据源注解
	* @author ss_419
	* TODO 这个注解将来可以加在service类上或者方法上，通过value属性来指定类或者方法应该使用那个数据源
	*/
	@Retention(RetentionPolicy.RUNTIME)
	@Target({ElementType.TYPE, ElementType.METHOD})
	public @interface DataSource {
	String value() default DataSourceType.DEFAULT_DS_NAME;
	}

3、创建一个多数据上下文对象

这个类用来存储当前线程所使用的数据源名称

	/**
	* TODO 这个类用来存储当前线程所使用的数据源名称
	*
	* @author ss_419
	* @version 1.0
	* @date 2023/5/21 09:21
	*/
	public class DynamicDataSourceContextHolder {
	private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();
	public static void setDataSourceType(String dataSourceType) {
	CONTEXT_HOLDER.set(dataSourceType);
	}
	public static String getDataSourceType() {
	return CONTEXT_HOLDER.get();
	}
	public static void clearDataSourceType() {
	CONTEXT_HOLDER.remove();
	}
	}

4、配置aop

• @annotation(org.pp.dd.annotation.DataSource) 如果有@DataSource注解就给拦截下来

• @within(org.pp.dd.annotation.DataSource) 表示类上有@DataSource注解就将类中的方法给拦截下来

	/**
	* TODO
	*
	* @author ss_419
	* @version 1.0
	* @date 2023/5/21 09:42
	*/
	@Component
	@Aspect
	@Order(11)
	public class DataSourceAspect {
	/**
	* 定义切点
	*
	* @annotation(org.pp.dd.annotation.DataSource) 如果有@DataSource注解就给拦截下来
	* @within(org.pp.dd.annotation.DataSource) 表示类上有@DataSource注解就将类中的方法给拦截下来
	*/
	@Pointcut("@annotation(org.pp.dd.annotation.DataSource) || @within(org.pp.dd.annotation.DataSource)")
	public void pc() {
	}
	/**
	* 环绕通知
	*
	* @param pjp
	* @return
	*/
	@Around("pc()")
	public Object around(ProceedingJoinPoint pjp) {
	// 获取方法上的有效注解
	DataSource dataSource = getDataSource(pjp);
	if (dataSource != null) {
	// 获取注解中数据源的名称
	String value = dataSource.value();
	DynamicDataSourceContextHolder.setDataSourceType(value);
	}
	try {
	return pjp.proceed();
	} catch (Throwable e) {
	throw new RuntimeException(e);
	} finally {
	DynamicDataSourceContextHolder.clearDataSourceType();
	}
	}
	private DataSource getDataSource(ProceedingJoinPoint pjp) {
	MethodSignature signature = (MethodSignature) pjp.getSignature();
	// 获取方法上的注解
	DataSource annotation = AnnotationUtils.findAnnotation(signature.getMethod(), DataSource.class);
	if (annotation != null) {
	// 说明方法上有注解
	return annotation;
	}
	return (DataSource) AnnotationUtils.findAnnotation(signature.getDeclaringType(), DataSource.class);
	}
	}

5、读取参数DruidProperties

	/**
	* TODO 读取数据源
	*
	* @author ss_419
	* @version 1.0
	* @date 2023/5/21 10:20
	*/
	@ConfigurationProperties(prefix = "spring.datasource")
	public class DruidProperties {
	private String type;
	private String driverClassName;
	private Map<String, Map<String ,String>> ds;
	private Integer initialSize;
	private Integer minIdle;
	private Integer maxActive;
	private Integer maxWait;
	/**
	* 在这个方法中设置公共属性
	* @param dataSource
	* @return
	*/
	public DataSource dataSource(DruidDataSource dataSource){
	dataSource.setInitialSize(initialSize);
	dataSource.setMinIdle(minIdle);
	dataSource.setMaxActive(maxActive);
	dataSource.setMaxWait(maxWait);
	return dataSource;
	}
	public String getType() {
	return type;
	}
	public void setType(String type) {
	this.type = type;
	}
	public String getDriverClassName() {
	return driverClassName;
	}
	public void setDriverClassName(String driverClassName) {
	this.driverClassName = driverClassName;
	}
	public Map<String, Map<String, String>> getDs() {
	return ds;
	}
	public void setDs(Map<String, Map<String, String>> ds) {
	this.ds = ds;
	}
	public Integer getInitialSize() {
	return initialSize;
	}
	public void setInitialSize(Integer initialSize) {
	this.initialSize = initialSize;
	}
	public Integer getMinIdle() {
	return minIdle;
	}
	public void setMinIdle(Integer minIdle) {
	this.minIdle = minIdle;
	}
	public Integer getMaxActive() {
	return maxActive;
	}
	public void setMaxActive(Integer maxActive) {
	this.maxActive = maxActive;
	}
	public Integer getMaxWait() {
	return maxWait;
	}
	public void setMaxWait(Integer maxWait) {
	this.maxWait = maxWait;
	}
	}

6、加载数据源LoadDataSource

	/**
	* TODO 加载数据源
	*
	* @author ss_419
	* @version 1.0
	* @date 2023/5/21 10:30
	*/
	@Component
	@EnableConfigurationProperties(DruidProperties.class)
	public class LoadDataSource {
	@Autowired
	DruidProperties druidProperties;
	public Map<String, DataSource> loadAllDataSource() {
	Map<String, DataSource> map = new HashMap<>();
	Map<String, Map<String, String>> ds = druidProperties.getDs();
	try {
	Set<String> keySet = ds.keySet();
	for (String key : keySet) {
	map.put(key, druidProperties.dataSource((DruidDataSource) DruidDataSourceFactory.createDataSource(ds.get(key))));
	}
	} catch (Exception e) {
	throw new RuntimeException(e);
	}
	return map;
	}
	}

7、定义数据源管理器

当系统需要调用数据源的时候，数据源以key-value存起来，当需要数据源时调用determineCurrentLookupKey()方法来获取数据源。
由于本人实力原因，解答不了大家这里的疑惑。大致功能 通过修改本地线程的值，来实现数据源的切换。

	/**
	* TODO 设置数据源
	* 当系统需要调用数据源的时候，数据源以key-value存起来，当需要数据源时调用determineCurrentLookupKey()方法
	* @author ss_419
	* @version 1.0
	* @date 2023/5/21 10:47
	*/
	@Component
	public class DynamicDataSource extends AbstractRoutingDataSource {
	public DynamicDataSource(LoadDataSource loadDataSource) {
	//1、设置所有的数据源
	Map<String, DataSource> allDs = loadDataSource.loadAllDataSource();
	super.setTargetDataSources(new HashMap<>(allDs));
	//2、设置默认数据源
	super.setDefaultTargetDataSource(allDs.get(DataSourceType.DEFAULT_DS_NAME));
	super.afterPropertiesSet();
	}
	/**
	* 这个方法用来返回数据源名称，当系统需要获取数据源的时候会自动调用该方法获取数据源名称
	* @return
	*/
	@Override
	protected Object determineCurrentLookupKey() {
	return DynamicDataSourceContextHolder.getDataSourceType();
	}
	}

定一个用于存储数据库类型的接口，这个接口类似于枚举类：

	/**
	* TODO
	*
	* @author ss_419
	* @version 1.0
	* @date 2023/5/21 10:54
	*/
	public interface DataSourceType {
	String DEFAULT_DS_NAME = "master";
	String DS_SESSION_KEY = "ds_session_key";
	}

8、测试

创建User实体：

	/**
	* TODO
	*
	* @author ss_419
	* @version 1.0
	* @date 2023/5/21 11:15
	*/
	public class User {
	private Integer id;
	private String username;
	private String password;
	@Override
	public String toString() {
	return "User{" +
	"id=" + id +
	", username='" + username + '\'' +
	", password='" + password + '\'' +
	'}';
	}
	public Integer getId() {
	return id;
	}
	public void setId(Integer id) {
	this.id = id;
	}
	public String getUsername() {
	return username;
	}
	public void setUsername(String username) {
	this.username = username;
	}
	public String getPassword() {
	return password;
	}
	public void setPassword(String password) {
	this.password = password;
	}
	}

创建UserService：

	@Service
	// 在类上加注解的效果，会使该类的所有方法都切入到新的数据源中
	//@DataSource
	public class UserService {
	@Autowired
	UserMapper userMapper;
	// 在方法上加注解的效果，只会让指定的方法切入到另一个数据源中
	//@DataSource("slave")
	public List<User> findUsers(){
	return userMapper.findAllUsers();
	}
	}

创建UserMapper：

	@Mapper
	public interface UserMapper {
	@Select("SELECT * FROM user")
	List<User> findAllUsers();
	}

测试类：

	@SpringBootTest
	class DynamicDatasourcesApplicationTests {
	@Autowired
	UserService userService;
	@Test
	void contextLoads() {
	List<User> users = userService.findUsers();
	users.stream()
	.forEach(user -> System.out.println(user));
	}
	}

默认选择主库的数据源：

执行结果如下：

在Service上加上注解，指定数据源为从库：
 

执行结果如下：