프록시 패턴 정리

📝 프록시란 무엇인가?

프록시(Proxy)란 클라이언트가 서버에 직접 요청하지 않고, 중간에 대리 객체를 통해 간접적으로 요청을 수행하는 구조이다. 이때 중간의 대리 객체가 바로 '프록시'이다. 프록시는 클라이언트와 서버 사이에 위치하여 요청을 가로채거나, 부가적인 작업을 수행하거나, 요청을 제어할 수 있다.

 

일반적으로 클라이언트는 자신이 요청하는 대상이 실제 서버인지, 프록시인지를 알지 못한다. 따라서 프록시는 서버와 동일한 인터페이스를 구현해야 한다. 이로 인해 클라이언트는 프록시든 서버든 동일한 방식으로 호출할 수 있으며, 구조가 변경되어도 클라이언트 코드는 전혀 영향을 받지 않는다.

서버와 프록시는 같은 인터페이스를 구현

🏗️ 프록시 패턴의 구조

프록시 패턴의 기본 구조는 다음과 같다.

• Client: 요청을 보내는 주체이다.
• Proxy: 서버 대신 요청을 받아 처리하거나, 서버에게 전달하는 중간 객체이다.
• RealSubject (Server): 실제 비즈니스 로직을 처리하는 서버 객체이다.

프록시 패턴

이 세 객체는 다음과 같은 인터페이스 구조를 갖는다.

public interface Subject {
    String operation();
}

public class RealSubject implements Subject {
    public String operation() {
        return "실제 객체 호출 결과";
    }
}

public class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    public String operation() {
        // 부가 기능 수행
        System.out.println("프록시에서 추가 작업 수행");
        return realSubject.operation();
    }
}
  

이렇게 구성되면 클라이언트는 아래처럼 사용할 수 있다.

public class Client {
    private Subject subject;

    public Client(Subject subject) {
        this.subject = subject;
    }

    public void execute() {
        String result = subject.operation();
        System.out.println("결과: " + result);
    }
}
  

이 구조에서 클라이언트는 Proxy를 주입받아도, RealSubject를 주입받아도 전혀 알 수 없으며, 코드의 수정 없이 동일하게 동작한다.

프록시 패턴과 데코레이터 패턴

GOF 디자인 패턴에서는 프록시 패턴과 데코레이터 패턴을 구분한다. 둘 다 구조적으로는 유사하지만, 의도(intent)가 다르다.

데코레이터 패턴

1. 프록시 패턴 - 접근 제어 목적

프록시 패턴은 보통 접근을 제어하기 위해 사용된다.

• 권한에 따른 접근 차단
• 결과를 캐싱해서 성능 향상
• 지연 로딩

예시: 캐시 프록시

public class CacheProxy implements Subject {
    private Subject target;
    private String cache;

    public CacheProxy(Subject target) {
        this.target = target;
    }

    public String operation() {
        if (cache == null) {
            cache = target.operation();
        }
        return cache;
    }
}
  

한 번만 서버에 접근하고, 이후에는 캐시된 결과를 리턴한다.

2. 데코레이터 패턴 - 기능 확장 목적

데코레이터 패턴은 기존 기능에 새로운 기능을 추가하는 데 사용된다. 구조는 프록시와 거의 동일하지만, 목적이 다르다.

예시: 메시지 변경 데코레이터

public class MessageDecorator implements Subject {
    private Subject target;

    public MessageDecorator(Subject target) {
        this.target = target;
    }

    public String operation() {
        String result = target.operation();
        return "[데코레이션] " + result;
    }
}
  

프록시를 연속적으로 연결하는 체인 형태로도 가능하다.

Subject realSubject = new RealSubject();
Subject decorator1 = new MessageDecorator(realSubject);
Subject decorator2 = new TimeDecorator(decorator1);

Client client = new Client(decorator2);
client.execute();
  

이처럼 데코레이터는 체인을 구성해서 점점 기능을 추가해 나갈 수 있다. 프록시 역시 마찬가지로 프록시 체인을 구성할 수 있다.

프록시 패턴의 핵심 정리

• 프록시는 서버와 동일한 인터페이스를 구현해야 한다.
• 프록시를 도입해도 클라이언트 코드는 변경 없이 동작해야 한다.
• 프록시는 체인 형태로 여러 개 연결할 수 있다.
• 접근 제어나 부가 기능 추가 등의 역할을 수행할 수 있다.
• 프록시는 스프링 AOP나 프록시 기반 DI 구현에서 매우 중요하다.

스프링에서의 실제 프록시 구현 예시

아래는 스프링에서 인터페이스 기반으로 프록시를 구현한 코드이다.

@RequiredArgsConstructor
public class OrderServiceInterfaceProxy implements OrderServiceV1 {
    private final OrderServiceV1 target;
    private final LogTrace logTrace;

    public void orderItem(String itemId) {
        TraceStatus status = null;
        try {
            status = logTrace.begin("OrderService.orderItem()");
            target.orderItem(itemId);
            logTrace.end(status);
        } catch (Exception e) {
            logTrace.exception(status, e);
            throw e;
        }
    }
}
  

이런 방식으로 OrderController, OrderRepository도 프록시 구현체를 만들어, 기존 구현체를 감싸는 방식으로 기능을 확장할 수 있다.

---

📌 JDK 동적 프록시 기술

프록시 기술을 활용하여 기존 코드를 수정하지 않고 부가 기능을 추가할 수 있었지만, 뭔가 해결해야할 부분이 남아있는 것 처럼 보인다.
같은 혹은 아주 유사한 기능을 수행하는 프록시라도 프록시를 적용하기 위해 적용 대상의 숫자 만큼 많은 프록시 클래스를 생산해야 한다는 점이다.

﹡ 적용 대상이 1억개의 클래스라면 프록시 클래스도 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";
    }
    
}

 

JDK 동적 프록시 기술은 이 리플렉션 기술을 이용하여 개발자가 직접 프록시를 만들지 않아도 되도록 해주는데, 런타임에 프록시 객체를 동적으로 만들어 주기 때문이다.

 

📝 예제를 통해 알아보자

AInterface

package hello.proxy.jdkdynamic.code;

public interface AInterface {
	String call();
}

 

AInterface 구현체

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

 

BInterface 구현체

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

JDK 동적 프록시가 제공하는 InvocationHandler (InvocationHandler을 구현해서 Proxy에 매개변수로 넣어줘야 한다.)

이게 JDK 동적 프록시에 적용할 공통 로직이다.

 

package java.lang.reflect;

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

package hello.proxy.jdkdynamic.code;

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

@Slf4j
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`
는 메서드 호출시 넘겨줄 인수이다.

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);
        
        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 동적 프록시 비교

특정 패턴의 URl만 동적 프록시를 적용하고 싶을 경우

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;

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

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