Advisor, Advice, Pointcut

스프링에서 프록시를 만들고 AOP 관련 개념을 접하면 한번은 듣는 단어인 Advisor, Advice, Pointcut에 대해 정리하고자 한다.

 

우선 그 전에 다음 포스팅을 참고하면 좋을 것 같다. https://cwchoiit.tistory.com/80

스프링이 지원하는 프록시

위 포스팅에서 스프링이 ProxyFactory를 제공해주고 이 프록시 팩토리로 동적 프록시를 만드는 내용을 얘기하면서 Advice라는 개념을 살짝 맛봤다. ProxyFactory에 Advice를 추가해서 프록시가 제공하는 추가 기능 로직을 담당하는 녀석이 Advice라고. 

 

728x90

SMALL

Advisor, Advice, Pointcut

• Advice: 프록시가 제공하는 추가 기능에 대한 로직을 가지고 있는 곳을 말한다. (조언)
• Pointcut: 프록시가 제공하는 추가 기능을 어디에 어떤 기준으로 적용할것인가?을 가지고 있는 곳을 말한다. (누구에게? / 어디에?)
• Advisor: Advice와 Pointcut을 한 개씩 가지고 있는 곳을 말한다. (조언자)

쉽게 풀어 얘기하면 프록시는 Pointcut(어디에?) Advice(조언 = 추가기능)을 할 것인가? 그리고 그 프록시가 어디에 어떤 조언을 할 지 알려줄 Advisor(조언자)를 가지고 있다.

 

그리고 ProxyFactory는 Advisor가 필수이다. 근데 저 위에 포스팅에서는 Advisor를 안 사용했고 addAdvice()만 호출해서 Advice만 넘겼는데 이렇게 하면 기본 Advisor에 모든 곳에 적용하는 Pointcut으로 할당된다. 단순 편의 메서드인 것 뿐이다.

 

한번 Advisor, Advice, Pointcut을 적용해 보는 코드를 작성해보자.

 

모든 대상에 대해 허용하는 Pointcut으로 Advisor를 만들기

어떤 요청이어도 Advice(프록시가 제공하는 추가 기능)를 모두 적용하는 Pointcut으로 Advisor를 만든다.

ServiceInterface.java

package com.example.advanced.common.service;

public interface ServiceInterface {
    void save();

    void find();
}

ServiceImpl.java

package com.example.advanced.common.service;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ServiceImpl implements ServiceInterface {
    @Override
    public void save() {
        log.info("save calling");
    }

    @Override
    public void find() {
        log.info("find calling");
    }
}

TimeAdvice.java

package com.example.advanced.common.advice;

import lombok.extern.slf4j.Slf4j;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

@Slf4j
public class TimeAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        log.info("TimeProxy Start");

        long startTime = System.currentTimeMillis();

        Object result = invocation.proceed();

        long endTime = System.currentTimeMillis();

        log.info("TimeProxy End. ResultTime = {}ms", endTime - startTime);
        return result;
    }
}

 

Advice를 만들었다. Advice를 만들기 위해 MethodInterceptor를 구현한다. 왜 Advice를 만든다고 해놓고 MethodInterceptor일까? MethodInterceptor가 상속받는 Interceptor가 있고 그 Interceptor가 상속받는 인터페이스가 'Advice'이기 때문이다. 이 MethodInterceptor를 구현하려면 'invoke()'를 구현해야한다. 이 메서드는 프록시가 추가로 제공해주는 기능에 대한 내용을 넣는 곳이다. 그리고 프록시는 항상 실제 객체가 있어야 하는데 기존에는 실제 객체를 주입받아서 프록시를 만들었는데 이 Advice에는 없다. 왜 그러냐면 ProxyFactory에 Advice가 적용될텐데 ProcyFactory가 실제 객체를 들고 있기 때문에 Advice에서는 필요가 없다. 그저 MethodInvocation 타입의 invocation.proceed()를 호출하면 ProxyFactory가 가지고 있는 실제 객체의 호출한 메서드가 호출된다.

 

AdvisorTest.java

package com.example.advanced.advisor;

import com.example.advanced.common.advice.TimeAdvice;
import com.example.advanced.common.service.ServiceImpl;
import com.example.advanced.common.service.ServiceInterface;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.aop.ClassFilter;
import org.springframework.aop.MethodMatcher;
import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.NameMatchMethodPointcut;

import java.lang.reflect.Method;

@Slf4j
public class AdvisorTest {

    @Test
    void advisorTest1() {
        // 실제 객체가 될 서비스 객체
        ServiceInterface target = new ServiceImpl();

        // ProxyFactory 객체를 생성
        ProxyFactory proxyFactory = new ProxyFactory(target);

        // DefaultPointcutAdvisor 객체를 생성.
        // 여기서 Pointcut.TRUE 는 모든 요청에 대해 내가 지금 전달한 TimeAdvice 로직을 적용하겠다는 의미다.
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(Pointcut.TRUE, new TimeAdvice());

        // ProxyFactory에 Advisor를 추가한다.
        proxyFactory.addAdvisor(advisor);

        // ProxyFactory로부터 프록시를 꺼낸다.
        ServiceInterface proxy = (ServiceInterface) proxyFactory.getProxy();

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

 

이제 Advisor, Advice, Pointcut을 만들어보자. 우선 첫번째로 해볼 것은 아무런 필터링도 하지 않는 'Pointcut'을 만드는 것이다.

그 부분이 아래 코드이다. Advisor를 만들기 위해 DefaultPointcutAdvisor 객체를 생성하는데 이 때 생성자에 두가지가 넘어간다. Pointcut과 Advice. 모든 대상에 대해 Advice를 적용하는 Pointcut.TRUE를 넘기면 위에서 말한것처럼 아무런 필터링도 하지 않는다.

DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(Pointcut.TRUE, new TimeAdvice());

 

 

두번째 파라미터는 'TimeAdvice()'를 넘겨주면 된다. 이렇게 만든 advisor를 ProxyFactory에 추가해준다.

proxyFactory.addAdvisor(advisor);

 

이제 프록시 팩토리에서 프록시를 꺼내서 프록시가 가진(실제 객체가 가진) 메서드를 호출할 수 있다. 이렇게 프록시를 만들고 프록시의 메서드를 호출해보자. 실제 객체가 가진 모든 메서드에 대해서 프록시가 주는 추가 기능(Advice)이 적용되어야 한다.

결과

결과 로그를 보면 save(), find() 모두 프록시가 제공하는 TimeProxy Start, End, ResultTime = Xms 로그가 찍히는 것을 볼 수 있다.

그러나, 이러면 사실상 Pointcut이 의미가 없기 때문에 Pointcut으로 필터링도 해보자. 딱 한번만 Pointcut을 직접 만들어 보자. 그 이후에는 스프링이 제공해주는 여러가지 Pointcut으로 편하게 사용하면 된다. 

 

 

일부 대상에 대해 허용하는 Pointcut으로 Advisor를 만들기

Pointcut을 만들어보자. Pointcut을 구현하면 되는데 두 가지 메서드가 있다. getClassFilter(), getMethodMatcher().

메서드 명만 봐도 어떤것을 하는 메서드인지 알 수 있을것 같다. 하나는 클래스로 필터링을 하는것이고 하나는 메서드로 필터링을 하는것.

    /**
     * 직접 만들일은 없음, 스프링이 만들어주는 Pointcut을 사용하면 되지만 한번 만들어보자.
     * 클래스와 메서드 둘 다 'true' 를 리턴해야만 Pointcut에 적합한 요청이라고 판단하여 Advice를 적용한다.
     * */
    static class MyPointcut implements Pointcut {
        /**
         * 클래스를 기준으로 필터링
         * ClassFilter.TRUE 를 반환하면 모든 클래스에 대해 Advice 적용을 허용
         * */
        @Override
        public ClassFilter getClassFilter() {
            return ClassFilter.TRUE;
        }

        /**
         * 메서드를 기준으로 필터링
         * MethodMatcher를 구현해야 한다.
         * */
        @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) {
            return false;
        }
    }

 

getMethodMatcher()는 MethodMatcher 타입을 반환하는데 이는 우리가 직접 구현하면 된다. 위 MyMethodMatcher 클래스가 그 예시이다. 이 MethodMatcher를 구현하면 세가지 메서드를 구현해야한다. 

 

우선, 간단하게 예시를 작성할거니까 'save()' 메서드만 Advice를 적용시켜보자. 이름으로 비교를 하기 위해 변수로 저장한다.

private String matchName = "save";

 

그 다음, 지금 전달받은 Method의 이름이 'save'와 일치하는지 판단한다.

boolean result = method.getName().equals(matchName);

 

맞다면, true를 반환해서 Advice가 적용되게끔 작성했다. 이제 우리가 직접만든 Pointcut으로 Advisor를 만들어보자.

@Test
@DisplayName("직접 만든 포인트컷")
void advisorTest2() {
    // 실제 객체 서비스
    ServiceInterface target = new ServiceImpl();

    // ProxyFactory 객체 생성 후 실제 객체를 전달
    ProxyFactory proxyFactory = new ProxyFactory(target);

    // ProxyFactory가 만들 Advisor
    // Pointcut을 직접 만들어서 넣었고, Advice도 만들어서 넣었음.
    DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(new MyPointcut(), new TimeAdvice());

    // ProxyFactory에 advisor 추가
    proxyFactory.addAdvisor(advisor);

    // ProxyFactory 로부터 proxy 를 꺼내온다.
    ServiceInterface proxy = (ServiceInterface) proxyFactory.getProxy();

    // Pointcut에 의하여 Advice 적용된다.
    proxy.save();
    // Pointcut에 의하여 Advice 적용되지 않는다.
    proxy.find();
}

 

위에서 모든 대상에 대해 Advice를 적용했던 예시 코드에 비교해서 바뀌는 부분은 딱 Pointcut이 달라지는것 말고 없다. 우리가 만든 Pointcut을 전달한다. 대신 실행 결과가 달라질 것이다. 'save()'가 아닌 'find()'에는 Advice는 적용되지 않는다.

결과 로그를 보면, save calling이 찍히기 전 후에 TimeProxy Start, TimeProxy End, ResultTime = Xms가 찍히지만, find calling은 없다. Pointcut이 잘 동작하는 것을 확인할 수 있다. 이제 두번 다시 Pointcut을 직접 만들지는 않을거다. 스프링의 도움을 받자.

 

 

스프링이 제공하는 Pointcut으로 Advisor를 만들기

이제 Spring이 제공해주는 여러가지 Pointcut이 있는데 그 중 하나로 Advisor를 만들어 보자. 

@Test
@DisplayName("스프링이 제공하는 포인트컷")
void advisorTest3() {
    // 실제 객체 서비스
    ServiceInterface target = new ServiceImpl();

    // ProxyFactory 객체 생성 후 실제 객체를 전달
    ProxyFactory proxyFactory = new ProxyFactory(target);

    // 스프링이 제공하는 포인트 컷 중 하나인 NameMatchMethodPointcut
    NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
    // Method 명이 save인 애들에게 Advice를 적용해주는 Pointcut을 만든다.
    pointcut.setMappedName("save");

    DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, new TimeAdvice());

    // ProxyFactory에 advisor 추가
    proxyFactory.addAdvisor(advisor);

    // ProxyFactory 로부터 proxy 를 꺼내온다.
    ServiceInterface proxy = (ServiceInterface) proxyFactory.getProxy();

    // Pointcut에 의하여 Advice 적용된다.
    proxy.save();
    // Pointcut에 의하여 Advice 적용되지 않는다.
    proxy.find();
}

 

스프링이 제공하는 Pointcut인 NameMatchMethodPointcut을 사용해보자. 

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

 

말 그대로 메서드의 이름으로 Pointcut을 설정하는 Pointcut이다. 위 코드처럼 'save'라는 값을 setMappedName()에 넘겨주면 이 Pointcut은 'save'라는 메서드명을 가진 요청에 한하여 Advice를 적용한다. 나머지는 동일하다. 결과를 보자.

save가 호출됐을 땐 TimeProxy가 동작하고 그렇지 않은 find가 호출됐을 땐 Advice가 적용되지 않았다. 이렇게 스프링이 제공해주는 Pointcut으로 편리하게 Pointcut을 만들 수 있다.

 

더 나아가서, 여러개의 Advisor를 사용할 수도 있다. 프록시가 여러개로 사용될 수 있는 것처럼 Advisor도 마찬가지로 여러개가 사용될 수 있다. 프록시 팩토리로 프록시를 만들 때 Advisor가 반드시 있어야 한다는 것은 프록시가 여러개면 Advisor도 여러개란 뜻이다. 그러나 프록시를 하나만 가지고 있고 Advisor가 여러개일수도 있다. 그리고 이게 더 일반적으로 많이 사용되는 방법이다.

 

Multi Advisor

 

이제 여러개의 Advisor를 사용해서 클라이언트 요청을 처리해보자. 우선 두 가지 경우를 다룰 것이다. 

 

1. Proxy가 2개 = Advisor가 2개

2. Proxy 1개가 가지고 있는 2개의 Advisor

 

먼저 공통으로 사용될 Advice1, 2를 먼저 살펴보자.

static class Advice1 implements MethodInterceptor {

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

 

static class Advice2 implements MethodInterceptor {

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

 

Proxy가 2개 = Advisor가 2개

@Test
@DisplayName("여러 프록시")
void multiAdvisorTest1() {
    // Client -> Proxy2(Advisor2) -> Proxy1(Advisor1) -> target

    // Proxy1 생성
    ServiceInterface target = new ServiceImpl();

    ProxyFactory proxyFactory1 = new ProxyFactory(target);
    DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(Pointcut.TRUE, new Advice1());
    proxyFactory1.addAdvisor(advisor);
    ServiceInterface proxy1 = (ServiceInterface) proxyFactory1.getProxy();

    // Proxy2 생성
    ProxyFactory proxyFactory2 = new ProxyFactory(proxy1);
    DefaultPointcutAdvisor advisor2 = new DefaultPointcutAdvisor(Pointcut.TRUE, new Advice2());
    proxyFactory2.addAdvisor(advisor2);
    ServiceInterface proxy2 = (ServiceInterface) proxyFactory2.getProxy();

    proxy2.save();
}

 

뭐 새로운 개념은 없다 ProxyFactory를 두개 생성해서 하나는 실제 객체를 target으로 받고 하나는 target을 실제 객체로 받은 프록시를 받으면 된다. 그래서 프록시를 target으로 받은 proxy를 실행하면 끝이다. 결과를 보자.

 

차례대로 Advice2, Advice1이 실행된다. 그리고 실제 객체인 target의 로직까지 실행됐다. 그러나 이건 프록시를 계속 만들어내야 하니까 프록시 하나에 여러개의 Advisor를 생성해보자. 

 

Proxy 1개가 가지고 있는 2개의 Advisor

@Test
@DisplayName("하나의 프록시, 여러 어드바이저")
void multiAdvisorTest2() {
    // Client -> Proxy -> Advisor2 -> Advisor1 -> target

    DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(Pointcut.TRUE, new Advice1());
    DefaultPointcutAdvisor advisor2 = new DefaultPointcutAdvisor(Pointcut.TRUE, new Advice2());

    // Proxy 생성
    ServiceInterface target = new ServiceImpl();

    ProxyFactory proxyFactory = new ProxyFactory(target);
    proxyFactory.addAdvisor(advisor2);
    proxyFactory.addAdvisor(advisor);

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

    proxy.save();
}

 

Advisor2개를 먼저 생성한다. 그리고 ProxyFactory에서 addAdvisor()를 두번하면 끝난다. 그럼 위 코드상 먼저 등록된 advisor2가 먼저 실행되고 그다음 advisor1이 실행될 것이다. 결과를 보자.

 

 

결론

이제 동적 프록시를 만들 때 스프링의 도움을 받아 ProxyFactory로 간단하게 만들 수 있었다. 또한 인터페이스를 제공하느냐 구체 클래스를 제공하느냐에 따라 동적 프록시를 만들어내는 방법이 달라지는 문제 또한 스프링의 ProxyFactory가 해결해 주었다. 이렇게 스프링은 유사한 여러 구현 기술이 있을 때 추상화를 통해 편리하게 사용할 수 있게 해준다. 그리고 ProxyFactory를 통해 프록시를 만들 때 항상 Advisor가 생성되어야 한다는 사실도 알았다. Advisor는 하나의 프록시에 여러개가 들어갈 수 있고 Pointcut으로 어떤 요청에 대해서는 Advice를 적용하고 적용하지 않을지도 필터링이 가능하다는 사실도 알았다. 

 

참고로, 이후에 AOP를 배우겠지만 하나의 target에 여러 AOP를 적용을 한다고 해도 프록시는 하나만 만들어진다. 위 내용이 그 근거이다.

 

Advisor, Advice, Pointcut을 실제 프로젝트 코드에 도입하기

이제 Advisor, Advice, Pointcut이 뭔지도 배웠고 ProxyFactory를 통해서 동적 프록시를 쉽게 만들 수 있게 됐으니 실제 프로젝트 코드에 도입해보자. 두 가지 케이스를 해볼것이다.

 

• 인터페이스로 프록시를 만드는 경우
• 구체 클래스로 프록시를 만드는 경우

 

우선, 인터페이스건 구체 클래스건을 떠나 프록시의 추가 기능을 담당하는 Advice를 만들어야 한다. 

 

Advice 만들기

LogTraceAdvice.java

package com.example.advanced.app.proxy.config.v3_proxyfactory.advice;

import com.example.advanced.trace.TraceStatus;
import com.example.advanced.trace.logtrace.LogTrace;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

import java.lang.reflect.Method;

public class LogTraceAdvice implements MethodInterceptor {

    private final LogTrace logTrace;

    public LogTraceAdvice(LogTrace logTrace) {
        this.logTrace = logTrace;
    }

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        TraceStatus status = null;

        try {
            Method method = invocation.getMethod();

            // Ex) "OrderController.request()"
            String message = method.getDeclaringClass().getSimpleName() + "." + method.getName() + "()";

            status = logTrace.begin(message);

            Object result = invocation.proceed();

            logTrace.end(status);
            return result;
        } catch (Exception e) {
            logTrace.exception(status, e);
            throw e;
        }
    }
}

 

Advice를 만들기 위해 MethodInterceptor를 구현하는 LogTraceAdvice 클래스를 만들었다. MethodInterceptor가 구현해야 하는 Invoke()를 기존에 계속 사용했던 LogTrace 기능으로 채워넣었다. Advice는 실제 객체를 주입받지 않아도 되기 때문에 편리함을 준다. 

 

이제 Advice를 만들었으니까 ProxyFactory를 통해서 만든 프록시를 스프링 빈으로 등록해보자.

 

인터페이스로 프록시를 만드는 경우

ProxyFactoryConfigV1.java

package com.example.advanced.app.proxy.config.v3_proxyfactory;

import com.example.advanced.app.proxy.config.v3_proxyfactory.advice.LogTraceAdvice;
import com.example.advanced.app.proxy.v1.OrderRepositoryV1;
import com.example.advanced.app.proxy.v1.OrderRepositoryV1Impl;
import com.example.advanced.app.proxy.v1.OrderServiceV1;
import com.example.advanced.app.proxy.v1.OrderServiceV1Impl;
import com.example.advanced.app.proxy_v1_controller.OrderControllerV1;
import com.example.advanced.app.proxy_v1_controller.OrderControllerV1Impl;
import com.example.advanced.trace.logtrace.LogTrace;
import org.springframework.aop.Advisor;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.NameMatchMethodPointcut;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ProxyFactoryConfigV1 {

    @Bean
    public OrderControllerV1 orderControllerV1(LogTrace logTrace) {
        OrderControllerV1Impl orderController = new OrderControllerV1Impl(orderServiceV1(logTrace));

        ProxyFactory proxyFactory = new ProxyFactory(orderController);
        proxyFactory.addAdvisor(getAdvisor(logTrace));

        return (OrderControllerV1) proxyFactory.getProxy();
    }

    @Bean
    public OrderServiceV1 orderServiceV1(LogTrace logTrace) {
        OrderServiceV1Impl orderService = new OrderServiceV1Impl(orderRepositoryV1(logTrace));

        ProxyFactory proxyFactory = new ProxyFactory(orderService);
        proxyFactory.addAdvisor(getAdvisor(logTrace));

        return (OrderServiceV1) proxyFactory.getProxy();
    }

    @Bean
    public OrderRepositoryV1 orderRepositoryV1(LogTrace logTrace) {
        OrderRepositoryV1Impl orderRepository = new OrderRepositoryV1Impl();

        ProxyFactory proxyFactory = new ProxyFactory(orderRepository);
        proxyFactory.addAdvisor(getAdvisor(logTrace));

        return (OrderRepositoryV1) proxyFactory.getProxy();
    }

    private Advisor getAdvisor(LogTrace logTrace) {

        NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
        pointcut.setMappedNames("request*", "order*", "save*");

        LogTraceAdvice advice = new LogTraceAdvice(logTrace);

        return new DefaultPointcutAdvisor(pointcut, advice);
    }
}

 

컨트롤러, 서비스, 레포지토리를 프록시로 스프링 컨테이너에 등록해야 한다. 그렇기 때문에 Configuration 파일이 필요하고 여기서 각각을 프록시로 등록하기 위해 ProxyFactory로 프록시를 만든다. ProxyFactory로 프록시를 만들려면 Advisor가 필요하기 때문에 Advisor를 만들어야 한다. Advisor는 Advice와 Pointcut이 필요하기 때문에 우리가 이 위에서 만든 Advice를 전달해야 하고 그 Advice가 적용될 Pointcut을 스프링이 제공하는 NameMatchMethodPointcut을 사용해서 만든다. 메서드 명이 'request'로 시작하는 것과 'order'로 시작하는 것과 'save'로 시작하는 것들은 이 Advice를 적용한다. 이제 Pointcut과 Advice를 Advisor에게 전달한다. 

 

 

이렇게 Config 파일 하나를 만들면 끝난다. 이게 인터페이스를 이용해서 ProxyFactory로 동적 프록시를 만드는 방법이다. 

테스트 해보자. '/v1/request'로 요청하면 LogTrace 정보가 남아야한다. '/v1/no-log'로 요청하면 LogTrace 정보가 남지 않아야 한다.

 

 

구체 클래스로 프록시를 만드는 경우

구체 클래스로 프록시를 만든다고 달라지는 건 없다. 반환 타입만 달라질 뿐이다. 왜냐하면 ProxyFactory를 사용하기 때문이다. ProxyFactory는 알아서 구체 클래스면 CGLIB로 프록시를, 인터페이스면 JDK Dynamic Proxy를 사용해서 프록시를 만들어 준다.

 

ProxyFactoryConfigV2.java

package com.example.advanced.app.proxy.config.v3_proxyfactory;

import com.example.advanced.app.proxy.config.v3_proxyfactory.advice.LogTraceAdvice;
import com.example.advanced.app.proxy.v2.OrderControllerV2;
import com.example.advanced.app.proxy.v2.OrderRepositoryV2;
import com.example.advanced.app.proxy.v2.OrderServiceV2;
import com.example.advanced.trace.logtrace.LogTrace;
import org.springframework.aop.Advisor;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.support.NameMatchMethodPointcut;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ProxyFactoryConfigV2 {

    @Bean
    public OrderControllerV2 orderControllerV2(LogTrace logTrace) {
        OrderControllerV2 orderController = new OrderControllerV2(orderServiceV2(logTrace));

        ProxyFactory proxyFactory = new ProxyFactory(orderController);
        proxyFactory.addAdvisor(getAdvisor(logTrace));

        return (OrderControllerV2) proxyFactory.getProxy();
    }

    @Bean
    public OrderServiceV2 orderServiceV2(LogTrace logTrace) {
        OrderServiceV2 orderService = new OrderServiceV2(orderRepositoryV2(logTrace));

        ProxyFactory proxyFactory = new ProxyFactory(orderService);
        proxyFactory.addAdvisor(getAdvisor(logTrace));

        return (OrderServiceV2) proxyFactory.getProxy();
    }

    @Bean
    public OrderRepositoryV2 orderRepositoryV2(LogTrace logTrace) {
        OrderRepositoryV2 orderRepository = new OrderRepositoryV2();

        ProxyFactory proxyFactory = new ProxyFactory(orderRepository);
        proxyFactory.addAdvisor(getAdvisor(logTrace));

        return (OrderRepositoryV2) proxyFactory.getProxy();
    }

    private Advisor getAdvisor(LogTrace logTrace) {

        NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
        pointcut.setMappedNames("request*", "order*", "save*");

        LogTraceAdvice advice = new LogTraceAdvice(logTrace);

        return new DefaultPointcutAdvisor(pointcut, advice);
    }
}

 

끝이다. Advice도 Pointcut도 이미 만들어 놓은거니까 가져다가 사용만 하면 된다. 아니면 이 코드처럼 복붙으로 처리해 버리기. 

'/v2/request' 로 요청하면 마찬가지로 LogTrace의 정보를 출력한다.

 

 

결론

확실히 프록시로 사용될 코드도 Advice 하나만 만들면 되고, 동적 프록시를 만들기 때문에 프록시를 일일이 만들어 줄 필요도 없으며 구체클래스냐 인터페이스냐에 따라 나뉘어지는 동적 프록시 생성 방법을 스프링의 도움을 받아 고민하지 않게됐다. 훨씬 개선되었지만 여전히 불편함은 남아있다. 어떤 게 불편하냐면 일단 프록시로 만들기 원하는 것들은 전부 이렇게 빈으로 등록해야 한다는 것이다. 만약 100개면 100개의 빈을 이렇게 일일이 등록해야 한다. 또 한가지는 컴포넌트 스캔 대상은 프록시로 만들수가 없다는 사실이다. 왜냐하면 스프링이 이미 스프링 컨테이너에 컴포넌트 스캔 대상 클래스를 등록해버렸기 때문에. 이도 역시 더 좋은 코드로 개선될 수 있지 않을까? '빈 후처리기'이다.