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
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 static class	TransactionalInterceptor.TransactionInfo<T> Opaque object used to hold transaction information.

Field Summary

Fields inherited from interface io.micronaut.aop.Interceptor

ARGUMENT, 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, io.micronaut.inject.ExecutableMethod<java.lang.Object,java.lang.Object> executableMethod) Create a transaction if necessary based on the given TransactionAttribute.
static <T> TransactionStatus<T>	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, io.micronaut.inject.ExecutableMethod<java.lang.Object,java.lang.Object> executableMethod, 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 <T> TransactionStatus<T> 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.

Type Parameters:

T - The connection type

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,
                                                                                io.micronaut.inject.ExecutableMethod<java.lang.Object,java.lang.Object> executableMethod)

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)

executableMethod - the method that is being executed (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,
                                                                          io.micronaut.inject.ExecutableMethod<java.lang.Object,java.lang.Object> executableMethod,
                                                                          @NonNull
                                                                          TransactionStatus status)

Prepare a TransactionInfo for the given attribute and status object.

Parameters:

tm - The transaction manager

txAttr - the TransactionAttribute (may be null)

executableMethod - 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