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

[YONGHYNG]

CGLIB - 소개

CGLIB: Code Generator Library

• 클래스 상속 기반
• CGLIB는 바이트코드를 조작해서 동적으로 클래스를 생성하는 기술을 제공하는 라이브러리
• CGLIB를 사용하면 인터페이스가 없어도 구체 클래스만 가지고 동적 프록시를 만들어낼 수 있음
• CGLIB는 원래는 외부 라이브러리인데, 스프링 프레임워크가 스프링 내부 소스 코드에 포함, 따라서 스프링을 사용한다면 별도의 외부 라이브러리를 추가하지 않아도 사용할 수 있음
• 참고로 우리가 CGLIB를 직접 사용하는 경우는 거의 없음, 이후에 설명할 스프링의 ProxyFactory 라는 것이 이 기술을 편리하게 사용하게 도와주기 때문에, 너무 깊이있게 파기 보다는 CGLIB가 무엇인지 대략 개념만 잡으면 됨

예제 코드로 CGLIB를 간단히 이해해보자

ServiceInterface

package hello.proxy.common.service;

public interface ServiceInterface {

    void save();

    void find();
}

ServiceImpl

package hello.proxy.common.service;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ServiceImpl implements ServiceInterface {

    @Override
    public void save() {
        log.info("save 호츌");
    }

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

ConcreteService

package hello.proxy.common.service;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ConcreteService {
    public void call() {
        log.info("ConcreteService 호출");
    }
}

CGLIB - 예제 코드

CGLIB 코드

• JDK 동적 프록시에서 실행 로직을 위해 InvocationHandler를 제공했듯이, CGLIB는 MethodInterceptor를 제공

MethodInterceptor -CGLIB 제공

package org.springframework.cglib.proxy;

public interface MethodInterceptor extends Callback {
         Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable;
}

• obj: CGLIB가 적용된 객체
• method: 호출된 메서드
• args: 메서드를 호출하면서 전달된 인수
• proxy: 메서드 호출에 사용

TimeMethodInterceptor

package hello.proxy.cglib.code;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

@Slf4j
public class TimeMethodInterceptor implements MethodInterceptor {

    private final Object target;

    public TimeMethodInterceptor(Object target) {
        this.target = target;
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args,
                            MethodProxy proxy) throws Throwable {
        log.info("TimeProxy 실행");
        long startTime = System.currentTimeMillis();

        Object result = proxy.invoke(target, args);

        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("TimeProxy 종료 resultTime={}", resultTime);
        return result;
    }
}

• TimeMethodInterceptor 는 MethodInterceptor 인터페이스를 구현해서 CGLIB 프록시의 실행 로직
  을 정의
• JDK 동적 프록시를 설명할 때 예제와 거의 같은 코드
• Object target : 프록시가 호출할 실제 대상 proxy.invoke(target, args) : 실제 대상을 동적으로 호출
• 참고로 method 를 사용해도 되지만, CGLIB는 성능상 MethodProxy proxy 를 사용하는 것을 권장

CglibTest

package hello.proxy.cglib;

import hello.proxy.cglib.code.TimeMethodInterceptor;
import hello.proxy.common.service.ConcreteService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.cglib.proxy.Enhancer;

@Slf4j
public class CglibTest {

    @Test
    void cglib() {
        ConcreteService target = new ConcreteService();

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ConcreteService.class);
        enhancer.setCallback(new TimeMethodInterceptor(target));
        ConcreteService proxy = (ConcreteService)enhancer.create();
        log.info("targetClass={}", target.getClass());
        log.info("proxyClass={}", proxy.getClass());

        proxy.call();
    }
}

• ConcreteService 는 인터페이스가 없는 구체 클래스, 여기에 CGLIB를 사용해서 프록시를 생성
• Enhancer : CGLIB는 Enhancer 를 사용해서 프록시를 생성
• enhancer.setSuperclass(ConcreteService.class) : CGLIB는 구체 클래스를 상속 받아서 프록시를 생성할 수 어떤 구체 클래스를 상속 받을지 지정
• enhancer.setCallback(new TimeMethodInterceptor(target)) 프록시에 적용할 실행 로직을 할당
• enhancer.create() : 프록시를 생성, 앞서 설정한 enhancer.setSuperclass(ConcreteService.class) 에서 지정한 클래스를 상속 받아서 프록시가 만들어 짐
• JDK 동적 프록시는 인터페이스를 구현(implement)해서 프록시를 만듦 CGLIB는 구체 클래스를 상속(extends)해서 프록시를 만듦

CGLIB가 생성한 프록시 클래스 이름

• CGLIB를 통해서 생성된 클래스의 이름을 확인
• ConcreteService$$EnhancerByCGLIB$$25d6b0e3 CGLIB가 동적으로 생성하는 클래스 이름은 다음과 같은 규칙으로 생성
• 대상클래스$$EnhancerByCGLIB$$임의코드 참고로 다음은 JDK Proxy가 생성한 클래스 이름
• proxyClass=class com.sun.proxy.$Proxy1

그림으로 정리

CGLIB 제약

• 클래스 기반 프록시는 상속을 사용하기 때문에 몇가지 제약이 있음
• 부모 클래스의 생성자를 체크해야 함, CGLIB는 자식 클래스를 동적으로 생성하기 때문에 기본 생성자가 필요
• 클래스에 final 키워드가 붙으면 상속이 불가능, CGLIB에서는 예외가 발생
• 메서드에 final 키워드가 붙으면 해당 메서드를 오버라이딩 할 수 없음, CGLIB에서는 프록시 로직이
  동작하지 않음

참고

• CGLIB를 사용하면 인터페이스가 없는 V2 애플리케이션에 동적 프록시를 적용할 수 있음, 그런데 지금 당장 적용하기에는 몇가지 제약이 있음
• V2 애플리케이션에 기본 생성자를 추가하고, 의존관계를 setter 를 사용해서 주입하면 CGLIB를 적용할 수 있음
• 하지만 다음에 학습하는 ProxyFactory 를 통해서 CGLIB를 적용하면 이런 단점을 해결하고 또 더 편리하기 때문에, 애플리케이션에 CGLIB로 프록시를 적용하는 것은 조금 뒤에 알아봄

정리 - 남은 문제

• 인터페이스가 있는 경우에는 JDK 동적 프록시를 적용하고, 그렇지 않은 경우에는 CGLIB를 적용하려면 어떻게 해야할까?
• 두 기술을 함께 사용할 때 부가 기능을 제공하기 위해서 JDK 동적 프록시가 제공, InvocationHandler
  와 CGLIB가 제공하는 MethodInterceptor 를 각각 중복으로 만들어서 관리해야 할까?
• 특정 조건에 맞을 때 프록시 로직을 적용하는 기능도 공통으로 제공되었으면

프록시 팩토리 - 소개

문제점

• 인터페이스가 있는 경우에는 JDK 동적 프록시를 적용하고, 그렇지 않은 경우에는 CGLIB를 적용하려면 어떻게 해야할까?
• 두 기술을 함께 사용할 때 부가 기능을 제공하기 위해 JDK 동적 프록시가 제공하는 InvocationHandler 와
  CGLIB가 제공하는 MethodInterceptor 를 각각 중복으로 만들어서 관리해야 할까?
• 특정 조건에 맞을 때 프록시 로직을 적용하는 기능도 공통으로 제공되었으면?

1. Q: 인터페이스가 있는 경우에는 JDK 동적 프록시를 적용하고, 그렇지 않은 경우에는 CGLIB를 적용하려면 어떻게 해야할까?

• 스프링은 유사한 구체적인 기술들이 있을 때, 그것들을 통합해서 일관성 있게 접근할 수 있고, 더욱 편리하게 사용할 수 있는 추상화된 기술을 제공
• 스프링은 동적 프록시를 통합해서 편리하게 만들어주는 프록시 팩토리( ProxyFactory )라는 기능을 제공
• 이전에는 상황에 따라서 JDK 동적 프록시를 사용하거나 CGLIB를 사용해야 했다면, 이제는 이 프록시 팩토리 하나로 편리하게 동적 프록시를 생성할 수 있음
• 프록시 팩토리는 인터페이스가 있으면 JDK 동적 프록시를 사용하고, 구체 클래스만 있다면 CGLIB를 사용함 그리고 이 설정을 변경할 수도 있음

1. 두 기술을 함께 사용할 때 부가 기능을 적용하기 위해 JDK 동적 프록시가 제공하는 InvocationHandler와
CGLIB가 제공하는 MethodInterceptor를 각각 중복으로 따로 만들어야 할까?

• 스프링은 이 문제를 해결하기 위해 부가 기능을 적용할 때 Advice 라는 새로운 개념을 도입, 개발자는
  InvocationHandler 나 MethodInterceptor 를 신경쓰지 않고, Advice 만 만들면 됨
• 결과적으로 InvocationHandler 나 MethodInterceptor 는 Advice 를 호출하게 됨 프록시 팩토리를 사용하면 Advice 를 호출하는 전용 InvocationHandler , MethodInterceptor 를 내부에서 사용

1. Q: 특정 조건에 맞을 때 프록시 로직을 적용하는 기능도 공통으로 제공되었으면?

• 앞서 특정 메서드 이름의 조건에 맞을 때만 프록시 부가 기능이 적용되는 코드를 직접 만듦 스프링은 Pointcut이라는 개념을 도입해서 이 문제를 일관성 있게 해결

프록시 팩토리 - 예제 코드1

Advice 만들기

• Advice 는 프록시에 적용하는 부가 기능 로직
• 이것은 JDK 동적 프록시가 제공하는 InvocationHandler 와 CGLIB가 제공하는 MethodInterceptor 의 개념과 유사
• 둘을 개념적으로 추상화 한 것 프록시 팩토리를 사용하면 둘 대신에 Advice 를 사용하면 됨

Advice를 만드는 방법은 여러가지지만, 기본적인 방법은 다음 인터페이스를 구현하면 됨

MethodInterceptor - 스프링이 제공하는 코드

package org.aopaliance.intercept;

public interface MethodInterceptor extends Interceptor {
         Object invoke(MethodInvocation invocation) throws Throwable;
}

1. MethodInvocation invocation

• 내부에는 다음 메서드를 호출하는 방법, 현재 프록시 객체 인스턴스, args , 메서드 정보 등이 포함됨
• 기존에 파라미터로 제공되는 부분들이 이 안으로 모두 들어갔다고 생각하면 됨

2. CGLIB의 MethodInterceptor 와 이름이 같으므로 패키지 이름에 주의

• 참고로 여기서 사용하는 org.aopalliance.intercept 패키지는 스프링 AOP 모듈( spring-aop ) 안에 있음

3. MethodInterceptor 는 Interceptor 를 상속하고 Interceptor 는 Advice 인터페이스를 상속

TimeAdvice

package hello.proxy.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 실행");
        long startTime = System.currentTimeMillis();

        Object result = invocation.proceed();

        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("TimeProxy 종료 resultTime={}ms", resultTime);

        return result;

    }
}

1. TimeAdvice 는 앞서 설명한 MethodInterceptor 인터페이스를 구현, 패키지 이름에 주의
2. Object result = invocation.proceed()

• invocation.proceed() 를 호출하면 target 클래스를 호출하고 그 결과를 받음
• 그런데 기존에 보았던 코드들과 다르게 target 클래스의 정보가 보이지 않음, target 클래스의 정보
  는 MethodInvocation invocation 안에 모두 포함되어 있음
• 그 이유는 바로 다음에 확인할 수 있는데, 프록시 팩토리로 프록시를 생성하는 단계에서 이미 target 정보
  를 파라미터로 전달받기 때문

ProxyFactoryTest

package hello.proxy.proxyfactory;

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.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.AopUtils;

import static org.assertj.core.api.AssertionsForClassTypes.assertThat;

@Slf4j
public class ProxyFactoryTest {

    @Test
    @DisplayName("인터페이스가 있으면 JDK 동적 프록시 사용")
    void interfaceProxy(){
        // 1. 실제 객체(타겟) 생성
        ServiceInterface target = new ServiceImpl();
        // 2. 프록시 팩토리 생성 및 타겟 설정
        ProxyFactory proxyFactory = new ProxyFactory(target);
        // 3. 부가 기능 (Advice) 등록 
        proxyFactory.addAdvice(new TimeAdvice());
        
        // 4. 프록시 객체 생성
        ServiceInterface proxy = (ServiceInterface) proxyFactory.getProxy();
        log.info("targetClass={}", target.getClass());
        log.info("proxyClass={}", proxy.getClass());
        // 5. 실제 메서드 호출(프록시가 감싸고 있어서 TimeAdvice가 먼저 실행)
        proxy.save(); 
       
        //6. 로그 및 프록시 종류 확인
        assertThat(AopUtils.isAopProxy(proxy)).isTrue(); //Aop 프록시인지
        assertThat(AopUtils.isJdkDynamicProxy(proxy)).isTrue(); //JDK 동적 프록시인지
        assertThat(AopUtils.isCglibProxy(proxy)).isTrue(); //CGLIB 프록시 인지
    }
}

• new ProxyFactory(target) : 프록시 팩토리를 생성할 때, 생성자에 프록시의 호출 대상을 함께 넘겨줌
• 프록시 팩토리는 이 인스턴스 정보를 기반으로 프록시를 만들어냄, 만약 이 인스턴스에 인터페이스가 있다면 JDK 동적 프록시를 기본으로 사용하고 인터페이스가 없고 구체 클래스만 있다면 CGLIB를 통해서 동적 프록시를 생성
• 여기서는 target 이 new ServiceImpl() 의 인스턴스이기 때문에 ServiceInterface 인터페이스가 있음
• 따라서 이 인터페이스를 기반으로 JDK 동적 프록시를 생성
• proxyFactory.addAdvice(new TimeAdvice()) : 프록시 팩토리를 통해서 만든 프록시가 사용할 부가
  기능 로직을 설정
• JDK 동적 프록시가 제공하는 InvocationHandler 와 CGLIB가 제공하는 MethodInterceptor 의 개념과 유사- - 이렇게 프록시가 제공하는 부가 기능 로직을 어드바이스 ( Advice )라 함
• 번역하면 조언을 해준다고 생각하면 됨,proxyFactory.getProxy() : 프록시 객체를 생성하고 그 결과를 받음

실행 결과

• 실행 결과를 보면 프록시가 정상 적용되었음, proxyClass=class com.sun.proxy.$Proxy13 코드를 통해 JDK 동적 프록시가 적용된 것을 확인 가능

프록시 팩토리를 통한 프록시 적용 확인

• 프록시 팩토리로 프록시가 잘 적용되었는지 확인하려면 다음 기능을 사용하면 됨
• AopUtils.isAopProxy(proxy) : 프록시 팩토리를 통해서 프록시가 생성되면 JDK 동적 프록시나, CGLIB
  모두 참
• AopUtils.isJdkDynamicProxy(proxy) : 프록시 팩토리를 통해서 프록시가 생성되고, JDK 동적 프록시
  인 경우 참
• AopUtils.isCglibProxy(proxy) : 프록시 팩토리를 통해서 프록시가 생성되고, CGLIB 동적 프록시인 경
  우 경우 참
• 물론 proxy.getClass() 처럼 인스턴스의 클래스 정보를 직접 출력해서 확인할 수 있음

ProxyFactoryTest - concreteProxy 추가

@Test
@DisplayName("구체 클래스만 있으면 CGLIB 사용")
void concreteProxy() {
         ConcreteService target = new ConcreteService();
         ProxyFactory proxyFactory = new ProxyFactory(target);
         proxyFactory.addAdvice(new TimeAdvice());
         ConcreteService proxy = (ConcreteService) proxyFactory.getProxy();
         log.info("targetClass={}", target.getClass());
         log.info("proxyClass={}", proxy.getClass());

         proxy.call();

         assertThat(AopUtils.isAopProxy(proxy)).isTrue();
         assertThat(AopUtils.isJdkDynamicProxy(proxy)).isFalse();
         assertThat(AopUtils.isCglibProxy(proxy)).isTrue();
}

• 이번에는 구체 클래스만 있는 ConcreteService 에 프록시를 적용
• 프록시 팩토리는 인터페이스 없이 구체 클래스만 있으면 CGLIB를 사용해서 프록시를 적용

• 실행 결과를 보면 프록시가 정상 적용된 것을 확인 가능,
• proxyClass=class..ConcreteService$, $EnhancerBySpringCGLIB$$103821ba 코드를 통해 CGLIB 프록시가 적용된 것도 확인할 수 있음

proxyTargetClass 옵션
ProxyFactoryTest - proxyTargetClass 추가

@Test
@DisplayName("ProxyTargetClass 옵션을 사용하면 인터페이스가 있어도 CGLIB를 사용하고, 클래스 기
반 프록시 사용")
void proxyTargetClass() {
       //진짜 로직이 있는 원본 객체 (target)
       ServiceInterface target = new ServiceImpl();
       ProxyFactory proxyFactory = new ProxyFactory(target);
       proxyFactory.setProxyTargetClass(true); //중요 여기서 CGLIB 강제 사용
       proxyFactory.addAdvice(new TimeAdvice());

       ServiceInterface proxy = (ServiceInterface) proxyFactory.getProxy();
       log.info("targetClass={}", target.getClass());
       log.info("proxyClass={}", proxy.getClass());
       proxy.save();

       assertThat(AopUtils.isAopProxy(proxy)).isTrue();
       assertThat(AopUtils.isJdkDynamicProxy(proxy)).isFalse();
       assertThat(AopUtils.isCglibProxy(proxy)).isTrue();
      }

• 마지막으로 인터페이스가 있지만, CGLIB를 사용해서 인터페이스가 아닌 클래스 기반으로 동적 프록시를 만드는 방법을 알아봄
• 프록시 팩토리는 proxyTargetClass 라는 옵션을 제공하는데, 이 옵션에 true 값을 넣으면 인터페이스가 있어도 강제로 CGLIB를 사용, 그리고 인터페이스가 아닌 클래스 기반의 프록시를 만들어줌

• ServiceImpl$$EnhancerBySpringCGLIB... 를 보면 CGLIB 기반의 프록시가 생성된 것을 확인할 수 있음, 인
  터페이스가 있지만 proxyTargetClass 옵션에 의해 CGLIB가 사용

프록시 팩토리의 기술 선택 방법

• 대상에 인터페이스가 있으면: JDK 동적 프록시, 인터페이스 기반 프록시
• 대상에 인터페이스가 없으면: CGLIB, 구체 클래스 기반 프록시
• proxyTargetClass=true : CGLIB, 구체 클래스 기반 프록시, 인터페이스 여부와 상관없음

정리

• 프록시 팩토리의 서비스 추상화 덕분에 구체적인 CGLIB, JDK 동적 프록시 기술에 의존하지 않고, 매우 편리하게 동적 프록시를 생성할 수 있음
• 프록시의 부가 기능 로직도 특정 기술에 종속적이지 않게 Advice 하나로 편리하게 사용할 수 있음
• 이것은 프록시 팩토리가 내부에서 JDK 동적 프록시인 경우 InvocationHandler 가 Advice 를 호출하도록 개발해두고, CGLIB인 경우 MethodInterceptor 가 Advice 를 호출하도록 기능을 개발해두었기 때문

참고

• 스프링 부트는 AOP를 적용할 때 기본적으로 proxyTargetClass=true 로 설정해서 사용
• 따라서 인터페이스가 있어도 항상 CGLIB를 사용해서 구체 클래스를 기반으로 프록시를 생성