注解方式切换数据源

1 注解类

@Target ({ ElementType.METHOD, ElementType.TYPE }) //注解作用的位置,ElemenetType.TYPE:类，接口（包括注解类型）或enum声明
@Retention(RetentionPolicy.RUNTIME) //注解的生命周期，表示注解会被保留到什么阶段，可以选择编译阶段、类加载阶段，或运行阶段
@Documented //注解信息会被添加到Java文档中
@Inherited //有该注解的类的子类会继承该注解
public @interface DataSource
{
    /**
     * 切换数据源名称
     */
    public DataSourceType value() default DataSourceType.SLAVE;
    //default DataSourceType.MASTER
}

DataSourceType是自定义的枚举类

package com.kun.demo.enums;

public enum DataSourceType {
MASTER,
SLAVE
}

2 写一个切面类给注解配置环绕通知

package com.kun.demo.aspect;

import com.kun.demo.anno.DataSource;
import com.kun.demo.util.DynamicDataSource;
import com.kun.demo.util.MultipleDatasource;
import com.sun.org.apache.regexp.internal.RE;
import org.aspectj.lang.ProceedingJoinPoint;
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.annotation.AnnotationUtils;
import org.springframework.stereotype.Component;

import java.util.Objects;

/**
 * @PackageName:com.kun.demo.aspect
 * @Description:
 * @Author 杨坤
 * @Date:2021/5/14 17:43
 */
@Aspect
@Component
public class Datasource_AroundAspect {
    @Pointcut("@annotation(com.kun.demo.anno.DataSource) || @within(com.kun.demo.anno.DataSource)")//@within能让注解加载类上也生效
    public void pointcut(){}
    @Around("pointcut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        DataSource dataSource = getDataSource(point);//DataSource是注解

        if (null != dataSource)
        {
            System.out.println("dataSource.value().name()"+dataSource.value().name());
            MultipleDatasource.setDataSourceType(dataSource.value().name());
        }

        try
        {
            return point.proceed();
        }
        finally
        {
            // 销毁数据源 在执行方法之后
            MultipleDatasource.cleanDataSourceType();
        }
    }
    /**
     * 获取需要切换的数据源
     */
    public DataSource getDataSource(ProceedingJoinPoint point)
    {
        MethodSignature signature = (MethodSignature) point.getSignature();

        DataSource dataSource = AnnotationUtils.findAnnotation(signature.getMethod(), DataSource.class);//获取方法上的注解
        if (Objects.nonNull(dataSource))
        {
            return dataSource;
        }
 return AnnotationUtils.findAnnotation(signature.getDeclaringType(), DataSource.class);//如果方法上没加注解，就获取类上的注解
    }
}
3 连接池的配置文件

# 数据源配置
spring:
    datasource:
#        type: com.alibaba.druid.pool.DruidDataSource
#        driverClassName: com.mysql.cj.jdbc.Driver
        druid:
            # 主库数据源
            master:
                url: jdbc:mysql://192.168.10.99:3306/vue?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
                username: root
                password: root
            # 从库数据源
            slave:
                # 从数据源开关/默认关闭
                enabled: false
                url: jdbc:mysql://192.168.10.99:3306/vue_slave?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
                username: root
                password: root
            # 初始连接数
            initialSize: 5
            # 最小连接池数量
            minIdle: 10
            # 最大连接池数量
            maxActive: 20
            # 配置获取连接等待超时的时间
            maxWait: 60000
            # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
            timeBetweenEvictionRunsMillis: 60000
            # 配置一个连接在池中最小生存的时间，单位是毫秒
            minEvictableIdleTimeMillis: 300000
            # 配置一个连接在池中最大生存的时间，单位是毫秒
            maxEvictableIdleTimeMillis: 900000
            # 配置检测连接是否有效
            validationQuery: SELECT 1 FROM DUAL
            testWhileIdle: true
            testOnBorrow: false
            testOnReturn: false
            webStatFilter:
                enabled: true
            statViewServlet:
                enabled: true
                # 设置白名单，不填则允许所有访问
                allow:
                url-pattern: /druid/*
                # 控制台管理用户名和密码
                login-username: admin
                login-password: 123456
            filter:
                stat:
                    enabled: true
                    # 慢SQL记录
                    log-slow-sql: true
                    slow-sql-millis: 1000
                    merge-sql: true
                wall:
                    config:
                        multi-statement-allow: true

记得在application.yml中添加进来连接池的配置文件

4 编写连接池的配置文件

package com.kun.demo.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

/**
 * druid 配置属性
 *
 * @author ruoyi
 */
@Configuration //这个注解包括了@component注解 ,DruidConfig会交给容器管理
public class DruidConfig
{
    @Value("${spring.datasource.druid.initialSize}")
    private int initialSize;

    @Value("${spring.datasource.druid.minIdle}")
    private int minIdle;

    @Value("${spring.datasource.druid.maxActive}")
    private int maxActive;

    @Value("${spring.datasource.druid.maxWait}")
    private int maxWait;

    @Value("${spring.datasource.druid.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;

    @Value("${spring.datasource.druid.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.maxEvictableIdleTimeMillis}")
    private int maxEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.validationQuery}")
    private String validationQuery;

    @Value("${spring.datasource.druid.testWhileIdle}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.druid.testOnBorrow}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.druid.testOnReturn}")
    private boolean testOnReturn;

    public DruidDataSource dataSource(DruidDataSource datasource)
    {
        /** 配置初始化大小、最小、最大 */
        datasource.setInitialSize(initialSize);
        datasource.setMaxActive(maxActive);
        datasource.setMinIdle(minIdle);
        /** 配置获取连接等待超时的时间 */
        datasource.setMaxWait(maxWait);

        /** 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 */
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);

        /** 配置一个连接在池中最小、最大生存的时间，单位是毫秒 */
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);

        /**
         * 用来检测连接是否有效的sql，要求是一个查询语句，常用select 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。
         */
        datasource.setValidationQuery(validationQuery);
        /** 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 */
        datasource.setTestWhileIdle(testWhileIdle);
        /** 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnBorrow(testOnBorrow);
        /** 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnReturn(testOnReturn);
        return datasource;
    }
}

5 编写mybatis配置文件

package com.kun.demo.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.kun.demo.enums.DataSourceType;
import com.kun.demo.util.DynamicDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
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.core.env.Environment;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import javax.sql.DataSource;
import java.util.*;

/**
 * @PackageName:com.kun.demo.config
 * @Description:
 * @Author 杨坤
 * @Date:2021/5/17 16:40
 */
@Configuration
public class MybatisConfig {
    @Autowired
    private Environment env;
@Bean
@ConfigurationProperties("spring.datasource.druid.master") //为了把spring.datasource.druid.master的属性给return对象赋值
public DataSource masterDatasource(DruidConfig druidConfig){//@Bean方法的参数默认用@autowire方式注入
    DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
    return druidConfig.dataSource(dataSource);//创建Druidconfig对象是为了把配置文件的公共属性给return对象赋值
}
    @Bean
    @ConfigurationProperties("spring.datasource.druid.slave") //为了把spring.datasource.druid.slave的属性给return对象赋值
    //@ConditionalOnProperty(prefix = "spring.datasource.druid.slave", name = "enabled", havingValue = "true")//配置文件中enabled这个值如果是true则Configuration注解生效
    public DataSource slaveDatasource(DruidConfig druidConfig){//@Bean方法的参数默认用@autowire方式注入
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        return druidConfig.dataSource(dataSource);
    }
    @Bean(name = "dynamicDataSource")
    public DynamicDataSource dataSource(@Qualifier("masterDatasource") DataSource testDatasource,@Qualifier("slaveDatasource") DataSource devDatasource)
    {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceType.MASTER.name(), testDatasource);
        targetDataSources.put(DataSourceType.SLAVE.name(), devDatasource);
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(testDatasource);
        return dynamicDataSource;
    }
    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dataSource) throws Exception
    {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/*.xml"));
        return sessionFactory.getObject();
    }


}
6 编写multifulDatasource用于给threadlocal类设置数据源

package com.kun.demo.util;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
/**
 * @PackageName:com.kun.demo.util
 * @Description:
 * @Author 杨坤
 * @Date:2021/5/17 11:40
 */
public class MultipleDatasource  {
private static final ThreadLocal<String> dataSourceKey = new InheritableThreadLocal<String>();
public static final Logger log = LoggerFactory.getLogger(MultipleDatasource.class);
public static void setDataSourceType(String type){
    log.info("切换到数据源: "+type);
    dataSourceKey.set(type);
}
public static String getDataSourceType(){
    return dataSourceKey.get();
}
public static void cleanDataSourceType(){
    dataSourceKey.remove();
}
}

7 编写DynamicDatasource用于选择数据源

package com.kun.demo.util;

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

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

/**
 * @PackageName:com.kun.demo.util
 * @Description:
 * @Author 杨坤
 * @Date:2021/5/18 15:45
 */
public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return MultipleDatasource.getDataSourceType();
    }
}

启动类上加

@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })//使用自定义的数据源
@MapperScan("com.kun.demo.mapper")//mapper接口扫描

用法:在service层的类或方法上加@DataSource(DataSourceType.MASTER) 就可以切换到master数据源,不加注解会mybatis配置文件配置的默认数据源