Springboot Mybatis结合AOP做多数据源切换

短命女 2023-05-22 06:34 11阅读 0赞

鉴于最近被网上博客的教程不全，决定自己写一篇Springboot结合AOP做多数据源切换，防止大家遇到各种问题浪费时间，同时也把遇到的问题总结，供各位参考！

# 1 Maven依赖 #

加入aop和阿里连接池的相关依赖

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjrt</artifactId>
                <version>1.8.9</version>
            </dependency>
    
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.8.9</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.21</version>
            </dependency>

注意：

springboot是2.0以上版本！

aspectjrt版本如果是1.6.11或以下版本可能会导致springboot启动时异常！

# 2 YML配置 #

server:
      port: 8122
      servlet:
        context-path: /api
    spring:
      # 开启aop
      aop:
        auto: true
    
      # 数据库连接配置
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        druid:
            master:
              jdbc-url: jdbc:mysql://10.10.28.17:3306/test1?useUnicode=true&characterEncoding=utf8&autoReconnect=true&rewriteBatchedStatements=TRUE&useSSL=true&serverTimezone=Asia/Shanghai
              username: root
              password: root
            slave:
              enabled: true
              jdbc-url: jdbc:mysql://10.1.3.104:63306/test2?useUnicode=true&characterEncoding=utf8&autoReconnect=true&rewriteBatchedStatements=TRUE&useSSL=true&serverTimezone=Asia/Shanghai
              username: root
              password: root
    
    
    #mybatis的相关配置
    mybatis:
      #mapper配置文件
      mapper-locations: classpath:mapper/*.xml
      type-aliases-package: com.xxx.xxx

配置好master数据源和slave数据源，这里用阿里的连接池，如果你本身是用其他的 也可以 对应改一下配置就可以。

# 3 切面注解及枚举 #

import com.superset.model.enums.DataSourceType;
    
    import java.lang.annotation.*;
    
    /**
     * 切换数据注解 可以用于类或者方法级别 方法级别优先级 > 类级别
     */
    @Target({ElementType.METHOD, ElementType.TYPE, ElementType.PARAMETER})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface DataSource  {
        /**
         * 切换数据源名称
         */
        DataSourceType value() default DataSourceType.MASTER;
    }

public enum DataSourceType {
        /**
         * 主库
         */
        MASTER,
    
        /**
         * 从库
         */
        SLAVE
    }

# 4 数据源配置类 #

DataSourceConfig ：这个类是springboot启动时加载的配置类，读取配置文件的数据源，装入Bean工厂

import com.superset.model.enums.DataSourceType;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    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 javax.sql.DataSource;
    import java.util.HashMap;
    import java.util.Map;
    
    @Configuration
    public class DataSourceConfig {
        @Bean
        @ConfigurationProperties("spring.datasource.druid.master")
        public DataSource masterDataSource() {
            return DataSourceBuilder.create().build();
        }
    
        @Bean
        @ConfigurationProperties("spring.datasource.druid.slave")
        @ConditionalOnProperty(prefix = "spring.datasource.druid.slave", name = "enabled", havingValue = "true")
        public DataSource slaveDataSource() {
            return DataSourceBuilder.create().build();
        }
    
        @Bean(name = "dynamicDataSource")
        @Primary
        public DynamicDataSource dataSource(DataSource masterDataSource, DataSource slaveDataSource) {
            Map<Object, Object> targetDataSources = new HashMap<>();
            targetDataSources.put(DataSourceType.MASTER.name(), masterDataSource);
            targetDataSources.put(DataSourceType.SLAVE.name(), slaveDataSource);
            return new DynamicDataSource(masterDataSource, targetDataSources);
        }
    }

DynamicDataSource：动态数据源路由配置

import lombok.extern.slf4j.Slf4j;
    import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
    
    import javax.sql.DataSource;
    import java.util.Map;
    
    /**
     * 动态数据源路由配置
     */
    @Slf4j
    public class DynamicDataSource extends AbstractRoutingDataSource {
    
        public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
            super.setDefaultTargetDataSource(defaultTargetDataSource);
            super.setTargetDataSources(targetDataSources);
            // afterPropertiesSet()方法调用时用来将targetDataSources的属性写入resolvedDataSources中的
            super.afterPropertiesSet();
        }
    
        /**
         * 根据Key获取数据源的信息
         *
         * @return
         */
        @Override
        protected Object determineCurrentLookupKey() {
            log.info("当前数据源：" + DynamicDataSourceContextHolder.getDataSourceType());
            return DynamicDataSourceContextHolder.getDataSourceType();
        }
    }

DynamicDataSourceContextHolder：数据源上下文

import lombok.extern.slf4j.Slf4j;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * 数据源上下文
     */
    @Slf4j
    public class DynamicDataSourceContextHolder {
    
        /**
         * 使用ThreadLocal维护变量，ThreadLocal为每个使用该变量的线程提供独立的变量副本，
         * 所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
         */
        private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();
    
    
        /**
         * 存储已经注册的数据源的key
         */
        public static List<String> dataSourceIds = new ArrayList<>();
    
        /**
         * 设置数据源变量
         *
         * @param dataSourceType
         */
        public static void setDataSourceType(String dataSourceType) {
            log.info("切换到{}数据源", dataSourceType);
            CONTEXT_HOLDER.set(dataSourceType);
        }
    
        /**
         * 获取数据源变量
         *
         * @return
         */
        public static String getDataSourceType() {
            return CONTEXT_HOLDER.get();
        }
    
        /**
         * 清空数据源变量
         */
        public static void clearDataSourceType() {
            CONTEXT_HOLDER.remove();
        }
    
    
        /**
         * 判断指定DataSrouce当前是否存在
         *
         * @param dataSourceId
         * @return
         */
        public static boolean containsDataSource(String dataSourceId) {
            return dataSourceIds.contains(dataSourceId);
        }
    }

# 5 配置切面类 #

import com.superset.model.annotation.DataSource;
    import com.superset.config.datasource.DynamicDataSourceContextHolder;
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.core.annotation.Order;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    
    @Aspect
    @Component
    @Order(1)
    @Slf4j
    public class DataSourceAspect {
    
        @Pointcut("@annotation(com.superset.model.annotation.DataSource)")
        public void dsPointCut() {
        }
    
        @Around("dsPointCut()")
        public Object around(ProceedingJoinPoint point) throws Throwable {
            log.info("aop数据源切换");
            MethodSignature signature = (MethodSignature) point.getSignature();
            Method method = signature.getMethod();
            DataSource dataSource = method.getAnnotation(DataSource.class);
            if (dataSource != null) {
                DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
            }
            try {
                return point.proceed();
            } finally {
                // 销毁数据源 在执行方法之后
                DynamicDataSourceContextHolder.clearDataSourceType();
            }
        }
    
    }

# 6 示例Mapper #

import com.superset.model.annotation.DataSource;
    import com.superset.model.entity.StoringReport;
    import com.superset.model.enums.DataSourceType;
    
    public interface StoringReportMapper {
    
        @DataSource(value = DataSourceType.MASTER)
        StoringReport selectByPrimaryKey(Integer id);
    
        @DataSource(value = DataSourceType.SLAVE)
        StoringReport selectByPrimaryId(Integer id);
    
    }

这里我在同一个mapper里面写了两个接口 分别去不同数据源获取，可以根据自己的情况修改，加这个注解即可，这个注解可加于方法 也可以加于类 看实际需求

# 7 启动类 #

@MapperScan("com.superset.mapper")//使用MapperScan批量扫描所有的Mapper接口；
    @Import({DataSourceConfig.class})
    @SpringBootApplication(exclude={DataSourceAutoConfiguration.class})
    public class SupersetApplication {
    
        public static void main(String[] args) {
           SpringApplication.run(SupersetApplication.class, args);
        }
    
    }

注意：如果少了这个@Import(\{DataSourceConfig.class\})和(exclude=\{DataSourceAutoConfiguration.class\})，可能会导致启动失败，很多博客都没有写到这个点，因为加入这个springboot才会自动加载数据源配置。

OK，这样就大功告成，随便一个controller 和 service  测试一下就可以啦，**如果好用麻烦点个赞！！！！**

然后推荐一篇MybatisPlus多数据源，这个的话 更加方便！

[《SpringBoot结合MybatisPlus多数据源解决方案》][SpringBoot_MybatisPlus]

[《坑：Mybatis-Plus 使用 @DS注解 做多数据源切换 mapper代理失败》][Mybatis-Plus _ _DS_ _ mapper]

[SpringBoot_MybatisPlus]: https://blog.csdn.net/qq_31226223/article/details/85322561?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-4&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-4
[Mybatis-Plus _ _DS_ _ mapper]: https://blog.csdn.net/Carson073/article/details/108831428