其實這裡介紹的東西主要是參考的另外一篇文章，資料庫讀寫分離的。

讀寫分離的功能我已經使用replication整合好了，因為我們需要單獨設定每個資料來源的連結屬性，而且使用的還是Hikari資料來源，所以又在網上找了兩天，最終昨天晚上發現了這種方式。
我這裡說說自己整合的時候的一些注意點。

配置檔案：

hikari:
  master:
    jdbc-url: jdbc:mysql://masterhost:3306/testdb?useUnicode=true&characterEncoding=utf8&useSSL=true&allowMultiQueries=true&verifyServerCertificate=false
 

    username: root
    password: root
    maximum-pool-size: 20
    pool-name: master
    connection-timeout: 30000
    idle-timeout: 600000
    max-lifetime: 1765000
  slave:
    jdbc-url: jdbc:mysql://slavehost:3306/testdb?useUnicode=true&characterEncoding=utf8&useSSL=true&allowMultiQueries=true&verifyServerCertificate=false
 

    username: root
    password: root
    maximum-pool-size: 80
    pool-name: slave
    connection-timeout: 30000
    idle-timeout: 600000
    max-lifetime: 1765000
    read-only: true

我這裡主要用到的是maximum-pool-size這個值，一般情況下讀資料庫（slave）總會比寫（master）要多一些，而且往往是一個master多個slave。所以，maximum-pool-size這個值在master的設定小於slave比較高效。

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @author Created by pangkunkun on 2017/12/18.
 */
@Component
@ConfigurationProperties(prefix = "hikari")
public class DBProperties {
    private HikariDataSource master;
    private HikariDataSource slave;

    public HikariDataSource getMaster() {
        return master;
    }

    public void setMaster(HikariDataSource master) {
        this.master = master;
    }

    public HikariDataSource getSlave() {
        return slave;
    }

    public void setSlave(HikariDataSource slave) {
        this.slave = slave;
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 * @author Created by pangkunkun on 2017/12/18.
 */
@Configuration
@EnableScheduling
public class DataSourceConfig {

    @Autowired
    private DBProperties properties;

    @Bean(name = "dataSource")
    public DataSource dataSource() {
        //按照目標資料來源名稱和目標資料來源物件的對映存放在Map中
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("master", properties.getMaster());
        targetDataSources.put("slave", properties.getSlave());
        //採用是想AbstractRoutingDataSource的物件包裝多資料來源
        DynamicDataSource dataSource = new DynamicDataSource();
        dataSource.setTargetDataSources(targetDataSources);
        //設定預設的資料來源，當拿不到資料來源時，使用此配置
        dataSource.setDefaultTargetDataSource(properties.getMaster());
        return dataSource;
    }

    @Bean
    public PlatformTransactionManager txManager() {
        return new DataSourceTransactionManager(dataSource());
    }
}

import com.easyar.cloud.cms.common.util.TargetDataSource;
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.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @author Created by pangkunkun on 2017/12/18.
 */
@Component
@Aspect
public class DataSourceAspect {


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

    //切換放在mapper介面的方法上，所以這裡要配置AOP切面的切入點
    @Pointcut("execution( * com.easyar.cloud.cms.dao.mapper.*.*(..))||execution( * com.easyar.cloud.cms.shiro.mapper.*.*(..))")
    public void dataSourcePointCut() {
    }

    @Before("dataSourcePointCut()")
    public void before(JoinPoint joinPoint) {
        Object target = joinPoint.getTarget();
        String method = joinPoint.getSignature().getName();
        Class<?>[] clazz = target.getClass().getInterfaces();
        Class<?>[] parameterTypes = ((MethodSignature) joinPoint.getSignature()).getMethod().getParameterTypes();
        try {
            Method m = clazz[0].getMethod(method, parameterTypes);
            //如果方法上存在切換資料來源的註解，則根據註解內容進行資料來源切換
            if (m != null && m.isAnnotationPresent(TargetDataSource.class)) {
                TargetDataSource data = m.getAnnotation(TargetDataSource.class);
                String dataSourceName = data.value();
                DynamicDataSourceHolder.putDataSource(dataSourceName);
                log.debug("current thread " + Thread.currentThread().getName() + " add " + dataSourceName + " to ThreadLocal");
            } else {
                log.debug("switch datasource fail,use default");
            }
        } catch (Exception e) {
            log.error("current thread " + Thread.currentThread().getName() + " add data to ThreadLocal error", e);
        }
    }

    //執行完切面後，將執行緒共享中的資料來源名稱清空
    @After("dataSourcePointCut()")
    public void after(JoinPoint joinPoint){
        DynamicDataSourceHolder.removeDataSource();
    }

}

上面這些程式碼的結合充分的解決了在看其他文章的時候對資料來源引入的部分疑問。
DBProperties這裡直接將配置檔案中的配置引數通過spring的註解讀取對映成HikariDataSource，在DataSourceConfig 將其載入。

文章中@TargetDataSource的註解是在mapper方法上，但是事物註解@Transactional一般都是在serviceImpl上，當@Transactional先於@TargetDataSource生效的時候根據自己的設定往往會找到預設的資料來源（我設定的是master）。

後來仔細想了下，將@Transactional註解由原來的類註解改為具體到方法上，而且一般用到@Transactional的地方都是增刪改，而且只要涉及到增刪改的請求（即使可能附帶查詢）都是要使用master資料來源的。所以，最終我們將@Transactional註解指定到具體某個增刪改的方法上，@TargetDataSource依然是在mapper的方法中。

這裡寫的東西不多，具體的還是參考人家的原文吧，如果有啥問題可以給我留言大家一起探討。