背景：
1、系统采用SSM架构、需要在10多个MYSQL数据库之间进行切换并对数据进行操作，上篇博文《springMVC+Mybatis(使用AbstractRoutingDataSource实现多数据源切换时)事务管理未生效的解决办法》
2、第一步先通过AbstractRoutingDataSource实现了多数据源的灵活切换，但是后来发现事务不起作用；
3、发现问题是因为重复扫描service包导致第二次扫入容器的BEAN没有纳入事务管理，因此在springMVC的配置文件中排除了对Service注解的扫描，防止重复扫描，事务生效了，测试又发现数据源不能成功切换了；
4、查阅资料发现是由于spring默认提供的事务管理DataSourceTransactionManager只能管理一个数据源的事务，因此考虑使用atomikos+JTA进行分布式事务管理
配置文件：
1、jdbc.properties
配置你需要连接的数据库资源
jdbc_zhs.driverClassName=com.mysql.jdbc.Driver
jdbc_zhs.url.spider=jdbc:mysql://127.0.0.1:3306/fms?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
jdbc_zhs.username=root
jdbc_zhs.password=root jdbc_jcs.driverClassName=com.mysql.jdbc.Driver
jdbc_jcs.url.spider=jdbc:mysql://127.0.0.1:3306/fms-jcs?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
jdbc_jcs.username=root
jdbc_jcs.password=root jdbc_hks.driverClassName=com.mysql.jdbc.Driver
jdbc_hks.url.spider=jdbc:mysql://127.0.0.1:3306/fms-hks?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
jdbc_hks.username=root
jdbc_hks.password=root jdbc_xts.driverClassName=com.mysql.jdbc.Driver
jdbc_xts.url.spider=jdbc:mysql://127.0.0.1:3306/fms-xts?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
jdbc_xts.username=root
jdbc_xts.password=root jdbc_xxgcs.driverClassName=com.mysql.jdbc.Driver
jdbc_xxgcs.url.spider=jdbc:mysql://127.0.0.1:3306/fms-xxgcs?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
jdbc_xxgcs.username=root
jdbc_xxgcs.password=root jdbc_zdhs.driverClassName=com.mysql.jdbc.Driver
jdbc_zdhs.url.spider=jdbc:mysql://127.0.0.1:3306/fms-zdhs?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
jdbc_zdhs.username=root
jdbc_zdhs.password=root jdbc_gfs.driverClassName=com.mysql.jdbc.Driver
jdbc_gfs.url.spider=jdbc:mysql://127.0.0.1:3306/fms-gfs?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
jdbc_gfs.username=root
jdbc_gfs.password=root jdbc_kxs.driverClassName=com.mysql.jdbc.Driver
jdbc_kxs.url.spider=jdbc:mysql://127.0.0.1:3306/fms-kxs?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
jdbc_kxs.username=root
jdbc_kxs.password=root jdbc_fyd.driverClassName=com.mysql.jdbc.Driver
jdbc_fyd.url.spider=jdbc:mysql://127.0.0.1:3306/fms-fyd?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
jdbc_fyd.username=root
jdbc_fyd.password=root jdbc_ybj.driverClassName=com.mysql.jdbc.Driver
jdbc_ybj.url.spider=jdbc:mysql://127.0.0.1:3306/fms-ybj?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
jdbc_ybj.username=root
jdbc_ybj.password=root jdbc_yzh.driverClassName=com.mysql.jdbc.Driver
jdbc_yzh.url.spider=jdbc:mysql://127.0.0.1:3306/fms-yzh?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
jdbc_yzh.username=root
jdbc_yzh.password=root
2、applicationContext-common.xml：
<?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: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.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 启动扫描 -->
<context:component-scan base-package="com.fms;com.job;com.jmda;">
<!-- <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" /> -->
</context:component-scan> <!-- 文件上传 -->
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="maxUploadSize" value="10240000"/>
<property name="maxInMemorySize" value="10240000" />
</bean> <bean id="freemarkerConfig" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
<property name="templateLoaderPaths">
<list>
<value>/WEB-INF/pages/</value>
<value>/WEB-INF/template/</value>
<value>classpath:/jmda-ftl/</value>
</list>
</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="classic_compatible">true</prop>
<prop key="template_exception_handler">ignore</prop>
</props>
</property>
</bean> <!-- 启用CGliB -->
<aop:aspectj-autoproxy /> <!-- 配置c3p0数据源，项目中有代码需要C3P0数据源支持时额外配置，不需要可以不配置 -->
<bean id="c3p0DataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
<property name="jdbcUrl">
<value><![CDATA[jdbc:mysql://localhost:3306/fms-zhs?useUnicode=yes&characterEncoding=UTF8]]></value>
</property>
<property name="driverClass" value="com.mysql.jdbc.Driver" />
<property name="user" value="root" />
<property name="password" value="root" />
<property name="maxPoolSize" value="200" />
<property name="minPoolSize" value="1" />
<property name="initialPoolSize" value="1" />
<property name="maxIdleTime" value="30" />
<property name="acquireIncrement" value="5" />
<property name="maxStatements" value="0" />
<property name="idleConnectionTestPeriod" value="60" />
<property name="acquireRetryAttempts" value="30" />
<property name="breakAfterAcquireFailure" value="true" />
<property name="testConnectionOnCheckout" value="false" />
</bean> <!-- 注入数据源连接配置文件 -->
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath*:/spring/jdbc.properties</value>
</list>
</property>
</bean> <!-- 多个数据源的公用配置，方便下面直接引用 -->
<bean id="abstractXADataSource" class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init"
destroy-method="close" abstract="true">
<property name="xaDataSourceClassName" value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource"/>
<property name="poolSize" value="10" />
<property name="minPoolSize" value="10"/>
<property name="maxPoolSize" value="30"/>
<property name="borrowConnectionTimeout" value="60"/>
<property name="reapTimeout" value="20"/>
<!-- 最大空闲时间 -->
<property name="maxIdleTime" value="60"/>
<property name="maintenanceInterval" value="60" />
<property name="loginTimeout" value="60"/>
<property name="logWriter" value="60"/>
<property name="testQuery">
<value>select 1</value>
</property> </bean> <!-- 下面是所有需要切换的数据源 -->
<!-- 综合所数据源 -->
<bean id="ds_zhs" parent="abstractXADataSource">
<!-- value只要多个XA数据源之间不重复就行，随便取名 -->
<property name="uniqueResourceName" value="mysql/zhs" />
<property name="xaDataSourceClassName"
value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />
<property name="xaProperties">
<props>
<prop key="URL">${jdbc_zhs.url.spider}</prop>
<prop key="user">${jdbc_zhs.username}</prop>
<prop key="password">${jdbc_zhs.password}</prop>
</props>
</property>
</bean> <!-- 舰船所数据源-->
<bean id="ds_jcs" parent="abstractXADataSource">
<property name="uniqueResourceName" value="mysql/jcs" />
<property name="xaDataSourceClassName"
value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />
<property name="xaProperties">
<props>
<prop key="URL">${jdbc_jcs.url.spider}</prop>
<prop key="user">${jdbc_jcs.username}</prop>
<prop key="password">${jdbc_jcs.password}</prop>
</props>
</property>
</bean> <!-- 航空所数据源-->
<bean id="ds_hks" parent="abstractXADataSource">
<property name="uniqueResourceName" value="mysql/hks" />
<property name="xaDataSourceClassName"
value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />
<property name="xaProperties">
<props>
<prop key="URL">${jdbc_hks.url.spider}</prop>
<prop key="user">${jdbc_hks.username}</prop>
<prop key="password">${jdbc_hks.password}</prop>
</props>
</property>
</bean> <!-- 系统所数据源-->
<bean id="ds_xts" parent="abstractXADataSource">
<property name="uniqueResourceName" value="mysql/xts" />
<property name="xaDataSourceClassName"
value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />
<property name="xaProperties">
<props>
<prop key="URL">${jdbc_xts.url.spider}</prop>
<prop key="user">${jdbc_xts.username}</prop>
<prop key="password">${jdbc_xts.password}</prop>
</props>
</property>
</bean> <!-- 信息工程所数据源-->
<bean id="ds_xxgcs" parent="abstractXADataSource">
<property name="uniqueResourceName" value="mysql/xxgcs" />
<property name="xaDataSourceClassName"
value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />
<property name="xaProperties">
<props>
<prop key="URL">${jdbc_xxgcs.url.spider}</prop>
<prop key="user">${jdbc_xxgcs.username}</prop>
<prop key="password">${jdbc_xxgcs.password}</prop>
</props>
</property>
</bean> <!-- 自动化所数据源-->
<bean id="ds_zdhs" parent="abstractXADataSource">
<property name="uniqueResourceName" value="mysql/zdhs" />
<property name="xaDataSourceClassName"
value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />
<property name="xaProperties">
<props>
<prop key="URL">${jdbc_zdhs.url.spider}</prop>
<prop key="user">${jdbc_zdhs.username}</prop>
<prop key="password">${jdbc_zdhs.password}</prop>
</props>
</property>
</bean> <!-- 规范所数据源-->
<bean id="ds_gfs" parent="abstractXADataSource">
<property name="uniqueResourceName" value="mysql/gfs" />
<property name="xaDataSourceClassName"
value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />
<property name="xaProperties">
<props>
<prop key="URL">${jdbc_gfs.url.spider}</prop>
<prop key="user">${jdbc_gfs.username}</prop>
<prop key="password">${jdbc_gfs.password}</prop>
</props>
</property>
</bean> <!-- 科信所数据源-->
<bean id="ds_kxs" parent="abstractXADataSource">
<property name="uniqueResourceName" value="mysql/kxs" />
<property name="xaDataSourceClassName"
value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />
<property name="xaProperties">
<props>
<prop key="URL">${jdbc_kxs.url.spider}</prop>
<prop key="user">${jdbc_kxs.username}</prop>
<prop key="password">${jdbc_kxs.password}</prop>
</props>
</property>
</bean> <!-- 翻译队数据源-->
<bean id="ds_fyd" parent="abstractXADataSource">
<property name="uniqueResourceName" value="mysql/fyd" />
<property name="xaDataSourceClassName"
value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />
<property name="xaProperties">
<props>
<prop key="URL">${jdbc_fyd.url.spider}</prop>
<prop key="user">${jdbc_fyd.username}</prop>
<prop key="password">${jdbc_fyd.password}</prop>
</props>
</property>
</bean> <!-- 院本级数据源-->
<bean id="ds_ybj" parent="abstractXADataSource">
<property name="uniqueResourceName" value="mysql/ybj" />
<property name="xaDataSourceClassName"
value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />
<property name="xaProperties">
<props>
<prop key="URL">${jdbc_ybj.url.spider}</prop>
<prop key="user">${jdbc_ybj.username}</prop>
<prop key="password">${jdbc_ybj.password}</prop>
</props>
</property>
</bean> <!-- 院综合系统数据源-->
<bean id="ds_yzh" parent="abstractXADataSource">
<property name="uniqueResourceName" value="mysql/yzh" />
<property name="xaDataSourceClassName"
value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" />
<property name="xaProperties">
<props>
<prop key="URL">${jdbc_yzh.url.spider}</prop>
<prop key="user">${jdbc_yzh.username}</prop>
<prop key="password">${jdbc_yzh.password}</prop>
</props>
</property>
</bean> <!-- 配置多数据源 MultipleDataSource-->
<bean name="dynamicDatasource" class="com.fms.common.datasource.MultipleDataSource">
<property name="targetDataSources">
<map>
<!-- key和value-ref尽量保持一致，我在测试的时候因为名称不一致一致报错，
找了好久都没找到原因，最后统一了名称终于成功启动了 -->
<entry key="ds_zhs" value-ref="ds_zhs"/>
<entry key="ds_jcs" value-ref="ds_jcs"/>
<entry key="ds_hks" value-ref="ds_hks"/>
<entry key="ds_xts" value-ref="ds_xts"/>
<entry key="ds_xxgcs" value-ref="ds_xxgcs"/>
<entry key="ds_zdhs" value-ref="ds_zdhs"/>
<entry key="ds_gfs" value-ref="ds_gfs"/>
<entry key="ds_kxs" value-ref="ds_kxs"/>
<entry key="ds_fyd" value-ref="ds_fyd"/>
<entry key="ds_ybj" value-ref="ds_ybj"/>
<entry key="ds_yzh" value-ref="ds_yzh"/>
</map>
</property>
<!-- 指定一个默认的数据源，即在不需要切换数据源时，本地系统默认使用的数据源 -->
<property name="defaultTargetDataSource" ref="ds_zhs" />
</bean> <!-- 下面开始配置SqlSessionFactoryBean，有多少个数据源需要支持就陪多少个 -->
<bean id="sqlSessionFactory_zhs" class="org.mybatis.spring.SqlSessionFactoryBean">
<!-- dataSource的ref对应数据源的id -->
<property name="dataSource" ref="ds_zhs"/>
<property name="configLocation" value="classpath:mybatis.xml" />
<property name="mapperLocations">
<list>
<value>classpath*:/com/fms/**/dao/*Mapper.xml</value>
<value>classpath*:/com/fms/**/dao/*DAO.xml</value>
</list>
</property>
</bean>
<bean id="sqlSessionFactory_jcs" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds_jcs"/>
<property name="configLocation" value="classpath:mybatis.xml" />
<property name="mapperLocations">
<list>
<value>classpath*:/com/fms/**/dao/*Mapper.xml</value>
<value>classpath*:/com/fms/**/dao/*DAO.xml</value>
</list>
</property>
</bean>
<bean id="sqlSessionFactory_hks" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds_hks"/>
<property name="configLocation" value="classpath:mybatis.xml" />
<property name="mapperLocations">
<list>
<value>classpath*:/com/fms/**/dao/*Mapper.xml</value>
<value>classpath*:/com/fms/**/dao/*DAO.xml</value>
</list>
</property>
</bean>
<bean id="sqlSessionFactory_xts" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds_xts"/>
<property name="configLocation" value="classpath:mybatis.xml" />
<property name="mapperLocations">
<list>
<value>classpath*:/com/fms/**/dao/*Mapper.xml</value>
<value>classpath*:/com/fms/**/dao/*DAO.xml</value>
</list>
</property>
</bean>
<bean id="sqlSessionFactory_xxgcs" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds_xxgcs"/>
<property name="configLocation" value="classpath:mybatis.xml" />
<property name="mapperLocations">
<list>
<value>classpath*:/com/fms/**/dao/*Mapper.xml</value>
<value>classpath*:/com/fms/**/dao/*DAO.xml</value>
</list>
</property>
</bean>
<bean id="sqlSessionFactory_zdhs" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds_zdhs"/>
<property name="configLocation" value="classpath:mybatis.xml" />
<property name="mapperLocations">
<list>
<value>classpath*:/com/fms/**/dao/*Mapper.xml</value>
<value>classpath*:/com/fms/**/dao/*DAO.xml</value>
</list>
</property>
</bean>
<bean id="sqlSessionFactory_gfs" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds_gfs"/>
<property name="configLocation" value="classpath:mybatis.xml" />
<property name="mapperLocations">
<list>
<value>classpath*:/com/fms/**/dao/*Mapper.xml</value>
<value>classpath*:/com/fms/**/dao/*DAO.xml</value>
</list>
</property>
</bean>
<bean id="sqlSessionFactory_kxs" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds_kxs"/>
<property name="configLocation" value="classpath:mybatis.xml" />
<property name="mapperLocations">
<list>
<value>classpath*:/com/fms/**/dao/*Mapper.xml</value>
<value>classpath*:/com/fms/**/dao/*DAO.xml</value>
</list>
</property>
</bean>
<bean id="sqlSessionFactory_fyd" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds_fyd"/>
<property name="configLocation" value="classpath:mybatis.xml" />
<property name="mapperLocations">
<list>
<value>classpath*:/com/fms/**/dao/*Mapper.xml</value>
<value>classpath*:/com/fms/**/dao/*DAO.xml</value>
</list>
</property>
</bean>
<bean id="sqlSessionFactory_ybj" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds_ybj"/>
<property name="configLocation" value="classpath:mybatis.xml" />
<property name="mapperLocations">
<list>
<value>classpath*:/com/fms/**/dao/*Mapper.xml</value>
<value>classpath*:/com/fms/**/dao/*DAO.xml</value>
</list>
</property>
</bean>
<bean id="sqlSessionFactory_yzh" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="ds_yzh"/>
<property name="configLocation" value="classpath:mybatis.xml" />
<property name="mapperLocations">
<list>
<value>classpath*:/com/fms/**/dao/*Mapper.xml</value>
<value>classpath*:/com/fms/**/dao/*DAO.xml</value>
</list>
</property>
</bean> <!-- 配置自定义的SqlSessionTemplate模板，注入相关配置 -->
<bean id="sqlSessionTemplate" class="com.fms.common.datasource.CustomSqlSessionTemplate" scope="prototype">
<!-- 构造注入参数指定本地默认数据源对应的SqlSessionFactoryBean -->
<constructor-arg ref="sqlSessionFactory_zhs" />
<property name="targetSqlSessionFactorys">
<map>
<!-- key和上文配置的数据源的id值尽量保持一致，我在测试的时候因为名称不一致一致报错，
找了好久都没找到原因，最后统一了名称终于成功启动了 -->
<entry value-ref="sqlSessionFactory_zhs" key="ds_zhs"/>
<entry value-ref="sqlSessionFactory_jcs" key="ds_jcs"/>
<entry value-ref="sqlSessionFactory_hks" key="ds_hks"/>
<entry value-ref="sqlSessionFactory_xts" key="ds_xts"/>
<entry value-ref="sqlSessionFactory_xxgcs" key="ds_xxgcs"/>
<entry value-ref="sqlSessionFactory_zdhs" key="ds_zdhs"/>
<entry value-ref="sqlSessionFactory_gfs" key="ds_gfs"/>
<entry value-ref="sqlSessionFactory_kxs" key="ds_kxs"/>
<entry value-ref="sqlSessionFactory_fyd" key="ds_fyd"/>
<entry value-ref="sqlSessionFactory_ybj" key="ds_ybj"/>
<entry value-ref="sqlSessionFactory_yzh" key="ds_yzh"/>
</map>
</property>
</bean> <!-- 配置mybatis接口扫描 -->
<bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.fms.**.dao" />
<property name="sqlSessionTemplateBeanName" value="sqlSessionTemplate"/>
</bean> <!-- jta配置，直接复用，不需要修改 -->
<!-- jta配置开始 -->
<bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager"
init-method="init" destroy-method="close">
<property name="forceShutdown">
<value>true</value>
</property>
</bean> <bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">
<property name="transactionTimeout" value="300" />
</bean> <bean id="springTransactionManager"
class="org.springframework.transaction.jta.JtaTransactionManager">
<property name="transactionManager">
<ref bean="atomikosTransactionManager" />
</property>
<property name="userTransaction">
<ref bean="atomikosUserTransaction" />
</property>
</bean>
<!-- jta配置结束 --> <!-- 配置事务管理 -->
<tx:annotation-driven transaction-manager="springTransactionManager" proxy-target-class="true" /> </beans>
3、springmvc-servlet.xml：
<?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:aop="http://www.springframework.org/schema/aop"
xmlns:cache="http://www.springframework.org/schema/cache"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:jms="http://www.springframework.org/schema/jms" xmlns:lang="http://www.springframework.org/schema/lang"
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:oxm="http://www.springframework.org/schema/oxm"
xmlns:p="http://www.springframework.org/schema/p" xmlns:task="http://www.springframework.org/schema/task"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:mongo="http://www.springframework.org/schema/data/mongo"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:ehcache="http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.1.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.1.xsd
http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-4.1.xsd
http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-4.1.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.1.xsd
http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm-4.1.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.1.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.1.xsd"> <context:component-scan base-package="com.fms;com.jmda;com.job;" >
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service" />
</context:component-scan>
<!-- <context:annotation-config/> --> <!-- message-converters -->
<mvc:annotation-driven>
<mvc:message-converters>
<bean class="org.springframework.http.converter.StringHttpMessageConverter">
<property name="supportedMediaTypes">
<list>
<value>text/plain;charset=UTF-8</value>
<value>text/html;charset=UTF-8</value>
</list>
</property>
</bean>
</mvc:message-converters>
</mvc:annotation-driven> <!-- 视图解析器 -->
<bean id="viewResolver"
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>
<property name="requestContextAttribute" value="request" />
<property name="exposeSpringMacroHelpers" value="true" />
<property name="exposeRequestAttributes" value="true" />
<property name="exposeSessionAttributes" value="true" />
</bean> <!-- 静态资源 -->
<mvc:resources mapping="/static/**" location="/static/" />
<mvc:resources mapping="/jmda-static/**" location="/jmda-static/" />
<mvc:resources mapping="/assets/**" location="/assets/" /> <!-- 拦截器 -->
<mvc:interceptors>
<bean class="com.fms.common.listener.SecurityInterceptor"/>
</mvc:interceptors>
</beans>
4、web.xml：
<?xml version="1.0" encoding="UTF-8"?>
<web-app metadata-complete="true" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath*:/spring/applicationContext*.xml
</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<listener>
<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>
<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> <servlet>
<servlet-name>spring4mvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:/spring/springmvc-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>spring4mvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!--文件下载 -->
<servlet>
<servlet-name>ServletDownload</servlet-name>
<servlet-class>com.fms.business.sjtb.service.ServletDownload</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ServletDownload</servlet-name>
<url-pattern>/servlet/download</url-pattern>
</servlet-mapping>
<context-param>
<param-name>log4jConfigLocation</param-name>
<param-value>/WEB-INF/classes/log4j.properties</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>
<listener>
<listener-class>com.fms.common.listener.CommListener</listener-class>
</listener>
<!-- 400错误 -->
<error-page>
<error-code>400</error-code>
<location>/error</location>
</error-page>
<!-- 404 页面不存在错误 -->
<error-page>
<error-code>404</error-code>
<location>/error</location>
</error-page>
<!-- 403 服务器拒绝请求 -->
<error-page>
<error-code>403</error-code>
<location>/error</location>
</error-page>
<!-- 500 服务器内部错误 -->
<error-page>
<error-code>500</error-code>
<location>/error</location>
</error-page>
<!-- 503 服务不可用 -->
<error-page>
<error-code>503</error-code>
<location>/error</location>
</error-page>
<!-- java.lang.Exception -->
<error-page>
<exception-type>java.lang.Exception</exception-type>
<location>/error</location>
</error-page>
<!-- java.lang.NullPointerException -->
<error-page>
<exception-type>java.lang.NullPointerException</exception-type>
<location>/error</location>
</error-page>
<error-page>
<exception-type>javax.servlet.ServletException</exception-type>
<location>/error</location>
</error-page>
<welcome-file-list>
<welcome-file></welcome-file>
</welcome-file-list>
</web-app>
5、在resources文件夹下增加jta.properties文件：
com.atomikos.icatch.service=com.atomikos.icatch.standalone.UserTransactionServiceFactory
com.atomikos.icatch.console_file_name = tm.out
com.atomikos.icatch.log_base_name = tmlog
com.atomikos.icatch.tm_unique_name = com.atomikos.spring.jdbc.tm
com.atomikos.icatch.console_log_level=WARN
JAVA代码：
1.MultipleDataSource：
package com.fms.common.datasource;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
public class MultipleDataSource extends AbstractRoutingDataSource {
private static final ThreadLocal<String> dataSourceKey = new InheritableThreadLocal<String>();
//将数据源重置为默认数据源
public static void changeTodefaultDataSource() {
dataSourceKey.remove();
}
// //院
// public static void setDataSourceY(){
// dataSourceKey.remove();
// dataSourceKey.set("yzhDataSource");
// }
//将数据源设置为配置文件中key值为dataSource参数对应的值的数据源
public static void setDataSource(String dataSource){
dataSourceKey.remove();
dataSourceKey.set(dataSource);
}
//获取当前数据源的key值
public static String getKey(){
return dataSourceKey.get();
}
//重写AbstractRoutingDataSource的方法，提供当前的数据源用于连接
@Override
protected Object determineCurrentLookupKey() {
return dataSourceKey.get();
}
}
2、自定义的SqlSessionTemlate类：
CustomSqlSessionTemplate
package com.fms.common.datasource; import static java.lang.reflect.Proxy.newProxyInstance;
import static org.apache.ibatis.reflection.ExceptionUtil.unwrapThrowable;
import static org.mybatis.spring.SqlSessionUtils.closeSqlSession;
import static org.mybatis.spring.SqlSessionUtils.getSqlSession;
import static org.mybatis.spring.SqlSessionUtils.isSqlSessionTransactional; import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.util.List;
import java.util.Map; import org.apache.ibatis.exceptions.PersistenceException;
import org.apache.ibatis.executor.BatchResult;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.MyBatisExceptionTranslator;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.dao.support.PersistenceExceptionTranslator;
import org.springframework.util.Assert; public class CustomSqlSessionTemplate extends SqlSessionTemplate { private final SqlSessionFactory sqlSessionFactory;
private final ExecutorType executorType;
private final SqlSession sqlSessionProxy;
private final PersistenceExceptionTranslator exceptionTranslator; private Map<Object, SqlSessionFactory> targetSqlSessionFactorys;
private SqlSessionFactory defaultTargetSqlSessionFactory; public void setTargetSqlSessionFactorys(Map<Object, SqlSessionFactory> targetSqlSessionFactorys) {
this.targetSqlSessionFactorys = targetSqlSessionFactorys;
} public void setDefaultTargetSqlSessionFactory(SqlSessionFactory defaultTargetSqlSessionFactory) {
this.defaultTargetSqlSessionFactory = defaultTargetSqlSessionFactory;
} public CustomSqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType());
} public CustomSqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType) {
this(sqlSessionFactory, executorType, new MyBatisExceptionTranslator(sqlSessionFactory.getConfiguration()
.getEnvironment().getDataSource(), true));
} public CustomSqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
PersistenceExceptionTranslator exceptionTranslator) { super(sqlSessionFactory, executorType, exceptionTranslator); this.sqlSessionFactory = sqlSessionFactory;
this.executorType = executorType;
this.exceptionTranslator = exceptionTranslator; this.sqlSessionProxy = (SqlSession) newProxyInstance(
SqlSessionFactory.class.getClassLoader(),
new Class[] { SqlSession.class },
new SqlSessionInterceptor()); this.defaultTargetSqlSessionFactory = sqlSessionFactory;
} @Override
public SqlSessionFactory getSqlSessionFactory() { SqlSessionFactory targetSqlSessionFactory = targetSqlSessionFactorys.get(MultipleDataSource.getKey());
if (targetSqlSessionFactory != null) {
return targetSqlSessionFactory;
} else if (defaultTargetSqlSessionFactory != null) {
return defaultTargetSqlSessionFactory;
} else {
Assert.notNull(targetSqlSessionFactorys, "Property 'targetSqlSessionFactorys' or 'defaultTargetSqlSessionFactory' are required");
Assert.notNull(defaultTargetSqlSessionFactory, "Property 'defaultTargetSqlSessionFactory' or 'targetSqlSessionFactorys' are required");
}
return this.sqlSessionFactory;
} @Override
public Configuration getConfiguration() {
return this.getSqlSessionFactory().getConfiguration();
} public ExecutorType getExecutorType() {
return this.executorType;
} public PersistenceExceptionTranslator getPersistenceExceptionTranslator() {
return this.exceptionTranslator;
} /**
* {@inheritDoc}
*/
public <T> T selectOne(String statement) {
return this.sqlSessionProxy.<T> selectOne(statement);
} /**
* {@inheritDoc}
*/
public <T> T selectOne(String statement, Object parameter) {
return this.sqlSessionProxy.<T> selectOne(statement, parameter);
} /**
* {@inheritDoc}
*/
public <K, V> Map<K, V> selectMap(String statement, String mapKey) {
return this.sqlSessionProxy.<K, V> selectMap(statement, mapKey);
} /**
* {@inheritDoc}
*/
public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey) {
return this.sqlSessionProxy.<K, V> selectMap(statement, parameter, mapKey);
} /**
* {@inheritDoc}
*/
public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
return this.sqlSessionProxy.<K, V> selectMap(statement, parameter, mapKey, rowBounds);
} /**
* {@inheritDoc}
*/
public <E> List<E> selectList(String statement) {
return this.sqlSessionProxy.<E> selectList(statement);
} /**
* {@inheritDoc}
*/
public <E> List<E> selectList(String statement, Object parameter) {
return this.sqlSessionProxy.<E> selectList(statement, parameter);
} /**
* {@inheritDoc}
*/
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
return this.sqlSessionProxy.<E> selectList(statement, parameter, rowBounds);
} /**
* {@inheritDoc}
*/
public void select(String statement, ResultHandler handler) {
this.sqlSessionProxy.select(statement, handler);
} /**
* {@inheritDoc}
*/
public void select(String statement, Object parameter, ResultHandler handler) {
this.sqlSessionProxy.select(statement, parameter, handler);
} /**
* {@inheritDoc}
*/
public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
this.sqlSessionProxy.select(statement, parameter, rowBounds, handler);
} /**
* {@inheritDoc}
*/
public int insert(String statement) {
return this.sqlSessionProxy.insert(statement);
} /**
* {@inheritDoc}
*/
public int insert(String statement, Object parameter) {
return this.sqlSessionProxy.insert(statement, parameter);
} /**
* {@inheritDoc}
*/
public int update(String statement) {
return this.sqlSessionProxy.update(statement);
} /**
* {@inheritDoc}
*/
public int update(String statement, Object parameter) {
return this.sqlSessionProxy.update(statement, parameter);
} /**
* {@inheritDoc}
*/
public int delete(String statement) {
return this.sqlSessionProxy.delete(statement);
} /**
* {@inheritDoc}
*/
public int delete(String statement, Object parameter) {
return this.sqlSessionProxy.delete(statement, parameter);
} /**
* {@inheritDoc}
*/
public <T> T getMapper(Class<T> type) {
return getConfiguration().getMapper(type, this);
} /**
* {@inheritDoc}
*/
public void commit() {
throw new UnsupportedOperationException("Manual commit is not allowed over a Spring managed SqlSession");
} /**
* {@inheritDoc}
*/
public void commit(boolean force) {
throw new UnsupportedOperationException("Manual commit is not allowed over a Spring managed SqlSession");
} /**
* {@inheritDoc}
*/
public void rollback() {
throw new UnsupportedOperationException("Manual rollback is not allowed over a Spring managed SqlSession");
} /**
* {@inheritDoc}
*/
public void rollback(boolean force) {
throw new UnsupportedOperationException("Manual rollback is not allowed over a Spring managed SqlSession");
} /**
* {@inheritDoc}
*/
public void close() {
throw new UnsupportedOperationException("Manual close is not allowed over a Spring managed SqlSession");
} /**
* {@inheritDoc}
*/
public void clearCache() {
this.sqlSessionProxy.clearCache();
} /**
* {@inheritDoc}
*/
public Connection getConnection() {
return this.sqlSessionProxy.getConnection();
} /**
* {@inheritDoc}
* @since 1.0.2
*/
public List<BatchResult> flushStatements() {
return this.sqlSessionProxy.flushStatements();
} /**
* Proxy needed to route MyBatis method calls to the proper SqlSession got from Spring's Transaction Manager It also
* unwraps exceptions thrown by {@code Method#invoke(Object, Object...)} to pass a {@code PersistenceException} to
* the {@code PersistenceExceptionTranslator}.
*/
private class SqlSessionInterceptor implements InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
final SqlSession sqlSession = getSqlSession(
CustomSqlSessionTemplate.this.getSqlSessionFactory(),
CustomSqlSessionTemplate.this.executorType,
CustomSqlSessionTemplate.this.exceptionTranslator);
try {
Object result = method.invoke(sqlSession, args);
if (!isSqlSessionTransactional(sqlSession, CustomSqlSessionTemplate.this.getSqlSessionFactory())) {
// force commit even on non-dirty sessions because some databases require
// a commit/rollback before calling close()
sqlSession.commit(true);
}
return result;
} catch (Throwable t) {
Throwable unwrapped = unwrapThrowable(t);
if (CustomSqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
Throwable translated = CustomSqlSessionTemplate.this.exceptionTranslator
.translateExceptionIfPossible((PersistenceException) unwrapped);
if (translated != null) {
unwrapped = translated;
}
}
throw unwrapped;
} finally {
closeSqlSession(sqlSession, CustomSqlSessionTemplate.this.getSqlSessionFactory());
}
}
} }
3、数据源切换切面ChooseDataSourceAspect：
package com.fms.common.aop; import java.lang.reflect.Method; 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.springframework.stereotype.Component; import com.fms.common.annotation.ChooseDataSource;
import com.fms.common.datasource.MultipleDataSource;
import com.fms.common.utils.reflect.ReflectUtil; /**
* 类描述：完成数据源的切换，抽类切面，具体项目继承一下，不需要重写即可使用
*/
@Aspect
public abstract class ChooseDataSourceAspect { protected static final ThreadLocal<String> preDatasourceHolder = new ThreadLocal<String>(); @Pointcut("@annotation(com.fms.common.annotation.ChooseDataSource)")
public void methodWithChooseAnnotation() {
System.err.println("************************************************//////////////////////////////////////////");
} /**
* 根据@ChooseDataSource的属性值设置不同的dataSourceKey,以供DynamicDataSource
*/
@Before("methodWithChooseAnnotation()")
public void changeDataSourceBeforeMethodExecution(JoinPoint jp) {
//拿到anotation中配置的数据源
String resultDS = determineDatasource(jp);
//没有配置实用默认数据源
if (resultDS == null) {
MultipleDataSource.changeTodefaultDataSource();
return;
}
preDatasourceHolder.set(MultipleDataSource.getKey());
//将数据源设置到数据源持有者
MultipleDataSource.setDataSource(resultDS); } /**
* 如果需要修改获取数据源的逻辑，请重写此方法 *
* @param jp
* @return
*/
@SuppressWarnings("rawtypes")
protected String determineDatasource(JoinPoint jp) {
String methodName = jp.getSignature().getName();
Class targetClass = jp.getSignature().getDeclaringType();
String dataSourceForTargetClass = resolveDataSourceFromClass(targetClass);
String dataSourceForTargetMethod = resolveDataSourceFromMethod(targetClass, methodName);
String resultDS = determinateDataSource(dataSourceForTargetClass, dataSourceForTargetMethod);
return resultDS;
} /**
* 方法执行完毕以后，数据源切换回之前的数据源。
* 比如foo()方法里面调用bar()，但是bar()另外一个数据源，
* bar()执行时，切换到自己数据源，执行完以后，要切换到foo()所需要的数据源，以供
* foo()继续执行。
*/
@After("methodWithChooseAnnotation()")
public void restoreDataSourceAfterMethodExecution() {
MultipleDataSource.setDataSource(preDatasourceHolder.get());
preDatasourceHolder.remove();
} /**
* @param targetClass
* @param methodName
* @return
*/
@SuppressWarnings("rawtypes")
private String resolveDataSourceFromMethod(Class targetClass, String methodName) { Method m = ReflectUtil.findUniqueMethod(targetClass, methodName);
if (m != null) {
ChooseDataSource choDs = m.getAnnotation(ChooseDataSource.class);
return resolveDataSourcename(choDs);
}
return null;
} /**
* 方法描述 :
* 确定最终数据源，如果方法上设置有数据源，则以方法上的为准，如果方法上没有设置，则以类上的为准，如果类上没有设置，则使用默认数据源
*
* @param classDS
* @param methodDS
* @return
*/
private String determinateDataSource(String classDS, String methodDS) {
// if (null == classDS && null == methodDS) {
// return null;
// }
// 两者必有一个不为null,如果两者都为Null，也会返回Null
return methodDS == null ? classDS : methodDS;
} /**
* 方法描述 : 类级别的 @ChooseDataSource的解析
*
* @param targetClass
* @return
*/
@SuppressWarnings({"unchecked", "rawtypes"})
private String resolveDataSourceFromClass(Class targetClass) {
ChooseDataSource classAnnotation = (ChooseDataSource) targetClass
.getAnnotation(ChooseDataSource.class);
// 直接为整个类进行设置
return null != classAnnotation ? resolveDataSourcename(classAnnotation)
: null;
} /**
* 方法描述 :
* 组装DataSource的名字
*
* @param ds
* @return
*/
private String resolveDataSourcename(ChooseDataSource ds) {
return ds == null ? null : ds.value();
} }
4、数据源切换注解ChooseDataSource：
package com.fms.common.annotation; import java.lang.annotation.*; /**
* 注解式数据源，用来进行数据源切换
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ChooseDataSource { String value() default "";
}
5、使用方式：
TestService：
package com.fms.business; import java.util.Map; import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import com.fms.common.dao.table.mapper.WfWorkflowPOMapper;
import com.fms.common.datasource.MultipleDataSource;
import com.fms.common.model.po.WfWorkflowPO;
import com.google.common.collect.Maps; @Service(value="testService")
public class TestService { //注入SqlSessionTemplate，执行自定义的Mapper.xml文件
@Autowired
SqlSessionTemplate sqlSessionTemplate;
String nameSpace = "com.fms.business.dao.TestServiceMapper"; @Transactional
public void test() throws Exception{
Map<String, Object> param = Maps.newHashMap();
param.put("id", "123");
param.put("name", "zhangsan");
//默认数据源ds_zhs
sqlSessionTemplate.insert(nameSpace+".testInsert", param);
//切换至ds_jcs
MultipleDataSource.setDataSource("ds_jcs");
sqlSessionTemplate.insert(nameSpace+".testInsert", param);
} @Transactional
public void test1() throws Exception{
Map<String, Object> param = Maps.newHashMap();
param.put("id", "124");
param.put("name", "lisi");
//默认数据源ds_zhs
sqlSessionTemplate.insert(nameSpace+".testInsert", param);
//切换至ds_jcs
MultipleDataSource.setDataSource("ds_jcs");
sqlSessionTemplate.insert(nameSpace+".testInsert", param);
//编写抛出异常的代码测试事务回滚
String str = null;
str.trim();
} //使用MyBatis自动生成的Mapper接口
@Autowired
WfWorkflowPOMapper wfWorkflowPOMapper;
@Transactional
public void test2() throws Exception{
WfWorkflowPO record = new WfWorkflowPO();
record.setWorkflowId("12345");
record.setName("xxxx");
wfWorkflowPOMapper.insert(record);
//切换至ds_jcs
MultipleDataSource.setDataSource("ds_jcs");
wfWorkflowPOMapper.insert(record);
//切换至ds_yzh
MultipleDataSource.setDataSource("ds_yzh");
wfWorkflowPOMapper.insert(record);
} }
TestController：
package com.fms.business; 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; @Controller
public class TestController { @Autowired
TestService testService; @RequestMapping("/test")
@ResponseBody
public String test(){
try {
testService.test();
return "ok";
} catch (Exception e) {
e.printStackTrace();
return "fail";
}
} @RequestMapping("/test1")
@ResponseBody
public String test1(){
try {
testService.test1();
return "ok";
} catch (Exception e) {
e.printStackTrace();
return "fail";
}
} @RequestMapping("/test2")
@ResponseBody
public String test2(){
try {
testService.test2();
return "ok";
} catch (Exception e) {
e.printStackTrace();
return "fail";
}
}
}Aspect
原例中还有使用@ChooseDataSource注解切换数据源的用法，需要AspectJ编译，捣鼓了一下没成功，数据源能够切换，但是分布式事务不起作用，有兴趣可以自己试试自己调试修改。
在项目中加入一个继承ChooseDataSourceAspect的类即可：
package com.fms.business;ChooseDataSource import org.aspectj.lang.annotation.Aspect; import com.fms.common.aop.ChooseDataSourceAspect;
@Component
@Aspect
public class TestAspect extends ChooseDataSourceAspect { }
参考博文：http://www.blogjava.net/zuxiong/archive/2015/09/24/427471.html