jie2workjava
- 浏览: 151182 次
- 性别:
- 来自: 广州
-
文章分类
最新评论
-
fantasySun：
LZ你好，有个问题要请教你一下，我通过修改tomcat下面的c ...
tomcat绑定域名 -
yyf365：
请问，你的这种实现方式，能否解决多个数据源同时使用OpenSe ...
多数据源---SessionFactory -
fengweizhi1985：
非常不错的正解！
java取整和java四舍五入方法 -
pye：
要使用runtimeException才会回滚的
Spring事务配置的五种方式 -
wubaodong：
通过apache实现了，谢谢您的文章
tomcat绑定域名
之前做过一个多database的例子，当时没有达到动态更换数据源的目的。
后来做了个多session工厂的例子，达到了动态更换数据源的目的了。在网上有些例子，
不过感觉有帮助但是不全，特此把我自己的弄得贴出来，如果说的不清楚的话，可以下载
附件看代码！
spring配置文件
<?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-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"
default-autowire="byName">
<context:annotation-config />
<bean id="parentDataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="username" value="root"></property>
<property name="password" value="hejie"></property>
</bean>
<bean id="primaryDataSource" parent="parentDataSource">
<property name="url">
<value>jdbc:mysql://localhost:3306/test1</value>
</property>
</bean>
<bean id="backupDataSource" parent="parentDataSource">
<property name="url">
<value>jdbc:mysql://localhost:3306/test2</value>
</property>
</bean>
<!--
<bean id="dataSource" scope="prototype"
class="com.mul.spring.MyAbstractRoutingDataSource">
<property name="targetDataSources">
<map key-type="java.lang.String">
<entry key="admin1" value-ref="primaryDataSource" />
<entry key="guest1" value-ref="backupDataSource" />
</map>
</property>
<property name="defaultTargetDataSource" ref="primaryDataSource" />
</bean>
-->
<bean id="sessionFactory1"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="primaryDataSource" />
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.current_session_context_class">
thread
</prop>
<prop key="hibernate.show_sql">false</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>
com/mul/entity/DataEntity.hbm.xml
</value>
</list>
</property>
<property name="exposeTransactionAwareSessionFactory">
<value>false</value>
</property>
</bean>
<bean id="sessionFactory2"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="backupDataSource" />
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<prop key="hibernate.current_session_context_class">
thread
</prop>
<prop key="hibernate.show_sql">false</prop>
</props>
</property>
<property name="mappingResources">
<list>
<value>
com/mul/entity/DataEntity.hbm.xml
</value>
</list>
</property>
<property name="exposeTransactionAwareSessionFactory">
<value>false</value>
</property>
</bean>
<bean id="sessionFactory" class="com.mul.spring.MultiSessionFactory">
<property name="sessionFactory"><ref local="sessionFactory2"/></property>
</bean>
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
<!-- <property name="hibernateManagedSession" value="false"/>-->
</bean>
<tx:annotation-driven transaction-manager="transactionManager" />
<context:component-scan base-package="com.mul" />
<aop:config>
<aop:pointcut id="testservice"
expression="execution(* com.mul.service.*Service.*(..))" />
<aop:advisor id="testServiceAd" advice-ref="txAdvice" pointcut-ref="testservice" />
</aop:config>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="*" propagation="REQUIRED" rollback-for="java.lang.Exception"/>
<!-- <tx:method name="*" propagation="REQUIRED"/>-->
</tx:attributes>
</tx:advice>
<!-- dao -->
<bean id="dataEntityDao" class="com.mul.dao.DataEntityDao">
</bean>
<!-- service -->
<bean id="dataEntityService" class="com.mul.service.DataEntityService">
</bean>
</beans>
映射文件
<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <!-- Mapping file autogenerated by MyEclipse Persistence Tools --> <hibernate-mapping> <class name="com.mul.entity.DataEntity" table="dataentity" mutable="false"> <id name="id" type="java.lang.Integer"> <column name="id" /> <generator class="native"></generator> </id> <property name="name" type="java.lang.String"> <column name="name" length="128" /> </property> <property name="age"> <column name="age" /> </property> </class> </hibernate-mapping>
dao
package com.mul.dao;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.mul.entity.DataEntity;
public class DataEntityDao extends HibernateDaoSupport{
public DataEntity save(DataEntity de){
this.getSession().save(de);
return de;
}
}
service
package com.mul.service;
import com.mul.dao.DataEntityDao;
import com.mul.entity.DataEntity;
import com.mul.spring.CustomerContextHolder;
import com.mul.spring.DynamicDataSourceType;
public class DataEntityService {
private DataEntityDao dataEntityDao ;
public DataEntity save(DataEntity de){
System.out.println("保存到s1："+DynamicDataSourceType.S1);
this.dataEntityDao.save(de);
return de;
}
public DataEntity save2(DataEntity de){
System.out.println("保存到s2："+DynamicDataSourceType.S2);
this.dataEntityDao.save(de);
return de;
}
public DataEntityDao getDataEntityDao() {
return dataEntityDao;
}
public void setDataEntityDao(DataEntityDao dataEntityDao) {
this.dataEntityDao = dataEntityDao;
}
}
servlet： 建议使用struts试一试，在servlet中跟我在网上查的不同
package com.mul.servlet;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.mul.entity.DataEntity;
import com.mul.service.DataEntityService;
import com.mul.spring.CustomerContextHolder;
import com.mul.spring.DataSourceTypeChoose;
import com.mul.spring.DataSourceTypeKey;
import com.mul.spring.DynamicDataSourceType;
public class mulDataServlet extends HttpServlet {
public mulDataServlet() {
super();
}
public void destroy() {
super.destroy();
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
this.doPost(request, response);
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String name = request.getParameter("name");
String age = request.getParameter("age");
String db = request.getParameter("db");
DataEntity de = new DataEntity(name,new Integer(age==null?"16":age));
System.out.println("要保存的对象："+de);
// if("admin1".equals(db))
// DataSourceTypeChoose.setThreadLocal(DataSourceTypeKey.ADMIN);
// else
// DataSourceTypeChoose.setThreadLocal(DataSourceTypeKey.GUEST);
if(DataSourceTypeKey.appContext == null)
DataSourceTypeKey.appContext = new ClassPathXmlApplicationContext("/applicationContext.xml");
DataEntityService dataEntityService = (DataEntityService)DataSourceTypeKey.appContext.getBean("dataEntityService");
System.out.println("开始保存到数据库");
if("admin1".equals(db)){
//必须在save方法
CustomerContextHolder.setCustomerType(DynamicDataSourceType.S1);
dataEntityService.save(de);
}else{
CustomerContextHolder.setCustomerType(DynamicDataSourceType.S2);
dataEntityService.save2(de);
}
// ApplicationContext appContext = new ClassPathXmlApplicationContext("/applicationContext.xml");
// DataEntityService dataE = (DataEntityService)appContext.getBean("dataEntityService");
// dataE.save(de);
request.setAttribute("de", de);
request.getRequestDispatcher("/index.jsp").forward(request, response);
}
/**
* Initialization of the servlet. <br>
*
* @throws ServletException if an error occurs
*/
public void init() throws ServletException {
// Put your code here
}
}
辅助类，为了线程安全
package com.mul.spring;
public class CustomerContextHolder {
private static final ThreadLocal contextHolder = new ThreadLocal();
public static void setCustomerType(String customerType) {
System.out.println(customerType+" customerType cannot be null");
contextHolder.set(customerType);
}
public static String getCustomerType() {
return (String) contextHolder.get();
}
public static void clearCustomerType() {
contextHolder.remove();
}
}
统一管理session工厂的id
package com.mul.spring;
public class DynamicDataSourceType {
public static final String S1= "sessionFactory1";
public static final String S2= "sessionFactory2";
}
多sessionFactory的实现
package com.mul.spring;
import java.io.Serializable;
import java.lang.ref.Reference;
import java.sql.Connection;
import java.util.Map;
import java.util.Set;
import javax.naming.NamingException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Interceptor;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.StatelessSession;
import org.hibernate.engine.FilterDefinition;
import org.hibernate.metadata.ClassMetadata;
import org.hibernate.metadata.CollectionMetadata;
import org.hibernate.stat.Statistics;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
* 多SessionFactory 的一个实现
* @author hejie
*/
public class MultiSessionFactory implements SessionFactory, ApplicationContextAware {
private static final long serialVersionUID = 2064557324203496378L;
private static final Log log = LogFactory.getLog(MultiSessionFactory.class);
private ApplicationContext applicationContext = null;
private SessionFactory sessionFactory = null;
public ApplicationContext getApplicationContext() {
return applicationContext;
}
public void setApplicationContext(ApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}
//在每次拿到bean时都会检查你当前的sessionFactory，sessionFactoryName就是bean的id
public SessionFactory getSessionFactory(String sessionFactoryName) {
System.out.println("=========sessionFactoryName:"+sessionFactoryName);
try{
if(sessionFactoryName==null||sessionFactoryName.equals("")){
return sessionFactory;
}
return (SessionFactory)this.getApplicationContext().getBean(sessionFactoryName);
}catch(NoSuchBeanDefinitionException ex){
throw new RuntimeException("There is not the sessionFactory <name:"+sessionFactoryName+"> in the applicationContext!");
}
}
public SessionFactory getSessionFactory() {
String sessionFactoryName = CustomerContextHolder.getCustomerType();
return getSessionFactory(sessionFactoryName);
}
public void setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#close()
*/
public void close() throws HibernateException {
getSessionFactory().close();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evict(java.lang.Class)
*/
public void evict(Class persistentClass) throws HibernateException {
getSessionFactory().evict(persistentClass);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evict(java.lang.Class, java.io.Serializable)
*/
public void evict(Class persistentClass, Serializable id) throws HibernateException {
getSessionFactory().evict(persistentClass, id);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evictCollection(java.lang.String)
*/
public void evictCollection(String roleName) throws HibernateException {
getSessionFactory().evictCollection(roleName);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evictCollection(java.lang.String, java.io.Serializable)
*/
public void evictCollection(String roleName, Serializable id) throws HibernateException {
getSessionFactory().evictCollection(roleName, id);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evictEntity(java.lang.String)
*/
public void evictEntity(String entityName) throws HibernateException {
getSessionFactory().evictEntity(entityName);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evictEntity(java.lang.String, java.io.Serializable)
*/
public void evictEntity(String entityName, Serializable id) throws HibernateException {
getSessionFactory().evictEntity(entityName, id);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evictQueries()
*/
public void evictQueries() throws HibernateException {
getSessionFactory().evictQueries();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#evictQueries(java.lang.String)
*/
public void evictQueries(String cacheRegion) throws HibernateException {
getSessionFactory().evictQueries(cacheRegion);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getAllClassMetadata()
*/
public Map getAllClassMetadata() throws HibernateException {
return getSessionFactory().getAllClassMetadata();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getAllCollectionMetadata()
*/
public Map getAllCollectionMetadata() throws HibernateException {
return getSessionFactory().getAllCollectionMetadata();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getClassMetadata(java.lang.Class)
*/
public ClassMetadata getClassMetadata(Class persistentClass) throws HibernateException {
return getSessionFactory().getClassMetadata(persistentClass);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getClassMetadata(java.lang.String)
*/
public ClassMetadata getClassMetadata(String entityName) throws HibernateException {
return getSessionFactory().getClassMetadata(entityName);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getCollectionMetadata(java.lang.String)
*/
public CollectionMetadata getCollectionMetadata(String roleName) throws HibernateException {
return getSessionFactory().getCollectionMetadata(roleName);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getCurrentSession()
*/
public org.hibernate.classic.Session getCurrentSession() throws HibernateException {
return getSessionFactory().getCurrentSession();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getDefinedFilterNames()
*/
public Set getDefinedFilterNames() {
return getSessionFactory().getDefinedFilterNames();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getFilterDefinition(java.lang.String)
*/
public FilterDefinition getFilterDefinition(String filterName) throws HibernateException {
return getSessionFactory().getFilterDefinition(filterName);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#getStatistics()
*/
public Statistics getStatistics() {
return getSessionFactory().getStatistics();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#isClosed()
*/
public boolean isClosed() {
return getSessionFactory().isClosed();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#openSession()
*/
public org.hibernate.classic.Session openSession() throws HibernateException {
return getSessionFactory().openSession();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#openSession(java.sql.Connection)
*/
public org.hibernate.classic.Session openSession(Connection connection) {
return getSessionFactory().openSession(connection);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#openSession(org.hibernate.Interceptor)
*/
public org.hibernate.classic.Session openSession(Interceptor interceptor) throws HibernateException {
return getSessionFactory().openSession(interceptor);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#openSession(java.sql.Connection, org.hibernate.Interceptor)
*/
public org.hibernate.classic.Session openSession(Connection connection, Interceptor interceptor) {
return getSessionFactory().openSession(connection, interceptor);
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#openStatelessSession()
*/
public StatelessSession openStatelessSession() {
return getSessionFactory().openStatelessSession();
}
/* (non-Javadoc)
* @see org.hibernate.SessionFactory#openStatelessSession(java.sql.Connection)
*/
public StatelessSession openStatelessSession(Connection connection) {
return getSessionFactory().openStatelessSession(connection);
}
/* (non-Javadoc)
* @see javax.naming.Referenceable#getReference()
*/
public javax.naming.Reference getReference() throws NamingException {
return getSessionFactory().getReference();
}
}
只创建一个application（struts等就不需要了）
package com.mul.spring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class DataSourceTypeKey {
public static ApplicationContext appContext ;
}
在servlet调用service时他去调用MultiSessionFactory openSession()
注意：发布项目是去掉asm-2.2.3.jar包
- muldatasearch.rar (651.8 KB)
- 下载次数: 68
1
顶
顶
0
踩
踩
分享到：
评论
2 楼
yyf365
2011-11-28
请问，你的这种实现方式，能否解决多个数据源同时使用OpenSessionInView功能呢？
由于不同的数据源使用不同的sessionfactory是否可以实现切换第二个乃至第三个数据源的时候也能load出子表信息？
还有就是能否使用不同类型的数据库？如mysql、oracle？
由于不同的数据源使用不同的sessionfactory是否可以实现切换第二个乃至第三个数据源的时候也能load出子表信息？
还有就是能否使用不同类型的数据库？如mysql、oracle？
1 楼
zmty123
2011-04-11
我问一下，你的dao是extends HibernateDaoSupport。这样sessionFactory可以得到。
如果我要自己写dao怎么注入sessionFactory
如果我要自己写dao怎么注入sessionFactory
发表评论
-
struts2+spring+hibernate完整的配置（cxf）
2011-06-03 17:33 0备忘录吧。 web.xml <?xml ver ... -
ssh的配置
2011-02-25 14:04 1210一。普通模式 applicationContext.xml ... -
多数据源
2011-01-22 17:56 1481多数据源配置，当时不能达到动态数据源。自己想要的是动态的，搞错 ... -
referenced file contains errors spring-beans-2.0.xsd
2010-09-16 16:58 5523spring配置文件错误referenced file con ... -
hibernate+struts1.x+spring
2010-03-19 21:45 1308第一种ssh配置： web.xml <?xml ve ... -
spring的配置文件等advice+advisor+beannameproxy...总结
2009-08-13 18:36 2567<?xml version="1.0" ... -
Spring事务配置的五种方式
2009-08-13 12:49 9613Spring事务配置的五种方式 前段时间对Spri ...
相关推荐
在Spring Boot 2框架中，实现多数据源的配置是一项重要的任务，特别是在大型企业级应用中，可能需要连接到不同的数据库来满足不同业务的需求。在这个项目中，我们有两个主要的数据访问技术：Hibernate和MyBatis，...
这样，MyBatis就能根据数据源选择正确的SessionFactory执行SQL语句。 在实际项目中，"demoWeb2MutiDataSouce"可能包含以下主要部分： 1. **配置文件**：如`applicationContext.xml`，其中会定义多个数据源，以及...
本示例主要介绍如何实现Spring Boot 2.0多数据源的集成，并结合Hibernate进行配置，特别是在DAO层使用`HibernateDaoSupport`进行操作，而非使用JPA（Java Persistence API）。 首先，让我们了解Spring Boot 2.0的...
在多数据源环境中，每个数据源需要一个单独的SessionFactory。我们可以为每个数据源创建一个SessionFactory配置，并指定相应的DataSource，实体扫描路径，以及其他的Hibernate配置参数。 在"压缩包子文件的文件名称...
为了操作多个数据库，需要在Spring配置文件中配置多个数据源，并为每个数据源配置相应的SessionFactory。这时会遇到如何区分和管理不同数据源下的SessionFactory的问题。 知识点四：使用GoF装饰器模式 为了更好的...
--sessionFactory--> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <prop key="dialect">org.hibernate.dialect.MySQLDialect ...
在Java开发中，多数据源是指应用程序能够连接和操作多个不同的数据库，这在大型系统或者分布式环境中非常常见。为了实现这种功能，开发者通常会利用框架如SpringMVC，结合ORM框架如MyBatis或Hibernate来处理数据访问...
在多数据源环境下，可以通过SessionFactory和Session接口配置多个数据源，每个数据源对应一个SessionFactory，以处理不同数据库的连接。 Maven是项目管理工具，它帮助开发者管理项目的构建、依赖和生命周期。在多库...
### 如何在Spring框架中解决多数据源的问题 #### 问题背景及挑战 在实际的软件开发过程中，尤其是在企业级应用开发中，经常会遇到需要同时处理多个数据源的情况。例如，一个应用程序可能需要同时访问Oracle数据库...
在Java开发中，多数据源配置是一项常见的需求，特别是在大型企业级应用中，可能需要连接到不同的数据库以实现数据隔离、读写分离或是分布式事务管理。本示例"多数据源配置demo"聚焦于如何利用Spring框架和Hibernate ...
在这种情况下，配置SSH以支持多个数据源就显得尤为重要。 首先，我们需要理解SSH框架中的每个组件的角色。Struts2是MVC（Model-View-Controller）架构的一部分，负责处理用户请求和展现视图；Spring作为容器，管理...
SSH动态切换数据源是一种在Java Web开发中处理多数据库连接切换的技术，主要应用于Spring、Struts和Hibernate（SSH）这三大框架集成的项目。SSH框架是企业级应用开发的常用组合，提供了强大的业务逻辑处理和数据持久...
Spring多数据源解决方案是针对大型应用中数据分片和分布式数据库管理的需求而设计的一种策略。在这样的场景下，为了提高系统的可扩展性和性能，数据通常会被分散到多个数据库实例上。这种架构如图1所示，每个数据库...
此外，对于SSH框架中的Hibernate，可以通过在SessionFactory配置中使用`org.springframework.jdbc.datasource.DataSourceTransactionManager`作为事务管理器，从而实现与Spring动态数据源的集成。 总结起来，SSH多...
本文将详细探讨如何在Spring环境中配置多个数据源，包括DataSource、SessionFactory、TransactionManager以及JTATransactionManager的设置。 #### 第一步：配置多个DataSource 在Spring中，配置多个数据源主要是...
本篇文章将详细讲解"多数据源MultiSessionFactory"这一主题，以及如何在Spring中通过动态配置数据源来实现数据源的灵活切换，并利用`MultiSessionFactory`重写sessionFactory。 首先，理解多数据源的概念。在很多...
在多数据源环境中，Hibernate可以通过SessionFactory配置多个数据源，每个数据源对应一个SessionFactory。 3. **Atomikos**： Atomikos是一个开源的JTA（Java Transaction API）实现，提供分布式事务管理服务。在...
Spring结合JOTM和Hibernate进行多数据源事务管理，主要涉及以下几个步骤：配置JOTM依赖，定义XADataSource，创建并配置AtomikosTransactionManager，设定事务策略，以及正确地集成Hibernate SessionFactory。...
首先，这个方案完全是在spring的框架下解决的，数据源依然配置在spring的配置文件中，sessionFactory依然去配置它的dataSource属性，它甚至都不知道dataSource的改变。 其次，实现简单，易于维护。这个方案虽然我说...