Uses of Class org.springframework.transaction.TransactionException (Spring Framework) - Spring Framework 1.2.9 API 文档英文版

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV NEXT

FRAMES NO FRAMES

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.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.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)

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.

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 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).

Object DefaultJdoDialect.beginTransaction(javax.jdo.Transaction transaction, TransactionDefinition definition)
This implementation invokes the standard JDO Transaction.begin method.

Methods in org.springframework.orm.jdo that throw TransactionException
`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).
`Object`	`DefaultJdoDialect.beginTransaction(javax.jdo.Transaction transaction, TransactionDefinition definition)` This implementation invokes the standard JDO `Transaction.begin` method.

Uses of TransactionException in org.springframework.test

Methods in org.springframework.test that throw TransactionException

protected void AbstractTransactionalSpringContextTests.startNewTransaction()
Start a new transaction.

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, i.e. 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.

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, i.e. 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)
          Roll back the given transaction.

void SavepointManager.rollbackToSavepoint(Object savepoint)
          Roll back to the given savepoint.

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)` Roll back the given transaction.
`void`	`SavepointManager.rollbackToSavepoint(Object savepoint)` Roll back to the given savepoint.

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 TransactionTemplate.execute(TransactionCallback action)
          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.

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.

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`	`TransactionTemplate.execute(TransactionCallback action)` 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.
`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.