基于mybatis的多数据源切换,首先要实现需要准备些什么东西呢?
1、pom依赖
2、yml配置参数
3、代码方面
(1)准备好连接的DataSource
(2)aspectj(切面),用于动态切换数据源
pom依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>spring-boot-group</artifactId>
<groupId>com.wolf.boy</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>spring-boot-mybatis-d2</artifactId>
<properties>
<mybatis-plus.version>3.4.2</mybatis-plus.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- springboot-aop包,AOP切面注解,Aspectd等相关注解 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
</dependencies>
</project>
yml参数配置
在yml参数配置里面,配置2个数据库源的配置
server:
port: 7777
spring:
datasource:
db1:
jdbc-url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&serverTimezone=Asia/Shanghai&tinyInt1isBit=false
username: root
password: 123456
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
db2:
jdbc-url: jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&serverTimezone=Asia/Shanghai&tinyInt1isBit=false
username: root
password: 123456
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
代码
DataSourceConfig 数据源配置
package com.wolf.boy.config;
/**
* Created by user on 2021/6/7.
*/
import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
import com.wolf.boy.config.holder.DynamicDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
/**
* 多数据源配置类
*/
@Configuration
public class DataSourceConfig {
//数据源1
@Bean(name = "datasource1")
@ConfigurationProperties(prefix = "spring.datasource.db1") // application.yml中对应属性的前缀
public DataSource dataSource1() {
return DataSourceBuilder.create().build();
}
//数据源2
@Bean(name = "datasource2")
@ConfigurationProperties(prefix = "spring.datasource.db2") // application.yml中对应属性的前缀
public DataSource dataSource2() {
return DataSourceBuilder.create().build();
}
//====以上部分,先准备好2个传统的数据源====
/**
* 动态数据源: 通过AOP在不同数据源之间动态切换
*
* @return
*/
@Primary
@Bean(name = "dynamicDataSource")
public DataSource dynamicDataSource() {
//自定义动态数据源类#定义一个动态数据源:继承AbstractRoutingDataSource 抽象类,并重写determineCurrentLookupKey()方法
DynamicDataSource dynamicDataSource = new DynamicDataSource();
// 默认数据源
dynamicDataSource.setDefaultTargetDataSource(dataSource1());
//配置多数据源(这个信息在选取datasource的时候,被determineCurrentLookupKey方法调用)
Map<Object, Object> dsMap = new HashMap();
dsMap.put("datasource1", dataSource1());
dsMap.put("datasource2", dataSource2());
dynamicDataSource.setTargetDataSources(dsMap);
return dynamicDataSource;
}
/* 配置@Transactional注解事物
*
* @return
*/
@Bean
public PlatformTransactionManager transactionManager() {
//把动态数据源给到事务管理器,进行事务管理
return new DataSourceTransactionManager(dynamicDataSource());
}
}
DynamicDataSource 自定义的动态数据源类。
主要还是继承AbstractRoutingDataSource并重写了determineCurrentLookupKey方法,用来动态获取dynamicDataSource数据源开始设置的
//配置多数据源(这个信息在选取datasource的时候,被determineCurrentLookupKey方法调用)
Map<Object, Object> dsMap = new HashMap();
dsMap.put("datasource1", dataSource1());
dsMap.put("datasource2", dataSource2());
这2个参数。这个里面装的就是实实在在最终需要使用的数据源;
package com.wolf.boy.config.holder;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
/**
* 定义一个动态数据源:继承AbstractRoutingDataSource 抽象类,并重写determineCurrentLookupKey()方法
*/
public class DynamicDataSource extends AbstractRoutingDataSource {
@Override
protected Object determineCurrentLookupKey() {
System.out.println("数据源为" + DataSourceContextHolder.getDB());
return DataSourceContextHolder.getDB();
}
}
DataSourceContextHolder 数据源上下文处理类
此类主要的作用就是通过ThreadLocal维护当前处理线程上下文,选择的数据源,然后在上面DynamicDataSource动态数据源determineCurrentLookupKey的方法选择数据源的时候一起融合使用
package com.wolf.boy.config.holder;
/**
*/
public class DataSourceContextHolder {
/**
* 默认数据源
*/
public static final String DEFAULT_DS = "datasource1";
private static final ThreadLocal<String> chooseDataSourceName = new ThreadLocal<>();
// 设置数据源名
public static void setDB(String dbType) {
System.out.println("切换到{" + dbType + "}数据源");
chooseDataSourceName.set(dbType);
}
// 获取数据源名
public static String getDB() {
return (chooseDataSourceName.get());
}
// 清除数据源名
public static void clearDB() {
chooseDataSourceName.remove();
}
}
DynamicDataSourceAspect 自定义基于aspect的切面类
关键:
1、如果要实现切面需要加上@Aspect注解
2、切面类必须加载到spring容器中,所以需要加上@Component注解
package com.wolf.boy.config.aspect;
/**
* Created by user on 2021/6/7.
*/
import com.wolf.boy.annotation.DbChoose;
import com.wolf.boy.config.holder.DataSourceContextHolder;
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.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
/**
* 自定义注解 + AOP的方式实现数据源动态切换。
*/
@Aspect //切点类
@Component
public class DynamicDataSourceAspect {
@Pointcut("@annotation(com.wolf.boy.annotation.DbChoose)")
public void pointCut() {
}
/**
* 在之前干的事情
*
* @param point
*/
@Before("pointCut()")
public void beforeSwitchDS(JoinPoint point) {
//获得当前访问的class
Class<?> className = point.getTarget().getClass();
//获得访问的方法名
String methodName = point.getSignature().getName();
//得到方法的参数的类型
Class[] argClass = ((MethodSignature) point.getSignature()).getParameterTypes();
String dataSource = DataSourceContextHolder.DEFAULT_DS;
try {
// 得到访问的方法对象
Method method = className.getMethod(methodName, argClass);
// 判断是否存在@DS注解
if (method.isAnnotationPresent(DbChoose.class)) {
DbChoose annotation = method.getAnnotation(DbChoose.class);
// 取出注解中的数据源名
dataSource = annotation.value();
}
} catch (Exception e) {
e.printStackTrace();
}
// 切换数据源
DataSourceContextHolder.setDB(dataSource);
System.out.println("【AOP切点--Before】设置数据源:" + dataSource);
}
@After("pointCut()")
public void afterSwitchDS(JoinPoint point) {
System.out.println("【AOP切点--After】操作干完了,释放当前选择的数据源");
DataSourceContextHolder.clearDB();
}
}
DbChoose 自定义注解
用于标记在需要使用的数据源的方法上,然后设置数据源的名称,通过aspect切面来获取切面类上面的注解信息,然后拿到value=数据源名称,然后通过上面的
DataSourceContextHolder 数据源上下文处理;这样就给当前执行线程把当前需要使用的数据源放进去了
package com.wolf.boy.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DbChoose {
String value() default "";
}
其他实现代码(为了检测结果)
- UserController 请求入口
package com.wolf.boy.controller;
import com.wolf.boy.annotation.DbChoose;
import com.wolf.boy.entity.User;
import com.wolf.boy.service.IUserService;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
*/
@RestController
@RequestMapping("/user/")
@AllArgsConstructor
public class UserController {
private final IUserService userService;
@GetMapping("goD1")
@DbChoose("datasource1")
public User saveD1() {
User user = new User();
user.setAge(18);
user.setName("张大仙去数据库01");
userService.save(user);
return user;
}
@GetMapping("goD2")
@DbChoose("datasource2")
public User saveD2() {
User user = new User();
user.setAge(20);
user.setName("理大仙去数据库02");
userService.save(user);
return user;
}
}
- User 实体类
package com.wolf.boy.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
*/
@Data
@TableName("user_t")
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
@TableId(value = "id", type = IdType.AUTO)
private Integer id;
/**
* 名称
*/
private String name;
/**
* 年龄
*/
private int age;
}
- Mapper接口类
package com.wolf.boy.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.wolf.boy.entity.User;
/**
*/
public interface UserMapper extends BaseMapper<User> {
}
- service接口及实现类
package com.wolf.boy.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.wolf.boy.entity.User;
import com.wolf.boy.mapper.UserMapper;
import com.wolf.boy.service.IUserService;
import org.springframework.stereotype.Service;
/**
*/
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
}
package com.wolf.boy.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.wolf.boy.entity.User;
/**
*/
public interface IUserService extends IService<User> {
}
- 程序主启动类
package com.wolf.boy;
import cn.hutool.json.JSONUtil;
import com.wolf.boy.entity.User;
import com.wolf.boy.service.IUserService;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.context.ConfigurableApplicationContext;
import java.util.List;
/**
*/
//要去掉springboot底层的自动配置数据源
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
@MapperScan("com.wolf.boy.mapper")
public class MainRun {
public static void main(String[] args) {
ConfigurableApplicationContext run = SpringApplication.run(MainRun.class, args);
}
}
测试
浏览器
输入:http://localhost:7777/user/goD1
输入:http://localhost:7777/user/goD2
然后在看数据库
test表
test01表
分别使用不用的数据源,插入了数据。
程序打印日志:
【AOP切点--Before】设置数据源:datasource2
数据源为datasource2
【AOP切点--After】操作干完了,释放当前选择的数据源
可以看到
- 通过切面的before设置了数据源,数据源是通过要进行切面的类的方法上面的注解读出来的
- 然后数据源选取上,通过步骤1设置的数据源进行读取初始化已设置的datasoucre
- 使用完毕以后,需要释放threadlocal存储的信息