[스프링 핵심원리 - 고급편] #6. 동적 프록시 기술(2)

[YONGHYNG]

JDK 동적 프록시 - 소개

• 지금까지 프록시를 적용하기 위해 적용 대상의 숫자 만큼 많은 프록시 클래스를 만듦
• 적용 대상이 100개면 프록시 클래스도 100개 만듦, 그런데 앞서 살펴본 것과 같이 프록시 클래스의 기본 코드와 흐름은 거의 같고, 프록시를 어떤 대상에 적용하는가 정도만 차이가 있음
• 쉽게 이야기해서 프록시의 로직은 같은데, 적용 대상만 차이가 있는 것
• 이 문제를 해결하는 것이 바로 동적 프록시 기술
• 동적 프록시 기술을 사용하면 개발자가 직접 프록시 클래스를 만들지 않아도 됨, 이름 그대로 프록시 객체를 동적으로 런타임에 개발자 대신 만들어줌
• 그리고 동적 프록시에 원하는 실행 로직을 지정할 수 있고, 사실 동적 프록시는 말로는 이해하기 쉽지 않아 예제 코드를 보자

주의

• JDK 동적 프록시는 인터페이스를 기반으로 프록시를 동적으로 만듦 따라서 인터페이스가 필수

기본 예제 코드

• JDK 동적 프록시를 이해하기 위해 아주 단순한 예제 코드를 만듦
• 간단히 A , B 클래스를 만드는데, JDK 동적 프록시는 인터페이스가 필수, 따라서 인터페이스와 구현체로 구분

AInterface

package hello.proxy.jdkdynamic.code;

public interface AInterface {
        String call();
}

AImpl

package hello.proxy.jdkdynamic.code;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class AImpl implements AInterface {
     @Override
     public String call() {
           log.info("A 호출");
           return "a";
       }
}

BInterface

package hello.proxy.jdkdynamic.code;

public interface BInterface {
        String call();
}

BImpl

package hello.proxy.jdkdynamic.code;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class BImplimplements **BInterface** {
     @Override
     public String call() {
           log.info("B 호출");
           return "b";
       }
}

JDK 동적 프록시 - 예제 코드

JDK 동적 프록시 InvocationHandler

• JDK 동적 프록시에 적용할 로직은 InvocationHandler 인터페이스를 구현해서 작성하면 됨
• 프록시가 대신 메서드를 실행할 때, 그 안에서 뭐할지 정해주는 설계도
• 메서드 실행 전/후에 추가 작업을 끼워넣고 싶을 때 사용

JDK 동적 프록시가 제공하는 InvocationHandler

package lang.reflect;

public interface InvocationHandler {

    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;

}

제공되는 파라미터는 다음과 같음

• Object proxy : 프록시 자신
• Method method : 호출한 메서드
• Object[] args : 메서드를 호출할 때 전달한 인수

TimeInvocationHandler

package lang.reflect;

import lombok.extern.slf4j.Slf4j;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

@Slf4j
//InvocationHandler 인터페이스를 직접 구현해서 프록시 객체가 메서드를 호출할 때 "대신 처리해주는 역할"
public class TimeInvocationHandler implements InvocationHandler{

    private final Object target; //일을 처리할 원래 객체

    public TimeInvocationHandler(Object target){ //생성자
        this.target = target;
    }

    @Override
    //프록시가 대신 메서드를 호출할 때 무조건 실행
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        log.info("TimeProxy실행");
        long startTime =System.currentTimeMillis();

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

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

• TimeInvocationHandler 은 InvocationHandler 인터페이스를 구현, 이렇게해서 JDK 동적 프록시에 적용할 공통 로직을 개발
• Object target : 동적 프록시가 호출할 대상
• method.invoke(target, args) : 리플렉션을 사용해서 target 인스턴스의 메서드를 실행, args는 메서드 호출시 넘겨줄 인수

TimeInvocationHandler 내부 동작

proxy.call()
↓
invoke(proxy, method, args)
↓
공통 로직 (시간 측정)
↓
method.invoke(target, args) → 진짜 객체의 메서드 실행
↓
공통 로직 (시간 측정 종료 + 로그)
↓
결과 리턴

JdkDynamicProxyTest

package hello.proxy.jdkdynamic;

import hello.proxy.jdkdynamic.code.AImpl;
import hello.proxy.jdkdynamic.code.AInterface;
import hello.proxy.jdkdynamic.code.BImpl;
import hello.proxy.jdkdynamic.code.BInterface;
import lang.reflect.TimeInvocationHandler;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

import java.lang.reflect.Proxy;

@Slf4j
public class JdkDynamicProxyTest {

    @Test
    void dynamicA(){
        AInterface target = new AImpl();
        TimeInvocationHandler handler = new TimeInvocationHandler(target);
        AInterface proxy = (AInterface)Proxy.newProxyInstance(AInterface.class.getClassLoader(), new Class[]{AInterface.class}, handler);
        proxy.call();
        log.info("targetClass={}", target.getClass());
        log.info("proxyClass={}", proxy.getClass());
    }

    @Test
    void dynamicB(){
        BInterface target = new BImpl();
        TimeInvocationHandler handler = new TimeInvocationHandler(target);
        BInterface proxy = (BInterface) Proxy.newProxyInstance(AInterface.class.getClassLoader(), new Class[]{AInterface.class}, handler);
        proxy.call();
        log.info("targetClass={}", target.getClass());
        log.info("proxyClass={}", proxy.getClass());
    }
}

• new TimeInvocationHandler(target) : 동적 프록시에 적용할 핸들러 로직
• Proxy.newProxyInstance(AInterface.class.getClassLoader(), new Class[] {AInterface.class}, handler)

1. 동적 프록시는 java.lang.reflect.Proxy 를 통해서 생성할 수 있음
2. 클래스 로더 정보, 인터페이스, 그리고 핸들러 로직을 넣어주면 됨, 그러면 해당 인터페이스를 기반으로
   동적 프록시를 생성하그결과를 반환

생성된 JDK 동적 프록시

• proxyClass=class com.sun.proxy.$Proxy1 이 부분이 동적으로 생성된 프록시 클래스 정보
• 이것은 우리가 만든 클래스가 아니라 JDK 동적 프록시가 이름 그대로 동적으로 만들어준 프록시
• 이 프록시는 TimeInvocationHandler 로직을 실행

실행 순서

1. 클라이언트는 JDK 동적 프록시의 call() 을 실행
2. JDK 동적 프록시는 InvocationHandler.invoke() 를 호출, TimeInvocationHandler 가 구현체로 있으로TimeInvocationHandler.invoke() 가 호출
3. TimeInvocationHandler 가 내부 로직을 수행하고, method.invoke(target, args) 를 호출해서 target 인 실제 객체( AImpl )를 호출
4. AImpl 인스턴스의 call() 이 실행
5. AImpl 인스턴스의 call() 의 실행이 끝나면 TimeInvocationHandler 로 응답이 돌아옴,
6. 시간 로그를 출력하고 결과를 반환한다.

동적 프록시 클래스 정보
dynamicA() 와 dynamicB() 둘을 동시에 함께 실행하면 JDK 동적 프록시가 각각 다른 동적 프록시 클래스를 만
들어주는 것을 확인 가능

proxyClass=class com.sun.proxy.$Proxy1 //dynamicA
proxyClass=class com.sun.proxy.$Proxy2 //dynamicB

정리

• 예제를 보면 AImpl , BImpl 각각 프록시를 만들지 않음, 프록시는 JDK 동적 프록시를 사용해서 동적으로 만듦
• TimeInvocationHandler 는 공통으로 사용 JDK 동적 프록시 기술 덕분에 적용 대상 만큼 프록시 객체를 만들지 않아도 됨
• 그리고 같은 부가 기능 로직을 한번만 개발해서 공통으로 적용 가능, 만약 적용 대상이 100개여도 동적 프록시를 통해서 생성하고, 각각 필요한 InvocationHandler 만 만들어서 넣어주면 됨
• 결과적으로 프록시 클래스를 수 없이 만들어야 하는 문제도 해결하고, 부가 기능 로직도 하나의 클래스에 모아서 단일책임 원칙(SRP)도 지킬 수 있게 됨
• JDK 동적 프록시 없이 직접 프록시를 만들어서 사용할 때와 JDK 동적 프록시를 사용할 때의 차이를 그림으로 비교
• 예전에는 프록시를 직접 클래스 하나씩 만들었음, 이제는 JDK 동적 프록시가 프록시 객체를 자동으로 만들어줌
• 공통로직은 InvocationHandler 하나만 만들어서 처리하면 끝

JDK 동적 프록시 도입 후

• 지금까지 학습한 JDK 동적 프록시를 애플리케이션에 적용

JDK 동적 프록시 - 적용1

• JDK 동적 프록시는 인터페이스가 필수이기 때문에 V1 애플리케이션에만 적용할 수 있음
• 먼저 LogTrace 를 적용할 수 있는 InvocationHandler 를 만듦

LogTraceBasicHandler

package hello.proxy.config.v2_dynamicproxy.handler;

import hello.proxy.trace.TraceStatus;
import hello.proxy.trace.logtrace.LogTrace;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class LogTraceBasicHandler implements InvocationHandler {

    private final Object target; //진짜 객체 - 실제로 기능을 수행하는 구현체
    private final LogTrace logTrace; //로그 추적기를 담당하는 객체(메서드 시작/종료/예외를 로깅)
    public LogTraceBasicHandler(Object target, LogTrace logTrace) {
        this.target = target;
        this.logTrace = logTrace;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws
            Throwable {
        TraceStatus status = null;
        try {
            String message = method.getDeclaringClass().getSimpleName() + "."
                    + method.getName() + "()";
            status = logTrace.begin(message);
            //로직 호출
            Object result = method.invoke(target, args);
            logTrace.end(status);
            return result;
        } catch (Exception e) {
            logTrace.exception(status, e);
            throw e;
        }
    }
}

• LogTraceBasicHandler 는 InvocationHandler 인터페이스를 구현해서 JDK 동적 프록시에서 사용
• private final Object target : 프록시가 호출할 대상 String message = method.getDeclaringClass().getSimpleName() + "." ... LogTrace 에 사용할 메시지
• 프록시를 직접 개발할 때는 "OrderController.request()" 와 같이 프록시마다 호출되는 클래스와 메서드 이름을 직접 남김 이제는 Method 를 통해서 호출되는 메서드 정보와 클래스 정보를 동적으로 확인할 수 있기 때문에 이 정보를 사용하면 됨
• 동적 프록시를 사용하도록 수동 빈 등록을 설정

DynamicProxyBasicConfig

package hello.proxy.config.v2_dynamicproxy;
import hello.proxy.app.v1.*;
import hello.proxy.config.v2_dynamicproxy.handler.LogTraceBasicHandler;
import hello.proxy.trace.logtrace.LogTrace;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.lang.reflect.Proxy;

@Configuration
public class DynamicProxyBasicConfig {
    @Bean
    public OrderControllerV1 orderControllerV1(LogTrace logTrace) {
        OrderControllerV1 orderController = new
                OrderControllerV1Impl(orderServiceV1(logTrace));
        OrderControllerV1 proxy = (OrderControllerV1)
                Proxy.newProxyInstance(OrderControllerV1.class.getClassLoader(),
                        new Class[]{OrderControllerV1.class},
                        new LogTraceBasicHandler(orderController, logTrace)
                );
        return proxy;
    }
    @Bean
    public OrderServiceV1 orderServiceV1(LogTrace logTrace) {
        OrderServiceV1 orderService = new
                OrderServiceV1Impl(orderRepositoryV1(logTrace)); //orderRepositoryV1() -> 이미 프록시 적용됨
        OrderServiceV1 proxy = (OrderServiceV1)
                Proxy.newProxyInstance(OrderServiceV1.class.getClassLoader(),
                        new Class[]{OrderServiceV1.class},
                        new LogTraceBasicHandler(orderService, logTrace)
                );
        return proxy;
    }
    @Bean
    public OrderRepositoryV1 orderRepositoryV1(LogTrace logTrace) {
        OrderRepositoryV1 orderRepository = new OrderRepositoryV1Impl(); //객체를 만듦
        OrderRepositoryV1 proxy = (OrderRepositoryV1)
                Proxy.newProxyInstance(OrderRepositoryV1.class.getClassLoader(),
                        new Class[]{OrderRepositoryV1.class},

                        //LogTraceBasicHandler를 통해 동적 프록시 생성
                        new LogTraceBasicHandler(orderRepository, logTrace) 
                );
        return proxy;
    }
}

• 이전에는 프록시 클래스를 직접 개발했지만, 이제는 JDK 동적 프록시 기술을 사용해서 각각의 Controller ,
  Service , Repository 에 맞는 동적 프록시를 생성해주면 됨
• LogTraceBasicHandler : 동적 프록시를 만들더라도 LogTrace 를 출력하는 로직은 모두 같기 때문에 프록
  시는 모두 LogTraceBasicHandler 를 사용

ProxyApplication - 수정

import hello.proxy.config.v2_dynamicproxy.DynamicProxyBasicConfig;

//@Import({AppV1Config.class, AppV2Config.class})
//@Import(InterfaceProxyConfig.class)
//@Import(ConcreteProxyConfig.class)

@Import(DynamicProxyBasicConfig.class)
@SpringBootApplication(scanBasePackages = "hello.proxy.app")
public class ProxyApplication {
           public static void main(String[] args) {
                 SpringApplication.run(ProxyApplication.class, args);
           }
           @Bean
           public LogTrace logTrace() {
                 return new ThreadLocalLogTrace();
    }
}

• @import(DynamicProxyBasicConfig.class) : 이제 동적 프록시 설정을 @import 하고 실행

남은 문제
=> no-log를 실행해도 동적 프록시가 적용되고, LogTraceBasicHandler가 실행되기 떄문에 로그가 남음, 이 부분을 로그가 남지 않도록 처리해야 함

JDK 동적 프록시 - 적용2

• 메서드 이름 필터 기능 추가
• 요구사항에 의해 이것을 호출 했을 때는 로그가 남으면 안 됨
• 이런 문제를 해결하기 위해 메서드 이름을 기준으로 특정 조건을 만족할 때만 로그를 남기는 기능을 개발

LogTraceFilterHandler

package hello.proxy.config.v2_dynamicproxy.handler;

import hello.proxy.trace.TraceStatus;
import hello.proxy.trace.logtrace.LogTrace;
import lang.reflect.InvocationHandler;
import org.springframework.util.PatternMatchUtils;

import java.lang.reflect.Method;

public class LogTraceFilterHandler implements InvocationHandler {

    private final Object target; //실제 비즈니스 객체 Impl 객체
    private final LogTrace logTrace; //로그 추적기 
    private final String[] patterns; //로그 추적할 때 메서드 이름 패턴들

    public LogTraceFilterHandler(Object target, LogTrace logTrace, String... patterns) {
        this.target = target;
        this.logTrace = logTrace;
        this.patterns = patterns;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //메서드 이름 필터
        String methodName = method.getName();
        //PatternMatchUtils.simpleMatch()를 통해 메서드 이름을 패턴과 비교
        if(!PatternMatchUtils.simpleMatch(patterns, methodName)) { 
            return method.invoke(target, args); //필터에 안 걸리면 그냥 실행
        }

        TraceStatus status = null;

        try {
            String message = method.getDeclaringClass().getSimpleName() + "." +
                    method.getName() + "()";
            status = logTrace.begin(message);

            //로직 호출
            Object result = method.invoke(target, args);

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

• LogTraceFilterHandler 는 기존 기능에 다음 기능이 추가 됨
• 특정 메서드 이름이 매칭 되는 경우에만 LogTrace 로직을 실행
• 이름이 매칭되지 않으면 실제 로직을 바로 호출
• 스프링이 제공하는 PatternMatchUtils.simpleMatch(..) 를 사용하면 단순한 매칭 로직을 쉽게 적용 가능

xxx : xxx가 정확히 매칭되면 참
xxx* : xxx로 시작하면 참
*xxx : xxx로 끝나면 참
xxx : xxx가 있으면 참

• String[] patterns : 적용할 패턴은 생성자를 통해서 외부에서 받음

DynamicProxyFilterConfig

package hello.proxy.config.v2_dynamicproxy;

import hello.proxy.app.v1.*;
import hello.proxy.config.v2_dynamicproxy.handler.LogTraceFilterHandler;
import hello.proxy.trace.logtrace.LogTrace;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.lang.reflect.Proxy;

@Configuration
public class DynamicProxyFilterConfig {
    private static final String[] PATTERNS = {"request*", "order*", "save*"};

    @Bean
    public OrderControllerV1 orderControllerV1(LogTrace logTrace) {
        OrderControllerV1 orderController = new
                OrderControllerV1Impl(orderServiceV1(logTrace));
        OrderControllerV1 proxy = (OrderControllerV1)
                Proxy.newProxyInstance(OrderControllerV1.class.getClassLoader(),
                        new Class[]{OrderControllerV1.class},
                        new LogTraceFilterHandler(orderController, logTrace, PATTERNS)
                );
        return proxy;
    }

    @Bean
    public OrderServiceV1 orderServiceV1(LogTrace logTrace) {
        OrderServiceV1 orderService = new
                OrderServiceV1Impl(orderRepositoryV1(logTrace));
        OrderServiceV1 proxy = (OrderServiceV1)
                Proxy.newProxyInstance(OrderServiceV1.class.getClassLoader(),
                        new Class[]{OrderServiceV1.class},
                        new LogTraceFilterHandler(orderService, logTrace, PATTERNS)
                );
        return proxy;
    }
    @Bean
    public OrderRepositoryV1 orderRepositoryV1(LogTrace logTrace) {
        OrderRepositoryV1 orderRepository = new OrderRepositoryV1Impl();
        OrderRepositoryV1 proxy = (OrderRepositoryV1)
                Proxy.newProxyInstance(OrderRepositoryV1.class.getClassLoader(),
                        new Class[]{OrderRepositoryV1.class},
                        new LogTraceFilterHandler(orderRepository, logTrace, PATTERNS)
                );
        return proxy;
    }
}

1. public static final String[] PATTERNS = {"request*", "order*", "save*"};
2. 적용할 패턴이다. request , order , save 로 시작하는 메서드에 로그가 남음
3. LogTraceFilterHandler : 앞서 만든 필터 기능이 있는 핸들러를 사용, 그리고 핸들러에 적용 패턴도 넣음

ProxyApplication - 추가

import hello.proxy.config.v2_dynamicproxy.DynamicProxyFilterConfig;

@Import(DynamicProxyFilterConfig.class)
@SpringBootApplication(scanBasePackages = "hello.proxy.app")
public class ProxyApplication {

     public static void main(String[] args) {
         SpringApplication.run(ProxyApplication.class, args);
     }

     @Bean
     public LogTrace logTrace() {
           return new ThreadLocalLogTrace();
     }
}

• @import(DynamicProxyFilterConfig.class) 으로 방금 만든 설정을 추가

JDK 동적 프록시 - 한계

• JDK 동적 프록시는 인터페이스가 필수
  그렇다면 V2 애플리케이션 처럼 인터페이스 없이 클래스만 있는 경우에는 어떻게 동적 프록시를 적용할 수 있을까?
  이것은 일반적인 방법으로는 어렵고 CGLIB 라는 바이트코드를 조작하는 특별한 라이브러리를 사용해야 함