了解下JAVA的浅谈怎样分离JDBC事件与Spring+Hibernate - 仓酷云

public　class　TransactionTemplate　{　　
　　　　protected　final　Log　logger　=　LogFactory.getLog(TransactionTemplate.class);　　
　　　　private　FlushMode　flushMode　=　FlushMode.ALWAYS;　　
　　　　public　Object　execute(TransactionCallback　callback)　{　　
　　　　　　　　//起首猎取sessionFactory　　
　　　　　　　　SessionFactory　sessionFactory　=　(SessionFactory)　Framework.getEngine()　
　
　　　　　　　　　　　　　　　　.getContainer().getComponent("sessionFactory");　　
　　　　　　　　//创立一个新的session并翻开　　
　　　　　　　　logger.debug("Opening　single　Hibernate　Session　in　
TransactionTemplate");　　
　　　　　　　　Session　session　=　getSession(sessionFactory);　　
　　　　　　　　//将session与以后线程绑定　　
　　　　　　　　TransactionSynchronizationManager.bindResource(sessionFactory,　new　
SessionHolder(session));　　
　　　　　　　　//猎取数据库毗连　　
　　　　　　　　Connection　conn　=　session.connection();　　
　　　　　　　　Object　result　=　null;　　
　　　　　　　　Transaction　transaction　=　null;　　
　　　　　　　　try　{　　
　　　　　　　　　　　　//入手下手处置JDBC事件　　
　　　　　　　　　　　　transaction　=　session.beginTransaction();　　
　　　　　　　　　　　　try　{　　
　　　　　　　　　　　　　　　　result　=　callback.doInTransaction(conn);　　
　　　　　　　　　　　　}　　
　　　　　　　　　　　　catch　(RuntimeException　ex)　{　　
　　　　　　　　　　　　　　　　doRollback(session,　transaction);　　
　　　　　　　　　　　　　　　　throw　ex;　　
　　　　　　　　　　　　}　　
　　　　　　　　　　　　catch　(Error　err)　{　　
　　　　　　　　　　　　　　　　doRollback(session,　transaction);　　
　　　　　　　　　　　　　　　　throw　err;　　
　　　　　　　　　　　　}　　
　　　　　　　　　　　　//假如数据库操纵过程当中没有产生非常则提交事件　　
　　　　　　　　　　　　transaction.commit();　　
　　　　　　　　}　catch　(WorkflowException　e)　{　　
　　　　　　　　　　　　logger.error("数据库操纵失利，事件回滚也失利！");　　
　　　　　　　　　　　　throw　e;　　
　　　　　　　　}　catch　(RuntimeException　ex)　{　　
　　　　　　　　　　　　logger.error("数据库操纵失利，事件被回滚！");　　
　　　　　　　　　　　　throw　ex;　　
　　　　　　　　}　catch　(Error　err)　{　　
　　　　　　　　　　　　logger.error("数据库操纵失利，事件被回滚！");　　
　　　　　　　　　　　　throw　err;　　
　　　　　　　　}　finally　{　　
　　　　　　　　　　　　//　将session与以后线程排除绑定　　
　　　　　　　　　　　　TransactionSynchronizationManager.unbindResource(sessionFactory);　
　
　　　　　　　　　　　　doClose(session);　　
　　　　　　　　}　　
　　　　　　　　return　result;　　
　　　　}　　
　
　　　　protected　Session　getSession(SessionFactory　sessionFactory)　{　　
　　　　　　　　Session　session　=　SessionFactoryUtils.getSession(sessionFactory,　true);
　　
　　　　　　　　FlushMode　flushMode　=　getFlushMode();　　
　　　　　　　　if　(flushMode　!=　null)　{　　
　　　　　　　　　　　　session.setFlushMode(flushMode);　　
　　　　　　　　}　　
　　　　　　　　return　session;　　
　　　　}　　
　
　　　　private　void　doRollback(Session　session,　Transaction　transaction)　{　　
　　　　　　　　logger.debug("数据库操纵非常，入手下手回滚事件");　　
　　　　　　　　try　{　　
　　　　　　　　　　　　transaction.rollback();　　
　　　　　　　　　　　　logger.debug("回滚事件乐成！");　　
　　　　　　　　}　　
　　　　　　　　catch　(Exception　e)　{　　
　　　　　　　　　　　　logger.error("回滚事件失利！");　　
　　　　　　　　　　　　throw　new　WorkflowException("回滚事件失利！");　　
　　　　　　　　}　finally　{　　
　　　　　　　　　　　　session.clear();　　
　　　　　　　　}　　
　　　　}　　
　
　　　　private　void　doClose(Session　session)　{　　
　　　　　　　　logger.debug("入手下手封闭毗连");　　
　　　　　　　　try　{　　
　　　　　　　　　　　　session.close();　　
　　　　　　　　}　　
　　　　　　　　catch　(Exception　e)　{　　
　　　　　　　　　　　　logger.error("封闭毗连失利！");　　
　　　　　　　　　　　　throw　new　WorkflowException("封闭毗连失利！");　　
　　　　　　　　}　　
　　　　}　　
　　　　public　FlushMode　getFlushMode()　{　　
　　　　　　　　return　flushMode;　　
　　　　}　　
　
　　　　public　void　setFlushMode(FlushMode　flushMode)　{　　
　　　　　　　　this.flushMode　=　flushMode;　　
　　　　}　　
}　　
public　interface　TransactionCallback　{　　
　
　　　　Object　doInTransaction(Connection　conn);　　
}

复制代码