Package com.ultikits.ultitools.aop

Class TransactionInterceptor

java.lang.Object

com.ultikits.ultitools.aop.TransactionInterceptor

All Implemented Interfaces:

MethodInterceptor

public class TransactionInterceptor
extends Object
implements MethodInterceptor

AOP interceptor that implements declarative transaction management.

This interceptor processes @Transactional annotations and manages transaction boundaries accordingly.

Since:

6.2.0

Author:

wisdomme

Field Summary

Fields

Modifier and Type	Field	Description
private static final Logger	LOGGER
private final AnnotationLookupCache<Transactional>	lookupCache	Instance-scoped on purpose - see AnnotationLookupCache's class javadoc.
private final TransactionManager	transactionManager

Constructor Summary

Constructors

Constructor	Description
TransactionInterceptor(TransactionManager transactionManager)	Creates a new transaction interceptor.

Method Summary

Modifier and Type	Method	Description
private Object	executeInNewTransaction(MethodInvocation invocation, Transactional tx)	Executes the invocation in a new transaction.
private Object	executeWithTransaction(MethodInvocation invocation, Transactional tx)	Executes the method invocation within a transaction context.
private int	inheritanceDepth(Class<?> thrownClass, Class<?> ruleClass)	Walks thrownClass's superclass chain to find the depth at which it matches ruleClass.
Object	invoke(MethodInvocation invocation)	Intercept the given method invocation.
private Integer	shallowestMatchDepth(Throwable thrown, Class<? extends Throwable>[] rules)	Returns the shallowest inheritance depth at which thrown's runtime class matches any rule in rules, or null if none match.
private boolean	shouldRollback(Throwable e, Transactional tx)	Determines if the transaction should be rolled back for the given exception.

Methods inherited from class java.lang.Object

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

Field Details

lookupCache

private final AnnotationLookupCache<Transactional> lookupCache

Instance-scoped on purpose - see AnnotationLookupCache's class javadoc.

LOGGER

private static final Logger LOGGER

transactionManager

private final TransactionManager transactionManager

Constructor Details

TransactionInterceptor

public TransactionInterceptor(TransactionManager transactionManager)

Creates a new transaction interceptor.

Parameters:

transactionManager - the transaction manager to use

Method Details

invoke

public Object invoke(MethodInvocation invocation)
              throws Throwable

Description copied from interface: MethodInterceptor

Intercept the given method invocation.

Implementations should call MethodInvocation.proceed() to continue the interceptor chain or invoke the target method.

Specified by:

invoke in interface MethodInterceptor

Parameters:

invocation - the method invocation context

Returns:

the result of the method invocation

Throws:

Throwable - if the interceptor or target method throws an exception

executeWithTransaction

private Object executeWithTransaction(MethodInvocation invocation,
 Transactional tx)
                               throws Throwable

Executes the method invocation within a transaction context.

Throws:

Throwable

executeInNewTransaction

private Object executeInNewTransaction(MethodInvocation invocation,
 Transactional tx)
                                throws Throwable

Executes the invocation in a new transaction.

Throws:

Throwable

shouldRollback

private boolean shouldRollback(Throwable e,
 Transactional tx)

Determines if the transaction should be rolled back for the given exception.

Additive, depth-ordered combination of rollbackFor and noRollbackFor (D-06/D-07 - confirmed by the maintainer during 02-06's checkpoint, matching Spring's RuleBasedTransactionAttribute): each array is checked for its shallowest matching inheritance depth via shallowestMatchDepth(Throwable, Class[]). When both arrays match, the shallower depth wins; an exact-depth tie - including the same exception class listed in both arrays - favours rollback. When only one array matches, that one decides. When neither matches (including when both arrays are empty), this falls through to the unchanged RuntimeException/Error default - a non-empty rollbackFor with no match no longer short-circuits to "commit" the way it did before this fix.

shallowestMatchDepth

private Integer shallowestMatchDepth(Throwable thrown,
 Class<? extends Throwable>[] rules)

Returns the shallowest inheritance depth at which thrown's runtime class matches any rule in rules, or null if none match. Depth 0 is an exact class match; each step up thrown's superclass chain toward a matching rule adds 1.

inheritanceDepth

private int inheritanceDepth(Class<?> thrownClass,
 Class<?> ruleClass)

Walks thrownClass's superclass chain to find the depth at which it matches ruleClass. Callers only reach this after confirming ruleClass.isInstance(...) of an instance of thrownClass already holds, so the walk is guaranteed to terminate at ruleClass rather than at null.