Java tutorial
/* * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springframework.orm.hibernate3; import javax.transaction.SystemException; import javax.transaction.Transaction; import javax.transaction.TransactionManager; import org.hibernate.FlushMode; import org.hibernate.HibernateException; import org.hibernate.JDBCException; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.engine.SessionImplementor; import org.springframework.core.Ordered; import org.springframework.dao.DataAccessException; import org.springframework.dao.DataAccessResourceFailureException; import org.springframework.jdbc.support.SQLExceptionTranslator; import org.springframework.transaction.support.TransactionSynchronization; import org.springframework.transaction.support.TransactionSynchronizationManager; /** * Callback for resource cleanup at the end of a Spring-managed JTA transaction, * that is, when participating in a JtaTransactionManager transaction. * * @author Juergen Hoeller * @since 1.2 * @see SessionFactoryUtils * @see org.springframework.transaction.jta.JtaTransactionManager */ class SpringSessionSynchronization implements TransactionSynchronization, Ordered { private final SessionHolder sessionHolder; private final SessionFactory sessionFactory; private final SQLExceptionTranslator jdbcExceptionTranslator; private final boolean newSession; /** * Whether Hibernate has a looked-up JTA TransactionManager that it will * automatically register CacheSynchronizations with on Session connect. */ private boolean hibernateTransactionCompletion = false; private Transaction jtaTransaction; private boolean holderActive = true; public SpringSessionSynchronization(SessionHolder sessionHolder, SessionFactory sessionFactory, SQLExceptionTranslator jdbcExceptionTranslator, boolean newSession) { this.sessionHolder = sessionHolder; this.sessionFactory = sessionFactory; this.jdbcExceptionTranslator = jdbcExceptionTranslator; this.newSession = newSession; // Check whether the SessionFactory has a JTA TransactionManager. TransactionManager jtaTm = SessionFactoryUtils.getJtaTransactionManager(sessionFactory, sessionHolder.getAnySession()); if (jtaTm != null) { this.hibernateTransactionCompletion = true; // Fetch current JTA Transaction object // (just necessary for JTA transaction suspension, with an individual // Hibernate Session per currently active/suspended transaction). try { this.jtaTransaction = jtaTm.getTransaction(); } catch (SystemException ex) { throw new DataAccessResourceFailureException("Could not access JTA transaction", ex); } } } /** * Check whether there is a Hibernate Session for the current JTA * transaction. Else, fall back to the default thread-bound Session. */ private Session getCurrentSession() { Session session = null; if (this.jtaTransaction != null) { session = this.sessionHolder.getSession(this.jtaTransaction); } if (session == null) { session = this.sessionHolder.getSession(); } return session; } @Override public int getOrder() { return SessionFactoryUtils.SESSION_SYNCHRONIZATION_ORDER; } @Override public void suspend() { if (this.holderActive) { TransactionSynchronizationManager.unbindResource(this.sessionFactory); // Eagerly disconnect the Session here, to make release mode "on_close" work on JBoss. getCurrentSession().disconnect(); } } @Override public void resume() { if (this.holderActive) { TransactionSynchronizationManager.bindResource(this.sessionFactory, this.sessionHolder); } } @Override public void flush() { try { SessionFactoryUtils.logger.debug("Flushing Hibernate Session on explicit request"); getCurrentSession().flush(); } catch (HibernateException ex) { throw translateException(ex); } } @Override public void beforeCommit(boolean readOnly) throws DataAccessException { if (!readOnly) { Session session = getCurrentSession(); // Read-write transaction -> flush the Hibernate Session. // Further check: only flush when not FlushMode.NEVER/MANUAL. if (!session.getFlushMode().lessThan(FlushMode.COMMIT)) { try { SessionFactoryUtils.logger.debug("Flushing Hibernate Session on transaction synchronization"); session.flush(); } catch (HibernateException ex) { throw translateException(ex); } } } } private DataAccessException translateException(HibernateException ex) { if (this.jdbcExceptionTranslator != null && ex instanceof JDBCException) { JDBCException jdbcEx = (JDBCException) ex; return this.jdbcExceptionTranslator.translate("Hibernate flushing: " + jdbcEx.getMessage(), jdbcEx.getSQL(), jdbcEx.getSQLException()); } return SessionFactoryUtils.convertHibernateAccessException(ex); } @Override public void beforeCompletion() { if (this.jtaTransaction != null) { // Typically in case of a suspended JTA transaction: // Remove the Session for the current JTA transaction, but keep the holder. Session session = this.sessionHolder.removeSession(this.jtaTransaction); if (session != null) { if (this.sessionHolder.isEmpty()) { // No Sessions for JTA transactions bound anymore -> could remove it. TransactionSynchronizationManager.unbindResourceIfPossible(this.sessionFactory); this.holderActive = false; } // Do not close a pre-bound Session. In that case, we'll find the // transaction-specific Session the same as the default Session. if (session != this.sessionHolder.getSession()) { SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session, this.sessionFactory); } else { if (this.sessionHolder.getPreviousFlushMode() != null) { // In case of pre-bound Session, restore previous flush mode. session.setFlushMode(this.sessionHolder.getPreviousFlushMode()); } // Eagerly disconnect the Session here, to make release mode "on_close" work nicely. session.disconnect(); } return; } } // We'll only get here if there was no specific JTA transaction to handle. if (this.newSession) { // Default behavior: unbind and close the thread-bound Hibernate Session. TransactionSynchronizationManager.unbindResource(this.sessionFactory); this.holderActive = false; if (this.hibernateTransactionCompletion) { // Close the Hibernate Session here in case of a Hibernate TransactionManagerLookup: // Hibernate will automatically defer the actual closing until JTA transaction completion. // Else, the Session will be closed in the afterCompletion method, to provide the // correct transaction status for releasing the Session's cache locks. SessionFactoryUtils.closeSessionOrRegisterDeferredClose(this.sessionHolder.getSession(), this.sessionFactory); } } else { Session session = this.sessionHolder.getSession(); if (this.sessionHolder.getPreviousFlushMode() != null) { // In case of pre-bound Session, restore previous flush mode. session.setFlushMode(this.sessionHolder.getPreviousFlushMode()); } if (this.hibernateTransactionCompletion) { // Eagerly disconnect the Session here, to make release mode "on_close" work nicely. // We know that this is appropriate if a TransactionManagerLookup has been specified. session.disconnect(); } } } @Override public void afterCommit() { } @Override public void afterCompletion(int status) { try { if (!this.hibernateTransactionCompletion || !this.newSession) { // No Hibernate TransactionManagerLookup: apply afterTransactionCompletion callback. // Always perform explicit afterTransactionCompletion callback for pre-bound Session, // even with Hibernate TransactionManagerLookup (which only applies to new Sessions). Session session = this.sessionHolder.getSession(); // Provide correct transaction status for releasing the Session's cache locks, // if possible. Else, closing will release all cache locks assuming a rollback. try { if (session instanceof SessionImplementor) { ((SessionImplementor) session).afterTransactionCompletion(status == STATUS_COMMITTED, null); } } finally { // Close the Hibernate Session here if necessary // (closed in beforeCompletion in case of TransactionManagerLookup). if (this.newSession) { SessionFactoryUtils.closeSessionOrRegisterDeferredClose(session, this.sessionFactory); } else if (!this.hibernateTransactionCompletion) { session.disconnect(); } } } if (!this.newSession && status != STATUS_COMMITTED) { // Clear all pending inserts/updates/deletes in the Session. // Necessary for pre-bound Sessions, to avoid inconsistent state. this.sessionHolder.getSession().clear(); } } finally { if (this.sessionHolder.doesNotHoldNonDefaultSession()) { this.sessionHolder.setSynchronizedWithTransaction(false); } } } }