如果@transactional 在类级别应用，如何拦截@transactional 参数

Question

I want to capture the argument of @transactional if it is applied at class level.

for eg if @transactional applied at method level like :-

class A {

    @transactional(readOnly= true)
    public void someMethod(){
      // some code...
     }
}

then I am able to Intercept and capture the formal argument ie readOnly with this code like :-

@Aspect
@Component
@Order(0)
public class ReadOnlyRouteInterceptor {

    private static final Logger logger = LoggerFactory.getLogger(ReadOnlyRouteInterceptor.class);

    @Around("@annotation(transactional)")
    public Object proceed(ProceedingJoinPoint proceedingJoinPoint, Transactional transactional) {
            if (transactional.readOnly())
             //do something
    }

However the above code will not work if @transactional applied at class level as :-

@transactional(readOnly= true)
class A {

    public void someMethod(){
      // some code...
     }
}

Now in order to Intercept the @transactional annotation which is applied at class level I have following code :-

@Pointcut("@within(org.springframework.transaction.annotation.Transactional *)")
public void beanAnnotatedWithTransactional() {}

@Pointcut("execution(public * *(..))")
public void publicMethod() {}

@Pointcut("publicMethod() && beanAnnotatedWithTransactional()")
public void publicMethodInsideAClassMarkedWithATransactional() {}

My actual problem here is I am unable to check the value of readOnly flag if @transactional is applied at class level.

Answer 1

For type level annotation :

@Around("@within(transactional)")
public Object myMethod(ProceedingJoinPoint pjp, Transactional transactional) throws Throwable {
    boolean readOnly = transactional.readOnly();
    ...
    return pjp.proceed();
}

For method level annotation:

  @Around("execution(public * *(..)) && @annotation(org.springframework.transaction.annotation.Transactional)")
    public Object myMethod(ProceedingJoinPoint pjp) throws Throwable {
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        Method method = signature.getMethod();

        Transactional annotation = method.getAnnotation(org.springframework.transaction.annotation.Transactional.class);
        boolean value = annotation. readOnly();
        ...
        return pjp.proceed();
    }

Another (cleaner) option for method level :

@Around("@annotation(transactional)")
 public Object myMethod(ProceedingJoinPoint pjp, Transactional transactional) throws Throwable {

}

or

With more control over tager :

    @Around("execution(@org.springframework.transaction.annotation.Transactional public * *(..)) && @annotation("transactional")
     public Object myMethod(ProceedingJoinPoint pjp, Transactional transactional) throws Throwable {

}

Answer 2

You may use the TransactionSynchronizationManager to get reference to the transaction details.

Following code provides the readonly details of the current active transaction.

import org.springframework.transaction.support.TransactionSynchronizationManager;

@Component
@Aspect
public class TestTransactionalAspect {


    @Pointcut("@within(org.springframework.transaction.annotation.Transactional)")
    public void beanAnnotatedWithTransactional() {}
    @Pointcut("execution(public * *(..))")
    public void publicMethod() {}


    @Around("publicMethod() && beanAnnotatedWithTransactional()")
    public void publicMethodInsideAClassMarkedWithATransactional(ProceedingJoinPoint pjp) {

        try {
            System.out.println("Intercepted "+pjp.toShortString());
            if (TransactionSynchronizationManager.isActualTransactionActive()) {
                System.out.println("Is transaction readonly : "+TransactionSynchronizationManager.isCurrentTransactionReadOnly());
            }
            pjp.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }

    }
}

Update:

Assuming this is not a Spring Boot project , @EnableTransactionManagement is mandatory for your spring application to work with transactions. Data will get persisted to database without transactions as well.

@EnableTransactionManagement annotation has to be used on @Configuration classes.

Following is a sample code to enable transaction management in spring

@Configuration
@EnableTransactionManagement
public class AppConfig {

         @Bean
         public FooRepository fooRepository() {
             // configure and return a class having @Transactional methods
             return new JdbcFooRepository(dataSource());
         }

         @Bean
         public DataSource dataSource() {
             // configure and return the necessary JDBC DataSource
         }

         @Bean
         public PlatformTransactionManager txManager() {
             return new DataSourceTransactionManager(dataSource());
         }
     }

Answer 3

Based on the answers above I tried with the following code it is very simple.

 /**
     * This Aspect advice will be called only if transactional applied at method level
     */
    @Around("@annotation(transactional)")
    public Object proceedWithMethodLevelAnnotation(ProceedingJoinPoint proceedingJoinPoint,
                                                   Transactional transactional)  {
                                      if( transactional.readOnly() ) {
                //do something
                  }

    /**
     * This Aspect advice will be called only if transactional annotation applied at class level
     */
    @Around("@within(transactional)")
    public Object proceedWithClassLevelAnnotation(ProceedingJoinPoint proceedingJoinPoint,
                                                  Transactional transactional) 
            if( transactional.readOnly() ) {
            //do something
    }
}