스프링 AOP 어드바이스 규칙은 종류마다 할 수 있는 일을 좁힌다

트랜잭션처럼 대상 메서드 호출의 앞뒤를 감싸는 부가 기능을 @Around 어드바이스(대상 메서드 호출을 감싸는 부가 기능 메서드)로 쓰다가 proceed() 호출을 빠뜨리면, Spring Boot 4.1.1(Spring Framework 7.0.9) 앱은 정상으로 뜨고 호출도 예외 없이 끝난다. 어드바이스가 찍는 트랜잭션 시작·커밋 로그는 남지만 대상 메서드는 한 번도 실행되지 않고, 예외가 나야 할 호출에서도 예외가 나오지 않는다. 스프링 AOP 어드바이스 규칙에서 대상 호출을 이어 가는 proceed()는 @Around만 받는 ProceedingJoinPoint에 있다. 대상 실행 전에 할 일만 있다면 @Before로 쓰면 되고, @Before에는 빠뜨릴 proceed()가 없다

어드바이스는 다섯 종류이고, 파라미터 규칙이 종류마다 할 수 있는 일의 경계를 긋는다. ProceedingJoinPoint는 @Around만, JoinPoint는 첫 파라미터로만 받고, returning·throwing에 적은 이름은 파라미터 이름과 같아야 한다. @Before·@AfterReturning에서 이 규칙을 어겨 본 세 경우는 7.0.9에서 앱을 멈추지 않고 그 어드바이스만 프록시(대상 대신 호출을 받아 어드바이스를 실행하는 객체)에서 빠졌고, 이유는 기본 로그 수준에서는 보이지 않는 DEBUG 로그에만 남았다. -parameters(메서드 파라미터 이름을 클래스 파일에 남기는 javac 옵션)를 켜고 컴파일했을 때의 결과다

여러 어드바이스가 한 메서드에 걸리면 순서도 따져야 한다. 한 애스펙트(어드바이스와 그것을 붙일 위치를 모은 클래스) 안에서 종류가 다른 어드바이스 사이의 순서는 규칙이 정한다. 같은 종류 둘이나 @Order가 없는 애스펙트 사이의 순서는 문서가 정하지 않고, 7.0.9에서는 메서드 이름이나 @Import에 적은 순서를 따라 감쌌다. 순서가 결과를 바꾸면 애스펙트를 나눠 @Order로 적어 둔다

애스펙트는 부가 기능과 붙일 위치를 모아 고칠 곳을 하나로 만든다

AOP(관점 지향 프로그래밍)는 로그·트랜잭션처럼 여러 클래스에 똑같이 붙는 부가 기능(횡단 관심사)을 핵심 기능 코드에서 떼어 한 모듈에 모으는 방법이고, 그 모듈이 애스펙트다. 애스펙트는 부가 기능 자체인 어드바이스와, 어드바이스를 끼울 조인 포인트를 고르는 포인트컷으로 이뤄진다. 조인 포인트는 어드바이스를 끼울 수 있는 실행 지점인데, 스프링 AOP에서는 늘 메서드 실행이다(AOP Concepts — Spring Framework 7.0 레퍼런스). 스프링 AOP는 실행 중에 대상 빈을 프록시로 바꿔 끼워 애스펙트를 연결한다

강의는 부가 기능을 클래스마다 직접 넣을 때의 가장 큰 문제로 수정을 꼽는다. 100개 클래스에 넣은 부가 기능은 방식을 바꾸거나 적용 범위를 좁힐 때도 100곳을 고쳐야 한다. 부가 기능을 애스펙트로 떼어 내는 이유는 중복을 줄이는 것보다 바꾸기 쉽게 하는 데 있다고 본다. 컨트롤러·서비스·리포지토리 전부에 남기던 로그를 서비스 계층에만 남기도록 좁히는 일이, 포인트컷 식 하나를 고치는 일이 된다

주문 서비스 OrderService가 주문 리포지토리 OrderRepository의 save()를 부르는 강의의 주문 앱을 쓴다. 두 클래스 모두 실행됐다는 로그만 한 줄 찍는다(리포지토리는 상품 ID가 "ex"면 IllegalStateException을 던진다). 애스펙트 AspectV4Pointcut은 주문 패키지(hello.advanced.aop.order)의 모든 메서드에 로그를, 그중 서비스 메서드에만 트랜잭션 흉내(실제 트랜잭션 없이 시작·커밋·롤백·릴리즈 로그만 찍는 어드바이스)를 붙인다. 포인트컷은 Pointcuts 클래스에 모으고, 애스펙트가 그 포인트컷을 패키지까지 적은 전체 이름으로 참조한다

public class Pointcuts {

    //hello.advanced.aop.order 패키지와 하위 패키지
    @Pointcut("execution (* hello.advanced.aop.order..*(..))") //pointcut expression
    public void allOrder(){} //pointcut signature

    //클래스 이름 패턴이 *Service
    @Pointcut("execution (* *..*Service.*(..))")
    public void allService(){}

    //allOrder && allService
    @Pointcut("allOrder() && allService()")
    public void orderAndService(){}
}

@Slf4j
@Aspect
public class AspectV4Pointcut {

    @Around("hello.advanced.aop.order.aop.Pointcuts.allOrder()")
    public Object doLog(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("[log] {}", joinPoint.getSignature());
        return joinPoint.proceed();
    }

    @Around("hello.advanced.aop.order.aop.Pointcuts.orderAndService()")
    public Object doTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
        try {
            log.info("[트랜잭션 시작] {}", joinPoint.getSignature());
            Object result = joinPoint.proceed();
            log.info("[트랜잭션 커밋] {}", joinPoint.getSignature());
            return result;
        } catch (Exception e) {
            log.info("[트랜잭션 롤백] {}", joinPoint.getSignature());
            throw e;
        } finally {
            log.info("[리소스 릴리즈] {}", joinPoint.getSignature());
        }
    }
}

@Pointcut을 붙인 메서드는 본문을 비워 두고, 그 메서드 이름이 식을 대신한다. orderAndService()는 주문 패키지 아래이면서 클래스 이름이 Service로 끝나는 타입의 메서드에 맞는다. 다른 클래스의 포인트컷은 패키지 이름까지 모두 적어 참조하는데, 애노테이션 안의 문자열이라 컴파일러가 확인하지 않는다. @Around 메서드가 받는 ProceedingJoinPoint는 지금 실행 중인 메서드의 시그니처·인수·대상 객체를 담은 정보이고, proceed()로 다음 어드바이스나 대상 메서드를 부른다

테스트 AopTest는 @SpringBootTest로 스프링 컨테이너를 띄우고 @Import로 애스펙트를 빈으로 등록한다. @Aspect만 붙인 클래스는 컴포넌트 스캔 대상이 아니라서 따로 등록해야 한다(Declaring an Aspect — Spring Framework 7.0 레퍼런스). 테스트는 두 빈이 AOP 프록시인지 로그로 찍는 aopInfo, 주문을 한 번 부르는 success, "ex"로 주문해 IllegalStateException이 밖으로 나오는지 단언하는 exception 세 개다. success가 남긴 로그다. [log]·[트랜잭션 …]·[리소스 릴리즈]는 두 어드바이스가, [OrderService]·[OrderRepository]는 대상 메서드가 찍었다

13:28:27.855 [Test worker] AspectV4Pointcut : [log] void hello.advanced.aop.order.OrderService.orderItem(String)
13:28:27.855 [Test worker] AspectV4Pointcut : [트랜잭션 시작] void hello.advanced.aop.order.OrderService.orderItem(String)
13:28:27.855 [Test worker] OrderService : [OrderService] 실행
13:28:27.855 [Test worker] AspectV4Pointcut : [log] String hello.advanced.aop.order.OrderRepository.save(String)
13:28:27.855 [Test worker] OrderRepository : [OrderRepository] 실행
13:28:27.855 [Test worker] AspectV4Pointcut : [트랜잭션 커밋] void hello.advanced.aop.order.OrderService.orderItem(String)
13:28:27.855 [Test worker] AspectV4Pointcut : [리소스 릴리즈] void hello.advanced.aop.order.OrderService.orderItem(String)

서비스 호출은 로그와 트랜잭션 두 어드바이스를 거치고, 리포지토리 호출은 로그 어드바이스만 거쳐 모두 7줄이다. 두 어드바이스가 붙는 범위가 다른 것은 각자 참조한 포인트컷 식, allOrder()와 orderAndService()의 차이뿐이다

필요한 일만 하는 어드바이스를 고르면 proceed()를 빠뜨릴 자리가 없다

어드바이스는 실행되는 시점에 따라 다섯 종류다(Declaring Advice — Spring Framework 7.0 레퍼런스)

  • @Around: 대상 호출을 감싼다. 대상을 부를지, 무엇을 넘기고 돌려줄지, 예외를 어떻게 할지 어드바이스가 정하고 proceed()로 대상을 부른다
  • @Before: 대상 메서드가 실행되기 전에 실행된다
  • @AfterReturning: 대상이 정상으로 반환한 뒤에 실행된다. 반환값을 받을 수 있다
  • @AfterThrowing: 대상이 예외로 끝난 뒤에 실행된다. 그 예외를 받을 수 있다
  • @After: 정상 반환이든 예외든 대상이 끝난 뒤에 실행된다. 주로 리소스를 해제하는 데 쓴다

@Around를 뺀 넷은 대상을 직접 부르지 않고, 스프링이 대상 앞뒤에서 불러 준다. 넷이 받는 JoinPoint는 ProceedingJoinPoint에서 proceed()가 빠진 상위 타입이다. 애스펙트 AspectV6Advice는 서비스에만 맞는 orderAndService()에 네 종류를 하나씩 붙였다

@Slf4j
@Aspect
public class AspectV6Advice {

    // @Around doTransaction(...)은 주석 처리돼 있다

    @Before("hello.advanced.aop.order.aop.Pointcuts.orderAndService()")
    public void doBefore(JoinPoint joinPoint) {
        log.info("[before] {}", joinPoint.getSignature());
    }

    @AfterReturning(value = "hello.advanced.aop.order.aop.Pointcuts.orderAndService()", returning = "result")
    public void doReturn(JoinPoint joinPoint, Object result) {
        log.info("[return] {} return={}", joinPoint.getSignature(), result);
    }

    @AfterThrowing(value = "hello.advanced.aop.order.aop.Pointcuts.orderAndService()", throwing = "ex")
    public void doThrowing(JoinPoint joinPoint, Exception ex) {
        log.info("[ex] {} messaging={}", ex, ex.getMessage());
    }

    @After(value = "hello.advanced.aop.order.aop.Pointcuts.orderAndService()")
    public void doAfter(JoinPoint joinPoint) {
        log.info("[after] {}", joinPoint.getSignature());
    }
}

강의에서 @Around 하나로 모든 일을 할 수 있어도 필요한 일만 할 수 있는 종류를 고르라고 배웠다. 좋은 설계에는 제약이 있고, 그 제약이 실수를 미리 막는다는 설명이다. 레퍼런스는 요구를 채우는 가장 약한 형태의 어드바이스를 쓰라고 권하며, before 어드바이스로 충분하면 around 어드바이스를 쓰지 말라는 예를 든다. ProceedingJoinPoint는 @Around에서만 받는다는 파라미터 규칙이 곧 나머지 종류의 제약이다. @Before는 proceed()를 쥐지 않아 대상 호출을 빠뜨릴 수 없고, 코드를 읽는 쪽도 doBefore를 실행 전에만 무언가 하는 코드로 좁혀 읽을 수 있다

주석 처리된 트랜잭션 어드바이스 doTransaction을 되살리면서 proceed() 호출만 빼고 돌렸다. 이 호출을 실수로 빠뜨리면 대상을 부르지 않는다고 강의가 짚은 코드다

@Around("hello.advanced.aop.order.aop.Pointcuts.orderAndService()")
public Object doTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
    try {
        log.info("[트랜잭션 시작] {}", joinPoint.getSignature());
        Object result = null; // joinPoint.proceed();
        log.info("[트랜잭션 커밋] {}", joinPoint.getSignature());
        return result;
    } catch (Exception e) {
        // ... 롤백 로그를 찍고 다시 던진다
    } finally {
        // ... 리소스 릴리즈 로그
    }
}

success가 남긴 로그 전부다

13:29:03.296 [Test worker] AspectV6Advice : [트랜잭션 시작] void hello.advanced.aop.order.OrderService.orderItem(String)
13:29:03.296 [Test worker] AspectV6Advice : [트랜잭션 커밋] void hello.advanced.aop.order.OrderService.orderItem(String)
13:29:03.296 [Test worker] AspectV6Advice : [리소스 릴리즈] void hello.advanced.aop.order.OrderService.orderItem(String)

트랜잭션 줄 셋이 찍혔으니 doTransaction은 프록시에 들어가 실행됐다. 그런데 대상 메서드가 찍는 [OrderService]·[OrderRepository] 줄도, doTransaction이 감싸는 [before]·[return]·[after] 줄도 없다. proceed()를 부르지 않는 @Around는 프록시에서 빠지지 않고 그대로 들어가, 대상 메서드와 안쪽 어드바이스를 하나도 부르지 않았다. 정상 주문 호출은 예외 없이 끝났고, "ex"로 주문해 예외가 나야 할 exception에서도 같은 세 줄만 찍힌 채 예외가 나오지 않아 그 테스트가 실패했다

레퍼런스는 proceed()를 한 번 부르든 여러 번 부르든 부르지 않든 모두 허용된다고 적는다. 캐시에 값이 있으면 대상을 부르지 않고 그 값을 돌려주는 어드바이스가 그런 예다. 스프링은 proceed()가 없는 @Around를 오류로 다루지 않는다

doTransaction이 ProceedingJoinPoint 대신 JoinPoint를 받게 바꿔도 결과가 같았다. JoinPoint에는 proceed()가 없으니 대상을 부를 방법이 없는 코드다. 레퍼런스는 around 어드바이스의 첫 파라미터가 ProceedingJoinPoint여야 한다(must)고 적지만, 7.0.9는 이 메서드를 그대로 어드바이스로 받아들였다. 어드바이스 메서드를 읽는 로거를 DEBUG로 켜 둔 실험의 시작 로그 한 줄과, 이어진 success 로그다

13:29:05.051 [Test worker] ReflectiveAspectJAdvisorFactory : Found AspectJ method: public java.lang.Object hello.advanced.aop.order.aop.AspectV6Advice.doTransaction(org.aspectj.lang.JoinPoint) throws java.lang.Throwable
13:29:05.739 [Test worker] AspectV6Advice : [트랜잭션 시작] void hello.advanced.aop.order.OrderService.orderItem(String)
13:29:05.739 [Test worker] AspectV6Advice : [트랜잭션 커밋] void hello.advanced.aop.order.OrderService.orderItem(String)
13:29:05.739 [Test worker] AspectV6Advice : [리소스 릴리즈] void hello.advanced.aop.order.OrderService.orderItem(String)

첫 줄은 스프링이 doTransaction(JoinPoint)를 어드바이스 메서드로 찾았다는 뜻이고, 이 메서드를 건너뛰었다는 줄은 시작 로그에 없었다. 아래에서 볼 다른 규칙 위반은 그 어드바이스를 프록시에서 빼는데, 이 경우는 프록시에 들어가 대상을 부르지 않는다

@Before·@AfterReturning이 파라미터 규칙을 어기면 앱은 뜨고 그 어드바이스만 빠진다

어드바이스 메서드의 파라미터에는 강의가 규칙으로 짚은 셋이 있다

  • ProceedingJoinPoint는 @Around만 받는다. 다른 종류는 JoinPoint를 받는다
  • JoinPoint는 받는다면 첫 파라미터로 받는다
  • returning·throwing에 적은 이름은 반환값·예외를 받을 파라미터 이름과 같아야 한다

셋째 규칙이 있는 것은 스프링이 반환값·예외를 그 이름의 파라미터에 넣기 때문이다. 스프링은 클래스 파일에 남은 파라미터 이름으로 이 짝을 맞추는데, Spring Boot Gradle 플러그인은 모든 Java 컴파일에 -parameters를 넣고(Spring Boot Gradle Plugin — Reacting to the Java Plugin), Maven의 spring-boot-starter-parent도 이 옵션으로 컴파일해(Spring Boot Maven Plugin — Using the Plugin) 그 이름을 남긴다

Boot는 AspectJ(자바용 AOP 프레임워크) 라이브러리가 클래스패스에 있으면 자동 프록시 생성기를 켠다(Aspect-Oriented Programming — Spring Boot 4.1). 생성기는 빈으로 등록된 애스펙트의 어드바이스 메서드마다 어드바이저(어드바이스 하나와 포인트컷 하나를 묶은 스프링 AOP의 단위)를 하나씩 만들고, 포인트컷에 맞는 빈을 프록시로 바꾼다. 생성기가 빈을 프록시로 바꾸는 과정은 빈 후처리기를 다룬 앞 편에서 다뤘다

AspectV6Advice에서 규칙을 하나씩 어기고 다시 돌렸다. 셋째 규칙은 returning 쪽만 어겨 봤고 throwing 쪽은 실행하지 않았다. 이 애스펙트의 어드바이스는 모두 서비스에만 맞아서 리포지토리 빈은 프록시가 아니다. 표의 마지막 칸은 관측용 테스트(같은 설정으로 컨테이너를 띄우고 서비스 빈의 프록시에서 어드바이저를 꺼내 바깥부터 적는 테스트)로 본 서비스 프록시다. 표는 -parameters를 켜고 컴파일한 결과다. 같은 위반을 담은 확인용 클래스를 이 옵션 없이 컴파일하자 스프링이 파라미터 이름을 추측해, 이름이 다른 returning에는 어드바이스가 붙었고 JoinPoint를 둘째에 둔 경우는 AmbiguousBindingException으로 멈췄다

바꾼 것success에 찍힌 어드바이스 로그서비스 프록시에 든 어드바이스(바깥부터)
바꾸지 않음[before], [return], [after]doBefore, doAfter, doReturn, doThrowing
doBefore의 파라미터를 ProceedingJoinPoint로[return], [after]doAfter, doReturn, doThrowing
doReturn(Object result, JoinPoint joinPoint)로 순서를 바꿈[before], [after]doBefore, doAfter, doThrowing
doReturn의 파라미터 이름만 res로 바꿈(returning = "result"는 그대로)[before], [after]doBefore, doAfter, doThrowing

세 경우 모두 스프링 컨테이너가 떴고 주문 호출도 끝났다. 규칙을 어긴 메서드만 프록시에서 빠지고, 나머지 어드바이스는 그대로 실행됐다. 세 조건의 시작 로그에서 스프링이 그 어드바이스를 건너뛰며 남긴 DEBUG 줄을 차례로 모았다

13:29:11.788 [Test worker] ReflectiveAspectJAdvisorFactory : Ignoring incompatible advice method: public void hello.advanced.aop.order.aop.AspectV6Advice.doBefore(org.aspectj.lang.ProceedingJoinPoint)
java.lang.IllegalArgumentException: ProceedingJoinPoint is only supported for around advice
13:29:14.031 [Test worker] AspectJExpressionPointcut : Pointcut parser rejected expression [hello.advanced.aop.order.aop.Pointcuts.orderAndService()]: java.lang.IllegalArgumentException: error at ::0 formal unbound in pointcut 
13:29:16.101 [Test worker] ReflectiveAspectJAdvisorFactory : Ignoring incompatible advice method: public void hello.advanced.aop.order.aop.AspectV6Advice.doReturn(org.aspectj.lang.JoinPoint,java.lang.Object)
java.lang.IllegalStateException: Returning argument name 'result' was not bound in advice arguments

Ignoring incompatible advice method는 어드바이스를 만들다 예외가 나 그 메서드를 건너뛰었다는 줄이고, 다음 줄이 그 예외다. 실제 시작 로그에서는 이 줄들 앞에 그 애스펙트의 Found AspectJ method 줄이, 예외 줄 아래에는 스택 트레이스가 이어진다. 7.0.9의 ReflectiveAspectJAdvisorFactory는 어드바이저를 만들다 IllegalArgumentException이나 IllegalStateException이 나면 DEBUG 로그를 남기고 그 메서드의 어드바이저를 만들지 않는다(ReflectiveAspectJAdvisorFactory.java — Spring Framework v7.0.9 소스)

JoinPoint를 둘째에 둔 경우는 포인트컷 식이 맞는데도 Pointcut parser rejected expression 줄이 남았다. 스프링 AOP는 @Aspect·@Around 같은 AspectJ의 애노테이션을 쓰고 포인트컷 식의 해석·매칭도 AspectJ 라이브러리에 맡기는데(AOP with @AspectJ — Spring Framework 7.0 레퍼런스), 이 줄은 그 해석이 실패했다는 뜻이다. 7.0.9는 첫 파라미터만 JoinPoint인지 보고, 나머지 가운데 returning 이름이 아닌 것은 포인트컷 식에서 값을 받을 파라미터로 넘긴다(AbstractAspectJAdvice.java — Spring Framework v7.0.9 소스). 둘째 자리의 joinPoint가 그런 파라미터가 됐는데 식에는 그 값을 채울 곳이 없어, AspectJ 해석기가 formal unbound in pointcut으로 거부한 것으로 읽힌다

포인트컷을 참조하는 이름을 틀려도 같은 방식으로 빠진다. AspectV4Pointcut의 doTransaction이 참조하는 orderAndService()를 orderAndServic()로 한 글자 틀리자, 앱은 떴고 서비스 프록시에는 doLog만 남아 success 로그에서 트랜잭션 줄 셋이 사라졌다. 시작 로그에는 다음 한 줄이 남았다

13:28:51.009 [Test worker] AspectJExpressionPointcut : Pointcut parser rejected expression [hello.advanced.aop.order.aop.Pointcuts.orderAndServic()]: java.lang.IllegalArgumentException: error at ::0 can't find referenced pointcut orderAndServic

AspectJExpressionPointcut은 식을 해석하다 예외가 나면 이렇게 DEBUG 로그를 남기고, 그 포인트컷이 어느 클래스에도 맞지 않는다고 답한다(AspectJExpressionPointcut.java — Spring Framework v7.0.9 소스). 그래서 doTransaction 어드바이저는 어느 빈의 프록시에도 들어가지 않았다

강의 당시 판인 Spring Boot 2.5 계열은 Spring 5.3을 쓰는데, 5.3.12에서는 이런 위반이 어드바이스를 붙이는 단계에서 예외를 냈다(대상 객체에 애스펙트를 붙이는 AspectJProxyFactory로 확인했다). 스프링은 해석에 실패한 포인트컷을 6.1.8·5.3.36부터(gh-32838), 만들 수 없는 어드바이스를 6.1.9·5.3.37부터(gh-32882) DEBUG 로그만 남기고 건너뛴다

Boot는 기본으로 INFO 이상만 찍으므로 이 DEBUG 줄은 그냥 두면 보이지 않는다(Logging — Spring Boot 4.1). 실험에서는 테스트 로그 설정으로 두 로거만 DEBUG로 켰고, Boot 앱이라면 application.properties에 다음처럼 줄 수 있다

logging.level.org.springframework.aop.aspectj.annotation.ReflectiveAspectJAdvisorFactory=debug
logging.level.org.springframework.aop.aspectj.AspectJExpressionPointcut=debug

ReflectiveAspectJAdvisorFactory는 건너뛴 어드바이스 메서드를, AspectJExpressionPointcut은 해석하지 못한 식을 남긴다. 앞 로거는 찾은 어드바이스 메서드마다 Found AspectJ method 줄도 남겨, 기대한 메서드가 목록에 있는지 함께 볼 수 있다. 애스펙트를 빈으로 등록하지 않으면 이 줄조차 없다. 처음 만든 애스펙트 AspectV1(주문 패키지 전체에 로그 @Around 하나)의 테스트에서 @Import를 빼고 돌리자 두 빈 모두 프록시가 아니었고, 두 로거가 남긴 줄은 0줄이었다. 프록시에 실제로 든 어드바이저를 꺼내 보는 방법은 ProxyFactory를 다룬 앞 편에서 다뤘다

규칙을 어겨 빠진 어드바이스와 헷갈리기 쉬운 것이 반환 타입이 맞지 않아 불리지 않는 어드바이스다. 레퍼런스는 returning으로 받는 파라미터의 타입이 반환값과 맞는 실행에만 어드바이스가 실행된다고 적는다. 주문 패키지 전체에 맞는 allOrder()에 @AfterReturning 셋을 더해 돌렸다. 반환값을 doReturnObject는 Object로, doReturnString은 String으로, doReturnInteger는 Integer로 받는다. 앞의 두 줄은 success에서 리포지토리 save()가 String을 돌려준 뒤 찍힌 줄이고, 마지막 줄은 관측용 테스트로 본 리포지토리 프록시다

13:29:07.933 [Test worker] AspectV6Advice : [ret-string] String hello.advanced.aop.order.OrderRepository.save(String) return=ok
13:29:07.934 [Test worker] AspectV6Advice : [ret-object] String hello.advanced.aop.order.OrderRepository.save(String) return=ok
13:29:07.963 [Test worker] Post07ProbeTest : PROBE chain orderRepository=[Expose,AspectV6Advice.doReturnInteger@AfterReturning,AspectV6Advice.doReturnObject@AfterReturning,AspectV6Advice.doReturnString@AfterReturning]

Expose는 ExposeInvocationInterceptor를 줄여 적은 것으로, 체인(프록시가 차례로 부르는 어드바이저 목록)에 AspectJ 어드바이스가 하나라도 들면 스프링이 지금의 호출 정보를 뒤의 어드바이스가 꺼내 쓸 수 있도록 맨 앞에 끼우는 인터셉터다(AspectJProxyUtils.java — Spring Framework v7.0.9 소스). Integer로 받는 doReturnInteger는 리포지토리 프록시에 들어 있지만 save()에서는 불리지 않았다. 반환값의 타입은 호출할 때마다 확인해 거르기 때문이다. 규칙을 어긴 어드바이스가 프록시에 아예 없는 것과 다르다

한 애스펙트 안에서 종류가 다른 어드바이스의 순서는 규칙이 정한다

AspectV6Advice의 doTransaction을 이번에는 proceed()를 부르는 원래 모양으로 되살려 다섯 종류를 함께 돌렸다. success 로그와, 관측용 테스트가 같은 서비스 프록시를 적은 줄이다

13:29:01.032 [Test worker] AspectV6Advice : [트랜잭션 시작] void hello.advanced.aop.order.OrderService.orderItem(String)
13:29:01.032 [Test worker] AspectV6Advice : [before] void hello.advanced.aop.order.OrderService.orderItem(String)
13:29:01.032 [Test worker] OrderService : [OrderService] 실행
13:29:01.032 [Test worker] OrderRepository : [OrderRepository] 실행
13:29:01.033 [Test worker] AspectV6Advice : [return] void hello.advanced.aop.order.OrderService.orderItem(String) return=null
13:29:01.033 [Test worker] AspectV6Advice : [after] void hello.advanced.aop.order.OrderService.orderItem(String)
13:29:01.033 [Test worker] AspectV6Advice : [트랜잭션 커밋] void hello.advanced.aop.order.OrderService.orderItem(String)
13:29:01.033 [Test worker] AspectV6Advice : [리소스 릴리즈] void hello.advanced.aop.order.OrderService.orderItem(String)
13:29:01.065 [Test worker] Post07ProbeTest : PROBE chain orderService=[Expose,AspectV6Advice.doTransaction@Around,AspectV6Advice.doBefore@Before,AspectV6Advice.doAfter@After,AspectV6Advice.doReturn@AfterReturning,AspectV6Advice.doThrowing@AfterThrowing]

들어갈 때는 Around([트랜잭션 시작]), Before 순이고, 대상이 끝난 뒤에는 AfterReturning([return]), After, 다시 Around(커밋·릴리즈) 순이다. 예외가 나는 exception에서는 [return] 자리에 [ex]가, 커밋 자리에 롤백이 찍히고 나머지 순서는 같았다. 레퍼런스가 정한 순서 그대로다. 같은 애스펙트에서 같은 조인 포인트에 걸린 어드바이스는 Around, Before, After, AfterReturning, AfterThrowing 순으로 우선순위가 높고, 우선순위가 높을수록 들어갈 때 먼저, 나올 때 나중에 실행된다. 다만 After는 finally처럼 실행돼 AfterReturning·AfterThrowing 뒤에 불린다(Advice Ordering — Spring Framework 7.0 레퍼런스). 체인에서는 doAfter가 doReturn보다 바깥인데 로그는 [return] 다음에 [after]가 찍힌 것이 그 모습이다

같은 종류 어드바이스의 순서는 문서가 정하지 않는다

로그와 트랜잭션을 한 애스펙트의 @Around 둘로 둔 AspectV4Pointcut에서는 첫 절의 로그처럼 [log]가 [트랜잭션 시작]보다 먼저 찍혔다. 레퍼런스는 한 애스펙트에 같은 종류 어드바이스가 둘이면 순서가 정해지지 않는다고 적는다. javac로 컴파일한 클래스에서는 소스에 선언한 순서를 리플렉션으로 알 수 없어서다. 그런데 7.0.9에서 돌려 보면 순서가 메서드 이름을 따라갔다. 세 조건의 결과다

조건서비스 프록시의 어드바이저(바깥부터)success 첫 줄
AspectV4Pointcut 그대로doLog, doTransaction[log]
doLog에 @Order(2), doTransaction에 @Order(1)을 붙임doLog, doTransaction[log]
doLog의 이름만 writeLog로 바꿈doTransaction, writeLog[트랜잭션 시작]

메서드에 붙인 @Order는 순서를 바꾸지 못했고, 이름만 바꾸자 트랜잭션이 바깥으로 갔다. 이름을 바꾼 조건의 success 로그다

13:28:49.362 [Test worker] AspectV4Pointcut : [트랜잭션 시작] void hello.advanced.aop.order.OrderService.orderItem(String)
13:28:49.363 [Test worker] AspectV4Pointcut : [log] void hello.advanced.aop.order.OrderService.orderItem(String)
13:28:49.363 [Test worker] OrderService : [OrderService] 실행
13:28:49.363 [Test worker] AspectV4Pointcut : [log] String hello.advanced.aop.order.OrderRepository.save(String)
13:28:49.363 [Test worker] OrderRepository : [OrderRepository] 실행
13:28:49.363 [Test worker] AspectV4Pointcut : [트랜잭션 커밋] void hello.advanced.aop.order.OrderService.orderItem(String)
13:28:49.363 [Test worker] AspectV4Pointcut : [리소스 릴리즈] void hello.advanced.aop.order.OrderService.orderItem(String)

앞에서 본 7.0.9의 ReflectiveAspectJAdvisorFactory 소스는 애스펙트의 어드바이스 메서드를 종류 순으로, 같은 종류 안에서는 메서드 이름 순으로 정렬해 어드바이저를 만든다. 이 애스펙트에서 로그가 먼저인 것은 문자열 순서로 doLog가 doTransaction보다 앞이어서다. 같은 소스의 주석은 JVM을 다시 띄워도 순서가 같도록 일부러 고정한 것이라고 적지만, 레퍼런스는 여전히 정해지지 않았다고 적는다. 메서드 이름으로 순서를 맞추는 코드는 문서가 약속하지 않은 동작에 기대는 셈이다

순서가 결과를 바꾸면 애스펙트를 나눠 @Order를 붙인다

순서가 필요한 예로 강의는 트랜잭션을 먼저 실행하고 그다음에 로그를 찍어야 하는 경우를 들고, 두 어드바이스를 서로 다른 애스펙트 클래스로 나눠 클래스에 @Order를 붙이는 방법을 보였다. @Order는 애스펙트 클래스 단위로만 통하기 때문이다(메서드에 붙인 @Order는 앞 절에서 순서를 바꾸지 못했다). 레퍼런스는 같은 종류 어드바이스를 한 메서드로 합치거나, 애스펙트를 나눠 Ordered나 @Order로 순서를 정하라고 권한다. AspectV5Order는 두 애스펙트를 중첩 클래스로 둔다

@Slf4j
public class AspectV5Order {

    @Aspect
    @Order(2)
    public static class LogAspect {
        @Around("hello.advanced.aop.order.aop.Pointcuts.allOrder()")
        public Object doLog(ProceedingJoinPoint joinPoint) throws Throwable {
            log.info("[log] {}", joinPoint.getSignature());
            return joinPoint.proceed();
        }
    }

    @Aspect
    @Order(1)
    public static class TxAspect {
        @Around("hello.advanced.aop.order.aop.Pointcuts.orderAndService()")
        public Object doTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
            // ... AspectV4Pointcut의 doTransaction과 같다
        }
    }
}

@Order 값이 작은 애스펙트가 우선순위가 높아 바깥에서 감싼다. 테스트는 @Import({AspectV5Order.LogAspect.class, AspectV5Order.TxAspect.class})로 두 애스펙트를 등록한다. 숫자를 서로 바꾸고, @Order를 둘 다 빼고, 뺀 상태에서 @Import 배열 순서만 바꿔 돌렸다

조건서비스 프록시의 어드바이저(바깥부터)success 첫 줄
AspectV5Order 그대로(TxAspect 1, LogAspect 2)TxAspect.doTransaction, LogAspect.doLog[트랜잭션 시작]
숫자를 바꿈(LogAspect 1, TxAspect 2)LogAspect.doLog, TxAspect.doTransaction[log]
@Order를 둘 다 뺌LogAspect.doLog, TxAspect.doTransaction[log]
@Order 없이 @Import 배열만 TxAspect, LogAspect 순으로TxAspect.doTransaction, LogAspect.doLog[트랜잭션 시작]

@Order가 있으면 숫자대로 감쌌다. @Order가 없을 때 레퍼런스는 서로 다른 애스펙트의 순서도 정해지지 않는다고 적는데, 이 실행에서는 @Import에 적은 차례대로 감쌌고 배열 순서만 바꿔도 뒤집혔다. 컴포넌트 스캔으로 등록한 애스펙트끼리의 순서는 확인하지 않았다

순서가 결과를 바꾸는 어드바이스라면, 지금 원하는 순서로 찍히더라도 애스펙트를 나눠 @Order로 적어 두는 것이 맞다고 본다. 7.0.9에서는 같은 애스펙트의 @Around 둘이 메서드 이름 순으로 감싸서, 이름만 바꿔도 순서가 뒤집혔다


출처와 범위

인프런 김영한님의 「스프링 핵심 원리 – 고급편」 강의를 듣고, 강의를 따라 만든 예제를 Spring Boot 4.1.1(Spring Framework 7.0.9, Tomcat 11.0.24)과 Java 25로 옮겨 실행하며 썼다. 실험은 조건마다 애스펙트나 테스트 코드 몇 줄을 바꾼 뒤, AopTest와 관측용 테스트(AopTest를 상속해 같은 설정으로 띄우고 Advised.getAdvisors()로 프록시의 어드바이저를 바깥부터 적는다)를 Gradle로 한 번씩 돌렸다. 판에 따른 결과와 -parameters를 끈 결과는 확인용 클래스 하나를 spring-aop 5.3.12·6.1.8·6.1.9·7.0.9에서 AspectJProxyFactory로 돌려 얻었다. 2026년 11월 15일 기준 공식 문서·스프링 소스·이슈 대조, 비교 실험 스크립트와 확인용 코드 작성, 원고 정리에 AI(Claude)를 썼다

참고 자료