Java TransactionSystemException类代码示例

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
@Override
protected void doRollback(DefaultTransactionStatus status) {
	JpaTransactionObject txObject = (JpaTransactionObject) status.getTransaction();
	if (status.isDebug()) {
		logger.debug("Rolling back JPA transaction on EntityManager [" +
				txObject.getEntityManagerHolder().getEntityManager() + "]");
	}
	try {
		EntityTransaction tx = txObject.getEntityManagerHolder().getEntityManager().getTransaction();
		if (tx.isActive()) {
			tx.rollback();
		}
	}
	catch (PersistenceException ex) {
		throw new TransactionSystemException("Could not roll back JPA transaction", ex);
	}
	finally {
		if (!txObject.isNewEntityManagerHolder()) {
			// Clear all pending inserts/updates/deletes in the EntityManager.
			// Necessary for pre-bound EntityManagers, to avoid inconsistent state.
			txObject.getEntityManagerHolder().getEntityManager().clear();
		}
	}
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
@Override
protected void doRollback(DefaultTransactionStatus status) {
	JdoTransactionObject txObject = (JdoTransactionObject) status.getTransaction();
	if (status.isDebug()) {
		logger.debug("Rolling back JDO transaction on PersistenceManager [" +
				txObject.getPersistenceManagerHolder().getPersistenceManager() + "]");
	}
	try {
		Transaction tx = txObject.getPersistenceManagerHolder().getPersistenceManager().currentTransaction();
		if (tx.isActive()) {
			tx.rollback();
		}
	}
	catch (JDOException ex) {
		throw new TransactionSystemException("Could not roll back JDO transaction", ex);
	}
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
@Test
public void testTransactionWithExceptionOnCommit() throws Exception {
	willThrow(new SQLException("Cannot commit")).given(con).commit();

	TransactionTemplate tt = new TransactionTemplate(tm);
	try {
		tt.execute(new TransactionCallbackWithoutResult() {
			@Override
			protected void doInTransactionWithoutResult(TransactionStatus status) {
				// something transactional
			}
		});
		fail("Should have thrown TransactionSystemException");
	}
	catch (TransactionSystemException ex) {
		// expected
	}

	assertTrue("Hasn't thread connection", !TransactionSynchronizationManager.hasResource(ds));
	verify(con).close();
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
@Test
public void testTransactionWithExceptionOnCommitAndRollbackOnCommitFailure() throws Exception {
	willThrow(new SQLException("Cannot commit")).given(con).commit();

	tm.setRollbackOnCommitFailure(true);
	TransactionTemplate tt = new TransactionTemplate(tm);
	try {
		tt.execute(new TransactionCallbackWithoutResult() {
			@Override
			protected void doInTransactionWithoutResult(TransactionStatus status) {
				// something transactional
			}
		});
		fail("Should have thrown TransactionSystemException");
	}
	catch (TransactionSystemException ex) {
		// expected
	}

	assertTrue("Hasn't thread connection", !TransactionSynchronizationManager.hasResource(ds));
	verify(con).rollback();
	verify(con).close();
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
@Test
public void testTransactionWithExceptionOnRollback() throws Exception {
	given(con.getAutoCommit()).willReturn(true);
	willThrow(new SQLException("Cannot rollback")).given(con).rollback();

	TransactionTemplate tt = new TransactionTemplate(tm);
	try {
		tt.execute(new TransactionCallbackWithoutResult() {
			@Override
			protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
				status.setRollbackOnly();
			}
		});
		fail("Should have thrown TransactionSystemException");
	}
	catch (TransactionSystemException ex) {
		// expected
	}

	assertTrue("Hasn't thread connection", !TransactionSynchronizationManager.hasResource(ds));
	InOrder ordered = inOrder(con);
	ordered.verify(con).setAutoCommit(false);
	ordered.verify(con).rollback();
	ordered.verify(con).setAutoCommit(true);
	verify(con).close();
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
@Override
protected void doCommit(DefaultTransactionStatus status) {
	DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
	Connection con = txObject.getConnectionHolder().getConnection();
	if (status.isDebug()) {
		logger.debug("Committing JDBC transaction on Connection [" + con + "]");
	}
	try {
		con.commit();
	}
	catch (SQLException ex) {
		throw new TransactionSystemException("Could not commit JDBC transaction", ex);
	}
	
	/**modify by guosg 这里提交ldtm事务*/
	SynchronizationManager.getCurrentUserTransation().commit();
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
@Override
protected void doRollback(DefaultTransactionStatus status) {
	DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
	Connection con = txObject.getConnectionHolder().getConnection();
	if (status.isDebug()) {
		logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
	}
	try {
		con.rollback();
	}
	catch (SQLException ex) {
		throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
	}
	
	/**modify by guosg 这里提交回滚事务*/
	SynchronizationManager.getCurrentUserTransation().rollback();
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
/**
 * Look up the JTA 1.1 TransactionSynchronizationRegistry in JNDI via the configured name.
 * <p>Can be overridden in subclasses to provide a different TransactionManager object.
 * @param registryName the JNDI name of the
 * TransactionSynchronizationRegistry
 * @return the TransactionSynchronizationRegistry object
 * @throws TransactionSystemException if the JNDI lookup failed
 * @see #setJndiTemplate
 * @see #setTransactionSynchronizationRegistryName
 */
protected Object lookupTransactionSynchronizationRegistry(String registryName) throws TransactionSystemException {
	if (transactionSynchronizationRegistryClass == null) {
		throw new TransactionSystemException(
				"JTA 1.1 [" + TRANSACTION_SYNCHRONIZATION_REGISTRY_CLASS_NAME + "] API not available");
	}
	try {
		if (logger.isDebugEnabled()) {
			logger.debug("Retrieving JTA TransactionSynchronizationRegistry from JNDI location [" + registryName + "]");
		}
		return getJndiTemplate().lookup(registryName, transactionSynchronizationRegistryClass);
	}
	catch (NamingException ex) {
		throw new TransactionSystemException(
				"JTA TransactionSynchronizationRegistry is not available at JNDI location [" + registryName + "]", ex);
	}
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
/**
 * Define how message exchanges are processed.
 *
 * @param exchange the InOut message exchange
 * @throws FcrepoOperationFailedException when the underlying HTTP request results in an error
 */
@Override
public void process(final Exchange exchange) throws FcrepoOperationFailedException {
    if (exchange.isTransacted()) {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            protected void doInTransactionWithoutResult(final TransactionStatus status) {
                final DefaultTransactionStatus st = (DefaultTransactionStatus)status;
                final FcrepoTransactionObject tx = (FcrepoTransactionObject)st.getTransaction();
                try {
                    doRequest(exchange, tx.getSessionId());
                } catch (FcrepoOperationFailedException ex) {
                    throw new TransactionSystemException(
                        "Error executing fcrepo request in transaction: ", ex);
                }
            }
        });
    } else {
        doRequest(exchange, null);
    }
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
@Override
protected void doCommit(final DefaultTransactionStatus status) {
    final FcrepoTransactionObject tx = (FcrepoTransactionObject)status.getTransaction();
    final InputStream is = null;
    final String contentType = null;

    try {
        getClient().post(URI.create(baseUrl + "/" + tx.getSessionId() + COMMIT))
            .body(is, contentType).perform();
    } catch (final FcrepoOperationFailedException ex) {
        LOGGER.debug("Transaction commit failed: ", ex);
        throw new TransactionSystemException("Could not commit fcrepo transaction");
    } finally {
        tx.setSessionId(null);
    }
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
@Override
protected void doCommit(DefaultTransactionStatus status) {
	JcrTransactionObject txObject = (JcrTransactionObject) status
			.getTransaction();
	if (status.isDebug()) {
		LOG.debug("Committing JCR transaction on session ["
				+ txObject.getSessionHolder().getSession() + "]");
	}
	try {
		txObject.getSessionHolder().getTransaction().commit();
	} catch (Exception ex) {
		// assumably from commit call to the underlying JCR repository
		throw new TransactionSystemException(
				"Could not commit JCR transaction", ex);
	}
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
@Override
protected void doRollback(DefaultTransactionStatus status) {
	JcrTransactionObject txObject = (JcrTransactionObject) status
			.getTransaction();
	if (status.isDebug()) {
		LOG.debug("Rolling back JCR transaction on session ["
				+ txObject.getSessionHolder().getSession() + "]");
	}
	try {
		txObject.getSessionHolder().getTransaction().rollback();
	} catch (Exception ex) {
		throw new TransactionSystemException(
				"Could not roll back JCR transaction", ex);
	} finally {
		if (!txObject.isNewSessionHolder()) {
			// Clear all pending inserts/updates/deletes in the Session.
			// Necessary for pre-bound Sessions, to avoid inconsistent
			// state.
			try {
				txObject.getSessionHolder().getSession().refresh(false);
			} catch (RepositoryException e) {
				// we already throw an exception (hold back this one).
			}
		}
	}
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
private void loadWebLogicTransactionClasses() throws TransactionSystemException {
	try {
		Class<?> userTransactionClass = getClass().getClassLoader().loadClass(USER_TRANSACTION_CLASS_NAME);
		this.weblogicUserTransactionAvailable = userTransactionClass.isInstance(getUserTransaction());
		if (this.weblogicUserTransactionAvailable) {
			this.beginWithNameMethod = userTransactionClass.getMethod("begin", String.class);
			this.beginWithNameAndTimeoutMethod = userTransactionClass.getMethod("begin", String.class, int.class);
			logger.info("Support for WebLogic transaction names available");
		}
		else {
			logger.info("Support for WebLogic transaction names not available");
		}

		// Obtain WebLogic ClientTransactionManager interface.
		Class<?> transactionManagerClass =
				getClass().getClassLoader().loadClass(CLIENT_TRANSACTION_MANAGER_CLASS_NAME);
		logger.debug("WebLogic ClientTransactionManager found");

		this.weblogicTransactionManagerAvailable = transactionManagerClass.isInstance(getTransactionManager());
		if (this.weblogicTransactionManagerAvailable) {
			Class<?> transactionClass = getClass().getClassLoader().loadClass(TRANSACTION_CLASS_NAME);
			this.forceResumeMethod = transactionManagerClass.getMethod("forceResume", Transaction.class);
			this.setPropertyMethod = transactionClass.getMethod("setProperty", String.class, Serializable.class);
			logger.debug("Support for WebLogic forceResume available");
		}
		else {
			logger.warn("Support for WebLogic forceResume not available");
		}
	}
	catch (Exception ex) {
		throw new TransactionSystemException(
				"Could not initialize WebLogicJtaTransactionManager because WebLogic API classes are not available",
				ex);
	}
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
/**
 * Initialize the UserTransaction as well as the TransactionManager handle.
 * @see #initUserTransactionAndTransactionManager()
 */
@Override
public void afterPropertiesSet() throws TransactionSystemException {
	initUserTransactionAndTransactionManager();
	checkUserTransactionAndTransactionManager();
	initTransactionSynchronizationRegistry();
}
 

import org.springframework.transaction.TransactionSystemException; //导入依赖的package包/类
/**
 * Initialize the UserTransaction as well as the TransactionManager handle.
 * @throws TransactionSystemException if initialization failed
 */
protected void initUserTransactionAndTransactionManager() throws TransactionSystemException {
	if (this.userTransaction == null) {
		// Fetch JTA UserTransaction from JNDI, if necessary.
		if (StringUtils.hasLength(this.userTransactionName)) {
			this.userTransaction = lookupUserTransaction(this.userTransactionName);
			this.userTransactionObtainedFromJndi = true;
		}
		else {
			this.userTransaction = retrieveUserTransaction();
			if (this.userTransaction == null && this.autodetectUserTransaction) {
				// Autodetect UserTransaction at its default JNDI location.
				this.userTransaction = findUserTransaction();
			}
		}
	}

	if (this.transactionManager == null) {
		// Fetch JTA TransactionManager from JNDI, if necessary.
		if (StringUtils.hasLength(this.transactionManagerName)) {
			this.transactionManager = lookupTransactionManager(this.transactionManagerName);
		}
		else {
			this.transactionManager = retrieveTransactionManager();
			if (this.transactionManager == null && this.autodetectTransactionManager) {
				// Autodetect UserTransaction object that implements TransactionManager,
				// and check fallback JNDI locations otherwise.
				this.transactionManager = findTransactionManager(this.userTransaction);
			}
		}
	}

	// If only JTA TransactionManager specified, create UserTransaction handle for it.
	if (this.userTransaction == null && this.transactionManager != null) {
		this.userTransaction = buildUserTransaction(this.transactionManager);
	}
}