多数据源动态配置及事务控制

Posted qingchen521

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了多数据源动态配置及事务控制相关的知识,希望对你有一定的参考价值。

1、动态数据源切换时,如何保证事务

  目前事务最灵活的方式,是使用spring的声明式事务,本质是利用了spring的aop,在执行数据库操作前后,加上事务处理。

  spring的事务管理,是基于数据源的,所以如果要实现动态数据源切换,而且在同一个数据源中保证事务是起作用的话,就需要注意二者的顺序问题,即:在事务起作用之前就要把数据源切换回来。

  举一个例子:web开发常见是三层结构:controller、service、dao。一般事务都会在service层添加,如果使用spring的声明式事务管理,在调用service层代码之前,spring会通过aop的方式动态添加事务控制代码,所以如果要想保证事务是有效的,那么就必须在spring添加事务之前把数据源动态切换过来,也就是动态切换数据源的aop要至少在service上添加,而且要在spring声明式事务aop之前添加.根据上面分析:

  • 最简单的方式是把动态切换数据源的aop加到controller层,这样在controller层里面就可以确定下来数据源了。不过,这样有一个缺点就是,每一个controller绑定了一个数据源,不灵活。对于这种:一个请求,需要使用两个以上数据源中的数据完成的业务时,就无法实现了。
  • 针对上面的这种问题,可以考虑把动态切换数据源的aop放到service层,但要注意一定要在事务aop之前来完成。这样,对于一个需要多个数据源数据的请求,我们只需要在controller里面注入多个service实现即可。但这种做法的问题在于,controller层里面会涉及到一些不必要的业务代码,例如:合并两个数据源中的list…
  • 此外,针对上面的问题,还可以再考虑一种方案,就是把事务控制到dao层,然后在service层里面动态切换数据源。

2、实例

本例子中,对不同数据源分包(package)管理,同一包下的代码使用了同一数据源。
1、写一个DynamicDataSource类继承AbstractRoutingDataSource,并实现determineCurrentLookupKey方法

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DatabaseContextHolder.getCustomerType(); 
  }
}

2、利用ThreadLocal解决线程安全问题:

public class DatabaseContextHolder {
    public static final String DATA_SOURCE_A = "dataSource";
    public static final String DATA_SOURCE_B = "dataSource2";
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();
    public static void setCustomerType(String customerType) {
        contextHolder.set(customerType);
    }
    public static String getCustomerType() {
        return contextHolder.get();
    }
    public static void clearCustomerType() {
        contextHolder.remove();
    }
}

3、定义一个数据源切面类,通过aop来控制数据源的切换:

import org.aspectj.lang.JoinPoint;

public class DataSourceInterceptor {

    public void setdataSourcemysql(JoinPoint jp) {
        DatabaseContextHolder.setCustomerType("dataSourceMySql");
    }
    
    public void setdataSourceOracle(JoinPoint jp) {
        DatabaseContextHolder.setCustomerType("dataSourceOracle");
    }
}

4、在spring的application.xml中配置多个dataSource:

<!-- 数据源1 -->
<bean id="dataSourceMysql" class="org.apache.commons.dbcp.BasicDataSource">
           <property name="driverClassName" value="net.sourceforge.jtds.jdbc.Driver"></property>
        <property name="url" value="jdbc:jtds:sqlserver://1.1.1.1:3306;databaseName=standards"></property>
        <property name="username" value="admin"></property>
        <property name="password" value="admin"></property>
</bean>
<!-- 数据源2 -->
<bean id="dataSourceOracle" class="org.apache.commons.dbcp.BasicDataSource">
           <property name="driverClassName" value="net.sourceforge.jtds.jdbc.Driver"></property>
        <property name="url" value="jdbc:jtds:sqlserver://2.2.2.2:1433;databaseName=standards"></property>
        <property name="username" value="admin"></property>
        <property name="password" value="admin"></property>
</bean>

<bean id="dataSource" class="com.core.DynamicDataSource">
    <property name="targetDataSources">
        <map key-type="java.lang.String">
            <entry key="dataSourceMySql" value-ref="dataSourceMySql" />
            <entry key="dataSourceOracle" value-ref="dataSourceOracle" />
        </map>
    </property>
    <property name="defaultTargetDataSource" ref="dataSourceMySql" /> <!-- 默认使用的数据源 -->
</bean>

<!-- 动态数据源切换aop 先与事务的aop  -->
<bean id="dataSourceInterceptor" class="com.core.DataSourceInterceptor" />
<aop:config>
    <aop:aspect id="dataSourceAspect" ref="dataSourceInterceptor">
        <aop:pointcut id="dsMysql" expression="execution(* com.service.mysql..*.*(..))" />
        <aop:pointcut id="dsOracle" expression="execution(* com.service.oracle..*.*(..))" />
        <aop:before method="setdataSourceMysql" pointcut-ref="dsMysql"/>
        <aop:before method="setdataSourceOracle" pointcut-ref="dsOracle"/>
    </aop:aspect>
</aop:config>

<!-- 事务管理器, Jdbc单数据源事务 -->
<bean id="transactionManager"   class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!-- 使用annotation定义事务 proxy-target-class="true"-->
<tx:annotation-driven transaction-manager="transactionManager"/>

3、DynamicDataSource讲解

  再来说下DynamicDataSource的实现原理,DynamicDataSource实现AbstractRoutingDataSource抽象类,然后实现了determineCurrentLookupKey方法,这个方法用于选择具体使用targetDataSources中的哪一个数据源
<bean id="dataSource" class="com.core.DynamicDataSource">
    <property name="targetDataSources">
        <map key-type="java.lang.String">
            <entry key="dataSourceMySql" value-ref="dataSourceMySql" />
            <entry key="dataSourceOracle" value-ref="dataSourceOracle" />
        </map>
    </property>
    <property name="defaultTargetDataSource" ref="dataSourceMySql" /> <!-- 默认使用的数据源 -->
</bean>

  可以看到Spring配置中DynamicDataSource设置了两个属性defaultTargetDataSource和targetDataSources,这两个属性定义在AbstractRoutingDataSource,当MyBatis执行查询时会先选择数据源,选择顺序时现根据determineCurrentLookupKey方法返回的值到targetDataSources中去找,若能找到怎返回对应的数据源,若找不到返回默认的数据源defaultTargetDataSource,具体参考AbstractRoutingDataSource的源码

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {

    private Map<Object, Object> targetDataSources;

    private Object defaultTargetDataSource;

    
    /**
     * Retrieve the current target DataSource. Determines the
     * {@link #determineCurrentLookupKey() current lookup key}, performs
     * a lookup in the {@link #setTargetDataSources targetDataSources} map,
     * falls back to the specified
     * {@link #setDefaultTargetDataSource default target DataSource} if necessary.
     * @see #determineCurrentLookupKey()
     */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;
    }

    /**
     * Determine the current lookup key. This will typically be
     * implemented to check a thread-bound transaction context.
     * <p>Allows for arbitrary keys. The returned key needs
     * to match the stored lookup key type, as resolved by the
     * {@link #resolveSpecifiedLookupKey} method.
     */protected abstract Object determineCurrentLookupKey();
  
  .............

}

 




以上是关于多数据源动态配置及事务控制的主要内容,如果未能解决你的问题,请参考以下文章

多数据源 spring怎么管理事务的

如何处理spring事务与多数据源冲突问题?

Spring4 -12 -声明式事务及完整的XML配置文件信息 -声明式事务中的相关属性(tx:advice的标签)

spring事务内如何查询别的数据源

MySQL-MVCC多版本控制及事务的隔离性

MySQL-MVCC多版本控制及事务的隔离性