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

旧城等待， 2022-05-16 10:56 544阅读 0赞

1.maven依赖

<parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.4.RELEASE</version>
            <relativePath/> 
        </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>
    
            
            <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();
    
        }
    }