springboot 配置動態切換數據源（兩個oracle數據庫）

項目中有些查詢情況數據並不在一個數據庫中，有可能在兩個數據庫甚至更多的數據庫中，這種情況就得用到動態切換數據源了

首先配置數據源的四大類

新建DataSource包，新建四個類

package com.zxht.smart.environment.datasource;

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

import com.zxht.smart.environment.annotation.DataSource;


@Aspect
@Order(-1)// 保證該AOP在@Transactional之前執行
@Component
public class DynamicDataSourceAspect {

	
	private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);

    @Before("@annotation(ds)")
    public void changeDataSource(JoinPoint point, DataSource ds) throws Throwable {
        String dsId = ds.value();
        if (DynamicDataSourceContextHolder.dataSourceIds.contains(dsId)) {
            logger.debug("Use DataSource :{} >", dsId, point.getSignature());
            DynamicDataSourceContextHolder.setDataSourceRouterKey(dsId);
        } else {
            logger.info("數據源[{}]不存在，使用默認數據源 >{}", dsId, point.getSignature());
            
        }
    }

    @After("@annotation(ds)")
    public void restoreDataSource(JoinPoint point, DataSource ds) {
        logger.debug("Revert DataSource : " + ds.value() + " > " + point.getSignature());
        DynamicDataSourceContextHolder.removeDataSourceRouterKey();

    }
}

package com.zxht.smart.environment.datasource;

import java.util.ArrayList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DynamicDataSourceContextHolder {

	
	private static Logger logger = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);

    /**
     * 存儲已經註冊的數據源的key
     */
    public static List<String> dataSourceIds = new ArrayList<>();

    /**
     * 線程級別的私有變量
     */
    private static final ThreadLocal<String> HOLDER = new ThreadLocal<>();

    public static String getDataSourceRouterKey () {
        return HOLDER.get();
    }

    public static void setDataSourceRouterKey (String dataSourceRouterKey) {
        logger.info("切換至{}數據源", dataSourceRouterKey);
        HOLDER.set(dataSourceRouterKey);
    }

    /**
     * 設置數據源之前一定要先移除
     */
    public static void removeDataSourceRouterKey () {
        HOLDER.remove();
    }

    /**
     * 判斷指定DataSrouce當前是否存在
     *
     * @param dataSourceId
     * @return
     */
    public static boolean containsDataSource(String dataSourceId){
        return dataSourceIds.contains(dataSourceId);
    }
}

package com.zxht.smart.environment.datasource;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.GenericBeanDefinition;
import org.springframework.boot.context.properties.bind.Bindable;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.context.properties.source.ConfigurationPropertyName;
import org.springframework.boot.context.properties.source.ConfigurationPropertyNameAliases;
import org.springframework.boot.context.properties.source.ConfigurationPropertySource;
import org.springframework.boot.context.properties.source.MapConfigurationPropertySource;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.util.StringUtils;

import com.zaxxer.hikari.HikariDataSource;

public class DynamicDataSourceRegister implements ImportBeanDefinitionRegistrar, EnvironmentAware{
	
	private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceRegister.class);


    /**
     * 配置上下文（也可以理解爲配置文件的獲取工具）
     */
    private Environment evn;

    /**
     * 別名
     */
    private final static ConfigurationPropertyNameAliases aliases = new ConfigurationPropertyNameAliases();

    /**
     * 由於部分數據源配置不同，所以在此處添加別名，避免切換數據源出現某些參數無法注入的情況
     */
    static {
        aliases.addAliases("url", new String[]{"jdbc-url"});
        aliases.addAliases("username", new String[]{"user"});
    }

    /**
     * 存儲我們註冊的數據源
     */
    private Map<String, DataSource> customDataSources = new HashMap<String, DataSource>();

    /**
     * 參數綁定工具 springboot2.0新推出
     */
    private Binder binder;

    /**
     * ImportBeanDefinitionRegistrar接口的實現方法，通過該方法可以按照自己的方式註冊bean
     *
     * @param annotationMetadata
     * @param beanDefinitionRegistry
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        // 獲取所有數據源配置
        Map config, defauleDataSourceProperties;
        defauleDataSourceProperties = binder.bind("spring.datasource.master", Map.class).get();
        // 獲取數據源類型
        String typeStr = evn.getProperty("spring.datasource.master.type");
        // 獲取數據源類型
        Class<? extends DataSource> clazz = getDataSourceType(typeStr);
        // 綁定默認數據源參數 也就是主數據源
        DataSource consumerDatasource, defaultDatasource = bind(clazz, defauleDataSourceProperties);
        DynamicDataSourceContextHolder.dataSourceIds.add("master");
        logger.info("註冊默認數據源成功");
        // 獲取其他數據源配置
        List<Map> configs = binder.bind("spring.datasource.cluster", Bindable.listOf(Map.class)).get();
        // 遍歷從數據源
        for (int i = 0; i < configs.size(); i++) {
            config = configs.get(i);
            clazz = getDataSourceType((String) config.get("type"));
            defauleDataSourceProperties = config;
            // 綁定參數
            consumerDatasource = bind(clazz, defauleDataSourceProperties);
            // 獲取數據源的key，以便通過該key可以定位到數據源
            String key = config.get("key").toString();
            customDataSources.put(key, consumerDatasource);
            // 數據源上下文，用於管理數據源與記錄已經註冊的數據源key
            DynamicDataSourceContextHolder.dataSourceIds.add(key);
            logger.info("註冊數據源{}成功", key);
        }
        // bean定義類
        GenericBeanDefinition define = new GenericBeanDefinition();
        // 設置bean的類型，此處DynamicRoutingDataSource是繼承AbstractRoutingDataSource的實現類
        define.setBeanClass(DynamicRoutingDataSource.class);
        // 需要注入的參數
        MutablePropertyValues mpv = define.getPropertyValues();
        // 添加默認數據源，避免key不存在的情況沒有數據源可用
        mpv.add("defaultTargetDataSource", defaultDatasource);
        // 添加其他數據源
        mpv.add("targetDataSources", customDataSources);
        // 將該bean註冊爲datasource，不使用springboot自動生成的datasource
        beanDefinitionRegistry.registerBeanDefinition("datasource", define);
        logger.info("註冊數據源成功，一共註冊{}個數據源", customDataSources.keySet().size() + 1);
    }

    /**
     * 通過字符串獲取數據源class對象
     *
     * @param typeStr
     * @return
     */
    private Class<? extends DataSource> getDataSourceType(String typeStr) {
        Class<? extends DataSource> type;
        try {
            if (StringUtils.hasLength(typeStr)) {
                // 字符串不爲空則通過反射獲取class對象
                type = (Class<? extends DataSource>) Class.forName(typeStr);
            } else {
                // 默認爲hikariCP數據源，與springboot默認數據源保持一致
                type = HikariDataSource.class;
            }
            return type;
        } catch (Exception e) {
            throw new IllegalArgumentException("can not resolve class with type: " + typeStr); //無法通過反射獲取class對象的情況則拋出異常，該情況一般是寫錯了，所以此次拋出一個runtimeexception
        }
    }

    /**
     * 綁定參數，以下三個方法都是參考DataSourceBuilder的bind方法實現的，目的是儘量保證我們自己添加的數據源構造過程與springboot保持一致
     *
     * @param result
     * @param properties
     */
    private void bind(DataSource result, Map properties) {
        ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
        Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
        // 將參數綁定到對象
        binder.bind(ConfigurationPropertyName.EMPTY, Bindable.ofInstance(result));
    }

    private <T extends DataSource> T bind(Class<T> clazz, Map properties) {
        ConfigurationPropertySource source = new MapConfigurationPropertySource(properties);
        Binder binder = new Binder(new ConfigurationPropertySource[]{source.withAliases(aliases)});
        // 通過類型綁定參數並獲得實例對象
        return binder.bind(ConfigurationPropertyName.EMPTY, Bindable.of(clazz)).get();
    }

    /**
     * @param clazz
     * @param sourcePath 參數路徑，對應配置文件中的值，如: spring.datasource
     * @param <T>
     * @return
     */
    private <T extends DataSource> T bind(Class<T> clazz, String sourcePath) {
        Map properties = binder.bind(sourcePath, Map.class).get();
        return bind(clazz, properties);
    }

    /**
     * EnvironmentAware接口的實現方法，通過aware的方式注入，此處是environment對象
     *
     * @param environment
     */
    @Override
    public void setEnvironment(Environment environment) {
        logger.info("開始註冊數據源");
        this.evn = environment;
        // 綁定配置器
        binder = Binder.get(evn);
    }
}

package com.zxht.smart.environment.datasource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicRoutingDataSource extends AbstractRoutingDataSource  {

	
	private static Logger logger = LoggerFactory.getLogger(DynamicRoutingDataSource.class);

    @Override
    protected Object determineCurrentLookupKey() {
        String dataSourceName = DynamicDataSourceContextHolder.getDataSourceRouterKey();
        logger.info("當前數據源是：{}", dataSourceName);
        return DynamicDataSourceContextHolder.getDataSourceRouterKey();
    }
}

然後配置文件添加雙數據源

#配置數據源
spring:
  datasource:
    master: 
      url: xxxx1
      username: xxxx1
      password: xxxx1
      driver-class-name: oracle.jdbc.OracleDriver
      type: com.zaxxer.hikari.HikariDataSource
    cluster: 
    - key: economy
      url: xxxx2
      username: xxxx2
      password: xxxx2
      driver-class-name: oracle.jdbc.OracleDriver
      type: com.zaxxer.hikari.HikariDataSource

master是主數據源也是默認的，cluster爲第二個數據源，key的值就是下面要用到的值

然後寫個註解類：

package com.zxht.smart.environment.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 切換數據註解 可以用於類或者方法級別 方法級別優先級 > 類級別
 */
@Target({ElementType.METHOD, ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
	String value() default "master"; //該值即key值
}

註解默認值是master ，也就是主數據源

記錄一下踩過的坑，第一個類DynamicDataSourceAspect，因爲是在網上找的素材，

改動之前是這樣的：

public class DynamicDataSourceAspect {

	
	private static final Logger logger = LoggerFactory.getLogger(DynamicDataSourceAspect.class);

    @Before("@annotation(ds)")
    public void changeDataSource(JoinPoint point, DataSource ds) throws Throwable {
        String dsId = ds.value();
        if (DynamicDataSourceContextHolder.dataSourceIds.contains(dsId)) {
            logger.debug("Use DataSource :{} >", dsId, point.getSignature());
            
        } else {
            logger.info("數據源[{}]不存在，使用默認數據源 >{}", dsId, point.getSignature());
            //這行代碼一開始是放在這裏的，所以導致註冊不上數據源
            DynamicDataSourceContextHolder.setDataSourceRouterKey(dsId);
        }
    }

所以啓動的時候數據源註冊不上，經過幾次debug之後， DynamicDataSourceContextHolder.setDataSourceRouterKey(dsId);這行代碼應該放在if 裏面，而不是else裏面，根據自己需求吧 else裏面也可以放這行代碼，只不過是找不到數據源的時候你可以使用默認的或者是其他的數據源

最後動態切換數據源

只需要在dao層上加上註解即可

package com.zxht.smart.environment.dao;

import java.util.List;

import org.apache.ibatis.annotations.Mapper;

import com.zxht.smart.environment.annotation.DataSource;
import com.zxht.smart.environment.entity.YkljSanitationResult;

@Mapper
public interface YkljSanitationResultDao {

	@DataSource("economy")
	List<xxxxxxResult> xxxxxxResult();
}

使用默認的數據源括號裏面不用給值

最後啓動類上別忘了加import註解

package com.zxht.smart.environment;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Import;
import org.springframework.scheduling.annotation.EnableScheduling;

import com.zxht.smart.environment.datasource.DynamicDataSourceRegister;


@SpringBootApplication
@EnableScheduling
@Import({DynamicDataSourceRegister.class}) // 註冊動態多數據源
public class SmartEnvironmentSystemApplication {

	public static void main(String[] args) {
		SpringApplication.run(SmartEnvironmentSystemApplication.class, args);
	}

}

至此完成數據源的動態切換。

springboot 配置動態切換數據源（兩個oracle數據庫）

Seata實戰-分佈式事務簡介及demo上手

Tomcat配置JNDI連接池 getConnection()獲取不到連接

springboot 配置動態切換數據源（兩個oracle數據庫）

springboot 定時任務使用

解決unicode轉碼

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結