Spring动态切换多数据源配置----ThreadLoacl应用

背景

最近，项目中有需求，要连接多数据源，并且实现动态切换，说实在的，这个东西很早就搭建过了，以前用的SSM，在spring配置文件中配置多个数据源，自定义动态数据源类继承AbstractRoutingDataSource，重写determineCurrentLookupKey方法，配置切面等，现在是使用Springboot通过注解类的方式配置，总的来说是差不多的，里面应用到的东西也不是特别多，面向切面就不说了，重写类也只是几行代码的事，里面最重要的就是ThreadLocal的使用，以前只是照猫画虎的配置了，今天拿出来好好理解一下。

配置多数据源的主要代码

直接说各种应用肯定是懵逼么，所以先看下，ThreadLocal应用的时候是在哪里，大致起到了什么作用，之后再看具体是怎么起作用了，这样了解原理的时候就可以对照着理解了，基本是参照着renren-fast的开源项目里面的多数据源来理解的，代码可以去看源码，我这里就不全都放了，毕竟主要是理解
先看下动态数据源类。

public class DynamicDataSource extends AbstractRoutingDataSource {
	private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
	public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }
    /**
    * 这里我们重写方法，改成从ThreadLocal中拿数据源
    */
    @Override
    protected Object determineCurrentLookupKey() {
        return getDataSource();
    }

    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
    }

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

    public static void clearDataSource() {
        contextHolder.remove();
    }
}

把上面的动态数据源的家伙好好初始化一下扔给spring

/**
* 没错，纯配置类，就是相当于初始化操作
*/
@Configuration
public class DynamicDataSourceConfig {
	...//这个就不写了，没啥意思占篇幅，想看的打开源码，去支持作者吧
}

在看下切面类

public class DataSourceAspect{
	//名字为DS的注解类为切入点，切换数据源的时候@DS("NAME")打到方法头上即可
	@Pointcut("@annotation(com.xxxxx.DS)")
    public void dsPointCut() {
    }
    /*
    * 呐呐呐呐呐，spring的通知
    */
    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        //在这里检查是否有注解，并进行数据源切换
    }
}

再来看下的注解类DS吧

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DS{
    String name() default "master";
}

当然了，既然要使用多数据源，那么肯定要更改springboot默认的数据源配置

//先把默认的自动装配数据源排除掉
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})
//引入自己的动态数据源类
@Import({DynamicDataSourceConfig.class})
@EnableConfigurationProperties
public class Application{
	...
}

最后application.yml中配置下数据源

spring:
    datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        druid:
            master:  #主基础信息
                driverClassName: oracle.jdbc.OracleDriver
                url: jdbc:oracle:thin:@ip:port:dbname
                username: root
                password: xxx
            slave: #本地的基础信息（基本都用这个，全局查询的信息用主的）
            	...

基本上都全了，想要所有代码的去支持作者吧，我也没有必要再重复罗列一遍了，告诉大家都有哪些类会用到，相信大家也能完美搞定了。

ThreadLocal的详细解析

接下来进入重点了，就好像上面的代码一样，我只是把DynamicDataSource 中的代码都弄出来了，为啥呢？因为这个类里面有个ThreadLocal啊（因为我懒啊），我们切换数据源，不影响其他线程运行，靠的就是它啊。
ThreadLocal：线程本地变量，在每个线程中对 变量 会创建一个副本，多线程之间互不影响，所以它是线程安全的，这样在多线程环境下，某个线程在进行数据源切换的时候只是操作的自己的变量副本，而其他的线程该干嘛干嘛，不受影响。
代码中有用到其中的get、set、remove方法，下面我们通过源码来详细看一下
首先是 set() 方法

public class ThreadLocal<T> {
	public void set(T value) {
		//这一步是取得当前线程
	    Thread t = Thread.currentThread();
	    //获取到一个ThreadLocalMap对象
	    ThreadLocalMap map = getMap(t);
	    //获取到map如果是null就创建并赋值
	    if (map != null)
	    	//map中的键为线程对象，值为变量副本
	        map.set(this, value);
	    else
	        createMap(t, value);
	}
	void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
	ThreadLocalMap getMap(Thread t) {
		//这个返回的是Thread的成员变量threadLocals
	    return t.threadLocals;
	}
	//这个ThreadLocalMap 是个内部类
	static class ThreadLocalMap {
		//Entry继承自WeakReference将ThreadLocal作为弱引用，GC运行, ThreadLocal即被回收
		static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
	}
}
public class Thread implements Runnable {
	//看吧Thread类中的threadLocals实际上就是ThreadLocalMap，并且ThreadLocalMap是ThreadLocal的内部类
	ThreadLocal.ThreadLocalMap threadLocals = null;
}

通过上面的代码可以看到，调用了set方法后是将ThreadLocal作为key（ThreadLocal引用传递，相当于传递ThreadLocal的副本），本次要切换的数据源作为值，存储到当前线程的ThreadLoadMap中，可以理解为Map<currentThread,datasource>,这样我们每个线程取数据源的时候只需要把这个引用的ThreadLocal作为key到线程自己的成员变量Map中去获取DataSource,那么就只能获取到自己保存的数据源了，这个Map是JDK里实现的一套特殊的Map，能够实现自动回收，这部分大家可以查下弱引用相关的知识。

弱引用WeakReference：如果一个对象只具有弱引用，那么垃圾回收器在扫描到该对象时，无论内存充足与否，都会回收该对象的内存。

接下来我们看下 get() 方法

public T get() {
 	Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}
private T setInitialValue() {
 	T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}
protected T initialValue() {
    return null;
}

有了上面set的理解get就好理解了，这一段就是说要从当前线程的ThreadLocalMap中拿到保存的副本值，setInitialValue()就是把ThreadLocalMap中的Entry 置位null，尽量避免内存泄漏

最后就是remove方法了

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

这个就更好理解了，其实就是把当前线程的ThreadLoaclMap置为null。。。

总结

ThreadLocal操作的其实就是Thread类的成员变量ThreadLocalMap，而每一个线程都是用ThreadLocal作为key，DataSource作为值，所以每个线程再从自己的ThreadLocalMap中获取数据源的时候，只需要传递ThreadLocal为key那么获取的就是自己设置的数据源，也就实现了动态切换数据源的功能了，而ThreadLocalMap我们可以把它看成就是一个Map，只是官方对于内存泄漏等的考虑的Map兄弟类，这样我们就能很好的理解这块代码了。

查询了很多篇博客资料等，最后自己梳理下所学，写下这篇博客，如果有什么不对的地方，欢迎指正，大家共同学习，共同进步。