Springboot+aop实现配置多数据源的示例代码_Java

前言

这是我司在对于动态数据源的一个处理方法，采用动态加载数据库信息实现动态数据源的切换。通过使用spring aop + 注解来替换当前线程threadlocal中的值，并且通过重写abstractroutingdatasource类重写determinecurrentlookupkey()方法，实现动态数据源切换，满足功能实现的代码0侵入性，并且高度解耦，实现可拔插功能效果

1、添加依赖（本项目是一个springboot项目）

<dependency>
    <groupid>com.baomidou</groupid>
    <artifactid>mybatis-plus-boot-starter</artifactid>
    <version>2.2.0</version>
</dependency>
<dependency>
    <groupid>com.baomidou</groupid>
    <artifactid>dynamic-datasource-spring-boot-starter</artifactid>
    <version>3.5.2</version>
</dependency>
<dependency>
    <groupid>com.baomidou</groupid>
    <artifactid>mybatis-plus-core</artifactid>
    <version>3.5.1</version>
</dependency>
<dependency>
    <groupid>org.mybatis</groupid>
    <artifactid>mybatis</artifactid>
    <version>3.5.9</version>
</dependency>
<dependency>
    <groupid>com.alibaba</groupid>
    <artifactid>druid-spring-boot-starter</artifactid>
    <version>1.1.22</version>
</dependency>
<dependency>
    <groupid>mysql</groupid>
    <artifactid>mysql-connector-java</artifactid>
    <version>8.0.32</version>
    <scope>runtime</scope>
</dependency>

2、定义数据库类型枚举类(enum)

/**
 * 数据库配置名字字段
 * @author zh
 * @data 17点14分
 *
 */
public enum dbtypeenum {
    cs1db("cs1-db"), cs2db("cs2-db");

    private string value;

    dbtypeenum(string value) {
        this.value = value;
    }

    public string getvalue() {
        return value;
    }
}

此枚举主要是用于简化if-else语句。

3、定义注解(annotation)

/**
 * @author zh
 * @data 17点18分
 */
@retention(retentionpolicy.runtime)
@target({elementtype.method})
public @interface datasourceswitch {
    /****
     * 顺便设置下默认数据源
     * @return
     */
    dbtypeenum value() default dbtypeenum.cs1db;
}

定义datasourceswitch注解，默认数据源为cs1db(数据库一)。

4、编写threadlocal存储数据上下文信息

/**
 * @author zh
 */
public class dbcontextholder {
    private static final threadlocal contextholder = new threadlocal<>();
    /**
     * 设置数据源
     * @param dbtypeenum
     */
    public static void setdbtype(dbtypeenum dbtypeenum) {
        contextholder.set(dbtypeenum.getvalue());
    }

    /**
     * 取得当前数据源
     * @return
     */
    public static string getdbtype() {
        return (string) contextholder.get();
    }

    /**
     * 清除上下文数据
     */
    public static void cleardbtype() {
        contextholder.remove();
    }
}

工具类dbcontextholder用于存储数据名上下文。

5、获取数据源信息

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

/**
 * @author  zh
 */
public class dynamicdatasource extends abstractroutingdatasource {
    /**
     * 取得当前使用哪个数据源
     * @return
     */
    @override
    protected object determinecurrentlookupkey() {
        return dbcontextholder.getdbtype();
    }
}

工具类dynamicdatasource继承abstractroutingdatasource重写determinecurrentlookupkey（）方法，从工具类dbcontextholder中获取当前数据源信息。

6、自定义切面(aspect)

/**
 *  @author zh
 *  数据源aop注解实现
 */
@component
@aspect
@order(-100)
public class datasourceswitchaspect {

    private logger log= loggerfactory.getlogger(datasourceswitchaspect.class);

    @pointcut("execution(* com.zh.cn.business.cs1db..*.*(..))")
    private void cs1dbaspect() {
    }

    @pointcut("execution(* com.zh.cn.business.cs2db..*.*(..))")
    private void cs2dbaspect() {
    }
    
    @before( "cs1dbaspect()" )
    public void basic(joinpoint joinpoint) {
        //log.info("切换到cs1db 数据源...");
        setdatasource(joinpoint, dbtypeenum.cs1db);
    }

    @before("cs2dbaspect()" )
    public void order (joinpoint joinpoint) {
        //log.info("切换到cs2db 数据源...");
        setdatasource(joinpoint,dbtypeenum.cs2db);
    }

    /**
     * 添加注解方式,如果有注解优先注解,没有则按传过来的数据源配置
     * @param joinpoint
     * @param dbtypeenum
     */
    private void setdatasource(joinpoint joinpoint, dbtypeenum dbtypeenum) {
        methodsignature methodsignature = (methodsignature) joinpoint.getsignature();
        datasourceswitch datasourceswitch = methodsignature.getmethod().getannotation(datasourceswitch.class);
        if (objects.isnull(datasourceswitch) || objects.isnull(datasourceswitch.value())) {
            dbcontextholder.setdbtype(dbtypeenum);
        }else{
           // log.info("根据注解来切换数据源,注解值为:"+datasourceswitch.value());
            switch (datasourceswitch.value().getvalue()) {
                case "cs1-db":
                    dbcontextholder.setdbtype(dbtypeenum.cs1db);
                    break;
                case "cs2-db":
                    dbcontextholder.setdbtype(dbtypeenum.cs2db);
                    break;
                default:
                    dbcontextholder.setdbtype(dbtypeenum);
            }
        }
    }
}

通过springaop自定义切面，切入点在* com.zh.cn.business.cs2db..*.*(..))，表示切入点在com.zh.cn.business.cs2db包下的任意子包、任意方法和任意返回值，并通过setdatasource（）方法设置工具类dbcontextholder中数据源信息。

7、配置数据源信息

import com.alibaba.druid.spring.boot.autoconfigure.druiddatasourcebuilder;
import com.baomidou.mybatisplus.core.mybatisconfiguration;
import com.baomidou.mybatisplus.extension.plugins.mybatisplusinterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.optimisticlockerinnerinterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.paginationinnerinterceptor;
import com.baomidou.mybatisplus.extension.spring.mybatissqlsessionfactorybean;
import com.baomidou.mybatisplus.generator.config.rules.dbtype;
import com.zh.cn.utils.dynamicdatasource;
import com.zh.cn.constants.dbtypeenum;
import org.apache.ibatis.plugin.interceptor;
import org.apache.ibatis.session.sqlsessionfactory;
import org.apache.ibatis.type.jdbctype;
import org.mybatis.spring.annotation.mapperscan;
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.util.hashmap;
import java.util.map;

/**
 * 加载datasource
 */
@configuration
@mapperscan({"com.zh.cn.**.mapper"})
public class mybatisplusconfig {

    /**
     * mapper-plus分页插件<br>
     * 文档：http://mp.baomidou.com<br>
     */
   /* @bean
    public paginationinterceptor paginationinterceptor() {
        paginationinterceptor paginationinterceptor = new paginationinterceptor();
        //paginationinterceptor.setlocalpage(true);// 开启 pagehelper 的支持
        return paginationinterceptor;
    }*/
   @bean
   public mybatisplusinterceptor mybatisplusinterceptor() {
      mybatisplusinterceptor interceptor = new mybatisplusinterceptor();
      interceptor.addinnerinterceptor(new paginationinnerinterceptor(dbtype.mysql));
      //乐观锁
      interceptor.addinnerinterceptor(new optimisticlockerinnerinterceptor());
      return interceptor;
   }


    @bean(name = "cs1db")
    @configurationproperties(prefix = "spring.datasource.druid.cs1-db" )
    public datasource cs1db () {
        return druiddatasourcebuilder.create().build();
    }

    @bean(name = "cs2db")
    @configurationproperties(prefix = "spring.datasource.druid.cs2-db" )
    public datasource cs2db () {
        return druiddatasourcebuilder.create().build();
    }

   /**
     * 动态数据源配置
     * @return
     */
    @bean
    @primary
    public datasource multipledatasource (@qualifier("cs1db") datasource cs1db,
                                          @qualifier("cs2db") datasource cs2db){
        dynamicdatasource dynamicdatasource = new dynamicdatasource();
        map< object, object > targetdatasources = new hashmap<>();
        targetdatasources.put(dbtypeenum.cs1db.getvalue(), cs1db );
        targetdatasources.put(dbtypeenum.cs2db.getvalue(), cs2db);

        dynamicdatasource.settargetdatasources(targetdatasources);
        dynamicdatasource.setdefaulttargetdatasource(cs1db);//指定默认
        return dynamicdatasource;
    }

    @bean("sqlsessionfactory")
    public sqlsessionfactory sqlsessionfactory() throws exception {
        mybatissqlsessionfactorybean sqlsessionfactory = new mybatissqlsessionfactorybean();
        sqlsessionfactory.setdatasource(multipledatasource(cs1db(),cs2db()));

        sqlsessionfactory.setmapperlocations(new 	pathmatchingresourcepatternresolver().getresources("classpath*:/mapper/*/*mapper.xml"));

        mybatisconfiguration configuration = new mybatisconfiguration();
        configuration.setjdbctypefornull(jdbctype.null);
        configuration.setmapunderscoretocamelcase(true);
        configuration.setcacheenabled(false);
        sqlsessionfactory.setconfiguration(configuration);
        sqlsessionfactory.setplugins(new interceptor[]{
            mybatisplusinterceptor()
        });
        return sqlsessionfactory.getobject();
    }


}

通过覆盖默认的datasource进行加载动态数据源的配置信息，通过**multipledatasource（）方法设置数据源，最后通过sqlsessionfactory（）**设置数据源的最终加载

8、编写配置文件

spring:
  datasource:
      type: com.alibaba.druid.pool.druiddatasource
      cs1-db:
        driverclassname: com.mysql.cj.jdbc.driver
        url: jdbc:mysql://127.0.0.1:3306/short-chain?useunicode=true&characterencoding=utf-8
        username: root
        password: 
        initialsize: 10
        minidle: 20
        maxactive: 100
        maxwait: 60000
      cs2-db:
        driverclassname: com.mysql.cj.jdbc.driver
        url: jdbc:mysql://127.0.0.1:3306/short-chain?useunicode=true&characterencoding=utf-8
        username: root
        password: 
        initialsize: 10
        minidle: 20
        maxactive: 100
        maxwait: 60000
      	maxactive: 100
        maxwait: 60000

到此这篇关于springboot+aop实现配置多数据源的示例代码的文章就介绍到这了,更多相关springboot aop多数据源内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！