关于Spring项目配置多个数据源的实例演示_service实现类中的方法如何同时使用两个数据源-优快云博客

本文链接：https://blog.youkuaiyun.com/Smile_Miracle/article/details/73795670

一、多数据源动态切换原理

项目中我们经常会遇到多数据源的问题，尤其是数据同步或定时任务等项目更是如此；又例如：读写分离数据库配置的系统。

1、多数据源设置：
1）静态数据源切换：

一般情况下，我们可以配置多个数据源，然后为每个数据源写一套对应的sessionFactory和dao层代码(以hibernate为例，mybatis同理)，——我们称之为静态数据源配置。

2）动态数据源切换：

可看出在Dao层代码中写死了两个SessionFactory，这样日后如果再多一个数据源，还要改代码添加一个SessionFactory，显然这并不符合开闭原则。比较好的做法是，配置多个数据源，只对应一套sessionFactory，数据源之间可以动态切换。

2、动态数据源切换时，如何保证数据库的事务：

目前事务最灵活的方式，是使用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层里面动态切换数据源。这些都是多数据源的aop处理方案，这里不做多说.下面来讲一种我常用的多数据解决方案：aop service层注解换源。

首先看下项目配置：

POM.XML

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.zhy</groupId>
  <artifactId>zhy-test</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <properties>  
        <!-- spring版本号 -->  
        <spring.version>4.0.2.RELEASE</spring.version>  
        <!-- mybatis版本号 -->  
        <mybatis.version>3.2.6</mybatis.version>  
        <!-- log4j日志文件管理包版本 -->  
        <slf4j.version>1.7.7</slf4j.version>  
        <log4j.version>1.2.17</log4j.version> 
        <comLog.version>1.1.1</comLog.version>
        <jackson.version>1.9.13</jackson.version>
    </properties>  
    <dependencies>  
       <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.8.6</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.module</groupId>
            <artifactId>jackson-module-jaxb-annotations</artifactId>
            <version>2.8.6</version>
        </dependency>
        <dependency>  
            <groupId>junit</groupId>  
            <artifactId>junit</artifactId>  
            <version>4.11</version>  
            <!-- 表示开发的时候引入，发布的时候不会加载此包 -->  
            <scope>test</scope>  
        </dependency>  
        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier><!--指定jdk版本 -->
        </dependency>
        <!-- mybatis核心包 -->  
        <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis</artifactId>  
            <version>${mybatis.version}</version>  
        </dependency>  
        <!-- mybatis/spring包 -->  
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis-spring</artifactId>  
            <version>1.2.2</version>  
        </dependency>  
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- 导入java ee jar 包 -->  
        <dependency>  
            <groupId>javax</groupId>  
            <artifactId>javaee-api</artifactId>  
            <version>7.0</version>  
        </dependency>  
        <!-- 导入Mysql数据库链接jar包 -->  
        <dependency>  
            <groupId>mysql</groupId>  
            <artifactId>mysql-connector-java</artifactId>  
            <version>5.1.30</version>  
        </dependency>  
        <!-- 导入dbcp的jar包，用来在applicationContext.xml中配置数据库 -->  
        <dependency>  
            <groupId>commons-dbcp</groupId>  
            <artifactId>commons-dbcp</artifactId>  
            <version>1.2.2</version>  
        </dependency>  
        <!-- JSTL标签类 -->  
        <dependency>  
            <groupId>jstl</groupId>  
            <artifactId>jstl</artifactId>  
            <version>1.2</version>  
        </dependency>  
        <!-- 日志文件管理包 -->  
        <!-- log start -->  
        <dependency>  
            <groupId>log4j</groupId>  
            <artifactId>log4j</artifactId>  
            <version>${log4j.version}</version>  
        </dependency>  
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>${comLog.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-core-asl</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-core-lgpl</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-jaxrs</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-lgpl</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-smile</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-xc</artifactId>
            <version>${jackson.version}</version>
        </dependency>       

        <!-- spring 核心jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc-portlet</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- SQLSERVER连接包 -->
        <dependency>
             <groupId>net.sourceforge.jtds</groupId>
             <artifactId>jtds</artifactId>
             <version>1.3.1</version>
         </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.16</version>
        </dependency>
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.7</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <!-- 格式化对象，方便输出日志 -->  
        <dependency>  
            <groupId>com.alibaba</groupId>  
            <artifactId>fastjson</artifactId>  
            <version>1.1.41</version>  
        </dependency>  
        <dependency>  
            <groupId>org.slf4j</groupId>  
            <artifactId>slf4j-api</artifactId>  
            <version>${slf4j.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.slf4j</groupId>  
            <artifactId>slf4j-log4j12</artifactId>  
            <version>${slf4j.version}</version>  
        </dependency>  
        <!-- log end -->  
        <!-- 上传组件包 -->  
        <dependency>  
            <groupId>commons-fileupload</groupId>  
            <artifactId>commons-fileupload</artifactId>  
            <version>1.3.1</version>  
        </dependency>  
        <dependency>  
            <groupId>commons-io</groupId>  
            <artifactId>commons-io</artifactId>  
            <version>2.4</version>  
        </dependency>  
        <dependency>  
            <groupId>commons-codec</groupId>  
            <artifactId>commons-codec</artifactId>  
            <version>1.9</version>  
        </dependency>  
    </dependencies>  

  <build>
    <plugins>
       <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.0</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>
    </plugins>
  </build>
</project>

c3p0.properties

#sqlserver
jdbc.initialPoolSize=5
jdbc.maxActive=20
jdbc.maxIdle=5
jdbc.defaultAutoCommit=true
jdbc.removeAbandoned=true  
jdbc.removeAbandonedTimeout=30 
jdbc.logAbandoned=true
jdbc.testWhileIdle=true
jdbc.timeBetweenEvictionRunsMillis=30000
jdbc.numTestsPerEvictionRun=10
jdbc.driverClassName=net.sourceforge.jtds.jdbc.Driver
jdbc.url=jdbc:jtds:sqlserver://你的数据库连接;
jdbc.username=1234
jdbc.password=1234

#mysql
db.user=root
db.password=123456
db.driverClass=com.mysql.jdbc.Driver
db.jdbcUrl=jdbc\:mysql\://localhost\:3306/student?useUnicode\=true&amp;characterEncoding\=UTF8
c3p0.maxPoolSize=20
c3p0.minPoolSize=5
c3p0.initialPoolSize=3
c3p0.maxIdleTime=60
c3p0.acquireRetryAttempts=5
c3p0.idleConnectionTestPeriod=60
c3p0.testConnectionOnCheckin=true
c3p0.automaticTestTable=c3p0Table
c3p0.numHelperThreads=20

Spring配置文件

① bean文件

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd 
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd "
>
   <context:annotation-config />
    <context:component-scan base-package="com.zhy.spdb.test"/>
    <bean id="properties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
        <property name="locations">
            <list>
                <value>classpath:conf/c3p0.properties</value>
            </list>
        </property>
    </bean>

    <bean class="org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer">
        <property name="properties" ref="properties"/>
    </bean> 

    <bean id="jsonHttpMessageConverter" class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>

    <!-- <bean id="imgFtlMap" class="com.lyt.base.ftl.ImageFtlMap"/> -->

    <bean id="stringHttpMessageConverter" class="org.springframework.http.converter.StringHttpMessageConverter"/>

    <import resource="classpath:spring/applicationContext-soa.xml"/>

</beans>

② 核心配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:task="http://www.springframework.org/schema/task"
    xmlns:aop="http://www.springframework.org/schema/aop" 
    xmlns:tx="http://www.springframework.org/schema/tx" 
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd 
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd 
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd "
>
    <context:annotation-config />
    <context:component-scan base-package="com.zhy.spdb.test.service"/>
    <context:component-scan base-package="com.zhy.spdb.test.utils"/>
    <bean id="properties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
        <property name="locations">
            <list>
                <value>classpath:conf/c3p0.properties</value>
            </list>
        </property>
    </bean>

    <bean class="org.springframework.beans.factory.config.PreferencesPlaceholderConfigurer">
        <property name="properties" ref="properties"/>
    </bean> 

    <!-- MySql数据源 -->
    <bean id="dataSourceMySql" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${db.user}"/>
        <property name="password" value="${db.password}"/>
        <property name="driverClass" value="${db.driverClass}"/>
        <property name="jdbcUrl" value="${db.jdbcUrl}"/>
        <property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
        <property name="minPoolSize" value="${c3p0.minPoolSize}"/>
        <property name="initialPoolSize" value="${c3p0.initialPoolSize}"/>
        <property name="maxIdleTime" value="${c3p0.maxIdleTime}"/>
        <property name="acquireRetryAttempts" value="${c3p0.acquireRetryAttempts}"/>
        <property name="idleConnectionTestPeriod" value="${c3p0.idleConnectionTestPeriod}"/>
        <property name="testConnectionOnCheckin" value="${c3p0.testConnectionOnCheckin}"/>
        <property name="automaticTestTable" value="${c3p0.automaticTestTable}"/>
        <property name="numHelperThreads" value="${c3p0.numHelperThreads}"/>
    </bean>

    <!-- SqlServer数据源 -->
    <bean id="dataSourceSqlServer" class="com.mchange.v2.c3p0.ComboPooledDataSource">  <!-- destroy-method="close" -->
        <property name="driverClass" value="${jdbc.driverClassName}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <!--property name="properties" ref="dataSourceProperties"/-->
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="idleConnectionTestPeriod" value="60"/>
        <property name="preferredTestQuery" value="SELECT 1"/>
        <property name="maxIdleTime" value="120"/>
        <property name="testConnectionOnCheckout" value="false"/>
    </bean>

    <bean id="dataSource" class="com.zhy.spdb.test.dbCore.ChooseDataSource">  
        <property name="targetDataSources">  
            <map key-type="java.lang.String">  
                <entry value-ref="dataSourceMySql" key="test"></entry>  
                <entry value-ref="dataSourceSqlServer" key="onLine"></entry>  
            </map>  
        </property>
        <property name="defaultTargetDataSource" ref="dataSourceMySql">  
        </property>  
    </bean>  

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" name="mainSqlSessionFactory">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"/>
        <property name="mapperLocations"><value>classpath:sqlmaps/**/*.xml</value></property>
    </bean>

    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.zhy.spdb.test.dao"/>
        <property name="sqlSessionFactoryBeanName" value="mainSqlSessionFactory"/>
    </bean>

    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="create*" propagation="REQUIRED" isolation="DEFAULT" rollback-for="Exception"/>
            <tx:method name="insert*" propagation="REQUIRED" isolation="DEFAULT" rollback-for="Exception"/>
            <tx:method name="add*" propagation="REQUIRED" isolation="DEFAULT" rollback-for="Exception"/>
            <tx:method name="upd*" propagation="REQUIRED" isolation="DEFAULT" rollback-for="Exception"/>
            <tx:method name="del*" propagation="REQUIRED" isolation="DEFAULT" rollback-for="Exception"/>
            <tx:method name="execute*" propagation="REQUIRED" isolation="DEFAULT" rollback-for="Exception"/>
            <tx:method name="do*" propagation="REQUIRED" isolation="DEFAULT" rollback-for="Exception"/>
            <tx:method name="save*" propagation="REQUIRED" isolation="DEFAULT" rollback-for="Exception"/>
            <tx:method name="set*" propagation="REQUIRED" isolation="DEFAULT" rollback-for="Exception"/>
            <tx:method name="get*" propagation="SUPPORTS" isolation="DEFAULT" read-only="true"/>
            <tx:method name="show*" propagation="SUPPORTS" isolation="DEFAULT" read-only="true"/>
            <tx:method name="list*" propagation="SUPPORTS" isolation="DEFAULT" read-only="true"/>
            <tx:method name="select*" propagation="SUPPORTS" isolation="DEFAULT" read-only="true"/>
            <tx:method name="query*" propagation="SUPPORTS" isolation="DEFAULT" read-only="true"/>
            <tx:method name="has*" propagation="SUPPORTS" isolation="DEFAULT" read-only="true"/>
            <tx:method name="ntx*" propagation="NOT_SUPPORTED"/>
            <tx:method name="*" propagation="SUPPORTS" isolation="DEFAULT" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <!-- 激活自动代理功能 -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>

    <bean id="dataSourceAspect" class="com.zhy.spdb.test.aop.DataSourceAspect" />

    <aop:config>
        <aop:aspect id="c" ref="dataSourceAspect">
            <aop:pointcut id="tx" expression="execution(* com.zhy.spdb.test.service..*.*(..))"/>
            <aop:before pointcut-ref="tx" method="before"/>
        </aop:aspect>
    </aop:config>

    <!-- <import resource="classpath:mybatis/applicationContext-mybatis.xml"/> -->

</beans>

mybatis配置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <package name="com.zhy.spdb.test.model"/>
        <package name="com.zhy.spdb.test.vo"/>
        <package name="com.zhy.spdb.test.parameter"/>
    </typeAliases>
</configuration>

springmvc配置

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd 
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"
>
   <context:annotation-config />
    <context:component-scan base-package="com.zhy.spdb.test.controller"/>
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="synchronizeOnSession" value="true"/>
        <property name="messageConverters">
            <list>
                <ref bean="jsonHttpMessageConverter"/>
            </list>
        </property>
        <property name="webBindingInitializer">
            <bean class="org.springframework.web.bind.support.ConfigurableWebBindingInitializer">
                <property name="conversionService"> <!-- @DateTimeFormat 依赖joda-time -->
                    <bean class="org.springframework.format.support.FormattingConversionServiceFactoryBean"/>
                </property>
            </bean>
        </property>
    </bean>

    <bean id="freeMarkerResolver" class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
        <property name="cache" value="true"/>
        <property name="suffix" value=".ftl"/>
        <property name="contentType" value="text/html;charset=UTF-8"/>
        <property name="requestContextAttribute" value="rc"/>
        <property name="exposeRequestAttributes" value="true"/>
        <property name="exposeSessionAttributes" value="true"/>
        <property name="allowSessionOverride" value="true"/>
        <property name="exposeSpringMacroHelpers" value="true"/>
        <property name="viewClass" value="org.springframework.web.servlet.view.freemarker.FreeMarkerView"/>
    </bean>

    <bean id="fmXmlEscape" class="freemarker.template.utility.XmlEscape" />
    <bean id="freeMarkerConfigurer" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
        <property name="templateLoaderPaths">
            <array>
                <value>/WEB-INF/ftl/</value>
            </array>
        </property>
        <property name="freemarkerVariables">
            <map>
                <entry key="xml_escape" value-ref="fmXmlEscape"/>
                <!-- <entry key="imgFtlMap" value-ref="imgFtlMap"/> -->
            </map>
        </property>
        <property name="freemarkerSettings">
            <props>
                <prop key="template_update_delay">0</prop>
                <prop key="default_encoding">UTF-8</prop>
                <prop key="number_format">0.##########</prop>
                <prop key="datetime_format">yyyy-MM-dd HH:mm:ss</prop>
                <prop key="date_format">yyyy-MM-dd</prop>
                <prop key="time_format">HH:mm:ss</prop>
                <prop key="classic_compatible">true</prop>
                <prop key="template_exception_handler">ignore</prop>
            </props>
        </property>
    </bean>

    <bean id="jsonResolver" class="org.springframework.web.servlet.view.json.MappingJacksonJsonView"/>
</beans>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" 
    xmlns="http://java.sun.com/xml/ns/javaee" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
>
    <display-name></display-name>
    <welcome-file-list>
        <welcome-file>index.html</welcome-file>
    </welcome-file-list>

    <context-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.XmlWebApplicationContext</param-value>
    </context-param>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath:spring/applicationContext-beans.xml
        </param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <servlet>
        <servlet-name>spdbTestSvlt</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc/mySpringMVC-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>default</servlet-name> <!-- 激活Tomcat/Jetty的defaultServlet来处理静态文件 -->
        <url-pattern>*.js</url-pattern>
        <url-pattern>*.ico</url-pattern>
        <url-pattern>*.css</url-pattern>
        <url-pattern>*.png</url-pattern>
        <url-pattern>*.jpg</url-pattern>
        <url-pattern>*.gif</url-pattern>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>spdbTestSvlt</servlet-name>
        <url-pattern>/</url-pattern> <!-- 拦截了所有的请求 -->
    </servlet-mapping>


   <!--  <filter>
         <filter-name>lytAppSSOFilter</filter-name>
         <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    <init-param>
         <param-name>targetBeanName</param-name>
         <param-value>ssoFilter</param-value>
    </init-param>
    </filter> 
    <filter-mapping>
         <filter-name>lytAppSSOFilter</filter-name>
         <url-pattern>/*</url-pattern>
    </filter-mapping> -->

    <!-- POST中文乱码过滤器配置开始 -->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <!-- POST中文乱码过滤器配置结束 -->

    <!-- session过期时间 -->
    <session-config>
        <session-timeout>60</session-timeout>
    </session-config>
</web-app>

配置方面就这么多，具体怎么用，后面来看具体用法：

首先，你得有一个注解，我们的原理是通过注解输入要调用的数据库的名字然后在service层前面切入通过放射注解上的数据库名字悬着相对的数据库。

注解类

package com.zhy.spdb.test.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 用注解来反射读取注解中输入的数据源已变确定要操作的数据源
 * @author zhy
 *
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DataSource {

              String value();

}

核心切换类

package com.zhy.spdb.test.dbCore;

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

public class ChooseDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return HandleDataSource.getDataSource();
    }

}




package com.zhy.spdb.test.dbCore;

public class HandleDataSource {

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

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

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


}

反射获取获取数据库名并设置数据库类

package com.zhy.spdb.test.aop;

import java.lang.reflect.Method;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;

import com.zhy.spdb.test.annotation.DataSource;
import com.zhy.spdb.test.dbCore.HandleDataSource;

public class DataSourceAspect {

    public void pointCut(){};


    /**
     * 在事务开始之前插入到service上，通过反射获取注解上的数据库
     * @param point
     */
    @Before(value="pointCut()")
    public void before(JoinPoint point){
        //拦截的实体类
        Object target = point.getTarget();
        //拦截的方法名称
        String methodName = point.getSignature().getName();
        Class<?>[] classes = target.getClass().getInterfaces();
        //拦截的放参数类型
        Class<?>[] parameterTypes = ((MethodSignature) point.getSignature())
                .getMethod().getParameterTypes();
        try {
            Method m = classes[0].getMethod(methodName, parameterTypes);
            if (m != null && m.isAnnotationPresent(DataSource.class)) {
                DataSource data = m.getAnnotation(DataSource.class);
                HandleDataSource.setDataSource(data.value());
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }


}

该注意的是你的数据库名字一定要和配置文件里面配置的那两个数据库相对应，不然它无法通过名字找到数据库资源，还有就是默认的数据库一般要设置成自己常用的库，然后就是默认库的数据库自定义注解默认可以不写。

最后附上一套完成的测试代码，显示具体使用方法，你会发现用起来很方便。

默认数据库：

cotroller:

package com.zhy.spdb.test.controller;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.zhy.spdb.test.service.IStudentService;
import com.zhy.spdb.test.vo.PacketHead;
import com.zhy.spdb.test.vo.ResultVo;

@Controller
@RequestMapping("/student")
public class StudentController {

    @Autowired
    private IStudentService studentService;

    @RequestMapping("getName")
    @ResponseBody
    public ResultVo getStudentName(Integer studentId){
        ResultVo vo = new ResultVo();
        if(studentId==null||studentId==0){
            vo.setErrorCode(PacketHead.JSON_ERR_FORMAT);
            vo.setErrorMsg("请求参数错误，请检查数据......");
        }else{
            String name = studentService.getSnameById(studentId);
            if(!StringUtils.isEmpty(name)){
                vo.setData(name);
            }
        }
        return vo;

    }

}

service及实现类：

package com.zhy.spdb.test.service;

import com.zhy.spdb.test.annotation.DataSource;

public interface IStudentService {
    //@DataSource("test") 默认的可以不写
    public String getSnameById(Integer studentId);

}

package com.zhy.spdb.test.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.zhy.spdb.test.dao.StudentDao;
import com.zhy.spdb.test.service.IStudentService;

@Service
public class StudentService implements IStudentService {

    @Autowired
    private StudentDao studentDao;

    @Override
    public String getSnameById(Integer studentId) {
        return studentDao.selectNameById(studentId);
    }

}

Dao层：

package com.zhy.spdb.test.dao;

public interface StudentDao {

    public String selectNameById(Integer studentId);

}

还有就是xml这里就不具体贴了。

第二个资源库：

controller：

package com.zhy.spdb.test.controller;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.zhy.spdb.test.service.ISsService;
import com.zhy.spdb.test.vo.PacketHead;
import com.zhy.spdb.test.vo.ResultVo;

@Controller
@RequestMapping("/ss")
public class SsController {

    @Autowired
    private ISsService sService;

    @RequestMapping("getName")
    @ResponseBody
    public ResultVo getStudentName(Integer sId){
        ResultVo vo = new ResultVo();
        if(sId==null||sId==0){
            vo.setErrorCode(PacketHead.JSON_ERR_FORMAT);
            vo.setErrorMsg("请求参数错误，请检查数据......");
        }else{
            String name = sService.getNameById(sId);
            if(!StringUtils.isEmpty(name)){
                vo.setData(name);
            }
        }
        return vo;

    } 

}

Service及实现类：

package com.zhy.spdb.test.service;

import com.zhy.spdb.test.annotation.DataSource;

public interface ISsService {

    @DataSource("onLine")
    public String getNameById(Integer sId);

}

package com.zhy.spdb.test.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.zhy.spdb.test.dao.SsDao;
import com.zhy.spdb.test.service.ISsService;

@Service
public class SsService implements ISsService {

    @Autowired
    private SsDao sDao;

    @Override
    public String getNameById(Integer sId) {
        return sDao.selectNameById(sId);
    }

}

Dao层：

package com.zhy.spdb.test.dao;

public interface SsDao {

    public String selectNameById(Integer sId);

}

经过测试完全可行，具体测试结果由于时间紧就不贴了，具体完整代码下载地址如下：Spring整合多数据源完整实例项目

如果任何问题请留言交流，谢谢大家。