package com.spreadthesource.tapestry.spring.hibernate; import org.apache.tapestry5.hibernate.HibernateSessionManager; import org.apache.tapestry5.hibernate.HibernateSessionSource; import org.apache.tapestry5.ioc.services.ThreadCleanupListener; import org.hibernate.FlushMode; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.springframework.context.ApplicationContext; import org.springframework.orm.hibernate3.HibernateAccessor; import org.springframework.orm.hibernate3.SessionFactoryUtils; import org.springframework.orm.hibernate3.SessionHolder; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.TransactionDefinition; import org.springframework.transaction.TransactionStatus; import org.springframework.transaction.support.DefaultTransactionDefinition; import org.springframework.transaction.support.TransactionSynchronizationManager; /** * Call Spring Transaction API to initialize transaction and close it when needed. This class add * the elements needed in the current to work with mixed spring datasource configuration. * * @author ccordenier */ public class SpringHibernateSessionManagerImpl extends HibernateAccessor implements HibernateSessionManager, ThreadCleanupListener { private final Session session; private final PlatformTransactionManager txManager; private final HibernateSessionSource source; private TransactionStatus status; private FlushMode previousFlushMode; private boolean existingTransaction; private SessionHolder sessionHolder; public SpringHibernateSessionManagerImpl(HibernateSessionSource source, ApplicationContext ctx, String txBeanName) { this.session = source.create(); this.source = source; this.session.setFlushMode(FlushMode.COMMIT); this.txManager = (PlatformTransactionManager) ctx.getBean(txBeanName); startNewTransaction(); } private void startNewTransaction() { sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(getSessionFactory()); existingTransaction = (sessionHolder != null && sessionHolder.containsSession(session)); if (existingTransaction) { logger.debug("Found thread-bound Session for HibernateInterceptor"); } else { if (sessionHolder != null) { sessionHolder.addSession(session); } else { TransactionSynchronizationManager.bindResource(getSessionFactory(), new SessionHolder(session)); } } this.previousFlushMode = applyFlushMode(session, existingTransaction); enableFilters(session); DefaultTransactionDefinition definition = new DefaultTransactionDefinition(); definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); this.status = txManager.getTransaction(definition); } public void abort() { this.txManager.rollback(this.status); startNewTransaction(); } public void commit() { this.flushIfNecessary(session, existingTransaction); this.txManager.commit(this.status); startNewTransaction(); } public Session getSession() { return session; } /** * Rollsback the transaction at the end of the request, then closes the session. This means that * any uncommitted changes are lost; code should inject the HSM and invoke {@link #commit()} * after making any changes, if they should persist. */ public void threadDidCleanup() { this.txManager.rollback(this.status); if (existingTransaction) { logger.debug("Not closing pre-bound Hibernate Session after HibernateInterceptor"); disableFilters(session); if (previousFlushMode != null) { session.setFlushMode(previousFlushMode); } } else { SessionFactoryUtils.closeSession(session); if (sessionHolder == null || sessionHolder.doesNotHoldNonDefaultSession()) { TransactionSynchronizationManager.unbindResource(getSessionFactory()); } } } @Override public SessionFactory getSessionFactory() { return this.source.getSessionFactory(); } }