Spring, MyBatis 多数据源的配置和管理

时间 2019-11-21

原文原文链接

同一个项目有时会涉及到多个数据库，也就是多数据源。多数据源又能够分为两种状况：java

1）两个或多个数据库没有相关性，各自独立，其实这种能够做为两个项目来开发。好比在游戏开发中一个数据库是平台数据库，其它还有平台下的游戏对应的数据库；mysql

2）两个或多个数据库是master-slave的关系，好比有mysql搭建一个 master-master，其后又带有多个slave；或者采用MHA搭建的master-slave复制；目前我所知道的 Spring 多数据源的搭建大概有两种方式，能够根据多数据源的状况进行选择。spring

1. 采用spring配置文件直接配置多个数据源 sql

好比针对两个数据库没有相关性的状况，能够采用直接在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。mybatis

须要注意的是，多个数据库的这种配置是不支持分布式事务的，也就是同一个事务中，不能操做多个数据库。这种配置方式的优势是很简单，可是却不灵活。对于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} app

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：ide

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 的数据源：ui

<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
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数据库上执行。

咱们能够不断的扩充 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，到此搞定！3. 总结从本文中咱们能够体会到AOP的强大和灵活。

本文使用的是mybatis,其实使用Hibernate也应该是类似的配置。