SpringBoot框架：通过AOP和自定义注解完成druid连接池的动态数据源切换（三）

一、引入依赖

　　引入数据库连接池的依赖——druid和面向切面编程的依赖——aop，如下所示：

        <!-- druid -->

        <dependency>

            <groupId>com.alibaba</groupId>

            <artifactId>druid-spring-boot-starter</artifactId>

            <version>1.1.21</version>

        </dependency>

        <!-- aop -->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-aop</artifactId>

        </dependency>

二、创建数据库

　　1、主数据库

　　使用前文中已经创建的名为spring_boot_demo的数据库。

　　spring_boot_demo中t_user数据如下：

　　2、辅数据库

　　数据库名为other_data，库中建立数据表t_user，表结构与spring_boot_demo中的t_user一致。

　　实际项目中，大多是跨数据库的数据源切换，常用在同公司的多个不同系统中共用一个用户数据库，或者二次开发项目在原有数据库基础上做拓展，保留原有的数据连接。

　　这里为了方便操作，就都在mysql下部署数据库并且使表结构一致，方便形成数据对比。

　　other_data中插入数据如下：

三、修改数据库连接配置信息

　　在application.yml中，修改数据库连接配置如下：

spring:

  application:

    name: spring-boot-demo

  datasource:

    type: com.alibaba.druid.pool.DruidDataSource

    druid:

      primary:

        url: jdbc:mysql://localhost:3306/spring_boot_demo?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true&serverTimezone=GMT%2B8

        username: root

        password: root

        driverClassName: com.mysql.jdbc.Driver

      second:

        url: jdbc:mysql://localhost:3306/other_data?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true&serverTimezone=GMT%2B8

        username: root

        password: root

        driverClassName: com.mysql.jdbc.Driver

四、编写代码

　　结构如下：

　　1、枚举类DataSourceName:

　　该类用来存放数据源的名称，定义两个数据源名称分别为PRIMARY和SECOND。

package com.example.demo.enums;

/**

 * DataSource的name常量

 * 便于切换

 * @author 我命倾尘

 */

public enum DataSourceName {

    /**

     * 主数据源 spring_boot_demo

     */

    PRIMARY("PRIMARY"),

    /**

     * 副数据源other_data

     */

    SECOND("SECOND");

    private String dataSourceName;

    private DataSourceName(String dataSourceName){

        this.dataSourceName=dataSourceName;

    }

    DataSourceName(){

    }

    public String getDataSourceName(){

        return this.dataSourceName;

    }

}

　　2、配置类DynamicDataSourceConfig：

　　通过@ConfigurationProperties读取配置文件中的数据源配置信息，并通过DruidDataSourceBuilder.create().build()创建数据连接，将多个数据源放入map，注入到IoC中：

package com.example.demo.config;

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;

import com.example.demo.bean.DynamicDataSource;

import com.example.demo.enums.DataSourceName;

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 javax.sql.DataSource;

import java.util.HashMap;

import java.util.Map;

/**

 * @author 我命倾尘

 */

@Configuration

public class DynamicDataSourceConfig {

    /**

     * 创建DataSource Bean，将数据源配置从配置文件中读出

     */

    @Bean

    @ConfigurationProperties("spring.datasource.druid.primary")

    public DataSource oneDataSource(){

        return DruidDataSourceBuilder.create().build();

    }

    @Bean

    @ConfigurationProperties("spring.datasource.druid.second")

    public DataSource twoDataSource(){

        return DruidDataSourceBuilder.create().build();

    }

    /**

     * 将数据源放入到 这个map中，注入到IoC

     */

    @Bean

    @Primary

    public DynamicDataSource dataSource(DataSource oneDataSource, DataSource twoDataSource){

        Map<Object,Object> targetDataSources=new HashMap<>(2);

        targetDataSources.put(DataSourceName.PRIMARY.getDataSourceName(),oneDataSource);

        targetDataSources.put(DataSourceName.SECOND.getDataSourceName(),twoDataSource);

        return new DynamicDataSource(oneDataSource,targetDataSources);

    }

}

　　3、动态数据源DynamicDataSource:

　　通过继承AbstractRoutingDataSource类，在构造函数中调用父类的方法，将配置类中放入map的数据源集合定为备选数据源，将传来的oneDataSource作为默认数据源：

package com.example.demo.bean;

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

import javax.sql.DataSource;

import java.util.Map;

/**

 * @author 我命倾尘

 */

public class DynamicDataSource extends AbstractRoutingDataSource {

    private static final ThreadLocal<String> contextHolder=new ThreadLocal<>();

    /**

     * 配置DataSource

     * 设置defaultTargetDataSource为主数据库

     */

    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object,Object> targetDataSources){

        super.setDefaultTargetDataSource(defaultTargetDataSource);

        super.setTargetDataSources(targetDataSources);

        super.afterPropertiesSet();

    }

    public static String getDataSource(){

        return contextHolder.get();

    }

    public static void setDataSource(String dataSource){

        contextHolder.set(dataSource);

    }

    public static void clearDataSource(){

        contextHolder.remove();

    }

    @Override

    protected Object determineCurrentLookupKey() {

        return getDataSource();

    }

}

　　setTargetDataSources设置备选的数据源集合，

　　setDefaultTargetDataSource设置默认数据源，

　　determineCurrentLookupKey决定当前数据源的对应的key。

　　4、自定义注释类DataSource：

package com.example.demo.annotation;

import com.example.demo.enums.DataSourceName;

import java.lang.annotation.*;

/**

 * @author 我命倾尘

 */

@Documented

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

public @interface DataSource {

    DataSourceName value() default DataSourceName.PRIMARY;

}

　　@Documented指定被标注的注解会包含在javadoc中，

　　@Target指定注释可能出现在Java程序中的语法位置（ElementType.METHOD则说明注解可能出现在方法上），

　　@Retention指定注释的保留时间（RetentionPolicy.RUNTIME则是在java文件编译成class类时也依旧保存该注释）。

　　5、切面类DataSourceAspect：

package com.example.demo.aspect;

import com.example.demo.annotation.DataSource;

import com.example.demo.bean.DynamicDataSource;

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.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.core.Ordered;

import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**

 * @author 我命倾尘

 */

@Aspect

@Component

public class DataSourceAspect implements Ordered {

    private Logger log= LoggerFactory.getLogger(DataSourceAspect.class);

    /**

     * 切点：所有配置DataSource注解的方法

     */

    @Pointcut("@annotation(com.example.demo.annotation.DataSource)")

    public void dataSourcePointCut(){

    }

    @Around(value = "dataSourcePointCut()")

    public Object around(ProceedingJoinPoint point) throws Throwable{

        Object result;

        MethodSignature signature=(MethodSignature)point.getSignature();

        Method method=signature.getMethod();

        DataSource ds=method.getAnnotation(DataSource.class);

        /**

         * 判断DataSource的值

         * 获取当前方法应用的数据源

         */

        DynamicDataSource.setDataSource(ds.value().getDataSourceName());

        try{

            result=point.proceed();

        }finally {

            DynamicDataSource.clearDataSource();

        }

        return result;

    }

    @Override

    public int getOrder() {

        return 1;

    }

}

　　Spring框架有很多相同接口的实现类，提供了Ordered接口来处理相同接口实现类之间的优先级问题。

　　通过环绕切面，对方法上的注释进行了检验，如果获取到有DataSource注释，则会进行数据源的切换，否则按默认数据源进行处理。

　　6、引入配置类：

　　既然手动配置了动态切换数据连接池，就要在入口类中排除自动引入，并引入数据源的配置类，以及开启AOP：

package com.example.demo;

import com.example.demo.config.DynamicDataSourceConfig;

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.annotation.EnableAspectJAutoProxy;

import org.springframework.context.annotation.Import;

@MapperScan("com.example.demo.mapper")

@Import({DynamicDataSourceConfig.class})

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})

@EnableAspectJAutoProxy

public class DemoApplication {

    public static void main(String[] args) {

        SpringApplication.run(DemoApplication.class, args);

    }

}

　　通过@Import引入配置类，在@SpringBootApplication后进行自动引入的排除。

　　@EnableAspectJAutoProxy用来开启AOP。

五、简单测试

　　1、不使用注解：

　　UserController中的方法如下：

　　@RequestMapping("/user/age")

　　public int getAgeOfUser(){

        return userService.getAgeByUsername("springbootdemo");

　　}

　　所得到的结果如下：

　　这个结果是从主数据源spring_boot_demo数据库的表中得到的数据。

　　2、在方法前添加注解@DataSource(DataSourceName.SECOND)：

　　UserController中的方法如下：

　　@RequestMapping("/user/age")

　　@DataSource(DataSourceName.SECOND)

　　public int getAgeOfUser(){

        return userService.getAgeByUsername("springbootdemo");

　　}

　　结果如下：

　　这个结果则是从辅数据源other_data中得到的数据。

　　前言：SpringBoot框架：使用mybatis连接mysql数据库完成数据访问（二）

巴特西

SpringBoot框架：通过AOP和自定义注解完成druid连接池的动态数据源切换（三）

最新文章

热门文章