org.springframework.transaction.annotation

Annotation Type Transactional

@Target(value={TYPE,METHOD})
 @Retention(value=RUNTIME)
 @Inherited
 @Documented
public @interface Transactional

Describes a transaction attribute on an individual method or on a class.

When this annotation is declared at the class level, it applies as a default to all methods of the declaring class and its subclasses. Note that it does not apply to ancestor classes up the class hierarchy; inherited methods need to be locally redeclared in order to participate in a subclass-level annotation. For details on method visibility constraints, consult the Transaction Management section of the reference manual.

This annotation is generally directly comparable to Spring's RuleBasedTransactionAttribute class, and in fact AnnotationTransactionAttributeSource will directly convert this annotation's attributes to properties in RuleBasedTransactionAttribute, so that Spring's transaction support code does not have to know about annotations.

Attribute Semantics

If no custom rollback rules are configured in this annotation, the transaction will roll back on RuntimeException and Error but not on checked exceptions.

Rollback rules determine if a transaction should be rolled back when a given exception is thrown, and the rules are based on patterns. A pattern can be a fully qualified class name or a substring of a fully qualified class name for an exception type (which must be a subclass of Throwable), with no wildcard support at present. For example, a value of "javax.servlet.ServletException" or "ServletException" will match javax.servlet.ServletException and its subclasses.

Rollback rules may be configured via rollbackFor()/noRollbackFor() and rollbackForClassName()/noRollbackForClassName(), which allow patterns to be specified as Class references or strings, respectively. When an exception type is specified as a class reference its fully qualified name will be used as the pattern. Consequently, @Transactional(rollbackFor = example.CustomException.class) is equivalent to @Transactional(rollbackForClassName = "example.CustomException").

WARNING: You must carefully consider how specific the pattern is and whether to include package information (which isn't mandatory). For example, "Exception" will match nearly anything and will probably hide other rules. "java.lang.Exception" would be correct if "Exception" were meant to define a rule for all checked exceptions. With more unique exception names such as "BaseBusinessException" there is likely no need to use the fully qualified class name for the exception pattern. Furthermore, rollback rules may result in unintentional matches for similarly named exceptions and nested classes. This is due to the fact that a thrown exception is considered to be a match for a given rollback rule if the name of thrown exception contains the exception pattern configured for the rollback rule. For example, given a rule configured to match on com.example.CustomException, that rule would match against an exception named com.example.CustomExceptionV2 (an exception in the same package as CustomException but with an additional suffix) or an exception named com.example.CustomException$AnotherException (an exception declared as a nested class in CustomException).

For specific information about the semantics of other attributes in this annotation, consult the TransactionDefinition and TransactionAttribute javadocs.

Transaction Management

This annotation commonly works with thread-bound transactions managed by a PlatformTransactionManager, exposing a transaction to all data access operations within the current execution thread. Note: This does NOT propagate to newly started threads within the method.

Alternatively, this annotation may demarcate a reactive transaction managed by a ReactiveTransactionManager which uses the Reactor context instead of thread-local variables. As a consequence, all participating data access operations need to execute within the same Reactor context in the same reactive pipeline.

Since:

1.2

Author:

Colin Sampaleanu, Juergen Hoeller, Sam Brannen, Mark Paluch

See Also:

TransactionAttribute, DefaultTransactionAttribute, RuleBasedTransactionAttribute

Optional Element Summary

Optional Elements

Modifier and Type	Optional Element and Description
Isolation	isolation The transaction isolation level.
String[]	label Defines zero (0) or more transaction labels.
Class<? extends Throwable>[]	noRollbackFor Defines zero (0) or more exception Classes, which must be subclasses of Throwable, indicating which exception types must not cause a transaction rollback.
String[]	noRollbackForClassName Defines zero (0) or more exception name patterns (for exceptions which must be a subclass of Throwable) indicating which exception types must not cause a transaction rollback.
Propagation	propagation The transaction propagation type.
boolean	readOnly A boolean flag that can be set to true if the transaction is effectively read-only, allowing for corresponding optimizations at runtime.
Class<? extends Throwable>[]	rollbackFor Defines zero (0) or more exception classes, which must be subclasses of Throwable, indicating which exception types must cause a transaction rollback.
String[]	rollbackForClassName Defines zero (0) or more exception name patterns (for exceptions which must be a subclass of Throwable), indicating which exception types must cause a transaction rollback.
int	timeout The timeout for this transaction (in seconds).
String	timeoutString The timeout for this transaction (in seconds).
String	transactionManager A qualifier value for the specified transaction.
String	value Alias for transactionManager().

Element Detail

value

@AliasFor(value="transactionManager")
public abstract String value

Alias for transactionManager().

See Also:

transactionManager()

Default:

""

transactionManager

@AliasFor(value="value")
public abstract String transactionManager

A qualifier value for the specified transaction.

May be used to determine the target transaction manager, matching the qualifier value (or the bean name) of a specific TransactionManager bean definition.

Since:

4.2

See Also:

value(), PlatformTransactionManager, ReactiveTransactionManager

Default:

""

label

public abstract String[] label

Defines zero (0) or more transaction labels.

Labels may be used to describe a transaction, and they can be evaluated by individual transaction managers. Labels may serve a solely descriptive purpose or map to pre-defined transaction manager-specific options.

See the documentation of the actual transaction manager implementation for details on how it evaluates transaction labels.

Since:

5.3

See Also:

DefaultTransactionAttribute.getLabels()

Default:

{}

propagation

public abstract Propagation propagation

The transaction propagation type.

Defaults to Propagation.REQUIRED.

See Also:

TransactionDefinition.getPropagationBehavior()

Default:

org.springframework.transaction.annotation.Propagation.REQUIRED

isolation

public abstract Isolation isolation

The transaction isolation level.

Defaults to Isolation.DEFAULT.

Exclusively designed for use with Propagation.REQUIRED or Propagation.REQUIRES_NEW since it only applies to newly started transactions. Consider switching the "validateExistingTransactions" flag to "true" on your transaction manager if you'd like isolation level declarations to get rejected when participating in an existing transaction with a different isolation level.

See Also:

TransactionDefinition.getIsolationLevel(), AbstractPlatformTransactionManager.setValidateExistingTransaction(boolean)

Default:

org.springframework.transaction.annotation.Isolation.DEFAULT

timeout

public abstract int timeout

The timeout for this transaction (in seconds).

Defaults to the default timeout of the underlying transaction system.

Exclusively designed for use with Propagation.REQUIRED or Propagation.REQUIRES_NEW since it only applies to newly started transactions.

Returns:

the timeout in seconds

See Also:

TransactionDefinition.getTimeout()

Default:

-1

timeoutString

public abstract String timeoutString

The timeout for this transaction (in seconds).

Defaults to the default timeout of the underlying transaction system.

Exclusively designed for use with Propagation.REQUIRED or Propagation.REQUIRES_NEW since it only applies to newly started transactions.

Returns:

the timeout in seconds as a String value, e.g. a placeholder

Since:

5.3

See Also:

TransactionDefinition.getTimeout()

Default:

""

readOnly

public abstract boolean readOnly

A boolean flag that can be set to true if the transaction is effectively read-only, allowing for corresponding optimizations at runtime.

Defaults to false.

This just serves as a hint for the actual transaction subsystem; it will not necessarily cause failure of write access attempts. A transaction manager which cannot interpret the read-only hint will not throw an exception when asked for a read-only transaction but rather silently ignore the hint.

See Also:

TransactionDefinition.isReadOnly(), TransactionSynchronizationManager.isCurrentTransactionReadOnly()

Default:

false

rollbackFor

public abstract Class<? extends Throwable>[] rollbackFor

Defines zero (0) or more exception classes, which must be subclasses of Throwable, indicating which exception types must cause a transaction rollback.

By default, a transaction will be rolled back on RuntimeException and Error but not on checked exceptions (business exceptions). See DefaultTransactionAttribute.rollbackOn(Throwable) for a detailed explanation.

This is the preferred way to construct a rollback rule (in contrast to rollbackForClassName()), matching the exception type, its subclasses, and its nested classes. See the class-level javadocs for further details on rollback rule semantics and warnings regarding possible unintentional matches.

See Also:

rollbackForClassName(), RollbackRuleAttribute(Class), DefaultTransactionAttribute.rollbackOn(Throwable)

Default:

{}

rollbackForClassName

public abstract String[] rollbackForClassName

Defines zero (0) or more exception name patterns (for exceptions which must be a subclass of Throwable), indicating which exception types must cause a transaction rollback.

See the class-level javadocs for further details on rollback rule semantics, patterns, and warnings regarding possible unintentional matches.

See Also:

rollbackFor(), RollbackRuleAttribute(String), DefaultTransactionAttribute.rollbackOn(Throwable)

Default:

{}

noRollbackFor

public abstract Class<? extends Throwable>[] noRollbackFor

Defines zero (0) or more exception Classes, which must be subclasses of Throwable, indicating which exception types must not cause a transaction rollback.

This is the preferred way to construct a rollback rule (in contrast to noRollbackForClassName()), matching the exception type, its subclasses, and its nested classes. See the class-level javadocs for further details on rollback rule semantics and warnings regarding possible unintentional matches.

See Also:

noRollbackForClassName(), NoRollbackRuleAttribute(Class), DefaultTransactionAttribute.rollbackOn(Throwable)

Default:

{}

noRollbackForClassName

public abstract String[] noRollbackForClassName

Defines zero (0) or more exception name patterns (for exceptions which must be a subclass of Throwable) indicating which exception types must not cause a transaction rollback.

See the class-level javadocs for further details on rollback rule semantics, patterns, and warnings regarding possible unintentional matches.

See Also:

noRollbackFor(), NoRollbackRuleAttribute(String), DefaultTransactionAttribute.rollbackOn(Throwable)

Default:

{}