[Spring] 동적 프록시 기술 (2) - JDK DynamicProxy

동적 프록시 기술은 언제 사용될까?

프록시 기술을 적용하기 위함인데, 앞에 동적이라는 단어가 왜 붙었는지 생각해보자. 

만약 100개의 클래스가 프록시 적용 대상이라고 하자. 그럼 100개의 클래스에 적용할 100개의 프록시를 개별적으로 만들어야할까? 단순 로그를 적용하는 기능의 프록시라면, 로직은 같은데 적용 대상에만 차이가 있는 것이다.

 

이 문제를 해결할 수 있는 것이 동적 프록시 기술이다. 동적 프록시 기술을 활용하면 개발자가 매번 프록시 클래스를 만들지 않아도 된다. 이름대로 프록시 객체를 동적으로 런타임에 (개발자 대신) 만들어준다.  그럼 코드를 보면서 어떤식으로 동적 프록시가 생성되고 적용되는지 확인해보자. 참고로 JDK 동적 프록시는 인터페이스를 기반으로 동적 프록시를 생성하기 때문에, 인터페이스가 필수다. 

 

 

AImpl 과 BImpl 은 각각 AInterface 와 BInterface를 구현한다. 두 인터페이스 모두 call() 추상 메서드를 갖는다.

// AInterface
public interface AInterface {
    String call();
}

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



// BInterface
public interface BInterface {
    String call();
}

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

 

InvocationHandler

JDK 동적 프록시가 제공하는 InvocationHander 를 구현하기 위해선 InvocationHandler 인터페이스를 구현하면 된다. 

아래 InvocationHandler 인터페이스는 JDK에서 제공하는 기본 패키지다.

package java.lang.reflect; // 자바에서 기본으로 제공하는 reflect 패키지

public interface InvocationHandler {
    Object invoke(Object var1, Method var2, Object[] var3) throws Throwable;
}

 

TimeInvocationHandler

InvocationHander 인터페이스를 구현한다. 생성자로 프록시를 적용할 대상인 target 객체를 주입받는다. 프록시는 대리자라는 의미를 가지기에 항상 원본 target 이 필요하다고 이해할 수 있다. 

@Slf4j // 실행 시간을 체크하기 위한 로그 -> 이걸 대상 클래스에 삽입하겠다.
public class TimeInvocationHandler implements InvocationHandler { // JDK 동적 프록시에 적용할 공통 로직을 담는 클래스

    private final Object target; // Proxy 는 항상 프록시가 호출할 대상이 필요

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

    @Override  // Proxy 객체가 call 하면 여기(invoke)가 수행됨
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("TimeProxy 실행");
        long startTime = System.currentTimeMillis();

        // 메서드를 호출하는 부분이 동적이다 => 어떠한 클래스나 그에 속하는 메서드를 다 사용할 수 있다는 뜻
        Object result = method.invoke(target, args); // AImpl or BImpl 의 call() 실행. 결과를 result 에 담음.

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

 

테스트 코드로 TimeInvocationHandler 를 실제 객체에 적용해보자. 

@Slf4j
public class JdkDynamicProxyTest {

    @Test
    void dynamicA() {
        AInterface target = new AImpl();
        TimeInvocationHandler handler = new TimeInvocationHandler(target); 
        // handler : 동적 프록시에 적용할 로직이 돤다.

        // Interface 가 여러개 있을 수 있으니, 배열로 받는다.
        AInterface proxy = (AInterface) Proxy.newProxyInstance(AInterface.class.getClassLoader(), new Class[]{AInterface.class}, handler);
        // 동적으로 프록시 객체를 생성해낸다.

        // client 는 JDK 동적 프록시의 call 을 실행
        proxy.call(); // AInterface 에 call() 메서드 존재
        // call() 하면 proxy 는 handler 의 로직을 수행한다.
        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(BInterface.class.getClassLoader(), new Class[]{BInterface.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) 
  • 동적 프록시는 java.lang.reflect.Proxy 를 통해 생성할 수 있다.
  • 인자로 1) 클래스 로더 정보, 2) 인터페이스, 3) 핸들러 로직을 넣어주면 된다. 해당 인터페이스를 기반으로 동적 프록시를 생성하고 그 결과를 반환한다. 

 

dynamicA() 테스트 결과

 

실행 순서

1. 클라이언트는 JDK 동적 프록시의 call() 을 실행한다. 이 call() 은 AInterface / Binterface 에 선언된 추상 메서드를 의미한다. 

하지만 프록시의 call() 메서드를 호출했으므로, AImpl, BImpl에 구현된 call() 메서드를 바로 호출하지 않고, proxy 객체의 call() 을 호출한다.

 

2. InvocationHandler 의 invoke() 메서드를 호출하는데, TimeInvocationHandler 가 구현체로 있으므로 TimeInvocationHandler.invoke() 가 호출된다. 

 

3. TimeInvocationHandler 에 정의된 내부 로직을 수행하고, method.invoke(target, args) 를 호출해서 target에 해당되는 실제 객체(AImpl / BImpl) 을 호출한다. 

 

4. AImpl / BImpl 의 call() 메서드가 실행된다. 

 

5. call() 메서드가 종료되면 다시 TimeInvocationHandler 로 응답이 돌아오고, 시간 로그를 출력하여 결과를 반환한다.

 

중간 정리

JDK 동적 프록시 기술 덕분에, AImpl, BImpl 각각의 프록시를 만들지 않아도, 프록시 기술을 적용할 수 있었다. 서두에서 언급한 100개의 클래스가 존재해도, 동적 프록시 기술을 적용하면 SRP 를 지키면서 프록시를 적용할 수 있다. 

 

JDK 동적 프록시 - 필터 

로그를 남기는 프록시를 적용할 때, 특정 메서드에는 로그 기능을 제외하고 싶을 수 있다. 그런 경우, PatternMatchUtils.simpleMatch() 같은 매칭 로직을 적용하여 공통 로직(로깅)을 제외할 수 있다. FilterInvocationHandler 는 if 문에서 분기처리하여 로그를 적용할 대상을 거른다. 

@Slf4j
public class FilterInvocationHandler implements InvocationHandler {

    private final Object target;
    private final String[] patterns;

    public FilterInvocationHandler(Object target, String[] patterns) {
        this.target = target;
        this.patterns = patterns;
    }

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

        String methodName = method.getName();
        if (!PatternMatchUtils.simpleMatch(patterns, methodName)) {
            return method.invoke(target, args);
        }
        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;
    }
}

// AImpl 도 아래와 같은 구조를 가지며, 로그 내용만 다르다. 
@Slf4j
public class BImpl implements BInterface {
    @Override
    public String call() {
        log.info("B 호출");
        return "b";
    }

    @Override
    public String filterCall() {
        log.info("B 필터");
        return "filter";
    }
}

@Slf4j
public class JDKDynamicProxyFilterTest {
    
    public static final String[] PATTERNS = {"call*"};

    @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();
        proxy.filterCall();
    }

    @Test
    void dynamicB() {
        BInterface target = new BImpl();
        FilterInvocationHandler handler = new FilterInvocationHandler(target, PATTERNS); // 동적 프록시에 적용할 로직이 돤다.

        BInterface proxy = (BInterface) Proxy.newProxyInstance(BInterface.class.getClassLoader(), new Class[]{BInterface.class}, handler);

        proxy.call();
        proxy.filterCall();
    }
}

 

dynamicA() 메서드에서는 기존 TimeInvocationHandler() 를 호출했다. proxy.call(), proxy.filterCall() 메서드 모두 time logging 이 함께 출력되는 것을 볼 수 있다.

 

dynamicB() 메서드에서는, 필터처리를 할 FilterInvocationHandler() 를 호출했고, PATTERNS 까지 생성자 주입을 받는다.  그 결과 proxy.call() 에서는 타임 로깅이 찍히지만, proxy.filterCall() 에서는 타임 로깅이 찍히지 않는 것을 확인할 수 있다.

 

정리

JDK 동적 프록시는 인터페이스가 필수다. 즉 구현체로만 이루어진 클래스에는 동적 프록시를 적용할 수 없다는 뜻인데, 이런 경우에는 CGLIB 라는 바이트코드 조작 라이브러리를 사용해야한다.  다음 포스팅에선 CGLIB 를 활용한 동적 프록시를 적용해보자 .

 

코드 및 자료 출처

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