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

[YuDeokRin]

섹션6. 동적 프록시 기술

1️⃣ 리플렉션

• 리플렉션이랑 JDK 동적 프록시를 기술이나 CGLIB같은 프록시 생성 오픈소스 기술을 활용하면 프록시 객체를 동적으로 만들어낼 수 있다. 즉, 프록시 클래스를 계속 안만들어도된다는 점이다.

➡️ ReflectionTest

• 공통 로직1과 2는 호출하는 메서드만 다르고 전체 코드 흐름이 완전히 같다
  • 먼저 start로그 출력
  • 어떤 메서드를 호출한다.
  • 메서드의 호출 결고를 로그로 출력

package hello.proxy.jdkdynamic;

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

@Slf4j
public class ReflectionTest {

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

        //공통 로직1 시작
        log.info("start");
        String result1 = target.callA();
        log.info("result1:{}", result1);
        //공통 로직1 종료

        //공통 로직2 시작
        log.info("start");
        String result2 = target.callB();
        log.info("result2:{}", result2);
        //공통 로직1 종료

    }

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

➡️ ReflectionTest - reflection1 추가

• dynamicCall(Method method Object target)

package hello.proxy.jdkdynamic;

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

import java.lang.reflect.Method;

@Slf4j
public class ReflectionTest {

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

        //공통 로직1 시작
        log.info("start");
        String result1 = target.callA();
        log.info("result1:{}", result1);
        //공통 로직1 종료

        //공통 로직2 시작
        log.info("start");
        String result2 = target.callB();
        log.info("result2:{}", result2);
        //공통 로직1 종료

    }

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

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

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

2️⃣ JDK 동적 프록시 - 소개

• 지금까지 배운 내용을 보면 프록시를 적용하기 위해서 100개의 적용 대상이 있으면 100개를 맞추는 1:1 방식으로 클래스를 만들었다.

• 프록시 클래스의 기본 코드와 흐름은 거의 비슷하고 프록시 적용 대상만 차이가 있었다.

• 위와 같은 문제를 해결 할 수 있는 방법 → 동적 프록시

주의 - JDK 동적 프록시는 인터페이스를 기반으로 프록시를 동적으로 만들어준다. 따라서 인터페이스가 필수이다.

• 자바가 기본으로 지원하는 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 BImpl implements BInterface {
    @Override
    public String call() {
        log.info("B 호출");
        return "B";
    }
}

3️⃣ JDK 동적 프록시 - 예제 코드

➡️ JDK 동적 프록시 InvocationHandler

• JDK 동적 프록시가 제공하는 InvocationHadler
  • 제공되는 파라미터
    • Object proxy : 프록시 자신
    • Method method : 호출한 메서드
    • Object[ ] args : 메서드를 호출할 때 전달할 인수

package java.lang.reflect;

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

➡️ TimeInvocationHandler

• 주의 : 테스트 코드(src/test)에 위치한다.

package hello.proxy.jdkdynamic.code;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

@Slf4j
@RequiredArgsConstructor
public class TimeInvocationHandler implements InvocationHandler { 
    // InvocationHandler JDK 동적 프록시에 적용할 공통 로직을 개발할 수있음
    
    private final Object target; // 동적 프록시가 호출할 대상
    

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("TimeProxy 실행");
        long startTime = System.currentTimeMillis();
        
        // 리플렉션을 사용해서 target인스턴스와 메서드를 실행한다. args는 메서드 호출시 넘겨줄 인수이다.
        Object result = method.invoke(target, args); 
        
        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("TimeProxy 종료 resultTime={}", resultTime);

        return result;
    }
}

➡️ JdkDynamicProxyTest

package hello.proxy.jdkdynamic;

import hello.proxy.jdkdynamic.code.*;
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); 
        
        //동적 프록시는 java.lang.reflect.Proxy를 통해서 생성
        //클래스 로더 정보, 인터페이스 그리고 핸들러 로직을 넣어주면 된다. 그러면 해당 인터페이스를 기반으로 동적 프록시를 생성하고 그 결과 번환
        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());
    }

}

• AImpl - A호출 결과

22:31:35.120 [main] INFO hello.proxy.jdkdynamic.code.TimeInvocationHandler - TimeProxy 실행
22:31:35.126 [main] INFO hello.proxy.jdkdynamic.code.AImpl - A 호출
22:31:35.126 [main] INFO hello.proxy.jdkdynamic.code.TimeInvocationHandler - TimeProxy 종료 resultTime=0
22:31:35.133 [main] INFO hello.proxy.jdkdynamic.JdkDynamicProxyTest - targetClass=class hello.proxy.jdkdynamic.code.AImpl
22:31:35.133 [main] INFO hello.proxy.jdkdynamic.JdkDynamicProxyTest - proxyClass=class com.sun.proxy.$Proxy9

• BImpl - B호출 결과

22:32:00.261 [main] INFO hello.proxy.jdkdynamic.code.TimeInvocationHandler - TimeProxy 실행
22:32:00.267 [main] INFO hello.proxy.jdkdynamic.code.BImpl - B 호출
22:32:00.267 [main] INFO hello.proxy.jdkdynamic.code.TimeInvocationHandler - TimeProxy 종료 resultTime=0
22:32:00.275 [main] INFO hello.proxy.jdkdynamic.JdkDynamicProxyTest - targetClass=class hello.proxy.jdkdynamic.code.BImpl
22:32:00.275 [main] INFO hello.proxy.jdkdynamic.JdkDynamicProxyTest - proxyClass=class com.sun.proxy.$Proxy9

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

➡️ 동적 프록시 클래스 정보

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

✅ JDK 동적 프록시 도입 전 - 직접 프록시 생성

• JDK 동적 프록시 도입 전 - 직접 프록시 생성

• JDK 동적 프록시 도입 후
  • 점선은 개발자가 직접 만든 클래스가 아니다.

4️⃣ JDK 동적 프록시 - 적용 1

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;

// LogTraceBasicHandler는 InvocationHandler 인터페이스를 구현해서 JDK 동적 프록시에서 사용된다.
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 {
        
		        // LogTrace에 사용할 메세지이다. 프록시를 직접 개발할 때는 "OrderController.request()"와 같이 프록시 마다 호출되는 클래스와 메서드이름이다. 
            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;
        }
    }
}

➡️ DynamicProxyBasicConfig

• 이제는 JDK 동적 프록시 기술을 사용해서 각각의 Controller ,
  Service , Repository 에 맞는 동적 프록시를 생성해주면 된다.
• LogTraceBasicHandler : 동적 프록시를 만들더라도 LogTrace 를 출력하는 로직은 모두 같기 때문에 프록시는 모두 LogTraceBasicHandler 를 사용한다.

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));
        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}, new LogTraceBasicHandler(orderRepository, logTrace));
        
        return proxy;
    }
}

🚨남은 문제

• no-log를 실행해도 동적 프록시가 적용되고, LogTraceBasicHandler 가 실행되기 때문에 로그가 남는다. 이 부분을 로그가 남지 않도록 처리해야 한다.

5️⃣ JDK 동적 프록시 - 적용 2

• LogTraceFilterHandler

package hello.proxy.config.v2_dynamicproxy.handler;

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

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

//LogTraceFilterHandler는 기존 기능에 다음 기능이 추가.
public class LogTraceFilterHandler implements InvocationHandler {

    private final Object target;
    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();
        if (!PatternMatchUtils.simpleMatch(methodName, patterns)) {
            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;
        }

        return null;
    }
}

• 스프링이 제공하는 PatternMatchUtils.simpleMatch(..) 를 사용하면 단순한 매칭 로직을 쉽게 적용할 수 있다.

• xxx : xxx가 정확히 매칭되면 참

• xxx* : xxx로 시작하면 참

• *xxx : xxx로 끝나면 참

• *xxx* : xxx가 있으면 참

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

• DynamicProxyFilterConfig

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

• 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();
		}
}