SpringAop动态数据源实现

文章目录

前期准备工作

新建一个SpringBoot的项目，暂时先导入两个必要的包
SpringAop动态数据源实现
当然还有导入一些其他的包，这里会用到aop，mybatis plus, druid 等，在pom文件中添加以上的依赖：

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

<!--mybatis plus-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.0.1</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

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

然后可以用代码生成工具生成简单的一条线entity,controller,service,dao,mapper，把项目目录结构先搞出来；
这是当前demo的目录结构，datasource那个包是做多数据源处理的，先建上；
SpringAop动态数据源实现
项目一开始启动时扫描不到controller和service，这里在启动类中加入@ComponentScan(“包名”)
启动类：DatasourceDemoApplication


@MapperScan("com.example.dao")
@ComponentScan("com.example.controller")
@ComponentScan("com.example.service")
@SpringBootApplication
public class DatasourceDemoApplication {
	public static void main(String[] args) {
		SpringApplication.run(DatasourceDemoApplication.class, args);
	}

}

集成动态数据源模块

  • 步骤1，在spring boot中，增加多数据源的配置
  • 步骤2，扩展Spring的AbstractRoutingDataSource抽象类，
    AbstractRoutingDataSource中的抽象方法determineCurrentLookupKey是实现多数据
    源的核心，并对该方法进行Override
  • 步骤3，配置DataSource，指定数据源的信息
  • 步骤4，通过注解，实现多数据源
  • 步骤5、配置加上(exclude={DataSourceAutoConfiguration.class})

然后按着上面的步骤来吧~

1. 步骤一 配置多数据源信息

在yml配置文件中添加数据源的信息，这里我复制了renren_fast的数据库，更名为renren_fast2，然后将renren_fast2中sys_user表中id为1的用户名改为了admin_456.

datasource-demo\src\main\resources\application.yml

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.jdbc.Driver
    druid:
      first:
        url: jdbc:mysql://localhost:3306/renren_fast?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
        username: root
        password: 123456
      second:
        url: jdbc:mysql://localhost:3306/renren_fast2?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
        username: root
        password: 123456

我们之前建好了datasource的包，这里开始做多数据源部分的处理了；
首先要编写配置类，配置多数据源信息；

/**
 * 配置多数据源
 * @author 天赋吉运-yxh
 * @create 2019-01-22 15:31
 */
@Configuration
public class DynamicDataSourceConfig {
    @Bean
    @ConfigurationProperties("spring.datasource.druid.first")
    public DataSource firstDataSource(){
        return DruidDataSourceBuilder.create().build();
    }
    @Bean
    @ConfigurationProperties("spring.datasource.druid.second")
    public DataSource secondDataSource(){
        return DruidDataSourceBuilder.create().build();
    }
    
}

另外，将步骤五的处理提前做了，因为我们的数据源是自己生成的，所以要去掉原型springboot启动时候自动装配的数据源配置。然后倒入自己写的配置。
在启动类添加以**解：

@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})
@Import({DynamicDataSourceConfig.class})

2.步骤二，扩展Spring的AbstractRoutingDataSource抽象类

package com.example.datasource;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import javax.sql.DataSource;
import java.util.Map;

/**
 * 动态数据源
 * @author 天赋吉运-杨晓慧
 * @create 2019-01-22 15:55
 */

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
     // determineCurrentLookupKey（）决定使用哪个数据源
    protected Object determineCurrentLookupKey() {
        return getDataSource();
    }
}

为了方便我们使用aop注解时候的得到的lookupkey参数能传递到这里。所以需要建一个线程安全的ThreadLocal变量，用于传参，避免复杂的参数传递过程。那么，我们获取这个lookupkey就从这个ThreadLocal里面去获取，所以determineCurrentLookupKey()直接返回getDataSource()。
/**

  • 动态数据源
  • determineCurrentLookupKey（）决定使用哪个数据源
  • @author 天赋吉运-杨晓慧
  • @create 2019-01-22 15:55
    */

public class DynamicDataSource extends AbstractRoutingDataSource {

/**
 * ThreadLocal 用于提供线程局部变量，在多线程环境可以保证各个线程内的变量独立于其他线程里的变量
 * 即 ThreadLocal可以为每个线程创建一个【单独的变量副本】
 * 相当于线程的private static类型变量
 */
private static final ThreadLocal<String> contextHolder =new ThreadLocal<>();


@Override
protected Object determineCurrentLookupKey() {
    return getDataSource();
}

public static void setDataSource(String dataSource){
    contextHolder.set(dataSource);
}

public static String getDataSource(){
    return contextHolder.get();
}

public static void clearDataSource(){
    contextHolder.remove();
}

 //构造方法
 //决定使用哪个数据源之前需要把多个数据源的信息以及默认数据源信息配置好

public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object,Object> targetDataSources){
    super.setDefaultTargetDataSource(defaultTargetDataSource);
    super.setTargetDataSources(targetDataSources);
    super.afterPropertiesSet();
}

}

但是仅做上面步骤还不够，因为自动装载数据源的这个过程我们在前面已经去掉了，所以需要我们自己手动去装配数据源的信息。调用determineCurrentLookupKey()方法的determineTargetDataSource()方法可以看到，里面有用到一些变量，比如resolvedDataSources，它是一个map，查看调用地方可以看到，它的初始化实在afterPropertiesSet()方法中，这初始化方法会用到一些变量，比如：targetDataSources、defaultTargetDataSource，然后你回发现，这个两个参数，都是一个set方法初始化的，setTargetDataSources(Map<Object, Object> targetDataSources)、setDefaultTargetDataSource(Object defaultTargetDataSource)，这两个就是所有数据源信息，和默认数据源信息，所以我们需要手动把我们配置的数据源信息set进去。
大家可以仔细看看org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource的源码
SpringAop动态数据源实现
SpringAop动态数据源实现

3.步骤三-配置DataSource，指定数据源的信息

确认最终使用哪个数据源的方法有很多，因为涉及到一个顺序问题，调用determineCurrentLookupKey()前一定要把数据源的信息初始化化好，所以我们可以写一个DynamicDataSource的构造方法。两个参数，一个默认数据源，一个所有数据源。然后调用afterPropertiesSet()，初始化必要的参数。

所以在DynamicDataSource类中增加一个构造函数，初始化必要的参数

     //构造方法
     //决定使用哪个数据源之前需要把多个数据源的信息以及默认数据源信息配置好
    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object,Object> targetDataSources){
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }

因为这数据源的信息启动时候就需要初始化，因为后面事务等类的初始化都需要依赖数据源bean，所以在DynamicDataSourceConfig配置中，我们生成一个DynamicDataSource的bean。
在DynamicDataSourceConfig配置类中增加一个bean

    /**
     * 因为数据源的信息启动时候就需要初始化，后面事务等类的初始化都需要依赖数据源bean,所以在DynamicDataSourceConfig中，我们生成了一个DynamicDataSource的bean
     */
    @Bean
    @Primary
    public DynamicDataSource dataSource(DataSource firstDataSource,DataSource secondDataSource){

        Map<Object,Object> targetDataSources=new HashMap<>();
        targetDataSources.put(DataSourceNames.FIRST,firstDataSource);
        targetDataSources.put(DataSourceNames.SECOND,secondDataSource);
        return new DynamicDataSource(firstDataSource,targetDataSources);
    }

@Primary 优先考虑，优先考虑被注解的对象注入。

数据源的名称经常会用到，我这里定义了一个枚举类

package com.example.datasource;

/*
 @author 天赋吉运-yxh
 @数据源名称
 @create 2019/1/23 
*/

public interface DataSourceNames {
    String FIRST = "first";
    String SECOND = "second";
}

通过上面的配置，我们可以说已经完成了手动装配我们自定义的多数据源的过程了。接下来的工作就是我们自己去指定ThreadLocal里面的值就行。

4.步骤四，通过注解，实现多数据源

我们采用aop的方式，在需要修改数据源的地方使用注解方式去切换，然后切面修改ThreadLocal的内容。这里比较简单，我就直接贴代码：

package com.example.datasource;

import java.lang.annotation.*;

/*
 @author 天赋吉运-yxh
 @多数据源注解
 @create 2019/1/22 
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
    // 采用AOP的方式，在需要修改数据源的地方使用注解的方式，去切换，然后通过切面修改ThreadLocal的内容
    String name() default "";
}

切面处理逻辑

package com.example.datasource;

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.slf4j.LoggerFactory;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 多数据源，切面处理类
 * @author 天赋吉运-杨晓慧
 * @create 2019-01-22 17:31
 */
@Aspect
@Component
public class DataSourceAspect implements Ordered{

    protected org.slf4j.Logger logger = LoggerFactory.getLogger(getClass());

    //设置切点
    @Pointcut("@annotation(com.example.datasource.DataSource)")
    public void  dataSourcePointCut(){

    }

    //切面
    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method =signature.getMethod();
        DataSource ds=method.getAnnotation(DataSource.class);
        if (ds ==null) {
            // 当数据源为空时 配置默认数据源为第一个
            DynamicDataSource.setDataSource(DataSourceNames.FIRST);
            logger.debug("set datasource is "+ DataSourceNames.FIRST);
        } else  {
            // 根据既定已配置数据源来设定
            DynamicDataSource.setDataSource(ds.name());
            logger.debug("set datasource is " + ds.name());
        }

        try {
            return point.proceed();
        } finally {
            DynamicDataSource.clearDataSource();
            logger.debug("clean datasource");
        }
    }

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

这是选择的目录结构呢
SpringAop动态数据源实现
最后收工，测试一把吧；
在service中定义两个接口，实现的时候分别查询不同的数据源

/**
 * <p>
 * 系统用户 服务类
 * </p>
 *
 * @author Hepburn_Yang
 * @since 2019-01-22
 */
public interface SysUserService extends  IService<SysUser> {

    SysUser findUserByFirstDb(long id);

    SysUser findUserBySecondDb(long id);

}

添加实现

/**
 * <p>
 * 系统用户 服务实现类
 * </p>
 *
 * @author Hepburn_Yang
 * @since 2019-01-22
 */
@Service("sysUserService")
public class SysUserServiceImpl extends ServiceImpl<SysUserDao, SysUser> implements SysUserService {

    @Override
    // 不设定数据源，连接默认数据库，（默认是firstDb）
    public SysUser findUserByFirstDb(long id) {
        return this.baseMapper.selectById(id);
    }

    @DataSource(name = DataSourceNames.SECOND)
    @Override
    // 设置数据源为secondDb，看上面的@DataSource
    public SysUser findUserBySecondDb(long id) {
        return this.baseMapper.selectById(id);
    }
}

走一波单元测试：

@RunWith(SpringRunner.class)
@SpringBootTest
public class DatasourceDemoApplicationTests {

	@Resource
	private SysUserService sysUserService;

	@Test
	public void test(){
		SysUser user1 =sysUserService.findUserByFirstDb(1);
		System.out.println("first DB ------------->"+user1.toString());

		SysUser user2 = sysUserService.findUserBySecondDb(1);
		System.out.println("second DB ------------>" + user2.toString());
	}
}

来看看日志输出：
SpringAop动态数据源实现

收工收工，拜拜了，有问题请留言~~

相关文章：

  • 2021-06-11
  • 2021-10-01
  • 2021-09-22
  • 2022-12-23
  • 2020-04-15
猜你喜欢
  • 2022-12-23
  • 2021-07-14
  • 2021-08-25
  • 2021-08-09
  • 2018-11-01
  • 2019-06-17
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode