SpringBoot

springboot集成多数据源,实现动态调用不同数据库

1. maven依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.4.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.10</version>
    </dependency>


    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.2</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

    <dependency>
        <groupId>com.microsoft.sqlserver</groupId>
        <artifactId>sqljdbc4</artifactId>
        <version>4.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2.数据源简要配置

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
 
#database1
spring.datasource.db1.driver-class-name=com.microsoft.sqlserver.jdbc.SQLServerDriver
spring.datasource.db1.jdbcUrl=jdbc:sqlserver://localhost:1433;databasename=testSqlServer
spring.datasource.db1.username=sa
spring.datasource.db1.password=123456
 
#database2
spring.datasource.canting.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.canting.jdbcUrl=jdbc:mysql://127.0.0.1:3306/testMySql	
spring.datasource.canting.username=root
spring.datasource.canting.password=root

3. 数据源配置

package com.tent.springboot.config;
 
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 org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
 
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
 
@Configuration
public class DataSourceConfig {
 
    @Bean(name = "db1")
    @ConfigurationProperties(prefix = "spring.datasource.db1")
    public DataSource db1(){
        return DataSourceBuilder.create().build();
    }
 
    @Bean(name = "db2")
    @ConfigurationProperties(prefix = "spring.datasource.db2")
    public DataSource db2(){
        return DataSourceBuilder.create().build();
    }
 
    /***
     * 动态数据源 通过AOP在不同数据源之间动态切换
     */
    @Primary
    @Bean(name ="dynamicDataSource")
    public DataSource dynamicDataSource(){
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        //默认数据源
        dynamicDataSource.setDefaultTargetDataSource(db1());
 
        //配置多数据源
        Map<Object,Object> dsMap = new HashMap<>();
        dsMap.put("db1",db1());
        dsMap.put("db2", db2());
        dynamicDataSource.setTargetDataSources(dsMap);
        return dynamicDataSource;
    }
    /**
     * 配置@Transactional注解事物
     * @return
     */
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dynamicDataSource());
    }
}

4.本地线程设置数据源

package com.tent.springboot.config;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class DataSourceContextHolder {
 
    public static final Logger log = LoggerFactory.getLogger(DataSourceContextHolder.class);
 
    /**
     * 默认数据源
     */
    public static final String DEFAULT_DB = "db1";
 
    private  static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
 
    //设置数据源名
    public static  void setDB(String dbType){
        log.debug("切换到数据源: ",dbType);
        contextHolder.set(dbType);
    }
 
    //获取数据源名
    public static String getDB(){
        return contextHolder.get();
    }
 
    //清除数据源
    public static void clearDB(){
        contextHolder.remove();
    }
}

5. 获取动态数据源

package com.tent.springboot.config;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.stereotype.Component;
 
public class DynamicDataSource extends AbstractRoutingDataSource {
 
    public static final Logger log = LoggerFactory.getLogger(DynamicDataSource.class);
 
    @Override
    protected Object determineCurrentLookupKey() {
        log.debug("数据源为: ",DataSourceContextHolder.getDB());
        return DataSourceContextHolder.getDB();
    }
}

6.自定义注解,用于指定要加载的数据源

package com.tent.springboot.config;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/***
 * 自定义注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({
        ElementType.METHOD
})
public @interface DS {
    String value() default "db1";
}

7.aop方式获取调用的数据源

package com.tent.springboot.config;

import com.tent.springboot.config.DS;
import com.tent.springboot.config.DataSourceContextHolder;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
@Aspect
@Component
public class DynamicDataSourceAspect {
    @Before("@annotation(DS)")
    public void beforeSwitchDS(JoinPoint point){

        //获得当前访问的class
        Class<?> className = point.getTarget().getClass();

        //获得访问的方法名
        String methodName = point.getSignature().getName();
        //得到方法的参数的类型
        Class[] argClass = ((MethodSignature)point.getSignature()).getParameterTypes();
        String dataSource = DataSourceContextHolder.DEFAULT_DB;
        try {
            // 得到访问的方法对象
            Method method = className.getMethod(methodName, argClass);

            // 判断是否存在@DS注解
            if (method.isAnnotationPresent(DS.class)) {
                DS annotation = method.getAnnotation(DS.class);
                // 取出注解中的数据源名
                dataSource = annotation.value();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 切换数据源
        DataSourceContextHolder.setDB(dataSource);
    }

    @After("@annotation(DS)")
    public void afterSwitchDS(JoinPoint point){
        DataSourceContextHolder.clearDB();
    }
}

本文由 创作，采用 知识共享署名4.0 国际许可协议进行许可。本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名。最后编辑时间为: 2021/04/21 10:43