多数据源，说白了，就是多数据库。因为我们配置数据源需要指定特定的数据库名称，如下，这是我们经常使用的配置数据源的XML文件内容中的一部分：

<!-- 配置数据源dataSource，连接MySQL数据库 、数据库：learn_system -->

    <!--

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">

        <property name="driverClassName"

            value="com.mysql.jdbc.Driver">

        </property>

        <property name="url"

            value="jdbc:mysql://localhost:3306/learn_system">

        </property>

        <property name="username" value="root"></property>

        <property name="password" value="root"></property>

    </bean>

    -->

这里value="jdbc:mysql://localhost:3306/learn_system"的learn_system就是我们的数据库名称。

如果我们需要配置多个数据源，我们就需要写多个bean，每个bean对应一个数据源。难点在于，如何控制多个数据源之间的切换。这里我们需要借助ThreadLocal类，这个类位于java.lang包下，首先说明ThreadLocal存放的值是线程内共享的，线程间互斥的，主要用于线程内共享一些数据，避免通过参数来传递，这样处理后，能够优雅的解决一些实际问题，比如：

1，Hibernate中的OpenSessionInView，就是借助ThreadLocal保存Session对象；

2，数据库连接，借助ThreadLocal来传递Connection对象；

同样的，今天我们实现多数据源，也要借助ThreadLocal类，通过ThreadLocal类传递数据源的参数，我们这里传递的是bean的id，也就是SpringMVC中bean的名称，通过这个id，我们就可以调用相应的bean，这样就实现了不同数据源之间的切换。

首先要明确：

 * ThreadLocal类，是什么？首先ThreadLocal不是Thread，因为如果我们要创建

 * 一个线程，我们需要继承Thread类或者实现Runnable接口，ThreadLocal没有

 * 继承Thread类，也没有继承Runnable接口。

ThreadLocal的作用，就是将本地变量，也就是当前内存中的变量，与线程关联起来。

好的，废话不多说，先上代码：

<bean id="datasource_test" class="org.apache.commons.dbcp.BasicDataSource">

<property name="driverClassName"

value="com.mysql.jdbc.Driver">

</property>

<property name="url"

value="jdbc:mysql://localhost:3306/test">

</property>

<property name="username" value="root"></property>

<property name="password" value="root"></property>

</bean> 

<bean id="datasource_learn_system" class="org.apache.commons.dbcp.BasicDataSource">

<property name="driverClassName"

value="com.mysql.jdbc.Driver">

</property>

<property name="url"

value="jdbc:mysql://localhost:3306/learn_system">

</property>

<property name="username" value="root"></property>

<property name="password" value="root"></property>

</bean> 

上面配置了2个数据源：datasource_test 和 datasource_learn_system，对应MySQL数据库中的2个不同的数据库；

然后我们需要写一个类：DynamicDataSource

<span style="font-size:14px;">import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/*

 * 配置多数据源

 */

public class DynamicDataSource extends AbstractRoutingDataSource{

public static final String DATASOURCE_TEST = "datasource_test";

public static final String DATASOURCE_LEARN_SYSTEM = "datasource_learn_system";

//本地线程，获取当前正在执行的currentThread

public 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();

    }

@Override

protected Object determineCurrentLookupKey() {

return getCustomerType();

}

}</span>

接下来我们要在配置文件中进行配置，

    <bean id="dataSource" class="com.spring.dynamic_datasource.DynamicDataSource">

        <property name="targetDataSources">

            <map key-type="java.lang.String">

                <entry value-ref="datasource_test" key="datasource_test"></entry>

                <entry value-ref="datasource_learn_system" key="datasource_learn_system"></entry>

            </map>

        </property>

        <property name="defaultTargetDataSource" ref="datasource_learn_system"></property>

</bean>

好了，通过这些代码，我们就可以实现多数据源的切换了，接下来，我们只需要在执行数据库操作之前，切换数据源，就可以实现动态切换数据库的项目需求了。接下来看一下实例代码：

//查询当前用户的所有上传图片

@Override

public boolean saveUploadPicture(Picture_of_user picture_of_user) {

//定义一个Boolean类型的flag，用来表示查询状态

boolean flag = false;

sql = "insert into picture_of_user(id,picture_name,picture_size,upload_date,picture_type,username) " +

"values(?,?,?,?,?,?);";

//切换数据源 datasource_test

//这段代码相当于，把String类型的参数 datasource_test 放在了保存到了本地线程的当前线程中，也就是当前正在执行的线程。

DynamicDataSource.setCustomerType(DynamicDataSource.DATASOURCE_LEARN_SYSTEM);

int i = this.getJdbcTemplate().update(sql, new Object[]{

null,

picture_of_user.getPicture_name(),

picture_of_user.getPicture_size(),

picture_of_user.getUpload_date(),

picture_of_user.getPicture_type(),

picture_of_user.getUsername()

});

//如果插入操作执行成功，则flag=true；否则flag=flase

if(i > 0){

//测试输出

System.out.println("i = " + i);

flag = true;

}

else{

//测试输出

System.out.println("i = " + i);

flag = false;

}

return flag;

}

我们只需要加上这一行代码，就可以实现数据源切换了：

DynamicDataSource.setCustomerType(DynamicDataSource.DATASOURCE_LEARN_SYSTEM);

这段代码做了什么呢？这段代码，把当前要选择的数据源，保存到ThreadLocal对象中。

接下来我们看一下源码：

<span style="font-size:14px;">package com.spring.dynamic_datasource;

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

/*

 * 配置多数据源

 */

public class DynamicDataSource extends AbstractRoutingDataSource{

public static final String DATASOURCE_TEST = "datasource_test";

public static final String DATASOURCE_LEARN_SYSTEM = "datasource_learn_system";

//本地线程，获取当前正在执行的currentThread

public static final ThreadLocal<String> contextHolder = new ThreadLocal<String>(); 

public static void setCustomerType(String customerType) {

//把当前请求的参数，存入当前线程，这个参数是我们定义的DATASOURCE_TEST 或者 DATASOURCE_LEARN_SYSTEM

//我们来看一下源码：

//public void set(T value) {

//    Thread t = Thread.currentThread();

//    ThreadLocalMap map = getMap(t);

//    if (map != null)

//        map.set(this, value);

//    else

//        createMap(t, value);

//这段代码的官方说明如下

    /**

     * Sets the current thread's copy of this thread-local variable

     * to the specified value.  Most subclasses will have no need to 

     * override this method, relying solely on the {@link #initialValue}

     * method to set the values of thread-locals.

     *

     * @param value the value to be stored in the current thread's copy of

     *        this thread-local.

     */

        //测试输出

        System.out.println("当前切换的数据源 = " + customerType);

        contextHolder.set(customerType);

    }

    public static String getCustomerType() {

    //官方文档如下：

        /**

         * Returns the value in the current thread's copy of this

         * thread-local variable.  If the variable has no value for the

         * current thread, it is first initialized to the value returned

         * by an invocation of the {@link #initialValue} method.

         *

         * @return the current thread's value of this thread-local

         */

        //public T get() {

            //Thread t = Thread.currentThread();

            //ThreadLocalMap map = getMap(t);

            //if (map != null) {

                //ThreadLocalMap.Entry e = map.getEntry(this);

                //if (e != null)

              //      return (T)e.value;

            //}

          //  return setInitialValue();

        //}

        return contextHolder.get();

    }

    public static void clearCustomerType() {

        /**

         * Removes the current thread's value for this thread-local

         * variable.  If this thread-local variable is subsequently

         * {@linkplain #get read} by the current thread, its value will be

         * reinitialized by invoking its {@link #initialValue} method,

         * unless its value is {@linkplain #set set} by the current thread

         * in the interim.  This may result in multiple invocations of the

         * <tt>initialValue</tt> method in the current thread.

         *

         * @since 1.5

         */

    //源代码如下：

         //public void remove() {

           //  ThreadLocalMap m = getMap(Thread.currentThread());

             //if (m != null)

               //  m.remove(this);

         //}

        contextHolder.remove();

    }

@Override

protected Object determineCurrentLookupKey() {

return getCustomerType();

}

}</span>

public class ThreadLocal<T> 类没有继承其他类，只是间接继承了Object类，我们来看一下官方对这个类的使用说明：

/**

 * This class provides thread-local variables.  These variables differ from

 * their normal counterparts in that each thread that accesses one (via its

 * <tt>get</tt> or <tt>set</tt> method) has its own, independently initialized

 * copy of the variable.  <tt>ThreadLocal</tt> instances are typically private

 * static fields in classes that wish to associate state with a thread (e.g.,

 * a user ID or Transaction ID).

 *

 * <p>For example, the class below generates unique identifiers local to each

 * thread.

 * A thread's id is

 * assigned the first time it invokes <tt>UniqueThreadIdGenerator.getCurrentThreadId()</tt> and remains unchanged on subsequent calls.

 * <pre>

 * import java.util.concurrent.atomic.AtomicInteger;

 *

 * public class UniqueThreadIdGenerator {

 *

 *     private static final AtomicInteger uniqueId = new AtomicInteger(0);

 *

 *     private static final ThreadLocal < Integer > uniqueNum = 

 *         new ThreadLocal < Integer > () {

 *             @Override protected Integer initialValue() {

 *                 return uniqueId.getAndIncrement();

 *         }

 *     };

 * 

 *     public static int getCurrentThreadId() {

 *         return uniqueId.get();

 *     }

 * } // UniqueThreadIdGenerator

 * </pre>

 * <p>Each thread holds an implicit reference to its copy of a thread-local

 * variable as long as the thread is alive and the <tt>ThreadLocal</tt>

 * instance is accessible; after a thread goes away, all of its copies of

 * thread-local instances are subject to garbage collection (unless other

 * references to these copies exist). 

 *

 * @author  Josh Bloch and Doug Lea

 * @version 1.42, 06/23/06

 * @since   1.2

 */

最后还是要重复说明：

 * ThreadLocal类，是什么？首先ThreadLocal不是Thread，因为如果我们要创建

 * 一个线程，我们需要继承Thread类或者实现Runnable接口，ThreadLocal没有

 * 继承Thread类，也没有继承Runnable接口。

ThreadLocal做了什么？ThreadLocal的作用，就是将本地变量，也就是当前内存中的变量，与线程关联起来，就像官方描述文档中说的：

 * ThreadLocal provides thread-local variables.  These variables differ from

 * their normal counterparts in that each thread that accesses one has its own, independently initialized

 * copy of the variable.  ThreadLocal instances are typically private

 * static fields in classes that wish to associate state with a thread (e.g.,

 * a user ID or Transaction ID).

思考：如果我们需要配置3个数据源，该如何操作呢？其实很简单，我们只需要再配置一个数据源就可以了。

思考：如果我们在项目中使用不同的数据库系统，比如MySQL、Oracle，该如何操作呢？同理，我们只需要对数据源的配置参数进行修改就可以了。

好了，关于多数据源的配置，就说到这里。接下来会给大家测试几个多数据源配置的实例。理论上可行的，还要经过实践检验。

---------------------