spring下hibernate多数据库解决方案,以及跨库事务的尝试(已合并)

这个我自己系统配置的一部分，系统会解析他，从而知晓究竟存在多少个sessionFactory,item's XmlNode中的id可以理解会托管客户的客户单位<o:p></o:p>

编号,当然，这个配置完全可以忽略，直接从ApplicationContext中一样可以获取到这样的信息<o:p></o:p>

在客户登陆的时候，系统要记录下该客户所属托管单位，然后通过上面的id找到bean's name ，最后获取这个sessionFactory,托管单位信息一般<o:p></o:p>

都是个编号而已跟己方系统的托管用户管理相结合，一般是保存这个编号在session里面,也可以象asp.net一样，记录在安全凭证里,还不知道JAVA方面有没有类似实现，个人认为asp.net这个方法很值得采用,虽然MS号称安全系数+++++这个观点值得怀疑<o:p></o:p>

<o:p> </o:p>

首先建立一个类,HibernateSupport ，存放当前请求线程所需sessionFactory

去掉HibernateAccessor 和HibernateTransactionManager中的上述两段代码,当然，也别忘了毙掉两个类中的<o:p></o:p>

afterPropertiesSet方法中那些检查代码<o:p></o:p>

然后 ,ant打包就可以了，如果不想修改spring的代码，也可以单独把这几个类提出来另建jar包,我是单独提出来新建的，比如HibernateTransactionManager我改名成CHibernateTransactionManager,其他类似，但是包名必须是org.springframework.orm.hibernate3 ,谁也不想这么做，可是谁让sessionFactoryUtils中一个closexxxx方法没定义成public了？？<o:p></o:p>

如果想变更sessionFactoryUtils，奉劝算了吧..<o:p></o:p>

然后可以做测试了，首先，部署测试的dao和service,先是事务部署<o:p></o:p>

<bean id="transactionManager" ref="transactionManager"/> <property name="transactionAttributeSource"><ref local="transres"/></property> </bean> <bean ref="transactionInterceptor"/> </bean>
我把事务配置在service层，事务管理采用的是我修改后的HibernateTransactionManager ，他不在要求sessionFactory的注入了
以下是测试的dao类和service类配置

<bean id="personDao" name="code">public class PersonDaoImpl extends CHibernateDaoSupport implements PersonDao; public class PersonServiceImpl implements PersonService; public class DepartDaoImpl extends CHibernateDaoSupport implements DepartDao; public class DepartServiceImpl implements DepartService; 

测试代码的目的是将两个实体类分别存放到mit和test库，假设默认用户是mit这个托管库的，这个方法就写在DepartServiceImpl类里面

public class DepartServiceImpl implements DepartService { private DepartDao dao; private PersonService service;  ..............................  public void executeTest(Depart depart,Person person)  { dao.save(depart); HibernateSupport.switchFactory("test"); service.save(person); HibernateSupport.restoreFactory(); }  .............................. 

上面代码中将depart对象存到mit库，而将person对象存到test库中.

事务 事务 ，没看见特别事务设置？ 其实事务已经在运行了

如前面配置，事务我配置在了service层，那么当executeTest执行时，会启动针对mit库的事务（前面我们改了HibernateTransactionManager的sessionFactory获取方式）,

dao.save(depart);//然后保存depart到mit库

HibernateSupport.switchFactory("test");//切换库到test

service.save(person);//调用personService的save方法,这也是个service，所以也会产生一个事务，而此时HibernateSupport.getCurrentFactory返回的sessionFactory已经是test库的了，所以,spring事务管理发现上下文中并没有针对test的事务，于是，会重新启动一个新的事务,这个service.save(person);方法执行完后，这个事务将会提交

HibernateSupport.restoreFactory();//切换回默认数据库

整个方法执行完后，针对mit的事务将会被提交

[color=green]如果service.save(person);发生异常，这两个事务就会被提交，一个简单跨库事务控制完成[color=green]

但是，问题也随之而来，如果在 HibernateSupport.restoreFactory();后，又进行了一些逻辑操作，那么发生异常时，而由于 service.save(person);这个事务已经被提交，也就是说，针对test的事务已经提交不会回滚了，这是个非常严重的问题。。

其实，也有解决方法，就是延迟提交，具体实现方式以后讲述private ThreadLocal lazytrace = new ThreadLocal();
LazyTransactionStatus用来管理需要延迟提交的事务

private static class LazyTransactionStatus{private java.util.List transliat;private int transnum;//代表未提交事务数量public LazyTransactionStatus(){transliat= new java.util.ArrayList();transnum=0;}public void newLazy(){transnum++;}public void push(TransactionStatus trasobj){objmap.add(trasobj);}public void removeLazy(TransactionStatus trasobj){transnum--;}public boolean canCommit(){if (transnum<1){return true;}elsereturn false;}public java.util.List getTransactionObjs(){return transliat;}}}

这就是local对象的存储内容.translist存放当前执行中的TransactionStatus实例
TransactionStatus顾名思义，事务状态，包含了事务、挂起资源等一系列信息
然后以事务提交为例
然后在AbstractTransactionManager增加如下两个方法

public final boolean isCommit(TransactionStatus status){if (lazytrace.get()!=null){LazyTransactionStatus lazystatus = (LazyTransactionStatus)lazytrace.get();lazystatus.removeLazy(status);return lazy.canCommit();}return true;}protected void begin(Object transaction, TransactionDefinition definition){doBegin(transaction,definition);LazyTransactionStatus lazystatus = null;if (lazytrace.get()==null){lazystatus = new LazyTransactionStatus();lazytrace.set(lazystatus);}else{lazystatus = (LazyTransactionStatus)lazytrace.get();}lazystatus.newLazy();}public final void registerTraceStatus(TransactionStatus status){LazyTransactionStatus lazystatus = null;if (lazytrace.get()==null){lazystatus = new LazyTransactionStatus();lazytrace.set(lazystatus);}else{lazystatus = (LazyTransactionStatus)lazytrace.get();}lazystatus.push(status);}

begin ，当一个事务开始时,将LazyTransactionStatus的transnum+1,表示又多了个刚开始，还未提交的事务
registerTraceStatus发生在commit的时候,注册这个事务到LazyTransactionStatus,同时，
注意 transnum表示的是未提交事务数量，所以当事务管理器执行commit表示要提交一个事务后，transnum将减一，如果减一后发现transnum<1，表示所有事务都提交了，那么，将所有事务提交。否则，不提交，继续等待...
关系如下:
begin->transnum+1 表示新事务诞生
registerTraceStatus(发生在commit的时候)->将准备提交的TransStatus放到LazyTransactionStatus,是的，这个事务要提交了，来吧，先注册一下
紧接着
isCommit()->将transnum-1,如果发现transnum小于1 ，表示闹够了，可以都提交滚蛋了
注意 ,transnum与LazyTransactionStatus的translist的链表长度在执行commit的时候是反方向发展的 一个增，一个减
好了，首先是注册事务数量，不用管了，在事务开始时begin方法它自己会调用了，
然后是修改AbstractPlatformTransactionManager的commit方法

public final void commit(TransactionStatus txstatus) throws TransactionException {this.registerTraceStatus(txstatus);if (this.isCommit(txstatus)){int error = 0;LazyTransactionStatus lazystatus = (LazyTransactionStatus)lazytrace.get();List statuslist = lazystatus.getTransactionObjs();for (int i=0;i<statuslist.size();i++){try{TransactionStatus status = (TransactionStatus)statuslist.get(i);if (status.isCompleted()) {error++;continue;//throw new IllegalTransactionStateException(//"Transaction is already completed - do not call commit or rollback more than once per transaction");}DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;if (defStatus.isLocalRollbackOnly()) {if (defStatus.isDebug()) {logger.debug("Transactional code has requested rollback");}processRollback(defStatus);error++;continue;}if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {if (defStatus.isDebug()) {logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");}processRollback(defStatus);// Throw UnexpectedRollbackException only at outermost transaction boundary// or if explicitly asked to.if (status.isNewTransaction() || isFailEarlyOnGlobalRollbackOnly()) {//throw new UnexpectedRollbackException(//"Transaction rolled back because it has been marked as rollback-only");error++;continue;}continue;}processCommit(defStatus);}catch (Exception ex){error++;ex.printStackTrace();continue;}}lazytrace.set(null);if (error>0)throw new IllegalTransactionStateException("Not commit all transaction");}}

this.registerTraceStatus(txstatus);//事务提交了，成了嫌疑犯，拖到threadlocal的LazyTransactionStatus监狱里面先关起来
if (isCommit()) //看看监狱的事务是不是满了，如果满了，就可以全放了
LazyTransactionStatus lazystatus = (LazyTransactionStatus)lazytrace.get();
List statuslist = lazystatus.getTransactionObjs();
for (int i=0;i<statuslist.size();i++)
{
........
processCommit(defStatus);
//看来真的满了，都放了吧
回滚道理是一样的，不过不用判断了，直接全部放出来让他们滚吧
当然，目前这个实现只是个模型，真要实际应用，还需要做进一步封装,实际做，我用了OpenSessionInViewFilter，我已经做过测试，测试了了OpenSessionInViewFilter中singleSession为true和false两种情况，测试都通过了，呵呵 7 楼 zlst 2007-09-20 CHibernateTransactionManager代码是怎么样的呢？帖出来好吗？用了你上面的代码，到一半了，我也想试用多数据源 8 楼 kyo100900 2007-10-06 tomcat 不能用JTA吧， 用了JTOM吗？