[Spring] AOP 동작원리 : 리플렉션, JDK 동적 프록시

🎓 이 글은 인프런에서 제공하는 "스프링 핵심 원리 - 고급편" 강의를 수강하면서 정리한 내용을 바탕으로 작성한 글입니다.

https://inf.run/FWeFN

 

이전글 에서 프록시를 사용해서 기존 코드를 변경하지 않고 부가기능을 적용하는 방법을 알아봤다. 그러나 클래스 기반 프록시의 경우 부가기능을 적용해야 하는 대상 클래스가 100개라면 프록시 클래스도 100개 만들어야 했다. 프록시 클래스를 하나만 만들어서 모든 곳에 적용할 수는 없을까 ? 

 

자바가 기본으로 제공하는 JDK 동적 프록시 기술을 활용하면 프록시 객체를 동적으로 만들어낼 수 있다. 

JDK 동적 프록시를 이해하기 위해서는 먼저 자바의 리플렉션 기술을 이해해야 한다. 

 

※ 리플렉션 기술

• 리플렉션 기술을 통해 클래스나 메서드의 메타정보를 동적으로 획득할 수 있다
• 리플렉션 기술을 통해 코드를 동적으로 호출할 수 있다

먼저 아래 코드를 보자

@Test
void reflection0() {
    Hello target = new Hello();

    //공통 로직1 시작
    log.info("start");
    String result1 = target.callA(); //호출하는 메서드가 다음
    log.info("result={}", result1);
    //공통 로직1 종료

    //공통 로직2 시작
    log.info("start");
    String result2 = target.callB(); //호출하는 메서드가 다음
    log.info("result={}", result2);
    //공통 로직2 종료
}

 

공통로직 1과 2는 호출하는 메서드만 다르고 전체 코드 흐름이 완전 같다.

여기서 공통 로직 1과 2를 하나의 메서드로 뽑아서 합치고 싶다.

중간에 호출하는 메서드가 다르기때문에 쉬워 보이지만 메서드로 뽑아서 공통화하는 것이 어렵다. 

 

이때 사용하는 기술이 리플렉션이다. 

리플렉션은 클래스나 메서드의 메타정보를 사용해서 동적으로 호출하는 메서드를 변경할 수 있다. 

 

    @Test
    void reflection1() throws Exception {
        //클래스 정보
        Class classHello = Class.forName("hello.proxy.jdkdynamic.ReflectionTest$Hello");

        Hello target = new Hello();
        //callA 메서드 정보
        Method methodCallA = classHello.getMethod("callA");
        Object result1 = methodCallA.invoke(target);
        log.info("result1={}", result1);

        //callB 메서드 정보
        Method methodCallB = classHello.getMethod("callB");
        Object result2 = methodCallB.invoke(target);
        log.info("result2={}", result2);
    }

 

• Class classHello = Class.forName("hello.proxy.jdkdynamic.ReflectionTest$Hello");
  • Class.forName(...) 은 클래스 이름을 문자열로 받아서 클래스를 JVM 에 로딩하고 클래스의 메타정보를 반환하는 역할을 한다. 
  • () 안에는 패키지명부터 내부 클래스까지 포함한 "완전한 클래스 이름" 이 들어간다. 
  • 메타정보에 포함된 내용은 클래스이름, 필드 정보, 메서드 정보, 생성자정보, 상위클래스 등이 있다. 

classHello.getMethod("A") 를 통해 메서드 메타정보를 획득한 뒤, methodCallA 에 할당한다.

methodCallA.invoke(인스턴스) 는 지정한 인스턴스(target)의 메서드(A)를 실핼할 수 있게 한다.

이렇게 하면 메서드 정보를 동적으로 변경할 수 있게 된다. 

 

메서드 호출 부분 공통로직으로 분리해내기

   @Test
    void reflection2() throws Exception {
        //클래스 정보
        Class classHello = Class.forName("hello.proxy.jdkdynamic.ReflectionTest$Hello");

        Hello target = new Hello();
        Method methodCallA = classHello.getMethod("callA");
        dynamicCall(methodCallA, target);

        Method methodCallB = classHello.getMethod("callB");
        dynamicCall(methodCallB, target);
    }
    
    private void dynamicCall(Method method, Object target) throws Exception {
        log.info("start");
        Object result = method.invoke(target);
        log.info("result={}", result);
    }

 

 

• dynamicCall(Method method, Object target)
  • 공통로직 1,2 를 한번에 처리할 수 있는 통합된 공통 처리 로직이다. 
  • Method method : 첫번째 파라미터는 호출할 메서드 정보가 넘어온다. 기존에는 메서드 이름을 직접 호출했지만 이제는 Method 메타정보를 통해서 호출할 메서드 정보가 동적으로 제공된다. 
  • Object target : 실제 실행할 인스턴스 정보가 넘어온다. 타입이 Object 이기 때문에 어떠한 인스턴스도 받을 수 있다. 
  • 주의 ! 당현히 method.invode(target) 을 사용할 때 호출할 클래스와 메서드 정보가 다르면 예외가 발생한다. 

 

Q. 메서드 호출 부분만 다른 공통 로직이 있을때, 이를 개선하는 방법은 무엇이 있을까요 ?

 

▶ A. 메서드 호출 부분만 다른 공통 로직이 있다면, 리플렉션 기술을 활용해 Method 라는 메타정보 객체로 추상화하여 공통 로직을 하나로 통합할 수 있습니다. 리플렉션을 사용하면, 호출할 메서드를 문자열로 지정하여 Method 객체로 얻고, 이를 통해 실제 인스턴스에 대해 동적으로 메서드를 실행할 수 있습니다. 이와 같이 리플렉션을 사용하면 클래스와 메서드의 메타 정보를 사용해서 애플리케이션을 동적으로 유연하게 만들 수 있지만, 리플렉션 기술은 런타임에 동작하기 때문에 컴파일 시점에 오류를 잡을 수 없습니다. 그래서 일반적으로는 권장되지 않습니다.

 

 

※ JDK 동적 프록시

JDK 동적 프록시를 알기 위해 먼저 리플렉션을 알아봤다. 

앞서서는 개발자가 직접 프록시 클래스를 만들어 문제를 해결했었다 (프록시 패턴, 데코레이터 패턴)

동적 프록시 기술을 사용하면 개발자가 직접 프록시 클래스를 만들지 않아도 된다(JVM 이 프록시 클래스를 런타임에 동적으로 생성해주기 때문) 동적 프록시 기술은 프록시 객체를 동적으로 런타임에 개발자 대신 만들어준다. 개발자는 동적 프록시에 원하는 실행 로직을 지정할 수 있다. JDK 동적 프록시는 인터페이스를 기반으로 프록시를 동적으로 만들어준다. 따라서 인터페이스가 필수이다. 

 

▶ 동적 프록시의 구성

public interface AInterface {
    String call();
}

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

public interface BInterface {
    String call();
}

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

 

 

⭐️⭐️⭐️ JDK 동적 프록시에 적용할 로직은 반드시 InvocationHandler 인터페이스를 구현해서 제공해야 한다 ⭐️⭐️⭐️

핸들러는 이 인터페이스를 구현한 객체여야만 프록시가 동작할 수 있다. 프록시가 가로챌 메서드 로직은 invoke() 내부에 정의해야하기 때문이다(invoke()는 InvocationHandler의 구현 메서드임)

public interface InvocationHandler {
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

• InvocationHandler 는 JDK 동적 프록시에서 메서드 호출을 가로채는 핸들러 인터페이스로, 프록시 객체의 메서드가 호출될 때 실제 구현체 대신 이 핸들러의 invoke() 메서드가 실행됨
  • proxy : 프록시 객체 자신
  • method : 호출된 메서드(메타정보)
  • args : 전달된 인자
  • 리턴값 : 원래 메서드의 실행결과

InvocationHandler 를 구현한 TimeInvocationHandler

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;
    }
}

 

• Object result = method.invoke(target, args) : target 인스턴스의 method 를 실행해(invoke) !!! 라는 뜻

 

 

▶ 동적 프록시의 사용

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(BInterface.class.getClassLoader(), new Class[]{BInterface.class}, handler);

        proxy.call();
        log.info("targetClass={}", target.getClass());
        log.info("proxyClass={}", proxy.getClass());
    }
}

 

위 코드에서 JDK 동적 프록시를 생성하는 핵심코드

AInterface proxy = (AInterface) Proxy.newProxyInstance(
    AInterface.class.getClassLoader(),     // ① 클래스 로더
    new Class[]{AInterface.class},         // ② 프록시가 구현할 인터페이스 목록
    handler                                // ③ 메서드 호출을 가로챌 InvocationHandler 구현체
);

 

• ① 클래스 로더 : 프록시 객체도 JVM 안에서 Class 로 생성되므로, JVM 이 로딩할때 클래스 로더가 필요한데, 이를 넘겨줌
• ② 프록시가 구현할 인터페이스 목록 : 동적 프록시는 인터페이스 기반이므로, 여기서 어떤 인터페이스를 구현해야할지를 명시해줌
• ③ 메서드 호출을 가로챌 InvocationHandler 구현체 : 모든 메서드 호출은 이 handler.invoke(proxy, method, args) 로 위임됨

이렇게 생성된 AInterface proxy 는 AInterface 를 구현하고 있으며,

proxy.call() 메서드 호출 시 직접 AImpl 을 호출하는 것이 아니라 TimeInvocationHandler.invoke() 내부로 흐름이 전달됨

 

실행순서

• 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 로 응답이 돌아온다. 시간로그를 출력하고 결과를 반환한다. 

 

Q. 메서드 호출 부분만 다른 공통 로직이 있을때, 이를 개선하는 방법은 무엇이 있을까요 ?

 

▶ A . 메서드 호출 부분만 다른 공통 로직이 반복된다면, JDK 동적 프록시를 활용해 공통 로직을 하나의 핸들러로 추상화할 수 있습니다. 

만약 적용 대상이 100개여도 동적 프록시를 통해서 생성하고 각각 필요한 InvocationHandler 만 만들어서 넣어주면 됩니다. 

JDK 의 동적 프록시 기능이 런타임에 프록시 객체를 자동으로 생성해주기 때문에, 개발자는 공통 로직만 한 곳에 작성하면 되고, 실제 메서드 호출은 동적으로 위임이 됩니다. 

 

 

여기까지 프록시 객체가 메서드를 가로채고, 핸들러에서 공통 로직을 수행한 뒤 실제 메서드를 호출하는 구조를 경험했는데,

스프링 AOP 역시 이러한 구조(프록시 기반 + 메서드 위임)를 바탕으로 핵심 비즈니스 로직과 공통 관심사(예: 트랜잭션, 로깅, 보안 등)를  분리한다.