这篇文章就直接引用AbstractRoutingDataSource动态数据源切换:https://blog.csdn.net/u012881904/article/details/77449710,望博主看到多包涵，我已经给了原文地址啦！

操作数据一般都是在DAO层进行处理，可以选择直接使用JDBC进行编程

或者是使用多个DataSource 然后创建多个SessionFactory，在使用Dao层的时候通过不同的SessionFactory进行处理，不过这样的入侵性比较明显，一般的情况下我们都是使用继承HibernateSupportDao进行封装了的处理，如果多个SessionFactory这样处理就是比较的麻烦了，修改的地方估计也是蛮多的.

最后一个，也就是使用AbstractRoutingDataSource的实现类通过AOP或者手动处理实现动态的使用我们的数据源，这样的入侵性较低，非常好的满足使用的需求。比如我们希望对于读写分离或者其他的数据同步的业务场景.

下面是对操作多数据库的几种方式：

方式1：

graph LR
Datasource-->SessionFactory
SessionFactory-->Dao层实现类

• 单数据源的场景（一般的Web项目工程这样配置进行处理，就已经比较能够满足我们的业务需求）

方式2：

graph LR
Datasource1-->SessionFactory1
Datasource2-->SessionFactory2
SessionFactory1-->Dao层实现类
SessionFactory2-->Dao层实现类

• 多数据源多SessionFactory这样的场景，估计作为刚刚开始想象想处理在使用框架的情况下处理业务，配置多个SessionFactory，然后在Dao层中对于特定的请求，通过特定的SessionFactory即可处理实现这样的业务需求，不过这样的处理带来了很多的不便之处，所有很多情况下我们宁愿直接使用封装的JDBC编程，或者使用Mybatis处理这样的业务场景

方式3：

graph LR
Datasource1-->AbstractRoutingDataSource每执行一次SQL操作就动态选择DataSource
Datasource2-->AbstractRoutingDataSource每执行一次SQL操作就动态选择DataSource
AbstractRoutingDataSource每执行一次SQL操作就动态选择DataSource-->SessionFactory
SessionFactory-->Dao层实现类

• 使用AbstractRoutingDataSource 的实现类，进行灵活的切换，可以通过AOP或者手动编程设置当前的DataSource，不用修改我们编写的对于继承HibernateSupportDao的实现类的修改，这样的编写方式比较好，至于其中的实现原理，让我细细到来。我们想看看如何去应用，实现原理慢慢的说！

我们接下来就来详细讲解方式3啦：

接下来我们需要做的就是：编写AbstractRoutingDataSource的实现类,HandlerDataSource就是提供给我们动态选择数据源的数据的信息，我们这里编写一个根据当前线程来选择数据源，然后通过AOP拦截特定的注解，设置当前的数据源信息，也可以手动的设置当前的数据源，在编程的类中。

AbstractRoutingDataSource实现类：

public class MultipleDataSourceToChoose extends AbstractRoutingDataSource {

    /**
     * @desction: 根据Key获取数据源的信息，上层抽象函数的钩子
     * @param:
     * @return:
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return HandlerDataSource.getDataSource();
    }
}

HandlerDataSource:代码是自己编写的一个动态选择数据源大道一个类

/**
 * descrption: 根据当前线程来选择具体的数据源
 */
public class HandlerDataSource {

    private static ThreadLocal<String> handlerThredLocal = new ThreadLocal<String>();

    /**
     * @desction: 提供给AOP去设置当前的线程的数据源的信息
     * @param: [datasource]
     * @return: void
     */
    public static void putDataSource(String datasource) {
        handlerThredLocal.set(datasource);
    }

    /**
     * @desction: 提供给AbstractRoutingDataSource的实现类，通过key选择数据源
     * @param: []
     * @return: java.lang.String
     */
    public static String getDataSource() {
        return handlerThredLocal.get();
    }

    /**
     * @desction: 使用默认的数据源
     */
    public static void clear() {
        handlerThredLocal.remove();
    }
}

接下来就有两种方案：

1.手动在程序中设置数据源。也就是通过手动调用HandlerDataSource中的putDataSource方法。

2.通过AOP编程(前置通知和后置通知来对我们需要更换数据源的方法进行代理增强，通过注解的方式辨别切换到哪个数据源)

我们这里就使用第二种方式，定义自定义注解：如果使用该注解的类或方法，就可以在在AOP编程的时候来判断注解的存在，从而来改变数据源。

/**
 * @description： 创建拦截设置数据源的注解
 * Created by wangji on 2017/8/21.
 */
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DynamicSwitchDataSource {

    String dataSource() default "";
}

我们已经定义了注解来判断切换哪个数据源，那么接下来，我们需要定义切面类，也就是增强类来对需要代理的类进行增强(也就是说对需要增强的类进行数据源的切换，至于切换哪个数据源，就通过扫描注解来确定)

/**
 * descrption: 使用AOP拦截特定的注解去动态的切换数据源
 */
@Aspect
@Component
public class HandlerDataSourceAop {
    
    @Pointcut("@within(com.common.utils.manydatasource.DynamicSwitchDataSource)||@annotation(com.common.utils.manydatasource.DynamicSwitchDataSource)")
    public void pointcut() {}

    @Before("pointcut()")
    public void doBefore(JoinPoint joinPoint)
    {
        Method method = ((MethodSignature)joinPoint.getSignature()).getMethod();
        DynamicSwitchDataSource annotationClass = method.getAnnotation(DynamicSwitchDataSource.class);//获取方法上的注解
        if(annotationClass == null){
            annotationClass = joinPoint.getTarget().getClass().getAnnotation(DynamicSwitchDataSource.class);//获取类上面的注解
            if(annotationClass == null) return;
        }
        //获取注解上的数据源的值的信息
        String dataSourceKey = annotationClass.dataSource();
        if(dataSourceKey !=null){
            //给当前的执行SQL的操作设置特殊的数据源的信息
            HandlerDataSource.putDataSource(dataSourceKey);
        }
        log.info("AOP动态切换数据源，className"+joinPoint.getTarget().getClass().getName()+"methodName"+method.getName()+";dataSourceKey:"+dataSourceKey==""?"默认数据源":dataSourceKey);
    }

    @After("pointcut()")
    public void after(JoinPoint point) {
        //清理掉当前设置的数据源，让默认的数据源不受影响
        HandlerDataSource.clear();
    }

}

上面我们已经对数据源切换的AOP编程代码进行了实现啦，接下来，我们就需要进行配置文件的配置啦！


配置文件需要配置的项有：数据源(如果需要切换哪些数据源，就需要把需要切换的数据源都配置出来)、数据源的切换配置(也就是上面我们定义的继承AbstractRoutingDataSource的MultipleDataSourceToChoose的类)、SessionFactory的配置就和以前一样，没有任何变化(根据Hibernate和Mybatis的SessionFactory配置)。

<!-- 配置数据源 -->
    <bean id="dataSource0" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close" init-method="init">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxActive" value="10"/>
    </bean>
    <bean id="dataSource1" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close" init-method="init">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc2.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxActive" value="10"/>
    </bean>
    <!-- 切换数据源-->
    bean id="dataSource" class="com.common.utils.manydatasource.MultipleDataSourceToChoose" lazy-init="true">
        <description>数据源</description>
        <property name="targetDataSources">
            <map key-type="java.lang.String" value-type="javax.sql.DataSource">
                <entry key="datasource0" value-ref="dataSource0" />
                <entry key="datasource1" value-ref="dataSource1" />
            </map>
        </property>
        <!-- 设置默认的目标数据源 -->
        <property name="defaultTargetDataSource" ref="dataSource0" />
    </bean>
    <!--SessionFactory的配置，这里就以Hibernate为例-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <!-- 注意这里的DataSource数据源就是切换的数据源，因为它会给我们提供一个代理的数据源，至于是提供那个数据源跟我们代码中的选择-->
        <property name="dataSource" ref="dataSource"/>
        <!--指定Hibernate属性 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">false</prop>
                <prop key="hibernate.format_sql">false</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
                <prop key="hibernate.autoReconnect">true</prop>
                <prop key="hibernate.jdbc.batch_size">50</prop>
              <prop key="hibernate.connection.autocommit">false</prop>
              <prop key="hibernate.connection.release_mode">after_transaction</prop>
              <prop key="hibernate.bytecode.use_reflection_optimizer">false</prop>
            </props>
        </property>
        <property name="packagesToScan">
            <list>
                <value>com.module</value>
            </list>
        </property>
    </bean>
    <!-- 事务的配置我们就省略啦，和之前的配置一样，只是数据源依然是切换数据源的id-->

接下来我们就进行测试：测试我们先对AOP动态代理切换数据源的方式进行测试，然后对手动切换数据源进行测试

AOP动态代理切换数据源测试

@Service
@Slf4j
public class UserInfoService implements IUserInfoService {


    @Resource
    private UserDao userDao;
    @Autowired
    private CommonHibernateDao commonDao;

    @TestValidateParam
    public User getUserInfoById(Integer id) {
        return userDao.findById(id);
    }
    
    //切换到dataSource0
    @DynamicSwitchDataSource(dataSource = "datasource0")
    public void save(User user) {
        userDao.save(user);
    }
    
    //切换到dataSource1
    @DynamicSwitchDataSource(dataSource = "datasource1")
    public List<User> findAll(){
        String sql = "select u.userName as name,u.userAge as age,u.userAddress as address,u.id from user u";
        List<User> list =commonDao.findListBySQL(sql,User.class);
        return list;
    }

}

手动方式切换数据源

    public void test(){
        HandlerDataSource.putDataSource("datasource1");
        String sql = "select u.userName as name,u.userAge as age,u.userAddress as address,u.id from user u";
        List<User> list =commonDao.findListBySQL(sql,User.class);

        HandlerDataSource.putDataSource("datasource0");
        commonDao.deleteById("2",User.class);
    }

实现原理

实现原理,MultipleDataSourceToChoose的继承结构图，之前说过他是DataSource的子类，由于无论我们是使用Mybatis还是使用Hibernate进行SQL操作的时候总会执行getConnection()，无论我们的数据源是否使用了数据库连接池，因为数据库连接池的主要作用就是保持一堆的Connection不进行关闭的处理，节省我们的关闭和打开连接的开销。这里提供一个浅谈数据库连接池说的简单易懂 。 Connection getConnection() throws SQLException;所以这句话总是要执行的，只是AbstractRoutingDataSource这个类给我们进行了一些中介的处理，在获取Connection的时候会去寻找保存的DataSource的引用，到底是选择哪个DataSource进行处理，看代码！

下面就给出继承图：

graph LR
MultipleDataSourceToChoose-->AbstractRoutingDataSource
AbstractRoutingDataSource-->InitializingBean
AbstractRoutingDataSource-->AbstractDataSource
AbstractDataSource-->DataSource

第一：我们去看targetDataSource的源码看究竟是什么

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {

    private Map<Object, Object> targetDataSources;

    private Object defaultTargetDataSource;

通过源码我们发现targetDataSource就是一个Map对象。

第二：我们去看小获取连接getConnection的源代码，看是怎么获取的

    @Override
    public Connection getConnection() throws SQLException {
        return determineTargetDataSource().getConnection();
    }

通过源代码，我们发现，是determineTargetDataSource()方法返回一个DataSource，然后就可以获取连接啦！

第三：关键的一步，我们去看下determineTargetDataSource()方法是如何获取DataSource的

    /**
     * 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");
        //determineCurrentLookupKey()方法就是我们重写的一个方法，他就是为targetDataSources的Map对象返回一个key
        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;
    }

通过这里我们应该就很清楚整个流程啦!