## Uses of Class
org.springframework.transaction.TransactionException

Packages that use TransactionException
org.springframework.jca.cci.connection: Provides a utility class for easy ConnectionFactory access, a PlatformTransactionManager for local CCI transactions, and various simple ConnectionFactory proxies/adapters.
org.springframework.jdbc.datasource: Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
org.springframework.orm.jdo: Package providing integration of JDO (Java Date Objects) with Spring concepts.
org.springframework.orm.jpa: Package providing integration of JPA (Java Persistence API) with Spring concepts.
org.springframework.orm.jpa.vendor: Support classes for adapting to specific JPA vendors.
org.springframework.test: Superclasses for tests requiring Spring application contexts, including support for transactional execution of test cases, with automatic rollback on completion.
org.springframework.transaction: Exception hierarchy for Spring's transaction infrastructure, independent of any specific transaction management system.
org.springframework.transaction.jta: Transaction SPI implementation for JTA.
org.springframework.transaction.support: Support classes for the org.springframework.transaction package.

Uses of TransactionException in org.springframework.jca.cci.connection

Methods in org.springframework.jca.cci.connection that throw TransactionException
`protected boolean` `CciLocalTransactionManager.isRollbackOnly(Object transaction)`

Uses of TransactionException in org.springframework.jdbc.datasource

Methods in org.springframework.jdbc.datasource that throw TransactionException
`Object` `JdbcTransactionObjectSupport.createSavepoint()` This implementation creates a JDBC 3.0 Savepoint and returns it.
`protected ConnectionHolder` `JdbcTransactionObjectSupport.getConnectionHolderForSavepoint()`
`void` `JdbcTransactionObjectSupport.releaseSavepoint(Object savepoint)` This implementation releases the given JDBC 3.0 Savepoint.
`void` `JdbcTransactionObjectSupport.rollbackToSavepoint(Object savepoint)` This implementation rolls back to the given JDBC 3.0 Savepoint.

Uses of TransactionException in org.springframework.orm.jdo

Methods in org.springframework.orm.jdo that throw TransactionException
`Object` `DefaultJdoDialect.beginTransaction(javax.jdo.Transaction transaction, TransactionDefinition definition)` This implementation invokes the standard JDO `Transaction.begin` method.
`Object` `JdoDialect.beginTransaction(javax.jdo.Transaction transaction, TransactionDefinition definition)` Begin the given JDO transaction, applying the semantics specified by the given Spring transaction definition (in particular, an isolation level and a timeout).

Uses of TransactionException in org.springframework.orm.jpa

Methods in org.springframework.orm.jpa that throw TransactionException
`Object` `DefaultJpaDialect.beginTransaction(javax.persistence.EntityManager entityManager, TransactionDefinition definition)` This implementation invokes the standard JPA `Transaction.begin` method.
`Object` `JpaDialect.beginTransaction(javax.persistence.EntityManager entityManager, TransactionDefinition definition)` Begin the given JPA transaction, applying the semantics specified by the given Spring transaction definition (in particular, an isolation level and a timeout).

Uses of TransactionException in org.springframework.orm.jpa.vendor

Methods in org.springframework.orm.jpa.vendor that throw TransactionException
`Object` `TopLinkJpaDialect.beginTransaction(javax.persistence.EntityManager entityManager, TransactionDefinition definition)`
`Object` `OpenJpaDialect.beginTransaction(javax.persistence.EntityManager entityManager, TransactionDefinition definition)`
`Object` `HibernateJpaDialect.beginTransaction(javax.persistence.EntityManager entityManager, TransactionDefinition definition)`
`Object` `EclipseLinkJpaDialect.beginTransaction(javax.persistence.EntityManager entityManager, TransactionDefinition definition)`

Uses of TransactionException in org.springframework.test

Methods in org.springframework.test that throw TransactionException
`protected void` `AbstractTransactionalSpringContextTests.startNewTransaction()` Start a new transaction.

Uses of TransactionException in org.springframework.transaction

Subclasses of TransactionException in org.springframework.transaction
`class` `CannotCreateTransactionException` Exception thrown when a transaction can't be created using an underlying transaction API such as JTA.
`class` `HeuristicCompletionException` Exception that represents a transaction failure caused by a heuristic decision on the side of the transaction coordinator.
`class` `IllegalTransactionStateException` Exception thrown when the existence or non-existence of a transaction amounts to an illegal state according to the transaction propagation behavior that applies.
`class` `InvalidIsolationLevelException` Exception that gets thrown when an invalid isolation level is specified, i.e. an isolation level that the transaction manager implementation doesn't support.
`class` `InvalidTimeoutException` Exception that gets thrown when an invalid timeout is specified, that is, the specified timeout valid is out of range or the transaction manager implementation doesn't support timeouts.
`class` `NestedTransactionNotSupportedException` Exception thrown when attempting to work with a nested transaction but nested transactions are not supported by the underlying backend.
`class` `NoTransactionException` Exception thrown when an operation is attempted that relies on an existing transaction (such as setting rollback status) and there is no existing transaction.
`class` `TransactionSuspensionNotSupportedException` Exception thrown when attempting to suspend an existing transaction but transaction suspension is not supported by the underlying backend.
`class` `TransactionSystemException` Exception thrown when a general transaction system error is encountered, like on commit or rollback.
`class` `TransactionTimedOutException` Exception to be thrown when a transaction has timed out.
`class` `TransactionUsageException` Superclass for exceptions caused by inappropriate usage of a Spring transaction API.
`class` `UnexpectedRollbackException` Thrown when an attempt to commit a transaction resulted in an unexpected rollback.

Methods in org.springframework.transaction that throw TransactionException
`void` `PlatformTransactionManager.commit(TransactionStatus status)` Commit the given transaction, with regard to its status.
`Object` `SavepointManager.createSavepoint()` Create a new savepoint.
`TransactionStatus` `PlatformTransactionManager.getTransaction(TransactionDefinition definition)` Return a currently active transaction or create a new one, according to the specified propagation behavior.
`void` `SavepointManager.releaseSavepoint(Object savepoint)` Explicitly release the given savepoint.
`void` `PlatformTransactionManager.rollback(TransactionStatus status)` Perform a rollback of the given transaction.
`void` `SavepointManager.rollbackToSavepoint(Object savepoint)` Roll back to the given savepoint.

Uses of TransactionException in org.springframework.transaction.jta

Methods in org.springframework.transaction.jta that throw TransactionException
`Object` `WebSphereUowTransactionManager.execute(TransactionDefinition definition, TransactionCallback callback)`

Uses of TransactionException in org.springframework.transaction.support

Methods in org.springframework.transaction.support that throw TransactionException
`void` `AbstractPlatformTransactionManager.commit(TransactionStatus status)` This implementation of commit handles participating in existing transactions and programmatic rollback requests.
`void` `AbstractTransactionStatus.createAndHoldSavepoint()` Create a savepoint and hold it for the transaction.
`Object` `AbstractTransactionStatus.createSavepoint()` This implementation delegates to a SavepointManager for the underlying transaction, if possible.
`protected abstract void` `AbstractPlatformTransactionManager.doBegin(Object transaction, TransactionDefinition definition)` Begin a new transaction with semantics according to the given transaction definition.
`protected abstract void` `AbstractPlatformTransactionManager.doCommit(DefaultTransactionStatus status)` Perform an actual commit of the given transaction.
`protected abstract Object` `AbstractPlatformTransactionManager.doGetTransaction()` Return a transaction object for the current transaction state.
`protected void` `AbstractPlatformTransactionManager.doResume(Object transaction, Object suspendedResources)` Resume the resources of the current transaction.
`protected abstract void` `AbstractPlatformTransactionManager.doRollback(DefaultTransactionStatus status)` Perform an actual rollback of the given transaction.
`protected void` `AbstractPlatformTransactionManager.doSetRollbackOnly(DefaultTransactionStatus status)` Set the given transaction rollback-only.
`protected Object` `AbstractPlatformTransactionManager.doSuspend(Object transaction)` Suspend the resources of the current transaction.
`Object` `TransactionOperations.execute(TransactionCallback action)` Execute the action specified by the given callback object within a transaction.
`Object` `TransactionTemplate.execute(TransactionCallback action)`
`Object` `CallbackPreferringPlatformTransactionManager.execute(TransactionDefinition definition, TransactionCallback callback)` Execute the action specified by the given callback object within a transaction.
`TransactionStatus` `AbstractPlatformTransactionManager.getTransaction(TransactionDefinition definition)` This implementation handles propagation behavior.
`protected boolean` `AbstractPlatformTransactionManager.isExistingTransaction(Object transaction)` Check if the given transaction object indicates an existing transaction (that is, a transaction which has already started).
`protected void` `AbstractPlatformTransactionManager.registerAfterCompletionWithExistingTransaction(Object transaction, List synchronizations)` Register the given list of transaction synchronizations with the existing transaction.
`void` `AbstractTransactionStatus.releaseHeldSavepoint()` Release the savepoint that is held for the transaction.
`void` `AbstractTransactionStatus.releaseSavepoint(Object savepoint)` This implementation delegates to a SavepointManager for the underlying transaction, if possible.
`protected void` `AbstractPlatformTransactionManager.resume(Object transaction, AbstractPlatformTransactionManager.SuspendedResourcesHolder resourcesHolder)` Resume the given transaction.
`void` `AbstractPlatformTransactionManager.rollback(TransactionStatus status)` This implementation of rollback handles participating in existing transactions.
`void` `AbstractTransactionStatus.rollbackToHeldSavepoint()` Roll back to the savepoint that is held for the transaction.
`void` `AbstractTransactionStatus.rollbackToSavepoint(Object savepoint)` This implementation delegates to a SavepointManager for the underlying transaction, if possible.
`protected AbstractPlatformTransactionManager.SuspendedResourcesHolder` `AbstractPlatformTransactionManager.suspend(Object transaction)` Suspend the given transaction.

Copyright © 2002-2008 The Spring Framework.