persistencebrokertransactionmanager.java

spring的源代码

				ConnectionHolder conHolder = new ConnectionHolder(con);
				if (definition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {
					conHolder.setTimeoutInSeconds(definition.getTimeout());
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Exposing OJB transaction as JDBC transaction [" + conHolder.getConnection() + "]");
				}
				TransactionSynchronizationManager.bindResource(getDataSource(), conHolder);
				txObject.setConnectionHolder(conHolder);
			}

			// Bind the persistence broker holder to the thread.
			TransactionSynchronizationManager.bindResource(getPbKey(), txObject.getPersistenceBrokerHolder());
		}

		catch (Exception ex) {
			releasePersistenceBroker(pb);
			throw new CannotCreateTransactionException("Could not open OJB PersistenceBroker for transaction", ex);
		}
	}

	protected Object doSuspend(Object transaction) {
		PersistenceBrokerTransactionObject txObject = (PersistenceBrokerTransactionObject) transaction;
		txObject.setPersistenceBrokerHolder(null);
		PersistenceBrokerHolder pbHolder =
				(PersistenceBrokerHolder) TransactionSynchronizationManager.unbindResource(getPbKey());
		ConnectionHolder connectionHolder = null;
		if (getDataSource() != null) {
			connectionHolder = (ConnectionHolder) TransactionSynchronizationManager.unbindResource(getDataSource());
		}
		return new SuspendedResourcesHolder(pbHolder, connectionHolder);
	}

	protected void doResume(Object transaction, Object suspendedResources) {
		SuspendedResourcesHolder resourcesHolder = (SuspendedResourcesHolder) suspendedResources;
		if (TransactionSynchronizationManager.hasResource(getPbKey())) {
			// From non-transactional code running in active transaction synchronization
			// -> can be safely removed, will be closed on transaction completion.
			TransactionSynchronizationManager.unbindResource(getPbKey());
		}
		TransactionSynchronizationManager.bindResource(getPbKey(), resourcesHolder.getPersistenceBrokerHolder());
		if (getDataSource() != null) {
			TransactionSynchronizationManager.bindResource(getDataSource(), resourcesHolder.getConnectionHolder());
		}
	}

	protected void doCommit(DefaultTransactionStatus status) {
		PersistenceBrokerTransactionObject txObject = (PersistenceBrokerTransactionObject) status.getTransaction();
		if (status.isDebug()) {
			logger.debug("Committing OJB transaction on PersistenceBroker [" +
					txObject.getPersistenceBrokerHolder().getPersistenceBroker() + "]");
		}
		try {
			txObject.getPersistenceBrokerHolder().getPersistenceBroker().commitTransaction();
		}
		catch (TransactionAbortedException ex) {
			// assumably from commit call to underlying JDBC connection
			throw new TransactionSystemException("Could not commit OJB transaction", ex);
		}
	}

	protected void doRollback(DefaultTransactionStatus status) {
		PersistenceBrokerTransactionObject txObject = (PersistenceBrokerTransactionObject) status.getTransaction();
		if (status.isDebug()) {
			logger.debug("Rolling back OJB transaction on PersistenceBroker [" +
					txObject.getPersistenceBrokerHolder().getPersistenceBroker() + "]");
		}
		txObject.getPersistenceBrokerHolder().getPersistenceBroker().abortTransaction();
	}

	protected void doSetRollbackOnly(DefaultTransactionStatus status) {
		PersistenceBrokerTransactionObject txObject = (PersistenceBrokerTransactionObject) status.getTransaction();
		if (status.isDebug()) {
			logger.debug("Setting OJB transaction on PersistenceBroker [" +
					txObject.getPersistenceBrokerHolder().getPersistenceBroker() + "] rollback-only");
		}
		txObject.setRollbackOnly();
	}

	protected void doCleanupAfterCompletion(Object transaction) {
		PersistenceBrokerTransactionObject txObject = (PersistenceBrokerTransactionObject) transaction;

		// Remove the persistence broker holder from the thread.
		TransactionSynchronizationManager.unbindResource(getPbKey());
		txObject.getPersistenceBrokerHolder().clear();

		// Remove the JDBC connection holder from the thread, if set.
		if (getDataSource() != null) {
			TransactionSynchronizationManager.unbindResource(getDataSource());
		}

		PersistenceBroker pb = txObject.getPersistenceBrokerHolder().getPersistenceBroker();
		try {
			Connection con = pb.serviceConnectionManager().getConnection();
			DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel());
		}
		catch (LookupException ex) {
			logger.info("Could not look up JDBC Connection of OJB PersistenceBroker", ex);
		}

		if (logger.isDebugEnabled()) {
			logger.debug("Closing OJB PersistenceBroker [" + pb + "] after transaction");
		}
		releasePersistenceBroker(pb);
	}


	/**
	 * Get an OJB PersistenceBroker for the PBKey of this transaction manager.
	 * <p>Default implementation simply creates a new PersistenceBroker.
	 * Can be overridden in subclasses, e.g. for testing purposes.
	 * @return the PersistenceBroker
	 * @throws OJBRuntimeException if PersistenceBroker cretion failed
	 * @see #setJcdAlias
	 * @see #setPbKey
	 * @see org.apache.ojb.broker.PersistenceBrokerFactory#createPersistenceBroker(org.apache.ojb.broker.PBKey)
	 */
	protected PersistenceBroker getPersistenceBroker() throws OJBRuntimeException {
		return PersistenceBrokerFactory.createPersistenceBroker(getPbKey());
	}

	/**
	 * Close the given PersistenceBroker, created for the PBKey of this
	 * transaction manager, if it isn't bound to the thread.
	 * <p>Default implementation delegates to OjbFactoryUtils.
	 * Can be overridden in subclasses, e.g. for testing purposes.
	 * @param pb PersistenceBroker to close
	 * @see #setJcdAlias
	 * @see #setPbKey
	 * @see OjbFactoryUtils#releasePersistenceBroker
	 */
	protected void releasePersistenceBroker(PersistenceBroker pb) {
		OjbFactoryUtils.releasePersistenceBroker(pb, getPbKey());
	}


	/**
	 * OJB transaction object, representing a PersistenceBrokerHolder.
	 * Used as transaction object by PersistenceBrokerTransactionManager.
	 *
	 * <p>Derives from JdbcTransactionObjectSupport to inherit the capability
	 * to manage JDBC 3.0 Savepoints for underlying JDBC Connections.
	 *
	 * @see PersistenceBrokerHolder
	 */
	private static class PersistenceBrokerTransactionObject extends JdbcTransactionObjectSupport {

		private PersistenceBrokerHolder persistenceBrokerHolder;

		public void setPersistenceBrokerHolder(PersistenceBrokerHolder persistenceBrokerHolder) {
			this.persistenceBrokerHolder = persistenceBrokerHolder;
		}

		public PersistenceBrokerHolder getPersistenceBrokerHolder() {
			return persistenceBrokerHolder;
		}

		public void setRollbackOnly() {
			getPersistenceBrokerHolder().setRollbackOnly();
			if (getConnectionHolder() != null) {
				getConnectionHolder().setRollbackOnly();
			}
		}

		public boolean isRollbackOnly() {
			return getPersistenceBrokerHolder().isRollbackOnly() ||
					(getConnectionHolder() != null && getConnectionHolder().isRollbackOnly());
		}
	}


	/**
	 * Holder for suspended resources.
	 * Used internally by doSuspend and doResume.
	 */
	private static class SuspendedResourcesHolder {

		private final PersistenceBrokerHolder persistenceBrokerHolder;

		private final ConnectionHolder connectionHolder;

		private SuspendedResourcesHolder(PersistenceBrokerHolder pbHolder, ConnectionHolder conHolder) {
			this.persistenceBrokerHolder = pbHolder;
			this.connectionHolder = conHolder;
		}

		private PersistenceBrokerHolder getPersistenceBrokerHolder() {
			return persistenceBrokerHolder;
		}

		private ConnectionHolder getConnectionHolder() {
			return connectionHolder;
		}
	}

}