스프링 AOP 포인트컷 지시자가 클래스만 보고 답하지 못하면 그 빈은 일단 프록시가 된다

스프링 AOP 포인트컷 지시자(포인트컷 표현식에서 execution·within·@target처럼 메서드를 고르는 기준을 정하는 키워드)를 쓸 때는 보통 무엇으로 고를지부터 정한다. 메서드 시그니처면 execution, 타입이면 within, 애노테이션이면 @within·@target·@annotation, 인수면 args다. 그런데 같은 애노테이션을 보는 @within과 @target도 고르는 메서드가 다르고, execution으로 좁힌 범위를 지우면 @target 쪽만 Boot 테스트의 스프링 컨테이너를 띄우지 못했다. 강의에서 배운 것은 지시자를 한 가지 기준으로 더 나눠 보는 법이다. 지시자는 무엇을 보고 고르는지와 함께, 그 정보를 클래스·메서드 선언에서 읽는지 실행 중인 객체에서 읽는지로 나뉜다

이 구분은 스프링이 빈을 프록시(대상 빈 대신 호출을 받아 앞뒤에서 어드바이스를 실행하는 객체)로 만들지 정하는 단계까지 이어진다. 스프링은 빈을 만들 때 그 빈에 맞을 수 있는 포인트컷이 있는지 클래스만 보고 묻는다. 실행 중인 객체나 인수를 봐야 정해지는 지시자는 이 질문에 답하지 못할 때가 있고, 그러면 스프링은 그 빈을 일단 프록시로 만든다. Spring Boot 4.1.1(Spring Framework 7.0.9)에서 execution으로 패키지를 좁힌 @target 어드바이스는 애스펙트를 뺀 범위 안 빈 6개를 모두 프록시로 만들었다. 그중 애노테이션이 붙은 빈은 2개다. 범위를 지운 @target·@args·args는 Boot가 등록하는 final 클래스의 빈을 프록시로 만들지 못해 시작이 멈췄다

파라미터 타입으로 고를 때 execution은 선언된 타입만, args는 넘어온 인수의 상위 타입까지 맞춘다

지시자를 시험할 대상은 강의에서 만든 회원 서비스다. 인터페이스 MemberService와 구현 클래스 MemberServiceImpl이 있고, 구현 클래스에는 인터페이스 메서드 hello(String) 말고 자기만 가진 internal(String)이 하나 더 있다. 클래스에는 @ClassAop, hello()에는 @MethodAop("test value")가 붙는데, 둘 다 실행 중에도 읽을 수 있도록(RetentionPolicy.RUNTIME) 만든 표시용 애노테이션이다

@ClassAop
@Component
public class MemberServiceImpl implements MemberService {

    @Override
    @MethodAop("test value")
    public String hello(String param) {
        return "ok";
    }

    public String internal(String param) {
        return "ok";
    }
}

강의는 스프링 AOP에서 가장 많이 쓰는 지시자로 execution을 꼽는다. execution·within·args의 규칙은 스프링 컨테이너 없이 확인한다. 테스트는 AspectJExpressionPointcut(AspectJ 포인트컷 표현식을 받아 메서드가 맞는지 판정하는 스프링 클래스)에 식을 넣고, 리플렉션으로 꺼낸 hello(String)의 Method와 MemberServiceImpl 클래스를 넘겨 matches()로 묻는다. execution이 맞추는 재료는 이 메서드의 선언 정보다. ExecutionTest가 찍은 Method 문자열이다

13:56:26.658 INFO  [Test worker] ExecutionTest : helloMethod=public java.lang.String hello.advanced.aop.member.MemberServiceImpl.hello(java.lang.String)

접근 제어자, 반환 타입, 패키지를 포함한 선언 타입, 메서드 이름, 파라미터 타입이 차례로 보인다. execution 식도 이 순서로 적고, 반환 타입·이름·파라미터를 뺀 나머지는 생략할 수 있다(Declaring a Pointcut — Spring Framework 7.0 레퍼런스). 테스트 세 클래스가 확인하는 규칙이고, 모두 통과했다

테스트확인하는 규칙결과
ExecutionTest이름·패키지의 * 패턴과 생략, 패키지의 .은 그 패키지만·..은 하위 패키지까지, 부모 타입 MemberService를 적으면 부모에 선언된 hello()만 맞고 internal()은 맞지 않음21개 통과
WithinTestwithin은 선언 타입이 정확히 맞아야 해서 부모 타입 MemberService를 적으면 맞지 않음(같은 자리의 execution은 맞음)5개 통과
ArgsTestargs는 Object·java.io.Serializable처럼 인수의 상위 타입도 맞고, execution은 선언 타입 String과 같아야 맞음2개 통과

execution과 within은 메서드와 타입의 선언을 읽는다. args는 실행 중에 넘어온 인수를 보는 지시자라, 인수의 상위 타입을 적어도 맞는다. 같은 레퍼런스가 java.io.Serializable로 이 대비를 든다. args(java.io.Serializable)은 실행 중에 넘어온 인수가 Serializable이면 맞고, execution(* *(java.io.Serializable))은 메서드가 Serializable 파라미터 하나를 선언했을 때만 맞는다

같은 애노테이션을 봐도 @target은 부모 클래스에서 물려받은 메서드까지 고르고 @within은 고르지 않는다

@within과 @target은 둘 다 클래스에 붙은 애노테이션으로 고른다. @within은 그 애노테이션이 붙은 타입에 선언된 메서드만 고르고, @target은 실행 중인 객체의 클래스에 애노테이션이 있으면 그 객체가 부모 클래스에서 물려받은 메서드까지 고른다. 실제 객체가 있어야 드러나는 차이라 이 둘은 스프링 컨테이너를 띄워 시험한다. AtTargetAtWithinTest는 부모 클래스 Parent와 @ClassAop가 붙은 자식 클래스 Child로 확인한다. 테스트 안의 설정 클래스 Config가 Parent·Child와 애스펙트를 빈으로 등록하고, 두 어드바이스는 모두 execution으로 범위를 hello.advanced.aop 패키지 아래로 좁힌다

@Slf4j
@Import({AtTargetAtWithinTest.Config.class})
@SpringBootTest
public class AtTargetAtWithinTest {

    @Autowired
    Child child;

    @Test
    void success() {
        log.info("child Proxy={}", child.getClass());
        child.childMethod(); //부모, 자식 모두 있는 메서드
        child.parentMethod(); //부모 클래스만 있는 메서드
    }

    static class Config {
        // @Bean으로 Parent, Child, AtTargetAtWithinAspect를 하나씩 등록한다
    }

    static class Parent {
        public void parentMethod() {
        }
    }

    @ClassAop
    static class Child extends Parent {
        public void childMethod() {
        }
    }

    @Slf4j
    @Aspect
    static class AtTargetAtWithinAspect {

        @Around("execution(* hello.advanced.aop..*(..)) && @target(hello.advanced.aop.member.annotation.ClassAop)")
        public Object atTarget(ProceedingJoinPoint joinPoint) throws Throwable {
            log.info("[@target] {}", joinPoint.getSignature());
            return joinPoint.proceed();
        }

        @Around("execution(* hello.advanced.aop..*(..)) && @within(hello.advanced.aop.member.annotation.ClassAop)")
        public Object atWithin(ProceedingJoinPoint joinPoint) throws Throwable {
            log.info("[@within] {}", joinPoint.getSignature());
            return joinPoint.proceed();
        }
    }
}

이 코드 그대로 돌린 테스트 로그다. 첫 줄은 주입받은 child의 클래스이고, 나머지는 두 어드바이스가 찍었다

13:56:33.683 INFO  [Test worker] AtTargetAtWithinTest : child Proxy=class hello.advanced.aop.pointcut.AtTargetAtWithinTest$Child$$SpringCGLIB$$0
13:56:33.684 INFO  [Test worker] AtTargetAtWithinTest$AtTargetAtWithinAspect : [@target] void hello.advanced.aop.pointcut.AtTargetAtWithinTest$Child.childMethod()
13:56:33.684 INFO  [Test worker] AtTargetAtWithinTest$AtTargetAtWithinAspect : [@within] void hello.advanced.aop.pointcut.AtTargetAtWithinTest$Child.childMethod()
13:56:33.684 INFO  [Test worker] AtTargetAtWithinTest$AtTargetAtWithinAspect : [@target] void hello.advanced.aop.pointcut.AtTargetAtWithinTest$Parent.parentMethod()

childMethod()에는 두 어드바이스가 모두, 부모에서 물려받은 parentMethod()에는 @target만 실행됐다. parentMethod()는 애노테이션이 없는 Parent에 선언돼 있어 클래스 선언을 읽는 @within에는 맞지 않는다. 실행 중인 객체를 보는 @target에는 그 객체가 @ClassAop가 붙은 Child라서 맞는다

빈을 프록시로 만들지는 클래스만 보고 정하고, 정하지 못하면 일단 만든다

실행 중인 객체나 인수를 봐야 정해지는 포인트컷은 프록시가 먼저 있어야 판단할 수 있다는 것을 강의에서 배웠다. 그래서 스프링은 빈을 만들 때 답을 내지 못하면 그 빈을 일단 프록시로 만들고, 어드바이스를 실행할지는 호출 때 정한다. 이 판단이 어디서 이뤄지는지는 스프링 소스에서 볼 수 있다

Boot는 AspectJ 라이브러리가 클래스패스에 있으면 자동 프록시 생성기를 켠다(Aspect-Oriented Programming — Spring Boot 4.1). 생성기는 빈을 만들 때마다 어드바이저(포인트컷 하나와 어드바이스 하나를 묶은 것, @Aspect 클래스의 어드바이스 메서드마다 하나씩 만들어진다)를 차례로 보고, 그 빈에 맞을 수 있는 어드바이저가 하나라도 있으면 프록시를 만든다. 맞을 수 있는지는 AopUtils.canApply()가 정한다. 포인트컷의 클래스 필터를 통과하면 그 클래스의 메서드를 물려받은 것까지 하나씩 matches(Method, Class)로 물어, 하나라도 true면 맞는다고 본다(AopUtils.java — Spring Framework v7.0.9 소스)

이때는 호출이 일어나기 전이라 실제 객체도 인수도 없다. AspectJ가 선언만으로는 알 수 없다(maybe)고 답하면 스프링은 일단 맞는다고 보고, 호출 때 실제 객체와 인수로 다시 묻는다. 다만 this·target·@this·@target·@annotation 검사가 남은 maybe는, 스프링에서는 대상 클래스가 이미 정해져 있으니 그 클래스로 한 번 더 확인해 거른다는 것이 소스 주석의 설명이다(AspectJExpressionPointcut.java — Spring Framework v7.0.9 소스)

지시자마다 이 질문에 어떻게 답하는지 AspectJExpressionPointcut에 식을 직접 묻는 확인용 테스트로 물었다. 애노테이션이 없는 클래스 Plain과 @ClassAop가 붙은 클래스 Marked는 둘 다 선언 타입이 Object인 메서드 accept(Object) 하나만 두었고 MemberService를 구현하지 않는다. 두 클래스에 같은 식으로 matches(Method, Class)를 물었다. 로그에서 static: 뒤가 물은 식이고, plain·marked가 두 클래스에 대한 답이다

13:56:30.878 INFO  [Test worker] Post08ArgsProbeTest : PROBE8 args key=static:@target(ClassAop) result=plain:true,marked:true
13:56:30.879 INFO  [Test worker] Post08ArgsProbeTest : PROBE8 args key=static:@within(ClassAop) result=plain:false,marked:true
13:56:30.880 INFO  [Test worker] Post08ArgsProbeTest : PROBE8 args key=static:@args(ClassAop) result=plain:true,marked:true
13:56:30.881 INFO  [Test worker] Post08ArgsProbeTest : PROBE8 args key=static:args(String) result=plain:true,marked:true
13:56:30.881 INFO  [Test worker] Post08ArgsProbeTest : PROBE8 args key=static:target(MemberService) result=plain:false,marked:false
13:56:30.882 INFO  [Test worker] Post08ArgsProbeTest : PROBE8 args key=static:this(MemberService) result=plain:false,marked:false

@within은 애노테이션이 없는 Plain에 false, Marked에 true로 클래스 선언을 보고 답했다. target(MemberService)·this(MemberService)는 두 클래스 모두 MemberService가 아니어서 false다. @target·@args·args(String)은 애노테이션이 있든 없든 true였다. 셋 다 호출 때 실제 객체나 인수를 봐야 결정되는 검사를 남겼고, 스프링이 그 검사를 클래스로 걸러 내지 않았다는 뜻이다

@target은 앞의 소스 주석이 거른다고 적은 목록에 들어 있는데도 Spring Framework 7.0.9와 aspectjweaver 1.9.25.1에서는 걸러지지 않았다. 소스를 맞춰 읽으면, AspectJ는 @target 검사를 대상 객체를 가리키는 변수에 걸어 두고(ThisOrTargetAnnotationPointcut.java — AspectJ 1.9.25.1 소스) 스프링은 @this·@target·@annotation 전용 변수에 걸린 애노테이션 검사만 대상 클래스로 거른다(RuntimeTestWalker.java — Spring Framework v7.0.9 소스). 실행으로 짚은 원인은 아니고, 의도된 동작인지는 관련 이슈를 찾지 못해 확인하지 못했다

지시자를 무엇을 보는지, 그 정보를 어디서 읽는지, 빈을 만들 때 묻는 질문에 어떻게 답하는지로 나누면 다음과 같다. execution·within·@annotation·bean은 확인용 테스트로 묻지 않았지만 메서드·클래스 선언이나 빈 이름만으로 정해지는 기준이다

지시자고르는 기준정보를 읽는 곳빈을 만들 때
execution메서드 시그니처메서드 선언선언으로 답한다
within메서드가 선언된 타입클래스 선언선언으로 답한다
@within선언 타입에 붙은 애노테이션클래스 선언선언으로 답한다
@annotation메서드에 붙은 애노테이션메서드 선언선언으로 답한다
bean스프링 빈 이름(스프링 AOP 전용)빈 이름빈 이름으로 답한다
this, target프록시 객체, 실제 대상 객체의 타입실행 중인 객체대상 클래스로 확인해 답한다
args넘어온 인수의 타입실행 중에 넘어온 인수Object처럼 넓은 선언 타입에는 답하지 못한다
@args넘어온 인수 객체의 클래스에 붙은 애노테이션실행 중에 넘어온 인수Object처럼 넓은 선언 타입에는 답하지 못한다
@target실행 중인 객체의 클래스에 붙은 애노테이션실행 중인 객체답하지 못한다(7.0.9·aspectjweaver 1.9.25.1에서)

@target 어드바이스는 execution으로 좁혀도 애스펙트를 뺀 범위 안 빈 6개를 모두 프록시로 만들었다

앞의 AtTargetAtWithinTest에서 어떤 빈이 프록시가 됐는지는 테스트 코드와 따로 둔 관측 장치로 셌다. 테스트 컨텍스트가 뜬 직후 이미 만들어진 싱글톤 빈을 훑어, AOP 프록시인 빈을 클래스 이름이 hello로 시작하는 앱 빈(app)과 그 밖의 프레임워크 빈(framework)으로 나눠 세고, 앱 빈마다 프록시 종류(kind)와 그 프록시에 든 AspectJ 포인트컷 식(exprs)을 한 줄씩 남긴다. PROBE8 proxies·PROBE8 bean=으로 시작하는 줄이 이 장치의 줄이다

13:56:33.255 INFO  [Test worker] Post08ProxyCounter : PROBE8 proxies app=6 framework=0 appBeans=child:CGLIB,hello.advanced.aop.pointcut.AtTargetAtWithinTest$Config:CGLIB,memberServiceImpl:CGLIB,orderRepository:CGLIB,orderService:CGLIB,parent:CGLIB
13:56:33.255 INFO  [Test worker] Post08ProxyCounter : PROBE8 bean=child kind=CGLIB target=Child aspectjAdvisors=2 exprs=execution(* hello.advanced.aop..*(..)) && @target(hello.advanced.aop.member.annotation.ClassAop)|execution(* hello.advanced.aop..*(..)) && @within(hello.advanced.aop.member.annotation.ClassAop)
13:56:33.255 INFO  [Test worker] Post08ProxyCounter : PROBE8 bean=hello.advanced.aop.pointcut.AtTargetAtWithinTest$Config kind=CGLIB target=Config aspectjAdvisors=1 exprs=execution(* hello.advanced.aop..*(..)) && @target(hello.advanced.aop.member.annotation.ClassAop)
13:56:33.255 INFO  [Test worker] Post08ProxyCounter : PROBE8 bean=memberServiceImpl kind=CGLIB target=MemberServiceImpl aspectjAdvisors=2 exprs=execution(* hello.advanced.aop..*(..)) && @target(hello.advanced.aop.member.annotation.ClassAop)|execution(* hello.advanced.aop..*(..)) && @within(hello.advanced.aop.member.annotation.ClassAop)
13:56:33.255 INFO  [Test worker] Post08ProxyCounter : PROBE8 bean=orderRepository kind=CGLIB target=OrderRepository aspectjAdvisors=1 exprs=execution(* hello.advanced.aop..*(..)) && @target(hello.advanced.aop.member.annotation.ClassAop)
13:56:33.255 INFO  [Test worker] Post08ProxyCounter : PROBE8 bean=orderService kind=CGLIB target=OrderService aspectjAdvisors=1 exprs=execution(* hello.advanced.aop..*(..)) && @target(hello.advanced.aop.member.annotation.ClassAop)
13:56:33.255 INFO  [Test worker] Post08ProxyCounter : PROBE8 bean=parent kind=CGLIB target=Parent aspectjAdvisors=1 exprs=execution(* hello.advanced.aop..*(..)) && @target(hello.advanced.aop.member.annotation.ClassAop)

이 테스트 컨텍스트에서 hello.advanced.aop 패키지 아래 빈은 7개다. 스캔으로 올라오는 MemberServiceImpl과 애스펙트를 시험하려고 만든 주문 서비스 OrderService·주문 리포지토리 OrderRepository(이 테스트는 부르지 않는다), 그리고 Config와 Config가 등록한 Parent·Child·애스펙트다. 애스펙트 빈은 자동 프록시 생성기가 프록시 대상에서 빼고(AnnotationAwareAspectJAutoProxyCreator.java — Spring Framework v7.0.9 소스), 나머지 6개가 모두 CGLIB 프록시가 됐다. 프레임워크 빈 프록시는 0개다. @ClassAop가 붙은 Child·MemberServiceImpl의 프록시에는 두 어드바이스가 다 들었고, 애노테이션이 없는 나머지 넷에는 @target 어드바이스 하나만 들었다

같은 관측 장치로 본 다른 테스트는 맞는 빈만 프록시로 만들었다. AtAnnotationTest와 BeanTest는 같은 앱 설정에 애스펙트를 하나씩만 더해 등록하고, 포인트컷은 아래 표의 식 하나뿐이다

테스트어드바이스의 포인트컷프록시가 된 앱 빈프레임워크 빈 프록시
AtAnnotationTest@annotation(hello.advanced.aop.member.annotation.MethodAop)memberServiceImpl0개
BeanTestbean(orderService) || bean(*Repository)orderRepository, orderService0개
AtTargetAtWithinTestexecution(...) && @target(...ClassAop), execution(...) && @within(...ClassAop)child, parent, Config, memberServiceImpl, orderService, orderRepository0개

@target 어드바이스가 Parent까지 프록시로 만든 것은 앞 절의 확인용 테스트에서 애노테이션 없는 Plain에 true가 나온 것과 같은 일이다. 늘어난 프록시의 비용(시작 시간, 호출 때마다 하는 판정)은 재지 않았다

범위를 지운 @target·@args·args는 Boot의 final 빈을 프록시로 만들려다 시작을 멈춘다

강의는 args·@args·@target을 단독으로 쓰지 말고 execution 같은 지시자로 대상을 먼저 줄이라고 한다. 스프링이 모든 스프링 빈에 프록시를 만들려 하는데, 스프링 내부 빈 가운데 final 클래스가 있어 오류가 날 수 있다는 이유다. AtTargetAtWithinTest의 @target 어드바이스에서 execution(...) &&만 지웠다

@Around("@target(hello.advanced.aop.member.annotation.ClassAop)")
public Object atTarget(ProceedingJoinPoint joinPoint) throws Throwable {

테스트는 스프링 컨테이너를 띄우지 못해 실패했다. 시작 오류 로그의 첫 예외 줄과, 스택 트레이스 아래쪽의 원인(Caused by) 두 줄이다

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'org.springframework.boot.autoconfigure.AutoConfigurationPackages': Could not generate CGLIB subclass of class org.springframework.boot.autoconfigure.AutoConfigurationPackages$BasePackages: Common causes of this problem include using a final class or a non-visible class
Caused by: org.springframework.aop.framework.AopConfigException: Could not generate CGLIB subclass of class org.springframework.boot.autoconfigure.AutoConfigurationPackages$BasePackages: Common causes of this problem include using a final class or a non-visible class
Caused by: java.lang.IllegalArgumentException: Cannot subclass final class org.springframework.boot.autoconfigure.AutoConfigurationPackages$BasePackages

AutoConfigurationPackages 빈은 Boot가 자동 구성 패키지(@SpringBootApplication이 붙은 클래스의 패키지)를 담아 두는 빈이고, 이 빈의 클래스 AutoConfigurationPackages$BasePackages는 final이다(AutoConfigurationPackages.java — Spring Boot v4.1.1 소스). @target이 이 빈에도 맞을 수 있다고 답해 스프링이 클래스를 상속하는 CGLIB 프록시를 만들려 했고, 상속할 수 없는 final 클래스라 실패했다. 레퍼런스도 final 클래스는 확장할 수 없어서 프록시를 만들 수 없다고 적는다(Proxying Mechanisms — Spring Framework 7.0 레퍼런스). 같은 자리에 args(String)만, @args(hello.advanced.aop.member.annotation.ClassAop)만 두고 돌려도 같은 빈에서 같은 원인으로 멈췄다. 시작이 첫 실패에서 멈추므로, 범위 없는 @target이 프록시로 만들려 한 빈이 모두 몇 개인지는 이 실행으로 셀 수 없었다

소스로 따져 보면, args·@args가 어느 빈에나 걸리는 데는 메서드 하나면 충분하다. 앞의 확인용 테스트에서 둘은 선언 타입이 Object인 accept(Object)에 true였고, canApply()는 클래스가 Object에서 물려받은 메서드까지 묻는다. 모든 클래스가 가진 equals(Object)가 그런 메서드라, 범위를 지운 args·@args는 어느 빈에서나 맞을 수 있다는 답을 받는 셈이다. 앞의 Boot 소스를 보면 처음 멈춘 BasePackages가 직접 선언한 메서드도 인수 없는 get() 하나뿐이라, 이 클래스에서 args(String)·@args가 맞을 수 있는 메서드는 물려받은 equals(Object)다

@within은 다르다. 같은 테스트에서 @target 어드바이스는 원래대로 두고 @within 어드바이스의 execution(...) &&만 지웠다. 관측 장치의 줄 가운데 프록시 수와 Child 줄이다

13:56:39.629 INFO  [Test worker] Post08ProxyCounter : PROBE8 proxies app=6 framework=0 appBeans=child:CGLIB,hello.advanced.aop.pointcut.AtTargetAtWithinTest$Config:CGLIB,memberServiceImpl:CGLIB,orderRepository:CGLIB,orderService:CGLIB,parent:CGLIB
13:56:39.629 INFO  [Test worker] Post08ProxyCounter : PROBE8 bean=child kind=CGLIB target=Child aspectjAdvisors=2 exprs=execution(* hello.advanced.aop..*(..)) && @target(hello.advanced.aop.member.annotation.ClassAop)|@within(hello.advanced.aop.member.annotation.ClassAop)

테스트는 통과했고, 프록시가 된 빈은 원래 코드와 같은 앱 빈 6개, 프레임워크 빈 0개다. Child의 프록시에 범위 없는 @within(...) 식이 들어 있지만, @within은 클래스 선언으로 답하므로 애노테이션이 없는 Boot 빈은 건드리지 않았다. 범위 없이 @annotation 하나만 쓴 AtAnnotationTest와, this·target 지시자만 쓴 ThisTargetTest도 프레임워크 빈 프록시는 0개였다

앞에서 본 레퍼런스 Declaring a Pointcut 문서의 Writing Good Pointcuts 절은 좋은 포인트컷에 execution 같은 종류 지정 지시자와 within 같은 범위 지시자를 함께 넣으라고 권하고, 이유로는 위빙(어드바이스를 대상 코드에 엮는 일) 성능을 든다. 프록시로 동작하는 스프링 AOP에서는 같은 원칙이 어떤 빈을 프록시로 만드느냐로 나타나고, 범위를 빼면 이 앱처럼 시작이 멈출 수 있다. 그래서 포인트컷에는 execution이나 within으로 범위를 먼저 적는 것을 습관으로 둔다. @target을 쓸 때는 좁힌 범위 안의 빈이 애노테이션과 상관없이 모두 프록시가 된다고 보고, 부모 클래스에서 물려받은 메서드까지 고를 필요가 없으면 @within을 쓴다

-parameters도 argNames도 없으면 this·target으로 변수 둘을 묶는 어드바이스에서 시작이 멈춘다

지시자는 메서드를 고르는 데서 그치지 않고 값을 어드바이스로 넘길 수도 있다. args(arg,..)처럼 타입 자리에 이름을 적고 어드바이스 메서드에 같은 이름의 파라미터를 두면, 그 자리의 값이 그 파라미터로 들어온다. 강의가 짚는 규칙은 둘이다. 이름이 맞아야 하고, 넘어오는 값의 타입은 어드바이스 파라미터에 적은 타입으로 제한된다. ParameterTest의 애스펙트는 MemberService가 있는 패키지 아래 모든 메서드를 고르는 포인트컷 allMember()에 이런 어드바이스 8개를 붙였다. 그 일부다

@Pointcut("execution(* hello.advanced.aop.member..*.*(..))")
private void allMember() {}

@Before("allMember() && args(arg,..)")
public void logArgs3(String arg) {
    log.info("[logArgs3] arg={}", arg);
}

@Before("allMember() && this(obj)")
public void thisArgs(JoinPoint joinPoint, MemberService obj) {
    log.info("[this]{}, obj={}", joinPoint.getSignature(), obj.getClass());
}

@Before("allMember() && target(obj)")
public void targetArgs(JoinPoint joinPoint, MemberService obj) {
    log.info("[target]{}, obj={}", joinPoint.getSignature(), obj.getClass());
}

@Before("allMember() && @annotation(annotation)")
public void atAnnotation(JoinPoint joinPoint, MethodAop annotation) {
    log.info("[@annotation]{}, annotationValue={}", joinPoint.getSignature(), annotation.value());
}

// 이 밖에 joinPoint.getArgs()로 인수를 꺼내는 logArgs1, args(arg,..)를 @Around로 받는 logArgs2,
// @target·@within으로 @ClassAop를 받는 어드바이스 둘이 있다

memberService.hello("helloA")를 부르자 8개가 모두 실행됐다. 그중 @annotation·target·this로 받은 값을 찍은 줄이다

13:57:02.952 INFO  [Test worker] ParameterTest$ParameterAspect : [@annotation]String hello.advanced.aop.member.MemberServiceImpl.hello(String), annotationValue=test value
13:57:02.953 INFO  [Test worker] ParameterTest$ParameterAspect : [target]String hello.advanced.aop.member.MemberServiceImpl.hello(String), obj=class hello.advanced.aop.member.MemberServiceImpl
13:57:02.953 INFO  [Test worker] ParameterTest$ParameterAspect : [this]String hello.advanced.aop.member.MemberServiceImpl.hello(String), obj=class hello.advanced.aop.member.MemberServiceImpl$$SpringCGLIB$$0

@annotation으로는 @MethodAop에 적은 값 test value를 꺼냈다. target으로 받은 객체는 MemberServiceImpl이고, this로 받은 객체는 그 클래스를 상속한 CGLIB 프록시 클래스($$SpringCGLIB$$가 붙은 이름)다. this는 스프링 컨테이너에 등록된 프록시를, target은 프록시 뒤의 실제 대상을 가리킨다는 차이가 바인딩한 값에서 보인다

이름을 맞추려면 스프링이 어드바이스 메서드의 파라미터 이름을 알아야 한다. 자바 애스펙트라면 스프링은 애노테이션의 argNames 속성, 컴파일러의 -parameters 옵션이 클래스 파일에 남긴 이름 순으로 찾고, 둘 다 없으면 포인트컷 식과 returning·throwing 절을 보고 추측한다(Determining Argument Names — Spring Framework 7.0 레퍼런스). Boot Gradle 플러그인은 모든 Java 컴파일 작업에 -parameters를 넣는다(Spring Boot Gradle Plugin — Reacting to the Java Plugin). 이 옵션은 build.gradle.kts에 다음 설정을 더해 컴파일 직전에 뺐다

tasks.withType<JavaCompile>().configureEach {
    doFirst { options.compilerArgs.removeAll { it == "-parameters" } }
}

ParameterTest를 옵션을 켜고 끈 두 빌드로 돌렸고, 변수 둘을 함께 묶는 어드바이스를 하나 더해 같은 비교를 했다. 더한 어드바이스다

@Before("allMember() && this(proxy) && target(tgt)")
public void thisAndTarget(JoinPoint joinPoint, Object proxy, Object tgt) {
    log.info("[this+target]{}, proxy={}, target={}", joinPoint.getSignature(), proxy.getClass(), tgt.getClass());
}

표의 마지막 칸은 컴파일된 애스펙트 클래스에서 파라미터 이름 정보(MethodParameters 속성)가 붙은 메서드 수를 javap로 센 값이다

빌드어드바이스결과이름 정보가 붙은 메서드
-parameters 켬(Boot 기본)ParameterTest의 8개통과, 8개 실행8개
-parameters 끔ParameterTest의 8개통과, 8개 실행0개
-parameters 켬8개 + thisAndTarget통과, 9개 실행9개
-parameters 끔8개 + thisAndTarget시작 실패(AmbiguousBindingException)0개
-parameters 끔8개 + argNames를 적은 thisAndTarget통과, 9개 실행0개

이름 정보가 없어도 ParameterTest의 8개는 그대로 돌았다. 어드바이스마다 포인트컷 식에서 값을 받는 변수가 많아야 하나라 스프링의 추측이 맞았다. this·target으로 변수 둘을 함께 받는 어드바이스를 더하자 시작이 멈췄다. 그 빌드의 시작 오류에서 마지막 원인 줄이다

Caused by: org.springframework.aop.aspectj.AspectJAdviceParameterNameDiscoverer$AmbiguousBindingException: Still 2 unbound args at this()/target()/args() binding stage, with no way to determine between them

this()·target()·args()를 보는 단계에서 묶이지 않은 인수가 둘 남아 어느 쪽인지 정할 수 없다는 예외다. 추측 규칙을 적은 Javadoc도 이 단계에서 묶이지 않은 인수가 둘 이상 남으면 이 예외를 던진다고 적는다(AspectJAdviceParameterNameDiscoverer — Spring Framework 7 API). argNames = "proxy,tgt"로 이름을 적어 주면 같은 빌드에서도 돌았다. 잰 것은 this와 target을 함께 묶은 한 가지다. 파라미터 이름이 클래스 파일에 남는지에 따라 결과가 갈리는 다른 경우는 @RequestParam 이름 생략을 다룬 앞 글에서 봤다

이름이 어긋나면 어드바이스 규칙을 다룬 앞 편에서 본 포인트컷 이름 오타처럼 오류 없이 그 어드바이스만 빠진다. 기본 빌드에서 logArgs3의 파라미터 이름만 value로 바꾸자 시작과 테스트는 통과하고 프록시의 어드바이저가 8개에서 7개가 됐다. AspectJExpressionPointcut 로그를 DEBUG로 켜면 포인트컷 식 해석이 실패했다는 Pointcut parser rejected expression 줄이 남았다

this에 구체 클래스를 적은 어드바이스는 JDK 동적 프록시에서 실행되지 않는다

this와 target은 둘 다 타입 하나를 정확히 적고 그 부모 타입도 허용한다. 앞 절에서 본 대로 this는 프록시 객체를, target은 실제 대상 객체를 본다. 스프링 AOP 프록시에는 대상 클래스를 상속해 만드는 CGLIB 프록시와, 대상이 구현한 인터페이스만 구현해 만드는 JDK 동적 프록시가 있어서, this에 구체 클래스를 적으면 프록시 종류에 따라 결과가 갈린다. ThisTargetTest는 인터페이스 MemberService와 구현 클래스 MemberServiceImpl을 this와 target에 하나씩 적은 @Around 넷을 둔다. 로그 태그는 this-interface·target-interface·this-impl·target-impl이다

@Slf4j
@Import(ThisTargetTest.ThisTargetAspect.class)
// @SpringBootTest(properties = "spring.aop.proxy-target-class=false") //JDK 동적 프록시
@SpringBootTest(properties = "spring.aop.proxy-target-class=true") //CGLIB 사용. 없어도 default가 CGLIB
public class ThisTargetTest {

    @Autowired
    MemberService memberService;

    @Test
    void success() {
        log.info("memberService proxy={}", memberService.getClass());
        memberService.hello("helloA");
    }

    @Slf4j
    @Aspect
    static class ThisTargetAspect {

        @Around("this(hello.advanced.aop.member.MemberService)")
        public Object doThisInterface(ProceedingJoinPoint joinPoint) throws Throwable {
            log.info("[this-interface] {}", joinPoint.getSignature());
            return joinPoint.proceed();
        }

        // target(MemberService)는 [target-interface], this(MemberServiceImpl)는 [this-impl],
        // target(MemberServiceImpl)은 [target-impl]을 찍는 같은 모양의 어드바이스다
    }
}

spring.aop.proxy-target-class는 AOP 프록시를 클래스 상속으로 만들지(true, CGLIB) 인터페이스 구현으로 만들지(false, JDK 동적 프록시) 정하는 Boot 설정이다. ThisTargetTest는 true 줄이 켜져 있고 false 줄은 주석이다. 그대로 돌린 로그다

13:57:36.860 INFO  [Test worker] ThisTargetTest : memberService proxy=class hello.advanced.aop.member.MemberServiceImpl$$SpringCGLIB$$0
13:57:36.863 INFO  [Test worker] ThisTargetTest$ThisTargetAspect : [target-impl] String hello.advanced.aop.member.MemberServiceImpl.hello(String)
13:57:36.864 INFO  [Test worker] ThisTargetTest$ThisTargetAspect : [target-interface] String hello.advanced.aop.member.MemberServiceImpl.hello(String)
13:57:36.864 INFO  [Test worker] ThisTargetTest$ThisTargetAspect : [this-impl] String hello.advanced.aop.member.MemberServiceImpl.hello(String)
13:57:36.864 INFO  [Test worker] ThisTargetTest$ThisTargetAspect : [this-interface] String hello.advanced.aop.member.MemberServiceImpl.hello(String)

CGLIB 프록시는 MemberServiceImpl을 상속하므로 프록시 객체가 MemberServiceImpl이기도 하고, 네 어드바이스가 모두 실행됐다. 속성을 false로 바꿔 돌렸다. 첫 줄은 관측 장치가 이 빈을 적은 줄이다

13:57:39.519 INFO  [Test worker] Post08ProxyCounter : PROBE8 bean=memberServiceImpl kind=JDK target=MemberServiceImpl aspectjAdvisors=4 exprs=target(hello.advanced.aop.member.MemberServiceImpl)|target(hello.advanced.aop.member.MemberService)|this(hello.advanced.aop.member.MemberServiceImpl)|this(hello.advanced.aop.member.MemberService)
13:57:39.907 INFO  [Test worker] ThisTargetTest : memberService proxy=class jdk.proxy3.$Proxy80
13:57:39.909 INFO  [Test worker] ThisTargetTest$ThisTargetAspect : [target-impl] String hello.advanced.aop.member.MemberService.hello(String)
13:57:39.910 INFO  [Test worker] ThisTargetTest$ThisTargetAspect : [target-interface] String hello.advanced.aop.member.MemberService.hello(String)
13:57:39.910 INFO  [Test worker] ThisTargetTest$ThisTargetAspect : [this-interface] String hello.advanced.aop.member.MemberService.hello(String)

JDK 동적 프록시는 인터페이스 MemberService만 구현한 별도 클래스라 MemberServiceImpl이 아니다. 그래서 this-impl만 실행되지 않고 셋이 실행됐다. target은 실제 대상을 보므로 두 줄이 다 남았다. 시그니처가 MemberService.hello로 찍힌 것은 JDK 프록시를 거친 호출이 인터페이스 메서드로 들어오기 때문이다

관측 장치의 줄을 보면 이 JDK 프록시에도 어드바이저는 4개이고 this(hello.advanced.aop.member.MemberServiceImpl)이 들어 있다. 프록시를 만들 때 스프링은 대상 클래스 MemberServiceImpl로 판정하므로 이 식도 맞을 수 있다고 보고 넣고, 호출 때 인수까지 받는 matches()에서 실제 프록시 객체의 클래스로 this를 다시 확인해 떨어뜨린다. 이 위치는 소스로 읽은 것이고 실행으로 짚지는 않았다. 시작 오류도 경고 로그도 없고, 프록시의 어드바이저 목록에도 이 어드바이스가 들어 있어서 목록만 보면 붙어 있는 것으로 보인다

Boot는 2.0부터 AOP 프록시를 CGLIB로 만드는 것이 기본이고(Spring Boot 2.0 Migration Guide — Default Proxying Strategy), 4.1에서도 기본값은 true다(Spring Boot Application Properties (4.1)). 속성 줄을 지우고 @SpringBootTest만 남기자 true일 때처럼 CGLIB 프록시에서 넷이 실행됐다. 그래서 기본값을 건드리지 않으면 this에 구체 클래스를 적어도 차이가 드러나지 않는다. Spring 7.0부터는 @Proxyable(INTERFACES)로 인터페이스를 구현한 빈 하나만 JDK 동적 프록시로 만들 수 있는데(Spring Framework 7.0 Release Notes), 전역 설정을 true로 둔 채 MemberServiceImpl에 붙이자 이 빈도 JDK 동적 프록시가 되어 false일 때처럼 this-impl만 실행되지 않았다

target으로 적은 두 어드바이스는 이 네 조건에서 모두 실행됐다. 강의는 this·target을 대상을 거르는 데 단독으로 쓰기보다 앞 절처럼 값을 넘기는 데 주로 쓴다고 설명한다. 그래도 구체 클래스로 대상을 거를 일이 있으면 this 대신 target을 쓴다. this는 프록시를 보기 때문에, 그 빈이 JDK 동적 프록시가 되면 구체 클래스를 적은 어드바이스가 오류 없이 실행되지 않는다


이 시리즈의 글: 스프링 프록시와 AOP

  1. ThreadLocal remove는 가상 스레드를 켜도 남겨 둔다
  2. 템플릿 콜백 패턴으로 감싸면 추적기를 ScopedValue로 옮길 수 있다
  3. @RequestMapping만 붙인 타입은 Spring 6부터 컨트롤러가 아니다
  4. JDK 동적 프록시의 InvocationHandler는 대상 예외를 풀어서 던져야 한다
  5. ProxyFactory 프록시는 어드바이저가 없으면 대상을 그대로 부른다
  6. 빈 후처리기가 받는 빈은 그 후처리기를 거치지 못한다
  7. 스프링 AOP 어드바이스 규칙은 종류마다 할 수 있는 일을 좁힌다
  8. 스프링 AOP 포인트컷 지시자가 클래스만 보고 답하지 못하면 그 빈은 일단 프록시가 된다 (이 글)
  9. 스프링 AOP 내부 호출은 프록시를 다시 지나게 해야 어드바이스가 걸린다

출처와 범위

인프런 김영한님의 「스프링 핵심 원리 – 고급편」 강의를 듣고, 강의를 따라 만든 예제를 Spring Boot 4.1.1(Spring Framework 7.0.9, Tomcat 11.0.24)과 Java 25로 옮겨 실행하며 썼다. 그중 테스트 여덟 클래스(ExecutionTest·WithinTest·ArgsTest·AtTargetAtWithinTest·AtAnnotationTest·BeanTest·ParameterTest·ThisTargetTest)는 코드를 고치지 않고 통과했고, 실험은 조건마다 테스트나 애스펙트, MemberServiceImpl, 빌드 설정을 몇 줄 바꾼 뒤 그 테스트 클래스만 Gradle로 한 번씩 돌렸으며 서버는 띄우지 않았다. AspectJ 라이브러리는 Boot가 고른 aspectjweaver 1.9.25.1이다. 프록시가 된 빈을 센 관측 장치는 테스트 코드 밖에서 리스너로만 등록했고, 매번 먼저 프록시가 아닌 객체·JDK 프록시·CGLIB 프록시를 직접 만들어 셋을 제대로 가르는지 확인했다. 2026년 11월 14일 기준 공식 문서·스프링·AspectJ 소스 대조, 비교 실험 스크립트와 관측 장치·확인용 테스트 작성, 원고 정리에 AI(Claude)를 썼다

참고 자료