[스프링 핵심원리 - 고급편] #7. 스프링이 지원하는 프록시(2)

[YONGHYNG]

포인트컷, 어드바이스, 어드바이저 - 소개

• 포인트컷(Pointcut) : 어디에 부가 기능을 적용할지, 어디에 부가 기능을 적용하지 않을지 판단하는 필터링 로직, 주로 클래스와 메서드 이름으로 필터링, 이름 그대로 어떤 포인트(Point)에 기능을 적용할지 하지 않을지 잘라서(cut) 구분하는 것

• 어드바이스(Advice) : 이전에 본 것 처럼 프록시가 호출하는 부가 기능, 단순하게 프록시 로직이라 생각하면 됨

• 어드바이저(Advisor) : 단순하게 하나의 포인트컷과 하나의 어드바이스를 가지고 있는 것 쉽게 이야기해서
  포인트컷1 + 어드바이스1

쉽게 기억하기

• 조언( Advice )을 어디( Pointcut )에 할 것인가?
• 조언자( Advisor )는 어디( Pointcut )에 조언( Advice )을 해야할지 알고 있음

역할과 책임

• 포인트컷은 대상 여부를 확인하는 필터 역할만 담당
• 어드바이스는 깔끔하게 부가 기능 로직만 담당
• 둘을 합치면 어드바이저가 됨 스프링의 어드바이저는 하나의 포인트컷 + 하나의 어드바이스로 구성

AdvisorTest

package hello.proxy.advisor;

import hello.proxy.common.advice.TimeAdvice;
import hello.proxy.common.service.ServiceImpl;
import hello.proxy.common.service.ServiceInterface;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;

@Slf4j
public class AdvisorTest {

    @Test
    void advisorTest1() {
        //1. 실제 대상 객체 생성
        ServiceInterface target = new ServiceImpl();
   
        //2. 프록시 팩토리 생성(타겟 설정)
        ProxyFactory proxyFactory = new ProxyFactory(target);
        
        //3. 어드바이저 생성(모든 메서드에 적용되는 Pointcut.TRUE + TimeAdvice 적용) 
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(Pointcut.TRUE, new TimeAdvice());
        
         //4. 프록시에 어드바이저 추가 
        proxyFactory.addAdvisor(advisor);

        //5. 프록시 객체 생성
        ServiceInterface proxy = (ServiceInterface) proxyFactory.getProxy();

        proxy.save();
        proxy.find();
    }
}

• new DefaultPointcutAdvisor : Advisor 인터페이스의 가장 일반적인 구현체, 생성자를 통해 하나의 포인트컷과 하나의 어드바이스를 넣어주면 됨, 어드바이저는 하나의 포인트컷과 하나의 어드바이스로 구성됨
• Pointcut.True : 항상 true를 반환하는 포인트컷
• proxyFactory.addAdvisor(advisor) : 프록시 팩토리에 적용할 어드바이저를 지정, 어드바이저는 내부에 포인트컷과 어드바이스를 모두 가짐, 따라서 어디에 부가 기능을 적용해야 할지 어드바이저 하나로 알 수 있음, 프록시 팩토리를 사용할 때 어드바이저는 필수
• 그런데 생각해보면 이전에 분명히 proxyFactory.addAdvice(new TimeAdvice()) 이렇게 어드바이저가 아니라 어드바이스를 바로 적용, 이것은 단순히 편의 메서드이고 결과적으로 해당 메서드 내부에서 지금 코드와 똑같은 다음 어드바이저가 생성, DefaultPointcutAdvisor(Pointcut.TRUE, new TimeAdvice())

프록시 팩토리 - 어드바이저 관계

실행 결과

예제 코드2 - 직접 만든 포인트 컷

• 이번에는 save() 메서드에는 어드바이스 로직을 적용하지만, find() 메서드에는 어드바이스 로직을 적용하지 않자
• 물론 과거에 했던 코드와 유사하게 어드바이스에 로직을 추가해서 메서드 이름을 보고 코드를 실행할지 말지 분기를 탐, 하지만 이런 기능에 특화되어서 제공되는 것이 바로 포인트컷

Pointcut 관련 인터페이스 - 스프링 제공

public interface Pointcut {
       ClassFilter getClassFilter(); //어떤 클래스에 적용할지 판단하는 로직 제공
       MethodMatcher getMethodMatcher(); //어떤 메서드에 적용할지 판단하는 로직 제공
}

public interface ClassFilter {
      boolean matched(Class<?> clazz); //클래스 대상으로 필터링 //메서드 필터링
}

public interface MethodMatcher {
      boolean matches(Method method, Class<?> targetClass); //해당 클래스에서 어던 메서드에 적용할지 결정
}

• 포인트컷은 크게 ClassFilter와 MethodMatcher 둘로 이루어짐, 이름 그대로 하나는 클래스가 맞는지, 하나는 메서드가 맞는지 확인할 때 사용, 둘 다 true로 반환해야 어드바이스를 적용 가능

AdvisorTest - advisorTest2() 추가

    @Test
    @DisplayName("직접 만든 포인트 컷")
    void advisorTest2(){
        ServiceImpl target = new ServiceImpl();
        ProxyFactory proxyFactory = new ProxyFactory(target);
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(new MyPointcut(), new TimeAdvice());
        proxyFactory.addAdvisor(advisor);
        ServiceInterface proxy = (ServiceInterface) proxyFactory.getProxy();

        proxy.save();
        proxy.find();
    }
    static class MyPointcut implements Pointcut {

        @Override
        public ClassFilter getClassFilter() {
            return ClassFilter.TRUE; //모든 클래스 허용
        }

        @Override
        public MethodMatcher getMethodMatcher() {
            return new MyMethodMatcher(); //메서드 이름으로 필터링
        }
    }

    static class MyMethodMatcher implements MethodMatcher {

        private String matchName = "save";

        @Override
        public boolean matches(Method method, Class<?> targetClass) {
            boolean result = method.getName().equals(matchName);
            log.info("포인트컷 호출 method={} targetClass={}", method.getName(), targetClass);
            log.info("포인트컷 결과 result={}", result);
            return result;
        }
        
        @Override
        public boolean isRuntime(){
            return false;
        }
        @Override
        public boolean matches(Method method, Class<?> targetClass, Object... args){
            throw new UnsupportedOperationException();
        }
    }

MyPointcut

• 직접 구현한 포인트컷, Pointcut 인터페이스를 구현
• 현재 메서드 기준으로 로직을 적용하면 됨, 클래스 필터는 항상 true를 반환하도록 했고, 메서드 비교 기능은 MyMethodMatcher를 사용

MyMethodMatcher

• 직접 구현한 MethodMatcher 이다. MethodMatcher 인터페이스를 구현
• matches() : 이 메서드에 method , targetClass 정보가 넘어옴, 이 정보로 어드바이스를 적용할지 적용 하지 않을지 판단할 수 있음
• 여기서는 메서드 이름이 "save" 인 경우에 true 를 반환하도록 판단 로직을 적용
• isRuntime() , matches(... args) : isRuntime() 이 값이 참이면 matches(... args) 메서드가 대신 호출, 동적으로 넘어오는 매개변수를 판단 로직으로 사용할 수 있음
• isRuntime() 이 false 인 경우 클래스의 정적 정보만 사용하기 때문에 스프링이 내부에서 캐싱을 통해 성능 향상이 가능하지만, isRuntime() 이 true 인 경우 매개변수가 동적으로 변경된다고 가정해 캐싱을 하지 않음

new DefaultPointcutAdvisor(new MyPointcut(), new TimeAdvice())

• 어드바이저에 직접 구현한 포인트컷을 사용
  
• 실행 결과를 보면 기대한 것과 같이 save()를 호출할 때 어드바이스가 적용되지만, find()를 호출할 때는 어드바이스가 적용되지 않음

save() 호출

• 포인트컷이 적용되어야 하는 경우

1. 클라이언트가 프록시의 save()를 호출
2. 포인트컷에 Service 클래스의 save() 메서드에 어드바이스를 적용해도 될지 물어봄
3. 포인트컷이 true를 반환, 따라서 어드바이스를 호출해서 부가 기능을 적용
4. 이후 실제 인스턴스의 save()를 호출

find() 호출

• 포인트컷이 적용되지 않는 경우

1. 클라이언트가 프록시의 find()를 호출
2. 포인트컷이 Service 클래스의 find() 메서드에 어드바이스를 적용해도 될지 물어봄
3. 포인트컷이 false를 반환, 따라서 어드바이스를 호출하지 않고 부가 기능도 적용되지 않음
4. 실제 인스턴스 호출

예제 코드3 - 스프링이 제공하는 포인트 컷

• 스프링은 우리가 필요한 포인트컷을 이미 대부분 제공
• 이번에는 스프링이 제공하는 NameMatchMethodPointcut을 사용해 구현

    @Test
    @DisplayName("스프링이 제공하는 포인트 컷")
    void advisorTest3(){
        ServiceImpl target = new ServiceImpl();
        ProxyFactory proxyFactory = new ProxyFactory(target);
        NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
        pointcut.setMappedNames("save");
         //new DefaultPointcutAdvisor(조건, 행동)
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, new TimeAdvice());              
                                                                                         

        proxyFactory.addAdvisor(advisor);
        ServiceInterface proxy = (ServiceInterface) proxyFactory.getProxy();

        proxy.save();
        proxy.find();
    }

NameMatchMethodPointcut 사용 코드

NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
pointcut.setMappedNames("save");

• NameMatchMethodPointcut을 생성하고 setMappedNames(...)으로 메서드 이름을 지정하면 포인트 컷이 완성

실행결과

• 실행 결과를 보면 save() 를 호출할 때는 어드바이스가 적용되지만, find() 를 호출할 때는 어드바이스가 적용되지 않음

스프링이 제공하는 포인트컷

• NameMatchMethodPointcut : 메서드 이름을 기반으로 매칭, 내부에서는 PatternMatchUtils를 사용
• JdkRegexpMethodPointcut: JDK 정규 표현식을 기반으로 포인트컷을 매칭
• TruePointcut : 항상 참을 반환
• AnnotationMatchingPointcut : 애노테이션으로 매칭
• AspectJexpressionPointcut : aspectJ 표현식으로 매칭

예제 코드4 - 여러 어드바이저 함께 적용

• 어드바이저는 하나의 포인트컷과 하나의 어드바이스를 가지고 있음
• 만약 여러 어드바이저를 하나의 target 에 적용하려면 어떻게 해야할까?
• 쉽게 이야기해서 하나의 target 에 여러 어드바이스를 적용하려면 어떻게 해야할까?

여러 프록시 - MultiAdvisorTest

package hello.proxy.advisor;

import hello.proxy.common.service.ServiceImpl;
import hello.proxy.common.service.ServiceInterface;
import lombok.extern.slf4j.Slf4j;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;

public class MultiAdvisorTest {

    @Test
    @DisplayName("여러 프록시")
    void multiAdvisorTest1() {
        //client -> proxy2(advisor2) -> proxy1(advisor1) -> target

        //프록시 1 생성
        ServiceInterface target = new ServiceImpl();
        ProxyFactory proxyFactory1 = new ProxyFactory(target);
        DefaultPointcutAdvisor advisor1 = new DefaultPointcutAdvisor(Pointcut.TRUE, new Advice1());
        proxyFactory1.addAdvisor(advisor1);
        ServiceInterface proxy1 = (ServiceInterface) proxyFactory1.getProxy();

        //프록시2 생성, target -> proxy1 입력
        ProxyFactory proxyFactory2 = new ProxyFactory(proxy1);
        DefaultPointcutAdvisor advisor2 = new DefaultPointcutAdvisor(Pointcut.TRUE, new Advice2());
        proxyFactory2.addAdvisor(advisor2);
        ServiceInterface proxy2 = (ServiceInterface) proxyFactory2.getProxy();
        //실행
        proxy2.save();
    }

    @Slf4j
    static class Advice1 implements MethodInterceptor {

        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
            log.info("advice1 호출");
            return invocation.proceed();
        }
    }

    @Slf4j
    static class Advice2 implements MethodInterceptor {
        @Override
        public Object invoke(MethodInvocation invocation) throws Throwable {
            log.info("advice2 호출");
            return invocation.proceed();
        }
    }
}

런타임 다음과 같이 동작 - 여러 프록시 사용

• 포인트컷은 advisor1, advisor2 모두 항상 true를 반환하도록 설정, 따라서 둘 다 어드바이스 적용

여러 프록시 문제
이 방법이 잘못된 것은 아니지만, 프록시를 2번 생성해야 한다는 문제가 있음 만약 적용해야 하는 어드바이저가 10개라면 10개의 프록시를 생성해야 함

하나의 프록시, 여러 어드바이저

• 스프링은 이 문제를 해결하기 위해 하나의 프록시에 여러 어드바이저를 적용할 수 있게 만들어 줌

MultiAdvisorTest - multiAdvisorTest2() 추가

@Test
@DisplayName("하나의 프록시, 여러 어드바이저")
void multi AdvisorTest2() {
        //proxy -> advisor2 -> advisor1 -> target
 
       DefaultPointcutAdvisor advisor2 = new DefaultPointcutAdvisor(Pointcut.TRUE, new Advice2());
       DefaultPointcutAdvisor advisor1 = new DefaultPointcutAdvisor(Pointcut.TRUE, new Advice1());

      ServiceInterface target = new ServiceImpl();
      ProxyFactory proxyFactory1 = new ProxyFactory(target);
      proxyFactory1.addAdvisor(advisor2);
      proxyFactory1.addAdvisor(advisor1);
      ServiceInterface proxy = (ServiceInterface) proxyFactory1.getProxy();

     //실행
      proxy.save();
}

• 프록시 팩토리에 원하는 만큼 addAdvisor()를 통해서 어드바이저를 등록하면 됨
• 등록하는 순서대로 advisor가 호출, 여기서는 advisor2, advisor1 순서로 등록

• 실행 결과를 보면 advice2 , advice1 순서대로 호출된 것을 알 수 있음

정리
결과적으로 여러 프록시를 사용할 때와 비교해서 결과는 같고, 성능은 더 좋음

중요

• 사실 이번 장을 이렇게 풀어서 설명한 이유가 있고, 스프링의 AOP를 처음 공부하거나 사용하면, AOP 적용 수 만큼 프록시가 생성된다고 착각하게 됨
• 실제 많은 실무 개발자들도 이렇게 생각하는 것을 봄
• 스프링은 AOP를 적용할 때, 최적화를 진행해서 지금처럼 프록시는 하나만 만들고, 하나의 프록시에 여러 어드바이저를 적용함
• 정리하면 하나의 target 에 여러 AOP가 동시에 적용되어도, 스프링의 AOP는 target 마다 하나의 프록시만 생성
• AOP가 겹겹이 감싸는 이유는 핵심 기능은 그대로 두고, 전처리/후처리 같은 부가기능을 유연하게 끼워넣기 위해서야