io.micronaut.transaction.interceptor

Class TransactionalInterceptor

java.lang.Object

io.micronaut.transaction.interceptor.TransactionalInterceptor

All Implemented Interfaces:

io.micronaut.aop.Interceptor<java.lang.Object,java.lang.Object>, io.micronaut.aop.MethodInterceptor<java.lang.Object,java.lang.Object>, io.micronaut.core.order.Ordered

@Singleton
 @Requires(beans=SynchronousTransactionManager.class)
public class TransactionalInterceptor
extends java.lang.Object
implements io.micronaut.aop.MethodInterceptor<java.lang.Object,java.lang.Object>

Default implementation of TransactionalAdvice. Forked from the reflection based code in Spring.

Since:

1.0

Author:

Rod Johnson, Juergen Hoeller, Stéphane Nicoll, Sam Brannen, graemerocher

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	TransactionalInterceptor.TransactionInfo Opaque object used to hold transaction information.

Field Summary

Fields inherited from interface io.micronaut.aop.Interceptor

HOTSWAP, LAZY, PROXY_TARGET

Fields inherited from interface io.micronaut.core.order.Ordered

HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE

Constructor Summary

Constructors

Constructor and Description
TransactionalInterceptor(io.micronaut.context.BeanLocator beanLocator) Default constructor.

Method Summary

Modifier and Type	Method and Description
protected void	cleanupTransactionInfo(TransactionalInterceptor.TransactionInfo txInfo) Reset the TransactionInfo ThreadLocal.
protected void	commitTransactionAfterReturning(TransactionalInterceptor.TransactionInfo txInfo) Execute after successful completion of call, but not after an exception was handled.
protected void	completeTransactionAfterThrowing(TransactionalInterceptor.TransactionInfo txInfo, java.lang.Throwable ex) Handle a throwable, completing the transaction.
protected TransactionalInterceptor.TransactionInfo	createTransactionIfNecessary(SynchronousTransactionManager tm, TransactionAttribute txAttr, java.lang.String joinpointIdentification) Create a transaction if necessary based on the given TransactionAttribute.
static TransactionStatus	currentTransactionStatus() Return the transaction status of the current method invocation.
int	getOrder()
java.lang.Object	intercept(io.micronaut.aop.MethodInvocationContext<java.lang.Object,java.lang.Object> context)
protected TransactionalInterceptor.TransactionInfo	prepareTransactionInfo(SynchronousTransactionManager tm, TransactionAttribute txAttr, java.lang.String joinpointIdentification, TransactionStatus status) Prepare a TransactionInfo for the given attribute and status object.
protected TransactionAttribute	resolveTransactionDefinition(io.micronaut.inject.ExecutableMethod<java.lang.Object,java.lang.Object> executableMethod)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.micronaut.aop.MethodInterceptor

intercept

Constructor Detail

TransactionalInterceptor

public TransactionalInterceptor(@NonNull
                                io.micronaut.context.BeanLocator beanLocator)

Default constructor.

Parameters:

beanLocator - The bean locator.

Method Detail

getOrder

public int getOrder()

Specified by:

getOrder in interface io.micronaut.core.order.Ordered

intercept

public java.lang.Object intercept(io.micronaut.aop.MethodInvocationContext<java.lang.Object,java.lang.Object> context)

Specified by:

intercept in interface io.micronaut.aop.MethodInterceptor<java.lang.Object,java.lang.Object>

currentTransactionStatus

public static TransactionStatus currentTransactionStatus()
                                                  throws NoTransactionException

Return the transaction status of the current method invocation. Mainly intended for code that wants to set the current transaction rollback-only but not throw an application exception.

Returns:

The current status

Throws:

NoTransactionException - if the transaction info cannot be found, because the method was invoked outside an AOP invocation context

createTransactionIfNecessary

protected TransactionalInterceptor.TransactionInfo createTransactionIfNecessary(@NonNull
                                                                                SynchronousTransactionManager tm,
                                                                                @NonNull
                                                                                TransactionAttribute txAttr,
                                                                                java.lang.String joinpointIdentification)

Create a transaction if necessary based on the given TransactionAttribute.

Allows callers to perform custom TransactionAttribute lookups through the TransactionAttributeSource.

Parameters:

tm - The transaction manager

txAttr - the TransactionAttribute (may be null)

joinpointIdentification - the fully qualified method name (used for monitoring and logging purposes)

Returns:

a TransactionInfo object, whether or not a transaction was created. The hasTransaction() method on TransactionInfo can be used to tell if there was a transaction created.

prepareTransactionInfo

protected TransactionalInterceptor.TransactionInfo prepareTransactionInfo(@NonNull
                                                                          SynchronousTransactionManager tm,
                                                                          @NonNull
                                                                          TransactionAttribute txAttr,
                                                                          java.lang.String joinpointIdentification,
                                                                          @NonNull
                                                                          TransactionStatus status)

Prepare a TransactionInfo for the given attribute and status object.

Parameters:

tm - The transaction manager

txAttr - the TransactionAttribute (may be null)

joinpointIdentification - the fully qualified method name (used for monitoring and logging purposes)

status - the TransactionStatus for the current transaction

Returns:

the prepared TransactionInfo object

commitTransactionAfterReturning

protected void commitTransactionAfterReturning(@NonNull
                                               TransactionalInterceptor.TransactionInfo txInfo)

Execute after successful completion of call, but not after an exception was handled. Do nothing if we didn't create a transaction.

Parameters:

txInfo - information about the current transaction

completeTransactionAfterThrowing

protected void completeTransactionAfterThrowing(@NonNull
                                                TransactionalInterceptor.TransactionInfo txInfo,
                                                java.lang.Throwable ex)

Handle a throwable, completing the transaction. We may commit or roll back, depending on the configuration.

Parameters:

txInfo - information about the current transaction

ex - throwable encountered

cleanupTransactionInfo

protected void cleanupTransactionInfo(@Nullable
                                      TransactionalInterceptor.TransactionInfo txInfo)

Reset the TransactionInfo ThreadLocal.

Call this in all cases: exception or normal return!

Parameters:

txInfo - information about the current transaction (may be null)

resolveTransactionDefinition

protected TransactionAttribute resolveTransactionDefinition(io.micronaut.inject.ExecutableMethod<java.lang.Object,java.lang.Object> executableMethod)

Parameters:

executableMethod - The method

Returns:

The TransactionAttribute