springboot整合mybatis（使用的baomidou的mybatis-plus-boot-starter）实现多数据源切换

 

基于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】操作干完了，释放当前选择的数据源

可以看到

1. 通过切面的before设置了数据源，数据源是通过要进行切面的类的方法上面的注解读出来的
2. 然后数据源选取上，通过步骤1设置的数据源进行读取初始化已设置的datasoucre
3. 使用完毕以后，需要释放threadlocal存储的信息