Spring coroutines AOP is not compatible with `@Transactional`

[backtony]

spring boot version 3.3.0

When using Spring Coroutine AOP, if the @transactional annotation and a custom AOP are applied together without specifying an order in the Aspect, there is an issue where the custom AOP does not get applied.

@Service
class TargetService() {
    private val log = KotlinLogging.logger { }

    @Logging
    @Transactional
    suspend fun aop(): String {
        delay(100)
        log.info { "aop target method call" }

        return "ok"
    }
}

@Aspect
//@Order(1)
@Component
class LoggingAspect {

    private val log = KotlinLogging.logger {}

    @Around("@annotation(com.example.aopwithtransaction.aop.Logging)")
    fun logging(joinPoint: ProceedingJoinPoint): Any? {
        return mono {
            log.info { "Aop Logging started" }

            val result = joinPoint.proceed().let { result ->
                if (result is Mono<*>) {
                    result.awaitSingleOrNull()
                } else {
                    result
                }
            }

            log.info { "Aop Logging completed" }

            result
        }
    }
}

In cases like the one above, the custom AOP does not function unless the order is specified, in which case it does function.

This is a simple example : https://github.com/backtony/spring-reactive-aop-transaction

[sdeleuze]

It is likely coming from the fact using mono {  } loses the CoroutineContext. I would suggest to write your aspect with Reactive operators if you are not familiar with those advanced concepts, for example this should work even without @Order(1):

@Around("@annotation(com.example.aopwithtransaction.aop.Logging)")
fun logging(joinPoint: ProceedingJoinPoint): Any? {
    log.info { "Aop Logging started" }
    return (joinPoint.proceed(joinPoint.args) as Mono<*>).doOnTerminate {
        log.info { "Aop Logging completed" }
    }
}

As a consequence, I am closing the issue as invalid.

[backtony]

@sdeleuze
Thank you for your response.

@Around("@annotation(com.example.aopwithtransaction.aop.Logging)")
fun logging(joinPoint: ProceedingJoinPoint): Any? {
    log.info { "Aop Logging started" }
    return (joinPoint.proceed(joinPoint.args) as Mono<*>).doOnTerminate {
        log.info { "Aop Logging completed" }
    }
}

Even when using the code you provided, applying both @transactional and @logging annotations on a method results in only @transactional being applied, and the @logging AOP is not applied.

The @logging AOP only works when @order is also added to the code you provided.

Is this really an issue related to the use of Mono? The same issue occurs even when using coroutines.

@Service
class TargetService() {
    private val log = KotlinLogging.logger { }

    @CoroutineLogging
    @Transactional
    suspend fun coroutineAop(): String {
        delay(100)
        log.info { "aop target method call" }

        return "ok"
    }
}

@Aspect
//@Order(1)
@Component
class LoggingAspect {

    private val log = KotlinLogging.logger {}
    @Around("@annotation(com.example.aopwithtransaction.aop.CoroutineLogging)")
    fun coroutineLogging(joinPoint: ProceedingJoinPoint): Any? {
        return joinPoint.runCoroutine {
            log.info { "coroutine logging" }

            val result = joinPoint.proceedCoroutine().let { result ->
                if (result is Mono<*>) {
                    result.awaitSingleOrNull()
                } else {
                    result
                }
            }

            log.info { "Coroutine logging" }
            result
        }
    }
}

fun ProceedingJoinPoint.runCoroutine(
    block: suspend () -> Any?,
): Any? = block.startCoroutineUninterceptedOrReturn(this.coroutineContinuation())

@Suppress("UNCHECKED_CAST")
fun ProceedingJoinPoint.coroutineContinuation(): Continuation<Any?> {
    return this.args.last() as Continuation<Any?>
}

fun ProceedingJoinPoint.coroutineArgs(): Array<Any?> {
    return this.args.sliceArray(0 until this.args.size - 1)
}

suspend fun ProceedingJoinPoint.proceedCoroutine(
    args: Array<Any?> = this.coroutineArgs(),
): Any? = suspendCoroutineUninterceptedOrReturn { continuation ->
    this.proceed(args + continuation)
}

[sdeleuze]

I checked locally with:

@GetMapping("/aop")
    suspend fun aop(): String {
        delay(100)
        return targetService.aop().awaitSingle()
    }

And

@Aspect
@Component
class LoggingAspect {

    private val log = KotlinLogging.logger {}

    @Around("@annotation(com.example.aopwithtransaction.aop.Logging)")
    fun logging(joinPoint: ProceedingJoinPoint): Any? {
        log.info { "Aop Logging started" }
        return (joinPoint.proceed(joinPoint.args) as Mono<*>).doOnTerminate {
            log.info { "Aop Logging completed" }
        }
    }
}

And the logging is working.

[backtony]

@sdeleuze
Thank you for your response.

Since TargetService.aop() is a suspend function, awaitSingle is not possible.

The reason AOP logging is printed in your local environment is probably because the targetService.aop() method did not have @transactional.

When both @transactional and @logging are attached to targetService.aop() as shown below, only @transactional is applied, and AOP for logging is not applied.

Please check the sample I provided again.
https://github.com/backtony/spring-reactive-aop-transaction

@RestController
class AopController(
    private val targetService: TargetService,
) {

    @GetMapping("/aop")
    suspend fun aop(): String {
        return targetService.aop()
    }
}

@Service
class TargetService() {
    private val log = KotlinLogging.logger { }

    @Logging
    @Transactional
    suspend fun aop(): String {
        delay(100)
        log.info { "aop target method call" }

        return "ok"
    }
}

@Aspect
@Component
class LoggingAspect() {

    private val log = KotlinLogging.logger {}

    @Around("@annotation(com.example.aopwithtransaction.aop.Logging)")
    fun logging(joinPoint: ProceedingJoinPoint): Any? {
        log.info { "Aop Logging started" }
        return (joinPoint.proceed(joinPoint.args) as Mono<*>).doOnTerminate {
            log.info { "Aop Logging completed" }
        }
    }
}

result

[sdeleuze]

Thanks for the updated sample, I can indeed reproduce (only with a suspending function, a function returning Mono<String> works as expected).