手把手教你springboot优雅的实现多数据源，看这一篇就够了

Spring boot提供了AbstractRoutingDataSource 根据用户定义的规则选择当前的数据源，这样我们可以在执行查询之前，设置使用的数据源。实现可动态路由的数据源，在每次数据库查询操作前执行。它的抽象方法 determineCurrentLookupKey() 决定使用哪个数据源。

具体实现

数据准备

所需依赖

<!--        aop-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.60</version>
        </dependency>

        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.oracle.database.nls/orai18n -->
        <!--oracle 必备 ， 用于处理oracle中文乱码 ， 可以删除试试代码运行情况，-->
        <dependency>
            <groupId>com.oracle.database.nls</groupId>
            <artifactId>orai18n</artifactId>
            <version>19.7.0.0</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>

        <!--mybatis-plus依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--模板引擎-->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.3</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.3.1</version>
        </dependency>

        <dependency>
            <groupId>com.oracle.database.jdbc</groupId>
            <artifactId>ojdbc8</artifactId>
            <version>12.2.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter-test</artifactId>
            <version>2.3.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

配置数据源

***********************需要改成自己的数据库 账号以及密码**************************************

spring:
  jpa:
    show-sql: true
  datasource:
    druid:
      # 主库数据源
      first:
        driverClassName: oracle.jdbc.driver.OracleDriver
        url: jdbc:oracle:thin:@10.10.0.10:1521:hyd**
        username: *****
        password: *****

        # 从库数据源
      second:
        driverClassName: com.microsoft.sqlserver.jdbc.SQLServerDriver
        url: jdbc:sqlserver://10.10.0.9;Database=ecolo**
        username: *****
        password: *****

# MyBatis
mybatis-plus:
  mapper-locations: classpath:mapper/*Mapper.xml
  type-aliases-package: com.example.fund.entity

这里添加两个数据源，一个是oracle，另一个sqlserver。

ThreadLocal存放数据源
采用ThreadLocal存放数据源，因为ThreadLocal是线程安全类。它类似于map，存储key-value形式的数据，但只能存储一个，当存储两个时，第二个会把第一个覆盖掉。ThreadLocal是线程本地存储，在每个线程中都创建了一个ThreadLocal对象，每个线程可以访问自己内部ThreadLocalMap对象内的value。
 

/**
 * @Author: krist
 * @Description:线程安全类，存放数据源
 */
public class DatabaseContextHolder {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static final String FIRST_DS = "first_datasource";
    public static final String SECOND_DS = "second_datasource";

    /**
     * 放入
     * @param type
     */
    public static void setDataBase(String type){
        contextHolder.set(type);
    }

    /**
     * 获取
     */
    public static String getDataBase(){
        return contextHolder.get();
    }

    /**
     * 清空
     */
    public static void chearDataSource(){
        contextHolder.remove();
    }
}

配置多数据源

***************************************注意 这里面我用的是Mybatis******************************

所以得改成

MybatisSqlSessionFactoryBean fb = new MybatisSqlSessionFactoryBean();

 我之前看的文章就很坑 找不读mybatis里面的文件就是用错了

如果出现找不到XML 那就是下面的路径不对

fb.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));

import com.alibaba.druid.filter.Filter;
import com.alibaba.druid.pool.DruidDataSource;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.annotation.Qualifier;
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 org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;


/**
 * @Author: krist
 * @Description:配置多数据源
 */
@Configuration
public class DynamicDataSourceConfig {
    /**
     * @Primary 该注解表示在同一个接口有多个实现类可以注入的时候，默认选择哪一个
     * @param statFilter
     * @return
     * @throws SQLException
     */
    @Primary
    @ConfigurationProperties(prefix="spring.datasource.druid.first")
    @Bean(name = "first_datasource")
    public javax.sql.DataSource first(Filter statFilter) throws SQLException {
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }
    @ConfigurationProperties(prefix="spring.datasource.druid.second")
    @Bean(name = "second_datasource")
    public javax.sql.DataSource second(Filter statFilter) throws SQLException {
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }

    /**
     * @Qualifier 根据名称进行注入，通常是在具有相同的多个类型的实例的一个注入（例如有多个DataSource类型的实例）
     * @param dataSource1    数据源1
     * @param dataSource2   数据源2
     * @return
     */
    @Bean(name = "dynamicDataSource")
    public DynamicDataSource dataSource(@Qualifier("first_datasource") javax.sql.DataSource dataSource1,
                                        @Qualifier("second_datasource") DataSource dataSource2){
        Map<Object, Object> dataSourceMap = new HashMap<>(2);
        dataSourceMap.put(DatabaseContextHolder.FIRST_DS,dataSource1);
        dataSourceMap.put(DatabaseContextHolder.SECOND_DS,dataSource2);

        DynamicDataSource dynamicDataSource=new DynamicDataSource();
        //该方法是AbstractRoutingDataSource的方法
        dynamicDataSource.setTargetDataSources(dataSourceMap);
        //根据实际需求，指定默认操作的库
        dynamicDataSource.setDefaultTargetDataSource(dataSource1);
        return dynamicDataSource;
    }

    /**
     * 根据数据源创建SqlSessionFactory
     * @param ds
     * @return
     * @throws Exception
     */
    @Bean
    public SqlSessionFactory sqlSessionFactory(DynamicDataSource ds) throws Exception {
//        SqlSessionFactoryBean fb = new SqlSessionFactoryBean();
        MybatisSqlSessionFactoryBean fb = new MybatisSqlSessionFactoryBean();
        //指定数据源(这个必须有，否则报错)
        fb.setDataSource(ds);
        fb.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));

        return fb.getObject();
    }

注意：上面指定了setDefaultTargetDataSource默认操作数据库为first_datasource，当方法没有指定数据源会默认操作test1数据库。

继承AbstractRoutingDataSource

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * @Author: krist
 * @Description:扩展 Spring 的 AbstractRoutingDataSource 抽象类，重写 determineCurrentLookupKey 方法
 * determineCurrentLookupKey() 方法决定使用哪个数据源
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DatabaseContextHolder.getDataBase();
    }
}

自定义注解+aop实现指定数据源

import java.lang.annotation.ElementType;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.*;

/**
 * @Author: krist
 * @Description:自定义数据源注解，用于指定数据源
 */

//表示注解的生命周期是运行时也存在 运行时需要动态获取☞
@Retention(RetentionPolicy.RUNTIME)
//表示注解可以在什么上面
@Target({ElementType.METHOD})
public @interface DataSource {
    String value() default "first_datasource";
}

import com.example.fund.config.datasource.DataSource;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @Author: krist
 * @Description:切面处理类
 * 当有注解时，按照指定的数据源进行操作
 * 没有注解时，按照默认的数据源进行操作
 * @Aspect 把当前类标识为一个切面供容器读取
 */
@Aspect
@Component
public class DataSourceAspect implements Ordered {
    /**
     * 指定切入点
     */
    @Pointcut("@annotation(com.example.fund.config.datasource.DataSource)")
    public void dataSourcePointCut(){

    }

    @After("dataSourcePointCut()")
    public void after(){
        DatabaseContextHolder.chearDataSource();
    }
    /**
     * 环绕通知，包含了五种通知类型
     * @return
     */
    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point){
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method=signature.getMethod();
        //默认数据源
        String defaultDataSource= DatabaseContextHolder.FIRST_DS;
        //获取该注解
        DataSource dataSource=method.getAnnotation(DataSource.class);
        //存在注解，直接切换该注解对应的数据源
        if(dataSource!=null){
            defaultDataSource=dataSource.value();
        }
        //切换数据源
        DatabaseContextHolder.setDataBase(defaultDataSource);
        //继续执行方法
        Object result=null;
        try {
            result=point.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        } finally {
            //最后清除数据源
            DatabaseContextHolder.chearDataSource();
        }
        return result;
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

测试

测试1 默认查询

写一个简单的查询数据接口  另一个写了一个插入

    @GetMapping("/test1")
    @ResponseBody
    public AjaxResult selectAll() {
        List<TPayMymYxt> tPayMymYxts = this.tPayMymYxtService.selectTPayMymYxtList(new TPayMymYxt());
        return AjaxResult.success(tPayMymYxts);
    }

    @GetMapping("/test2")
    @ResponseBody
    @DataSource(value = "second_datasource")
    public AjaxResult getTestCount1() {
        UfSkrlbyl ufSkrlbyl = new UfSkrlbyl();
        ufSkrlbyl.setRequestid(333);
        int materialCount = ufSkrlbylService.insert(ufSkrlbyl);
        return AjaxResult.success(materialCount);
    }

查询走的xml 配置了查询sql

@Service
public class TPayMymYxtServiceImpl implements TPayMymYxtService {
    @Autowired
    private TPayMymYxtMapper tPayMymYxtMapper;

    /**
     * 查询所有数据
     *
     * @param tPayMymYxt 筛选条件
     * @return 查询结果
     */
    @Override
    public List<TPayMymYxt> selectTPayMymYxtList(TPayMymYxt tPayMymYxt) {
        return this.tPayMymYxtMapper.selectTPayMymYxtList(tPayMymYxt);
    }

插入走的BaseMapper

@Service
public class UfSkrlbylServiceImpl implements UfSkrlbylService {

    @Resource
    private UfSkrlbylMapper ufSkrlbylMapper;


    /**
     * 新增数据
     *
     * @param ufSkrlbyl 实例对象
     * @return 实例对象
     */
    @Override
    @DataSource(value = "second_datasource")
    public int insert(UfSkrlbyl ufSkrlbyl) {
        return ufSkrlbylMapper.insert(ufSkrlbyl);
    }

*****************@DataSource(value = "second_datasource")*****************************

默认数据库不用写  备用数据库需要在方法是注解

测试结果

1 test1 查询

2 test2 插入

结论：在service层增加注解，可以对方法进行指定数据源操作。
至此，多数据源操作就完成了。