Spring, MyBatis 多數據源的配置和管理

同一個項目有時會涉及到多個數據庫，也就是多數據源。多數據源又能夠分爲兩種狀況：

1）兩個或多個數據庫沒有相關性，各自獨立，其實這種能夠做爲兩個項目來開發。好比在遊戲開發中一個數據庫是平臺數據庫，其它還有平臺下的遊戲對應的數據庫；

2）兩個或多個數據庫是master-slave的關係，好比有mysql搭建一個 master-master，其後又帶有多個slave；或者採用MHA搭建的master-slave複製；

目前我所知道的 Spring 多數據源的搭建大概有兩種方式，能夠根據多數據源的狀況進行選擇。

1. 採用spring配置文件直接配置多個數據源

好比針對兩個數據庫沒有相關性的狀況，能夠採用直接在spring的配置文件中配置多個數據源，而後分別進行事務的配置，以下所示：

    <context:component-scan base-package="net.aazj.service,net.aazj.aop" />
    <context:component-scan base-package="net.aazj.aop" />
    <!-- 引入屬性文件 -->
    <context:property-placeholder location="classpath:config/db.properties" />

    <!-- 配置數據源 -->
    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc_url}" />
        <property name="username" value="${jdbc_username}" />
        <property name="password" value="${jdbc_password}" />
        <!-- 初始化鏈接大小 -->
        <property name="initialSize" value="0" />
        <!-- 鏈接池最大使用鏈接數量 -->
        <property name="maxActive" value="20" />
        <!-- 鏈接池最大空閒 -->
        <property name="maxIdle" value="20" />
        <!-- 鏈接池最小空閒 -->
        <property name="minIdle" value="0" />
        <!-- 獲取鏈接最大等待時間 -->
        <property name="maxWait" value="60000" />
    </bean>
    
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
      <property name="dataSource" ref="dataSource" />
      <property name="configLocation" value="classpath:config/mybatis-config.xml" />
      <property name="mapperLocations" value="classpath*:config/mappers/**/*.xml" />
    </bean>
    
    <!-- Transaction manager for a single JDBC DataSource -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    
    <!-- 使用annotation定義事務 -->
    <tx:annotation-driven transaction-manager="transactionManager" /> 
    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
      <property name="basePackage" value="net.aazj.mapper" />
      <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>

    <!-- Enables the use of the @AspectJ style of Spring AOP -->
    <aop:aspectj-autoproxy/>
    
    <!-- ===============第二個數據源的配置=============== -->
    <bean name="dataSource_2" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc_url_2}" />
        <property name="username" value="${jdbc_username_2}" />
        <property name="password" value="${jdbc_password_2}" />
        <!-- 初始化鏈接大小 -->
        <property name="initialSize" value="0" />
        <!-- 鏈接池最大使用鏈接數量 -->
        <property name="maxActive" value="20" />
        <!-- 鏈接池最大空閒 -->
        <property name="maxIdle" value="20" />
        <!-- 鏈接池最小空閒 -->
        <property name="minIdle" value="0" />
        <!-- 獲取鏈接最大等待時間 -->
        <property name="maxWait" value="60000" />
    </bean>
    
    <bean id="sqlSessionFactory_slave" class="org.mybatis.spring.SqlSessionFactoryBean">
      <property name="dataSource" ref="dataSource_2" />
      <property name="configLocation" value="classpath:config/mybatis-config-2.xml" />
      <property name="mapperLocations" value="classpath*:config/mappers2/**/*.xml" />
    </bean>
    
    <!-- Transaction manager for a single JDBC DataSource -->
    <bean id="transactionManager_2" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource_2" />
    </bean>
    
    <!-- 使用annotation定義事務 -->
    <tx:annotation-driven transaction-manager="transactionManager_2" /> 
    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
      <property name="basePackage" value="net.aazj.mapper2" />
      <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory_2"/>
    </bean>

如上所示，咱們分別配置了兩個 dataSource，兩個sqlSessionFactory，兩個transactionManager，以及關鍵的地方在於MapperScannerConfigurer 的配置——使用sqlSessionFactoryBeanName屬性，注入不一樣的sqlSessionFactory的名稱，這樣的話，就爲不一樣的數據庫對應的 mapper 接口注入了對應的 sqlSessionFactory。

須要注意的是，多個數據庫的這種配置是不支持分佈式事務的，也就是同一個事務中，不能操做多個數據庫。這種配置方式的優勢是很簡單，可是卻不靈活。對於master-slave類型的多數據源配置而言不太適應，master-slave性的多數據源的配置，須要特別靈活，須要根據業務的類型進行細緻的配置。好比對於一些耗時特別大的select語句，咱們但願放到slave上執行，而對於update,delete等操做確定是只能在master上執行的，另外對於一些實時性要求很高的select語句，咱們也可能須要放到master上執行——好比一個場景是我去商城購買一件兵器，購買操做的很定是master，同時購買完成以後，須要從新查詢出我所擁有的兵器和金幣，那麼這個查詢可能也須要防止master上執行，而不能放在slave上去執行，由於slave上可能存在延時，咱們可不但願玩家發現購買成功以後，在揹包中卻找不到兵器的狀況出現。

因此對於master-slave類型的多數據源的配置，須要根據業務來進行靈活的配置，哪些select能夠放到slave上，哪些select不能放到slave上。因此上面的那種所數據源的配置就不太適應了。

2. 基於 AbstractRoutingDataSource 和 AOP 的多數據源的配置

基本原理是，咱們本身定義一個DataSource類ThreadLocalRountingDataSource，來繼承AbstractRoutingDataSource，而後在配置文件中向ThreadLocalRountingDataSource注入 master 和 slave 的數據源，而後經過 AOP 來靈活配置，在哪些地方選擇  master 數據源，在哪些地方須要選擇 slave數據源。下面看代碼實現：

1）先定義一個enum來表示不一樣的數據源：

package net.aazj.enums;

/**
 * 數據源的類別：master/slave
 */
public enum DataSources {
    MASTER, SLAVE
}

2）經過 TheadLocal 來保存每一個線程選擇哪一個數據源的標誌(key)：

package net.aazj.util;

import net.aazj.enums.DataSources;

public class DataSourceTypeManager {
    private static final ThreadLocal<DataSources> dataSourceTypes = new ThreadLocal<DataSources>(){
        @Override
        protected DataSources initialValue(){
            return DataSources.MASTER;
        }
    };
    
    public static DataSources get(){
        return dataSourceTypes.get();
    }
    
    public static void set(DataSources dataSourceType){
        dataSourceTypes.set(dataSourceType);
    }
    
    public static void reset(){
        dataSourceTypes.set(DataSources.MASTER0);
    }
}

3）定義 ThreadLocalRountingDataSource，繼承AbstractRoutingDataSource：

package net.aazj.util;

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

public class ThreadLocalRountingDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceTypeManager.get();
    }
}

4）在配置文件中向 ThreadLocalRountingDataSource 注入 master 和 slave 的數據源：

    <context:component-scan base-package="net.aazj.service,net.aazj.aop" />
    <context:component-scan base-package="net.aazj.aop" />
    <!-- 引入屬性文件 -->
    <context:property-placeholder location="classpath:config/db.properties" />    
    <!-- 配置數據源Master -->
    <bean name="dataSourceMaster" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc_url}" />
        <property name="username" value="${jdbc_username}" />
        <property name="password" value="${jdbc_password}" />
        <!-- 初始化鏈接大小 -->
        <property name="initialSize" value="0" />
        <!-- 鏈接池最大使用鏈接數量 -->
        <property name="maxActive" value="20" />
        <!-- 鏈接池最大空閒 -->
        <property name="maxIdle" value="20" />
        <!-- 鏈接池最小空閒 -->
        <property name="minIdle" value="0" />
        <!-- 獲取鏈接最大等待時間 -->
        <property name="maxWait" value="60000" />
    </bean>    
    <!-- 配置數據源Slave -->
    <bean name="dataSourceSlave" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc_url_slave}" />
        <property name="username" value="${jdbc_username_slave}" />
        <property name="password" value="${jdbc_password_slave}" />
        <!-- 初始化鏈接大小 -->
        <property name="initialSize" value="0" />
        <!-- 鏈接池最大使用鏈接數量 -->
        <property name="maxActive" value="20" />
        <!-- 鏈接池最大空閒 -->
        <property name="maxIdle" value="20" />
        <!-- 鏈接池最小空閒 -->
        <property name="minIdle" value="0" />
        <!-- 獲取鏈接最大等待時間 -->
        <property name="maxWait" value="60000" />
    </bean>    
    <bean id="dataSource" class="net.aazj.util.ThreadLocalRountingDataSource">
        <property name="defaultTargetDataSource" ref="dataSourceMaster" />
        <property name="targetDataSources">
            <map key-type="net.aazj.enums.DataSources">
                <entry key="MASTER" value-ref="dataSourceMaster"/>
                <entry key="SLAVE" value-ref="dataSourceSlave"/>
                <!-- 這裏還能夠加多個dataSource -->
            </map>
        </property>
    </bean>    
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
      <property name="dataSource" ref="dataSource" />
      <property name="configLocation" value="classpath:config/mybatis-config.xml" />
      <property name="mapperLocations" value="classpath*:config/mappers/**/*.xml" />
    </bean>    
    <!-- Transaction manager for a single JDBC DataSource -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>    
    <!-- 使用annotation定義事務 -->
    <tx:annotation-driven transaction-manager="transactionManager" /> 
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
      <property name="basePackage" value="net.aazj.mapper" />
      <!-- <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/> -->
    </bean>        

上面spring的配置文件中，咱們針對master數據庫和slave數據庫分別定義了dataSourceMaster和dataSourceSlave兩個dataSource，而後注入到<bean id="dataSource" class="net.aazj.util.ThreadLocalRountingDataSource"> 中，這樣咱們的dataSource就能夠來根據 key 的不一樣來選擇dataSourceMaster和 dataSourceSlave了。

5）使用Spring AOP 來指定 dataSource 的 key ，從而dataSource會根據key選擇 dataSourceMaster 和 dataSourceSlave：

package net.aazj.aop;

import net.aazj.enums.DataSources;
import net.aazj.util.DataSourceTypeManager;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect    // for aop
@Component // for auto scan
@Order(0)  // execute before @Transactional
public class DataSourceInterceptor {    
    @Pointcut("execution(public * net.aazj.service..*.getUser(..))")
    public void dataSourceSlave(){};
    
    @Before("dataSourceSlave()")
    public void before(JoinPoint jp) {
        DataSourceTypeManager.set(DataSources.SLAVE);
    }
    // ... ...
}

這裏咱們定義了一個 Aspect 類，咱們使用 @Before 來在符合 @Pointcut("execution(public * net.aazj.service..*.getUser(..))") 中的方法被調用以前，調用 DataSourceTypeManager.set(DataSources.SLAVE) 設置了 key 的類型爲 DataSources.SLAVE，因此 dataSource 會根據key=DataSources.SLAVE 選擇 dataSourceSlave 這個dataSource。因此該方法對於的sql語句會在slave數據庫上執行(經網友老劉1987提醒，這裏存在多個Aspect之間的一個執行順序的問題，必須保證切換數據源的Aspect必須在@Transactional這個Aspect以前執行，因此這裏使用了@Order(0)來保證切換數據源先於@Transactional執行)。

咱們能夠不斷的擴充 DataSourceInterceptor  這個 Aspect，在中進行各類各樣的定義，來爲某個service的某個方法指定合適的數據源對應的dataSource。

這樣咱們就能夠使用 Spring AOP 的強大功能來，十分靈活進行配置了。

6）AbstractRoutingDataSource原理剖析

ThreadLocalRountingDataSource繼承了AbstractRoutingDataSource，實現其抽象方法protected abstract Object determineCurrentLookupKey(); 從而實現對不一樣數據源的路由功能。咱們從源碼入手分析下其中原理：

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean

AbstractRoutingDataSource 實現了 InitializingBean 那麼spring在初始化該bean時，會調用InitializingBean的接口
void afterPropertiesSet() throws Exception; 咱們看下AbstractRoutingDataSource是如何實現這個接口的：

    @Override
    public void afterPropertiesSet() {
        if (this.targetDataSources == null) {
            throw new IllegalArgumentException("Property 'targetDataSources' is required");
        }
        this.resolvedDataSources = new HashMap<Object, DataSource>(this.targetDataSources.size());
        for (Map.Entry<Object, Object> entry : this.targetDataSources.entrySet()) {
            Object lookupKey = resolveSpecifiedLookupKey(entry.getKey());
            DataSource dataSource = resolveSpecifiedDataSource(entry.getValue());
            this.resolvedDataSources.put(lookupKey, dataSource);
        }
        if (this.defaultTargetDataSource != null) {
            this.resolvedDefaultDataSource = resolveSpecifiedDataSource(this.defaultTargetDataSource);
        }
    }

targetDataSources 是咱們在xml配置文件中注入的 dataSourceMaster 和 dataSourceSlave. afterPropertiesSet方法就是使用注入的
dataSourceMaster 和 dataSourceSlave來構造一個HashMap——resolvedDataSources。方便後面根據 key 從該map 中取得對應的dataSource。
咱們在看下 AbstractDataSource 接口中的 Connection getConnection() throws SQLException; 是如何實現的：

    @Override
    public Connection getConnection() throws SQLException {
        return determineTargetDataSource().getConnection();
    }

關鍵在於 determineTargetDataSource()，根據方法名就能夠看出，應該此處就決定了使用哪一個 dataSource ：

    protected DataSource determineTargetDataSource() {
        Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
        Object lookupKey = determineCurrentLookupKey();
        DataSource dataSource = this.resolvedDataSources.get(lookupKey);
        if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
            dataSource = this.resolvedDefaultDataSource;
        }
        if (dataSource == null) {
            throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
        }
        return dataSource;
    }

Object lookupKey = determineCurrentLookupKey(); 該方法是咱們實現的，在其中獲取ThreadLocal中保存的 key 值。得到了key以後，
在從afterPropertiesSet()中初始化好了的resolvedDataSources這個map中得到key對應的dataSource。而ThreadLocal中保存的 key 值
是經過AOP的方式在調用service中相關方法以前設置好的。OK，到此搞定！

7）擴展 ThreadLocalRountingDataSource

上面咱們只是實現了 master-slave 數據源的選擇。若是有多臺 master 或者有多臺 slave。多臺master組成一個HA，要實現當其中一臺master掛了是，自動切換到另外一臺master，這個功能能夠使用LVS/Keepalived來實現，也能夠經過進一步擴展ThreadLocalRountingDataSource來實現，能夠另外加一個線程專門來每一個一秒來測試mysql是否正常來實現。一樣對於多臺slave之間要實現負載均衡，同時當一臺slave掛了時，要實現將其從負載均衡中去除掉，這個功能既能夠使用LVS/Keepalived來實現，一樣也能夠經過近一步擴展ThreadLocalRountingDataSource來實現。

3. 總結

從本文中咱們能夠體會到AOP的強大和靈活。

本文使用的是mybatis,其實使用Hibernate也應該是類似的配置。