Dynamic Proxy, CGLIB - Java로 인터셉터 만들어보기

AOP, Interceptor... 왜 필요할까?

---

애플리케이션을 개발하면서, 특정한 객체의 메소드가 호출될 때마다 로깅을 남기거나, 트랜잭션을 관리하는 등의 작업이 필요할 때가 있습니다. 이러한 작업을 위해서는 각각의 메소드에 코드를 추가해주어야 하지만, 이는 번거로운 작업입니다. 이러한 경우, 동적 프록시와 CGLIB을 이용하여 인터셉터를 구현하여, 중복 코드를 제거하고 작업을 간편하게 할 수 있습니다. 이러한 인터셉터를 구현하는 것이 대표적인 AOP라고 합니다. 비즈니스 로직과 인프라 로직을 분리하는 것이죠.

 

간단하게 제가 만들고 있는 웹 서버의 루트 디렉토리를 접속했을 때 index.html을 보여주는 예제를 어떻게 개선했는지 보여드리겠습니다. 주석만 살펴보면 루트로 HTTP 요청이 들어오면 index.html의 뷰를 보여주면 됩니다. 그렇지만 index.html의 뷰 안에는 회원인지 비회원인지 표시하는 기능이 있다고 합시다. 그러면 단순히 view를 리턴하는 것이 아닌, 현재의 세션 상태를 확인해서 동적으로 HTML을 렌더링해서 뷰를 리턴해야할 것입니다.

 

Home 옆에 세션 정보를 표시한다고 합시다.

문제는 이러한 세션과 관련된 로직은 하나의 URL에만 적용되지 않겠죠? 이러한 상단 navigator 바에 표시해야한다면 모든 URL을 클릭할 때마다 세션을 검증하는 로직이 필요할 것입니다. 그렇다면 n개의 url이 있다고하면 n개만큼의 동일한 로직이 handler에 포함되어야할 것입니다. 아주 보기가 좋겠죠?

 @MethodType(value = "GET")
    public String home(HttpRequest httpRequest, HttpResponse httpResponse) {
        Optional<String> sessionId = httpRequest.getSessionId();
        //Home 아이콘에 비회원 Or 회원 ID를 표시해주는 기능
        httpResponse.setModelAttribute("loginedUserId", "비회원");
         if (!sessionId.isEmpty()) {
            String parsedSessionId = HttpRequestUtils.parseSessionId(sessionId.get());

            User loginedUser = SessionDb.getUserBySessionId(parsedSessionId);

            //유효한 세션이 아닌 경우 쿠키를 초기화
            if (loginedUser == null) {
                //유효 세션이 아니면 요청에 보내고 있는 쿠키 무효화하기
                httpResponse.addHeader("Set-Cookie", String.format("sid=%s; Path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT;", parsedSessionId));
             throw new UserInfoException("세션이 만료되었습니다.");
            }

            httpResponse.setModelAttribute("loginedUserId", loginedUser.getUserId());
        }
         return "/index.html";
    }

 

그렇다면, OOP에 기반하여 항상 해왔듯이 중복되는 코드를 리팩토링해봅시다. 이렇게 하면 어떨까요? 

 @MethodType(value = "GET")
    public String home(HttpRequest httpRequest, HttpResponse httpResponse) {
        //Home 아이콘에 비회원 Or 회원 ID를 표시해주는 기능
        checkCurrentSession(httpRequest, httpResponse);
        
        return "/index.html";
    }

한 줄이라 간단해 보입니다. 그렇지만 다음 코드처럼 만약 관심사를 분리해야하는 항목이 훨씬 더 많다면 어떨까요?

예를 들어 모든 핸들러의 전/후로 로깅을 찍고, 세션을 확인하는 것만 생각해봅시다.

 @MethodType(value = "GET")
    public String home(HttpRequest httpRequest, HttpResponse httpResponse) {
        doPreLogging();
        checkCurrentSession(httpRequest, httpResponse);
        ...
        doPostLogging();
        
        return "/index.html";
    }

 

어느새 다시 복잡도가 올라가고 있습니다. 아래에서 소개할 동적 프록시 객체를 이용하면 요청이 들어왔을 때 요청을 위임할 객체를 실시간으로 생성해서 특정 로직을 수행하게 구현할 수 있습니다.

그리고, Spring의 Interceptor, 그리고 Servlet에서 제공하는 J2EE 표준 스펙인 Filter 등에서는 이러한 동적 프록시를 이용하여 Dispatcher Servlet이 컨트롤러를 호출하기 전, 후에 요청과 응답을 가로채 어떠한 처리를 할 수 있게 됩니다.

 

 @MethodType(value = "GET")
    public String home(HttpRequest httpRequest, HttpResponse httpResponse) {
        //관심사를 분리하여, Controller에서는 비즈니스 로직만 처리하도록 구현하고 싶다!
        return "/index.html";
    }

---

프록시

---

먼저, 프록시가 무엇인지에 대해서 알아봅시다. 프록시란, 대상 객체의 기능을 대신 수행하는 객체를 말합니다. 대상 객체를 감싸고 있으며, 대신 기능을 수행하므로, 대상 객체에 직접적으로 접근할 필요가 없습니다. 프록시는 보안, 로깅, 캐싱 등 다양한 용도로 활용됩니다.

 

아래는 간단한 정적 프록시로 이미지 캐싱을 수행하는 예제입니다. 공통의 인터페이스를 정의하고, 프록시 객체를 만들어 수행하고 싶은 동작을 구현해주는 예제를 살펴봅시다.

 

공통의 인터페이스를 갖는 프록시

public interface Image {
    void display();
}

public class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName){
        this.fileName = fileName;
        loadFromDisk(fileName);
    }

    @Override
    public void display() {
        System.out.println("Displaying " + fileName);
    }

    private void loadFromDisk(String fileName){
        System.out.println("Loading " + fileName);
    }
}

public class ProxyImage implements Image{
    private RealImage realImage;
    private String fileName;

    public ProxyImage(String fileName){
        this.fileName = fileName;
    }

    @Override
    public void display() {
        if(realImage == null){
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}

public class Main {
    public static void main(String[] args) {
        Image image = new ProxyImage("test.jpg");

        // 처음 호출시 실제 이미지 로딩
        image.display();
        System.out.println("");

        // 두번째 호출시 실제 이미지 로딩 없이 캐시에서 불러옴
        image.display();
    }
}

위처럼 작성했을 때, 클라이언트가 요청했을 때 흐름은 아래와 같을 것입니다. Proxy image가 요청을 받고, 필요에 따라 real image로 요청을 위임하는 방식으로 작동합니다.

 

이렇게 프록시 객체를 직접 구현해주는 방식을 정적 프록시라고 하는데요, 쉽지만 단점이 있습니다. 단점은 바로, 구현체를 구현해야하기 때문에, 프록시를 도입하고자 하는 클래스만큼 프록시 클래스를 만들고 구현해주어야한다는 것입니다. 몇 개 안된다면 괜찮겠지만, 보통 인프라 로직은 중복되고 불러오는 시점이 동일한 경우가 많습니다. 비슷비슷한 로직인데도 계속 구현체를 만들어주는게 굉장히 비효율적입니다. 따라서 이 단점을 보완하는 방법이 동적 프록시인데, 이에 대해 살펴보겠습니다.

---

동적 프록시

---

동적 프록시는, 모든 구현체를 구현하는 것이 아닌, 실행 시점에 동적으로 프록시를 생성하고 동적으로 타겟 메소드에 위임하는 방법을 뜻합니다. 동적 프록시를 구현하는 방법에는 두 가지가 있습니다.

1. JDK DynamicProxy - InvocationHandler를 구현해서 사용합니다. 반드시 인터페이스가 존재해야합니다.
2. CGLIB(Code Generator Library) - MethodInterceptor 인터페이스를 구현해서 사용합니다. 인터페이스가 없이 구현체만 있어도 프록시를 생성할 수 있습니다.

JDK Dynamic Proxy 방식

JDK 동적 프록시 방식의 특징은 아래와 같습니다.

• JDK에서 제공하는 Interface 기반으로 Proxy를 생성해주는 방식, 1.3버전 이후부터 지원된다.
• Interface 기반이므로 Interface 구현을 강제화한다는 단점이 있다.
• Invocation Handler를 상속받아 구현하는데, Reflection 사용으로 인한 성능이 떨어진다.

주의할 점은 반드시 프록시 객체와 Target 구현체가 동일한 Interface를 상속해야한다는 것입니다. 프록시 객체는 동적으로 생성되므로 Target 구현체가 구현되는 Interface가 존재해야한다는 의미입니다. 그리고 Proxy 객체가 처리하고 싶은 로직은 MethodInterceptor에서 상속받아서 구현하면 됩니다. 

public class MyInterceptor implements MethodInterceptor {
    public Object invoke(MethodInvocation invocation) throws Throwable {
        preHandle();
        Object result = invocation.proceed();
        postHandle();
        return result;
    }

    private void preHandle() {
        System.out.println("preHandle() is called.");
    }

    private void postHandle() {
        System.out.println("postHandle() is called.");
    }
}

public class Main {
    public static void main(String[] args) {
        MyInterface target = new MyClass();
        MyInterceptor interceptor = new MyInterceptor();

        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            interceptor
        );

        proxy.doSomething();
    }
}

간단히 요약하면 아래와 같습니다.

1. InvocationHandler 인터페이스를 구현한 구현체를 만듭니다.
2. 프록시가 참조할 실제 객체를 만듭니다.
3. Proxy.newInstance로 Proxy 객체를 생성합니다. 이 때 클래스 로더 정보, 클래스 정보, 프록시 타겟 정보 등 메타 정보로 객체가 생성되도록 합니다.
4. Proxy.call()로 프록시를 호출할 수 있습니다. 이 때, handler의 invoke가 호출되고 메타 정보가 target의 invoke에 넘어갑니다.

CGLib

CGLIB은 바이트코드를 기반으로 자바에서 런타임에 동적으로 인터페이스 없이 구체 클래스 만으로 자바 클래스의 프록시를 생성해주는 라이브러리입니다. 

• Code Generator Library
• Enhancer를 바탕으로 Proxy를 구현하는 방식입니다.
• Hibernate, Spring, Mockito 등에서 사용됩니다. 성능이 상대적으로 더 빠르다고 알려져있다고 합니다.
• 스프링은 ProxyFactory로 동적 프록시 추상화 라이브러리를 제공합니다.
• JDK dynamic proxy에서 InvocationHandler를 구현해서 프록시 객체를 구현한 것처럼, CGLIB에서는 MethodInterceptor로 구현 가능합니다.

 

CGLIB는 인터페이스를 구현하는 것이 아닌, 타겟의 클래스를 상속 받아서 프록시를 생성합니다. 이 과정에서 CGLIB는 타겟 클래스에 포함된 모든 메소드를 재정의하고, 바이트 코드를 조작하여 프록시를 생성하게 됩니다. 따라서 CGLIB를 적용할 클래스는 final 메소드가 들어있거나, final 클래스면 에러가 발생합니다. 더불어, private 접근자로 된 메소드도 상속이 불가하므로 주의가 필요합니다.

간단하게 우선, 아무런 동작도 하지 않고 프록시로 감싼 컨트롤러의 구현을 살펴보겠습니다. setSuperClass()로 target 구현체를 지정할 수 있으며, setCallBack()으로 프록시 객체가 실행할 인스턴스를 지정할 수 있습니다.

Enhancer enhancer = new Enhancer();
                    enhancer.setSuperclass(controllerImpl.getClass());
                    //어떤 동작도 하지 않음
                    enhancer.setCallback(NoOp.INSTANCE);
                    Controller proxyController = (Controller) enhancer.create();

                    mapper.put(controllerImpl.getDeclaredAnnotation(RequestMapping.class).url(),
                            proxyController);

 

정리하면, 아래와 같습니다.

1. 타겟 구현체를 생성합니다.
2. MethodInterceptor를 구현하는 구체 클래스를 생성하여, 프록시 몸통을 만들어줍니다.
3. CGLIB 프록시 생성자 역할을 할 Enhancer()를 만듭니다.
4. Enhancer에 setCallBack을 통해 프록시 몸통이 실행할 callBack 인스턴스를 지정합니다.
5. Enhacer를 통해 프록시를 생성합니다.

아래는, 도입부의 interceptor를 CGLIB으로 구현한 예시입니다. Controller Mapping을 Controller 대신 Proxy Controller로 이루어지도록 하여, 관심사의 분리가 가능해졌습니다.

Enhancer enhancer = new Enhancer();
                    enhancer.setSuperclass(controllerImpl);

                    enhancer.setCallback(new Interceptor());
                    Controller proxyController = (Controller) enhancer.create();

                    mapper.put(controllerImpl.getDeclaredAnnotation(RequestMapping.class).url(),
                            proxyController);

public class Interceptor implements MethodInterceptor {

    private static final Logger logger = LoggerFactory.getLogger(Interceptor.class);

	//세션 초기화 및 로깅 인터셉터 구현
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
        throws Throwable {
        //원하는 Method만 PointCut합니다. 여기에서는 process()에만 적용했습니다.
        if (method.getName().contains("process")) {
            try {
                prehandle(obj, method, args);
            } catch (UserInfoException e) {
                logger.debug("현재 세션이 유효하지 않아 초기화됩니다.");
                return "redirect:/";
            }
            Object object = proxy.invokeSuper(obj, args);
            posthandle(obj, method);
            return object;
        }

		//PointCut 지점이 아니더라도 target의 메서드를 invoke해주어야합니다.
        return proxy.invokeSuper(obj, args);
    }

    private void prehandle(Object obj, Method method, Object[] args) {
        logger.debug("실행 전 - 현재 실행 클래스 : {}, 메소드 : {}", obj.getClass().getSuperclass().toString(), method.getName() );
        checkCurrentSession((HttpRequest) args[0], (HttpResponse) args[1]);
    }

    private void posthandle(Object obj, Method method) {
        logger.debug("실행 후 - 현재 실행 클래스 : {}, 메소드 : {}", obj.getClass().getSuperclass().toString(), method.getName() );
    }
}

 

참고 - 스프링의 Proxy Factory

스프링에서는 클라이언트가 메서드를 요청하면 ProxyFactoryBean에서 인터페이스 유무를 확인하여 인터페이스가 있으면 JDK Dynamic Proxy를 호출하고 없으면 CGLIB 방식으로 프록시를 생성한다고 합니다. 다음에 기회가 된다면 자세히 다루어보겠습니다.