[Spring] 동적 프록시 기술(1) - 리플렉션

로깅등의 부가 처리 기능을 위해 프록시 클래스를 매번 만들기엔, 적용 대상 클래스 수 만큼 프록시 클래스를 만들어야 하는 문제가 있다. 로그 추적을 위한 프록시 클래스의 소스코드는 거의 같은 모양을 하고 있다. 같은 모양의 클래스를 여러개 만드는 것은 비효율적일 뿐더러 SRP 원칙을 위배하기 때문에, 동적 프록시 기술을 활용하여 이 문제를 점진적으로 해결해보자. 

 

리플렉션 이란?

객체를 통해 클래스의 메타정보를 분석하는 프로그램 기법을 의미한다. 투영, 반사라는 사전적 의미를 가지는데, 클래스의 메타정보를 투영한다고 이해하면 된다.

그럼 뭐하러 굳이 객체를 통해 클래스의 정보를 알아내야할까?

구체적인 클래스의 타입을 알지 못해도, 해당 클래스가 가지고 있는 메소드, 타입, 변수 등에 접근해야 할 경우가 있기 때문이다.

예를 들어 코드를 작성할 시점에는 어떤 타입의 클래스를 사용할지 몰라도 되지만, 애플리케이션이 실행중인 런타임 시점에는 실행중인 클래스를 가져와야 할 경우가 있다. 이럴 때 리플렉션 기법을 사용하면 동적으로 객체를 가져와 실행할 수 있다.  아래 예시를 보면서 더 자세히 알아보자. 

 

같은 로그 기능, 중복되는 코드

여기서 공통되는 기능은 log.info("start") 와 result의 로그를 찍는 부분이고, 개별 기능은 각각의 개별 메서드를 호출( target.callA(), target.callB() )하는 부분이다.

@Slf4j
public class ReflectionTest {

    @Test
    @DisplayName("로그 찍는 공통 로직 사이에 개별 로직 존재할 때")
    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 종료
    }

    @Slf4j
    static class Hello {
        public String callA() {
            log.info("callA");
            return "A";
        }
        public String callB() {
            log.info("callB");
            return "B";
        }
    }
}

지금은 callA(), callB() 메서드가 전부이지만, 로그의 대상이 되는 메서드가 수백개로 늘어난다면?

매번 log.info("start") 를 찍을 수도 없는 노릇이다. 추상화를 통해 공통 로직을 뽑아내고 싶지만, 중간에 호출하는 개별 메서드가 다르기 때문에 쉽지 않다. 그렇다면 호출하는 메서드인 target.callA(), target.callB() 부분만 동적으로 처리할 수 있다면 문제를 해결할 수 있다.

 

 

package hello.proxy.jdkdynamic;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

@Slf4j
public class ReflectionTest {

    @Test
    @DisplayName("공통 로직 처리하는 dynamicCall() 로 로그 처리")
    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); // 메서드 정보와 target 만 넘기면 된다.

        Method methodCallB = classHello.getMethod("callB");
        dynamicCall(methodCallB, target);
    }

    // 공통 로직 1, 2 를 한번에 처리할 수 있는 통합된 공통 처리 로직.
    // Method method 인자 : 호출할 메서드의 정보가 넘어온다. 기존에는 메서드 이름을 직접 호출했다.
    private void dynamicCall(Method method, Object target) throws Exception {
        log.info("start");
        Object result = method.invoke(target);
        log.info("result={}", result);
    }

    @Slf4j
    static class Hello {
        public String callA() {
            log.info("callA");
            return "A";
        }
        public String callB() {
            log.info("callB");
            return "B";
        }
    }
}

 

코드를 라인 바이 라인 알아보자. 

• method.invoke(target) : target 인스턴스에 있는 method 를 호출한다.  -> invoke() 의 인자로 있는 인스턴스의 method(메서드 명) 를 호출한다.
• Class.forName("클래스명") : 클래스의 메타정보를 획득한다. 참고로 내부 클래스는 구분을 위해 $ 를 사용한다.
• dynamicCall(Method method, Object target) : 공통 로직 1, 2 를 한번에 처리할 수 있는 통합된 공통 처리 로직. 
  • 첫 번째 파라미터인 Method method 는 호출할 메서드 정보에 해당되며, 위 예시에서는 Hello 클래스의 callA(), callB() 메서드에 해당된다. 
  • 기존에는 target.callB() 형태로 메서드 이름을 직접 호출했지만, 이제는 Method 라는 메타정보를 통해 호출할 메서드 정보를 동적으로 파라미터화 한다.
  • Object target : 실제 실행할 인스턴스 정보가 넘어온다. 실제 실행할 인스턴스라 함은, method를 정의한 실제 인스턴스를 의미한다. 그렇기 때문에 invoke() 메서드의 인자로 실제 인스턴스인 target 을 받는 것이다. 물론 method.invoke(target) 을 사용할 때 호출할 클래스와 메서드 정보가 다르면 예외가 발생한다.

 

정리

매번 개별로 호출했던 target.callA(), target.callB() 코드를 리플렉션을 사용하여 Method 라는 메타정보로 추상화했다. 

하지만 리플렉션은 현업에서는 가급적 사용을 지양해야한다. 왜냐하면 리플렉션 기술은 런타임에 동작하기 때문에 컴파일 시점에 오류를 잡을 수 없기 때문이다. getMethod()의 인자로 들어갈 메서드명에 오타가 있더라도 컴파일 시점에는 문제를 인지할 수 없다. 즉 런타임이 되서야, 애플리케이션이 실행되고 나서야 에러가 발생할 수 있는 문제를 가지고 있다. 

 

 

코드 및 자료 출처

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