继承AbstractRoutingDataSource再通过AOP实现动态数据源切换

package com.zdd.data.aspect;

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

import org.apache.commons.lang3.StringUtils;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * 获取数据源
 * 

 */
public class ChooseDataSource extends AbstractRoutingDataSource {
    public static Map<String, List<String>> METHODTYPE = new HashMap<String, List<String>>();

    // 获取数据源名称
    protected Object determineCurrentLookupKey() {
        System.out.println(HandleDataSource.getDataSource());
        return HandleDataSource.getDataSource();
    }

    // 设置方法名前缀对应的数据源
    public void setMethodType(Map<String, String> map) {
        for (String key : map.keySet()) {
            List<String> v = new ArrayList<String>();
            String[] types = map.get(key).split(",");
            for (String type : types) {
                if (StringUtils.isNotBlank(type)) {
                    v.add(type);
                }
            }
            METHODTYPE.put(key, v);
        }
    }
}

package com.zdd.data.aspect;

import org.apache.commons.lang3.StringUtils;
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.slf4j.LoggerFactory;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;




@Aspect
@EnableAspectJAutoProxy(proxyTargetClass = true)
@Component
public class DataSourceAspect {
    private final org.slf4j.Logger logger = LoggerFactory.getLogger(DataSourceAspect.class);

    @Pointcut("execution(* com.zdd.data.service.impl.*.*(..))")
    public void aspect() {}
        
        

    /**
     * 配置前置通知,使用在方法aspect()上注册的切入点
     */
    @Before("aspect()")
    public void before(JoinPoint point) {
        String className = point.getTarget().getClass().getName();
        String method = point.getSignature().getName();
        logger.info(className + "." + method + "(" + StringUtils.join(point.getArgs(), ",") + ")");
        try {
            L: for (String key : ChooseDataSource.METHODTYPE.keySet()) {
                for (String type : ChooseDataSource.METHODTYPE.get(key)) {
                    if (method.startsWith(type)) {
                        System.out.println(key);
                        HandleDataSource.putDataSource(key);
                        break L;
                    }
                }
            }
        } catch (Exception e) {
            logger.error(e.toString());
            HandleDataSource.putDataSource("write");
        }
    }

    @After("aspect()")
    public void after(JoinPoint point) {
        HandleDataSource.clear();
    }
}

package com.zdd.data.aspect;

/**

 */
public class HandleDataSource {
    // 数据源名称线程池
    private static final ThreadLocal<String> holder = new ThreadLocal<String>();

    public static void putDataSource(String datasource) {
        holder.set(datasource);
    }

    public static String getDataSource() {
        return holder.get();
    }

    public static void clear() {
        holder.remove();
    }
}

　　以上是核心代码，我疑惑的地方在于AbstractRoutingDataSource这里，刚开始去看的时候不明白为什么继承这个就能实现数据源切换，

最后进入AbstractRoutingDataSource.class去查看究竟，发现继承了一个AbstractDataSource的抽象类，

这里我突然有点明白AbstractRoutingDataSource的意思，一个路由数据源，一般用到Routing的地方都可以进行动态配置

• 

  大致翻译一下源码作者对这个类的说明：调用一个基于各种目标数据源

      继续往下看又看到几个重要信息

    

     上图发现2个方法分别是setTargetDataSources(注入目标数据源) 和setDefaultTargetDataSource(注入默认的数据源);

然后脑海里想到是可以通过spring xml 配置来注入这2个方法,带着这个思绪继续接着继续往下看;关于看源码一定要看个究竟，

不然云里雾绕的。然后又看到比较重要的信息如下：

 上图发现有getConnection方法,jdbc获取连接的方法,而当我点进determineTargetDataSource方法时得到了一个确切答案，代码如下：

 　　上图大致的意思是会调用determineCurrentLookupKey这个抽象方法获取数据源，如果是null则获取默认的数据源,反之则是获取我们注入的数据源, 这样就实现了数据源

的动态切换, 这时候我通过断点启动也验证了这一个流程确实如此。

---

   分析了一个动态切换流程后，那么问题来了，如何让我们的代码实现这个功能呢？其实就是重写AbstractRoutingDataSource方法后

再通过aop动态切换数据源，那么如何知道切换条件是什么？这时候可以根据Service层的方法来确定，一般我们Service都是会以find,add,delete,update 开头;

例如发现是find,get开头则走读库，delete,update则走写库。

  分析完后把spring配置文件贴上来

<bean id="dataSource" class="com.zdd.data.aspect.ChooseDataSource" lazy-init="true">
        <description>数据源</description>
        <property name="targetDataSources">
            <map key-type="java.lang.String" value-type="javax.sql.DataSource">
                <!-- write -->
                <entry key="write" value-ref="writedataSource" />
                <!-- read -->
                <entry key="read" value-ref="readdataSource" />
            </map>
        </property>
        <!-- 设置默认的目标数据源为读 -->
        <property name="defaultTargetDataSource" ref="readdataSource" />
        <property name="methodType">
            <map key-type="java.lang.String">
                <!-- read -->
                <entry key="read" value=",get,,find,select,count,list,query," />
                <!-- write -->
                <entry key="write" value=",add,insert,create,update,delete,remove," />
            </map>
        </property>
    </bean>

   上面的配置大概流程是先指定2个数据源注入targetDataSources，然后配置一组数组用来存放判断走读库还是写库的条件,如果是read那么肯定是把read注入的数据源拿出来，

如果是write则把write的数据源取出来。

   但是这时候会有一个奇怪的现象就是每次调用的时候会走chooseDataSource再走AOP，方法解决很简单，设置一下AOP的优先级，如下图：