[스프링 핵심원리 - 고급편] #8. 빈 후처리기

[YONGHYNG]

프록시 팩토리 - 적용1

LogTraceAdvice

package hello.proxy.config.v3_proxyfactory.advice;

import hello.proxy.trace.TraceStatus;
import hello.proxy.trace.logtrace.LogTrace;
import lombok.extern.slf4j.Slf4j;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import java.lang.reflect.Method;

@Slf4j
/**
* MethodInterceptor 
* AOP에서 메서드 실행 전후에 끼어들 수 있게 해주는 인터페이스
*/
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();
            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;
        }
    }
}

ProxyFactoryConfigV1

package hello.proxy.config.v3_proxyfactory;

import hello.proxy.app.v1.*;
import hello.proxy.config.v3_proxyfactory.advice.LogTraceAdvice;
import lombok.extern.slf4j.Slf4j;
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;

@Slf4j
public class ProxyFactoryConfigV1 {

    @Bean
    public OrderControllerV1 orderControllerV1(LogTrace logTrace) {
        //컨트롤러 객체 생성, 의존성으로 서비스 넣어줌
        OrderControllerV1 orderController = new OrderControllerV1Impl(orderServiceV1(logTrace));

        //프록시 공장을 만들고, 로그 찍는 기능을 넣어줌
        ProxyFactory factory = new ProxyFactory(orderController);
        factory.addAdvisor(getAdvisor(logTrace));

        //만든 프록시를 실제 스프링 빈으로 등록
        OrderControllerV1 proxy = (OrderControllerV1) factory.getProxy();
        log.info("ProxyFactory proxy={}, target={}", proxy.getClass(), orderController.getClass());
        return proxy;
    }

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

        ProxyFactory factory = new ProxyFactory(orderService);
        factory.addAdvisor(getAdvisor(logTrace));
        OrderServiceV1 proxy = (OrderServiceV1) factory.getProxy();
        log.info("ProxyFactory proxy={}, target={}", proxy.getClass(), orderService.getClass());
        return proxy;
    }

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

        ProxyFactory factory = new ProxyFactory(orderRepository);
        factory.addAdvisor(getAdvisor(logTrace));
        OrderRepositoryV1 proxy = (OrderRepositoryV1) factory.getProxy();
        log.info("ProxyFactory proxy={}, target={}", proxy.getClass(), orderRepository.getClass());
        return proxy;
    }

    private Advisor getAdvisor(LogTrace logTrace) {
        NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
        //request, order, save로 시작하는 메서드들만 로그 찍게 함
        pointcut.setMethodNames("request*", "order*", "save*");

        //advice
        LogTraceAdvice advice = new LogTraceAdvice(logTrace);

        //advisor = pointcut + advice
        //이 조건에 맞는 메서드엔 이 기능을 적용해
        return new DefaultPointcutAdvisor(pointcut, advice);
    }
}

개인정리

• 모든 비즈니스 로직에 로그를 자동으로 넣기 위해 프록시 객체를 만들어주는 설정 코드
• 실제 만든 로직들 (OrderControllerV1Impl, OrderServiceV1Impl, OrderRepositoryV1Impl) 주문 받고, 서비스 처리하고, 저장도 하는 애들
• 근데 그냥 쓰면 로그가 안 찍혀 -> 로그 찍는 프록시(대리자)를 만듦 -> 진짜 객체 앞에 '대리 객체'를 하나 둬서 대리자가 대신 일하고 로그도 찍고 예외도 찍어줌
• 이 프록시를 만드는 도구 ProxyFactory 우리가 만든 OrderServiceImpl 객체를 감싸고 LogTraceAdvice라는 로그 찍는 로직 붙여줌

정리

• 포인트컷은 NameMatchMethodPointcut 을 사용한다. 여기에는 심플 매칭 기능이 있어서 * 을 매칭할 수 있
  다.

1. request* , order* , save* : request 로 시작하는 메서드에 포인트컷은 true 를 반환한다. 나머지도 같다.
2. 이렇게 설정한 이유는 noLog() 메서드에는 어드바이스를 적용하지 않기 위해서다.

• 어드바이저는 포인트컷( NameMatchMethodPointcut ), 어드바이스( LogTraceAdvice )를 가지고 있다.
• 프록시 팩토리에 각각의 target 과 advisor 를 등록해서 프록시를 생성한다. 그리고 생성된 프록시를 스프링
  빈으로 등록한다.

애플리케이션 로딩 로그

• V1 애플리케이션은 인터페이스가 있기 때문에 프록시 팩토리가 JDK 동적 프록시를 적용
• 애플리케이션 로딩 로그를 통해서 JDK 동적 프록시가 적용된 것을 확인할 수 있음

프록시 팩토리 - 적용2

• 이번에는 인터페이스가 없고, 구체 클래스만 있는 v2 애플리케이션에 LogTrace 기능을 프록시 팩토리를 통해서 프록시를 만들어 적용해 보자

ProxyFactoryConfigV2

package hello.proxy.config.v3_proxyfactory;

import hello.proxy.app.v2.OrderControllerV2;
import hello.proxy.app.v2.OrderRepositoryV2;
import hello.proxy.app.v2.OrderServiceV2;
import hello.proxy.config.v3_proxyfactory.advice.LogTraceAdvice;
import lombok.extern.slf4j.Slf4j;
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;

@Slf4j
@Configuration
public class ProxyFactoryConfigV2 {

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

        ProxyFactory factory = new ProxyFactory(orderController);
        factory.addAdvisor(getAdvisor(logTrace));
        OrderControllerV2 proxy = (OrderControllerV2) factory.getProxy();
        log.info("ProxyFactory proxy={}, target={}", proxy.getClass(), orderController.getClass());
        return proxy;
    }

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

        ProxyFactory factory = new ProxyFactory(orderService);
        factory.addAdvisor(getAdvisor(logTrace));
        OrderServiceV2 proxy = (OrderServiceV2) factory.getProxy();
        log.info("ProxyFactory proxy={}, target={}", proxy.getClass(), orderService.getClass());
        return proxy;
    }

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

        ProxyFactory factory = new ProxyFactory(orderRepository);
        factory.addAdvisor(getAdvisor(logTrace));
        OrderRepositoryV2 proxy = (OrderRepositoryV2) factory.getProxy();
        log.info("ProxyFactory proxy={}, target={}", proxy.getClass(), orderRepository.getClass());
        return proxy;
    }

    private Advisor getAdvisor(LogTrace logTrace){
        //pointcut
        NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
        pointcut.setMappedNames("request*", "order*", "save*");
        //advice
        LogTraceAdvice advice = new LogTraceAdvice(logTrace);
        //advisor = pointcut + advice
        return new DefaultPointcutAdvisor(pointcut, advice);
    }
}

애플리케이션 로딩 로그

• V2 애플리케이션은 인터페이스가 없고 구체 클래스만 있기 때문에 프록시 팩토리가 CGLIB을 적용한다.
• 애플리케이션 로딩 로그를 통해서 CGLIB 프록시가 적용된 것을 확인할 수 있다.

정리

• 프록시 팩토리 덕분에 개발자는 매우 편리하게 프록시를 생성할 수 있게 되었다.
• 추가로 어드바이저, 어드바이스, 포인트컷 이라는 개념 덕분에 어떤 부가 기능을 어디에 적용할 지 명확하게 이해할 수 있었다.
• 인터페이스 기반 : 인터페이스가 있는 클래스는 인터페이스를 흉내 내서 프록시를 만듦, OrderService 인터페이스가 있으면, 이걸 기준으로 프록시를 만듦
• 구체 클래스 기반 : 인터페이스가 없을 땐 그냥 그 클래스를 상속해서 프록시를 만듦, OrderService 클래스만 있을 때는, 얘를 상속해서 감쌈

빈 후처리기

빈 후처리기 - 소개

• @bean 이나 컴포넌트 스캔으로 스프링 빈을 등록하면, 스프링은 대상 객체를 생성하고 스프링 컨테이너 내부의 빈 저장소에 등록한다.
• 그리고 이후에는 스프링 컨테이너를 통해 등록한 스프링 빈을 조회해서 사용하면 된다.

빈 후처리기 - BeanPostProcessor

• 스프링이 빈 저장소에 등록할 목적으로 생성한 객체를 빈 저장소에 등록하기 직전에 조작하고 싶다면 빈 후처리기를 사용하면 된다.
• 빈 포스트 프로세서( BeanPostProcessor )는 번역하면 빈 후처리기인데, 이름 그대로 빈을 생성한 후에 무언가를 처리하는 용도로 사용한다.

빈 후처리기 기능

• 빈 후처리기의 기능은 막강하다.
• 객체를 조작할 수도 있고, 완전히 다른 객체로 바꿔치기 하는 것도 가능하다.
  

빈 등록 과정을 빈 후처리기와 함께 살표보자

1. 생성 : 스프링 빈 대상이 되는 객체를 생성(@bean, 컴포넌트 스캔 모두 포함)
2. 전달 : 생성된 객체를 빈 저장소에 등록하기 직전에 빈 후처리기에 전달
3. 후 처리 작업 : 빈 후처리기는 전달된 스프링 빈 객체를 조작하거나 다른 객체로 바꿔치기 할 수 있음
4. 등록 : 빈 후처리기는 빈을 반환, 전달 된 빈을 그대로 반환하면 해당 빈이 등록되고, 바꿔치기 하면 다른 객체가 빈 저장소에 등록 됨

package hello.proxy.postprocessor;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
public class BasicTest {
    @Test
    void basicConfig() {
        /**
         * ApplicationContext는 스프링의 중심, 모든 빈을 관리
         * BasicConfig.class 를 넘겨서 BasicConfig 설정에 따라 빈이 등록
         * */
        ApplicationContext applicationContext = new
                AnnotationConfigApplicationContext(BasicConfig.class);

        //A는 빈으로 등록된다.
        A a = applicationContext.getBean("beanA", A.class);
        a.helloA();

        //B는 빈으로 등록되지 않는다. 꺼내려고 하면 예외 터짐
        Assertions.assertThrows(NoSuchBeanDefinitionException.class,
                () -> applicationContext.getBean(B.class));
    }
    @Slf4j
    @Configuration
    static class BasicConfig {
        @Bean(name = "beanA")
        public A a() {
            return new A();
        }
    }
    @Slf4j
    static class A {
        public void helloA() {
            log.info("hello A");
        }
    }
    @Slf4j
    static class B {
        public void helloB() {
            log.info("hello B");
        }
    }
}

• new AnnotationConfigApplicationContext(BasicConfig.class) 스프링 컨테이너를 생성하면서 BasicConfig.class 를 넘겨주었다.
• BasicConfig.class 설정 파일은 스프링 빈으로 등록된다.

BasicConfig.class

@Bean(name = "beanA")
public A a() {
        return new A();
}

• beanA라는 이름으로 A 객체를 스프링 빈으로 등록

조회

• A a = applicationContext.getBean("beanA", A.class)
  => beanA 라는 이름으로 A 타입의 스프링 빈을 찾을 수 있다.
• applicationContext.getBean(B.class)
  => B 타입의 객체는 스프링 빈으로 등록한 적이 없기 때문에 스프링 컨테이너에서 찾을 수 없다.

테스트 결과

빈 후처리기 - 예제 코드2

• 빈 후처리기 적용
• 이번에는 빈 후처리기를 통해서 A 객체를 B 객체로 바꿔자
  

BeanPostProceessor 인터페이스 - 스프링 제공

public interface BeanPostProcessor{
       Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException
                   Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException
}

• 빈 후처리기를 사용하려면 BeanPostProcessor 인터페이스를 구현하고, 스프링 빈으로 등록하면 됨
• postProcessBeforeInitialization : 객체 생성 이후에 @PostConstruct 같은 초기화가 발생하기 전에 호출되는 포스트 프로세서임
• postProcessAfterInitialization : 객체 생성 이후에 @PostConstruct 같은 초기화가 발생한 다음에 호출되는 포스트 프로세서

BeanPostProcessorTest

package hello.proxy.postprocessor;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContext;
import
        org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
public class BeanPostProcessorTest {
    @Test
    //스프링 컨테이너 만들면서 설정 클래스(BeanPostProcessorConfig) 전달
    void postProcessor() {
        ApplicationContext applicationContext = new
                AnnotationConfigApplicationContext(BeanPostProcessorConfig.class);

        //beanA 이름으로 B 객체가 빈으로 등록된다.
        B b = applicationContext.getBean("beanA", B.class);
        b.helloB();

        //A는 빈으로 등록되지 않는다.
        Assertions.assertThrows(NoSuchBeanDefinitionException.class,
                () -> applicationContext.getBean(A.class));
    }

    @Slf4j
    @Configuration
    static class BeanPostProcessorConfig {
        @Bean(name = "beanA")
        public A a() {
            return new A();
        }
        /**
         * AToBPostProcessor
         * 등록되어 있어 A를 B로 바꿔버림
         * */
        @Bean
        public AToBPostProcessor helloPostProcessor() {
            return new AToBPostProcessor();
        }
    }

    @Slf4j
    static class A {
        public void helloA() {
            log.info("hello A");
        }
    }
    @Slf4j
    static class B {
        public void helloB() {
            log.info("hello B");
        }
    }

    /**
     * AToBPostProcessor 가 호출되면 스프링이 A객체를 초기화한 후, postProcessAfterInitialization() 호출
     * 이때 A가 발견되면 B로 바꿔치기
     * */
    @Slf4j
    static class AToBPostProcessor implements BeanPostProcessor {
        @Override
        public Object postProcessAfterInitialization(Object bean, String
                beanName) throws BeansException {
            log.info("beanName={} bean={}", beanName, bean);
            if (bean instanceof A) {
                return new B();
            }
            return bean;
        }
    }
}

AToBPostProcessor

• 빈 후처리기, 인터페이스인 BeanPostProcessor를 구현하고, 스프링 빈으로 등록하면 스프링 컨테이너가 빈 후처리기로 인식하고 동작
• 이 빈 후처리기는 A 객체를 B 객체로 바꿔치기 함, 파라미터로 넘어오는 빈(bean) 객체가 A의 인스턴스이면 새로운 B 객체를 생성해서 반환
• 여기서 A 대신에 반환된 값인 B가 스프링 컨테이너에 등록
• 다음 실행결과를 보면 beanName=beanA, bean=A 객체의 인스턴스가 빈 후처리기에 넘어온 것을 확인할 수 있음

BeanPostProcessor

• 스프링 컨테이너가 모든 빈을 생성하고 나서 개입할 수 있음
• 등록만 해두면 모든 빈이 생성될 때 자동으로 호출
• 즉, 스프링이 만드는 모든 객체에 대해 "이거 수정할 것 있어?"라고 물어봐주는 자동 후처리 훅
• 단순한 new A() -> new B() 같은 함수는 그냥 코드 흐름 안에서 바꾸고, BeanPostProcessor는 스프링 빈 등록 단계에 개입할 수 있는 시스템 레벨의 기능

결과

B b = applicationContext.getBean("beanA", B.class)

• 실행 결과를 보면 최종적으로 "beanA" 라는 스프링 빈 이름에 A 객체 대신에 B 객체가 등록된 것을 확인할 수
  있다. A 는 스프링 빈으로 등록조차 되지 않는다.

정리

• 빈 후처리기는 빈을 조작하고 변경할 수 있는 후킹 포인트이다.
• 이것은 빈 객체를 조작하거나 심지어 다른 객체로 바꾸어 버릴 수 있을 정도로 막강하다.
• 여기서 조작이라는 것은 해당 객체의 특정 메서드를 호출하는 것을 뜻한다.
• 일반적으로 스프링 컨테이너가 등록하는, 특히 컴포넌트 스캔의 대상이 되는 빈들은 중간에 조작할 방법이 없는데, 빈후처리기를 사용하면 개발자가 등록하는 모든 빈을 중간에 조작할 수 있다.
• 이 말은 빈 객체를 프록시로 교체하는 것도 가능하다는 뜻이다.

참고 - @PostConstruct의 비밀

• @PostConstruct 는 스프링 빈 생성 이후에 빈을 초기화 하는 역할을 한다.
• 그런데 생각해보면 빈의 초기화 라는 것이 단순히 @PostConstruct 애노테이션이 붙은 초기화 메서드를 한번 호출만 하면 된다.
• 쉽게 이야기해서 생성된 빈을 한번 조작하는 것이다.
• 따라서 빈을 조작하는 행위를 하는 적절한 빈 후처리기가 있으면 될 것 같다.
• 스프링은 CommonAnnotationBeanPostProcessor 라는 빈 후처리기를 자동으로 등록하는데, 여기에서
  @PostConstruct 애노테이션이 붙은 메서드를 호출한다. 따라서 스프링 스스로도 스프링 내부의 기능을 확장
  하기 위해 빈 후처리기를 사용한다.