[Spring] 빈 후처리기, Bean Postprocessor

잠시 스프링 컨테이너가 빈을 관리하는 방식을 짚어보자.

@Bean 어노테이션을 사용하거나, 컴포넌트 스캔으로 스프링 빈을 등록하면 스프링은 대상 객체를 생성하고 스프링 컨테이너 내부의 빈 저장소에 등록한다. 이제 컨테이너에 등록된 스프링 빈을 조회하여 필요할 때 해당 빈을 사용한다. 

 

이전 포스트에서 프록시를 설정한 방법을 생각해보자. 

실제 객체를 스프링 빈으로 등록하는 것이 아닌 ProxyFactoryConfigV1 처럼, 부가 기능이 있는 프록시를 실제 객체 대신 스프링 컨테이너에 빈으로 등록해야 한다. 그럼 Component Scan 방식으로 빈을 등록하는 경우엔 어떻게 프록시 설정을 할 수 있을까? 이미 스프링 컨테이너에 등록이 됐기 때문에 프록시를 실제 객체 대신 등록할 수 도 없게 됐다. 

만약 실제 객체가 스프링 빈으로 등록되기 직전에 프록시 객체로 대체할 수 있다면, 스프링 컨테이넌에 프록시 객체를 대신 등록할 수 있을 것이다. 이를 위해 우리는 빈 후처리기 라는 기술을 알아보겠다. 

 

ProxyFactoryConfigV1

@Slf4j
@Configuration
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) {
        OrderRepositoryV1Impl 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();
        pointcut.setMappedNames("request*", "order*", "save*");  // no-log 제외하기 위함..?
        LogTraceAdvice advice = new LogTraceAdvice(logTrace);
        return new DefaultPointcutAdvisor(pointcut, advice);
    }
}

 

 

빈 후처리기 - BeanPostProcessor

빈 후처리기는 스프링 빈 저장소에 등록할 목적으로 생성한 객체를 빈 저장소에 등록하기 직전에 조작하고 싶을 때 사용할 수 있다. 빈 후처리기는 객체를 조작할 수 있고, 완전히 다른 객체로 바꿔치기 하는 것도 가능하다. 

 

빈 후처리기를 통한 빈 등록 과정

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

빈 후처리기 적용 - 예시 코드

public class BeanPostProcessorTest {

    @Test
    void basicConfig() {
        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();
        }

        @Bean // BeanPostProcessor 를 구현한 클래스를 빈으로 등록하면 스프링 컨테이너가 자동으로 빈 후처리기를 인식하고 동작시킨다.
        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");
        }
    }

    @Slf4j
    static class AToBPostProcessor implements BeanPostProcessor {

        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 객체로 바꿔치기 한다. 
• 위 코드를 순서대로 분석해보자. 

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

 

중간 정리

빈 후처리기는 빈을 조작하고 변경할 수 있는 후킹 포인트다. 

일반적으로 스프링 컨테이너가 등록하는, (특히 컴포넌트 스캔의 대상이 되는) 스프링 빈은 중간에 조작할 방법이 없는데, 빈 후처리기를 사용하면 개발자가 등록하는 모든 빈을 중간에 조작할 수 있다. 즉 우리가 원했던, 실제 빈 객체(컴포넌트 스캔의 대상)를 프록시로 교체하는 것도 가능하다는 의미다.

 

 

스프링이 제공하는 빈 후처리기

위의 방법을 이용하면 (BeanPostProcessor 를 구현해 스프링 Config 로 직접 등록) 프록시 생성에 빈 후처리기를 적용할 수 있지만, 스프링은 이미 프록시를 생성하기 위한 빈 후처리기를 만들어 제공한다. 

 

 

자동 프록시 생성기 - AutoProxyCreator

이 라이브러리를 추가하면 aspectJ 관련 라이브러리를 등록하고, 스프링부트가 AOP 관련 클래스를 자동으로 스프링 빈에 등록한다. 

  implementation 'org.springframework.boot:spring-boot-starter-aop'

이 라이브러리를 추가하면, AnnotationAwareAspectJAutoProxyCreator 라는 빈 후처리기가 스프링 빈으로 자동 등록된다. 이름 그대로 자동으로 프록시를 생성하는 빈 후처리기다. (해당 빈 후처리기는 여러 부모 관계를 거쳐 BeanPostProcessor 를 상속받는다.)

이 빈 후처리기는 스프링 빈으로 등록된 Advisor를 찾아 프록시가 필요한 곳에 자동으로 적용해주는데, Advisor 에는 이미 Pointcut 과 Advice 가 포함되어 있기 때문에 가능하다.  이를 좀 더 풀어서 생각해보자. 

 

자동으로 프록시를 생성하는 빈 후처리기?

어떻게 하면 프록시를 자동으로 생성할 수 있을까? 프록시 생성에 필요한 요소를 차례대로 생각해보자. 우선 프록시를 적용할 대상 객체(target)가 필요하다. 그 다음엔 프록시 생성에 필요한 ProxyFactory 객체가 필요하고, ProxyFactory 객체에 적용할 Advisor도 필요하다. 

우리가 자동 프록시 생성기를 사용하는 이유는, 컴포넌트 스캔의 대상이 되는 빈을 프록시로 교체하기 위함이므로, 대상 객체(target)에 해당되는 요소는 준비가 된 상태다. 이제 Advisor 가 필요한데, 프로젝트 코드 어딘가에 Advisor 가 존재하면,  <code> 가 자동으로 이를 찾아 프록시 팩토리에 적용해준다고 볼 수 있다. 

 

자동 프록시 생성기 작동 과정

1. 생성 : 스프링이 스프링 빈 대상이 되는 객체를 생성한다. 
2. 전달 : 생성된 객체를 스프링 빈으로 등록하기 전에 빈 후처리기에 전달한다. 
3. 모든 Advisor 조회 : 자동 프록시 생성기 - 빈 후처리기 는 스프링 컨테이너에서 모든 Advisor 를 조회한다.
4. 프록시 적용 대상 체크 : 조회한 Advisor 의 포인트컷을 사용해 타겟 객체가 프록시 적용 대상인지 판단한다. 해당 객체의 모든 메서드를 포인트컷에 하나하나 매칭해본다. 하나라도 조건에 만족하면 프록시 적용 대상이 돼 프록시 객체가 생성된다. 즉 10개의 메서드를 가진 객체에서 포인트컷에 매칭되는 메서드가 하나 뿐일지라도 프록시 적용 대상이 되는 것이다.
5. 프록시 생성 : 프록시 적용 대상이면 프록시 객체를 생성해 스프링 컨테이너에 등록한다. 그렇지 않다면 원본 객체를 스프링 컨테이너에 그대로 등록한다.
6. 빈 등록 : 반환된 객체는 스프링 빈으로 등록한다. 

 

실제 적용 코드 - AspectJExpressionPointcut

눈에 띄게 코드량이 줄어든 것을 볼 수 있는데, 빈 후처리기 자체(AnnotationAwareAspectJAutoProxyCreator)가 스프링에 의해 자동으로 등록됐기 때문이다. 

@Configuration
@Import({AppV1Config.class, AppV2Config.class})
public class AutoProxyConfig {

    @Bean
    public Advisor advisor(LogTrace logTrace) {
    
        //pointcut
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression("execution(* hello.proxy.app..*(..)) 
                               && !execution(* hello.proxy.app..noLog(..))");
        
        //advice
        LogTraceAdvice advice = new LogTraceAdvice(logTrace);
        return new DefaultPointcutAdvisor(pointcut, advice);
    }

}

 

프록시는 하나만 생성된다.

스프링빈이 Advisor1, Advisor2 가 제공하는 포인트컷의 조건을 모두 만족하면 프록시 자동 생성기는 프록시를 몇개 생성할까? 포인트컷 조건을 만족하는 객체마다 프록시를 생성할까? 그렇지 않다. 프록시 자동 생성기는 프록시를 하나만 생성한다. 왜냐하면 프록시 팩토리가 생성하는 프록시는 내부에 여러 advisor 를 포함할 수 있기 때문이다. 따라서 프록시를 여러 개 생성해서 비용을 낭비할 이유가 없다. 

즉, Proxy 는 하나만 생성될 뿐이고 여러 어드바이저가 들어갈 뿐이다. 

 

 

정리

빈 후처리기는 BeanPostProcessor 인터페이스를 구현하여, 스프링 컨테이너에 등록되기 직전에 빈을 조작할 수 있다. 이렇게 빈 후처리기를 사용하면 컴포넌트 스캔으로 컨테이너에 자동으로 등록되는 빈에 대해서도 프록시 객체를 생성할 수 있다.

또한 AutoProxyCreator 를 사용하면, 직접 BeanPostProcessor 를 구현과정을 생략하고, 편리하게 프록시 생성기를 만들 수 있다. 개발자는 Advisor 만 준비하면 프록시를 손쉽게 생성할 수 있게 된다. 

 

코드 및 자료 출처

스프링 핵심 원리 - 고급편 - 인프런 | 강의