[스프링 핵심원리 - 고급편] #5. 프록시 패턴과 데코레이터 패턴(3)

[YuDeokRin]

1️⃣3️⃣ 인터페이스 기반 프록시 - 적용

• 인터페이스와 구현체가 이는 V1 App에 프록시를 도입해서 LogTrace를 사용해보자.

• 프록시를 사용하면 기존 코드를 전혀 수정하지 않고 로그 추적 기능을 도입할 수 있다고 한다. 어떻게하는지 알아보고 그 부분을 정확히 배워가자.

• V1 기본 클래스 의존 관계 - 클래스 의존 관계

• V1 런타임 객체 의존 관계 - 런타임 객체 의존 관계

• V1 프록시 의존 관계 추가 - 클래스 의존 관계

• V1 프록시 런타임 객체 의존 관계 - 런타임 객체 의존 관계

애플리케이션 실행 시점에 프록시를 사용하도록 의존 관계를 설정해주어야 한다. 이 부분은 빈을 등록하는 설정 파일을 활용하면 된다.

➡️OrderRepositoryInterfaceProxy

package hello.proxy.config.v1_proxy.interface_proxy;

import hello.proxy.app.v1.OrderRepositoryV1;
import hello.proxy.trace.TraceStatus;
import hello.proxy.trace.logtrace.LogTrace;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
public class OrderRepositoryInterfaceProxy implements OrderRepositoryV1 {
    
    private final OrderRepositoryV1 target; 
    private final LogTrace logTrace;
    
    @Override
    public void save(String itemId) {
        TraceStatus status = null;

        try {
            
            status = logTrace.begin("OrderRepository.save()");
            
            //target 호출
            target.save(itemId); //OrderRepositoryV1 (인터페이스) 
            logTrace.end(status);
        } catch (Exception e) {
            logTrace.exception(status, e);
            throw e;
        }
    }
}

🗒️ 위 코드 설명

• 프록시를 만들기 위해서 인터페이스를 구현
• 구현한 메서드에 LogTrace를 사용하는 로직 추가
• 원래 OrderRepositoryImpl에 이런 로직을 추가했었다. 하지만 프록시를 사용함으로써 프록시가 대신 처리해주게 되었다. → OrderRepositoryImpl 코드를 변경하지 않아도 된다.
• OrderRepositoryV1 target : 프록시가 실제 호출할 원본 리포지토리의 참조를 가지고 있어야 한다.

➡️OrderServiceInterfaceProxy

package hello.proxy.config.v1_proxy.interface_proxy;

import hello.proxy.app.v1.OrderServiceV1;
import hello.proxy.trace.TraceStatus;
import hello.proxy.trace.logtrace.LogTrace;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
public class OrderServiceInterfaceProxy implements OrderServiceV1 {

    private final OrderServiceV1 target;
    private final LogTrace logTrace;
    
    
    @Override
    public void orderItem(String itemId) {
        TraceStatus status = null;

        try {

            status = logTrace.begin("OrderService.orderItem()");
            //target호출
            target.orderItem(itemId);
            logTrace.end(status);

        } catch (Exception e) {
            logTrace.exception(status, e);
            throw e;
        }
    }
}

➡️OrderControllerInterfaceProxy

package hello.proxy.config.v1_proxy.interface_proxy;

import hello.proxy.app.v1.OrderControllerV1;
import hello.proxy.app.v1.OrderServiceV1;
import hello.proxy.trace.TraceStatus;
import hello.proxy.trace.logtrace.LogTrace;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
public class OrderControllerInterfaceProxy implements OrderControllerV1 {

    private final OrderControllerV1 target;
    private final LogTrace logTrace;

    @Override
    public String request(String itemId) {
        TraceStatus status = null;
        try {
            status = logTrace.begin("OrderController.request()");
            //target 호출
            String result = target.request(itemId);
            logTrace.end(status);
            return result;
        } catch (Exception e) {
            logTrace.exception(status, e);
            throw e;
        }
    }

    @Override
    public String noLog() {
        return target.noLog();
    }
}

➡️InterfaceProxyConfig

package hello.proxy.config.v1_proxy;

import hello.proxy.app.v1.*;
import hello.proxy.config.v1_proxy.interface_proxy.OrderControllerInterfaceProxy;
import hello.proxy.config.v1_proxy.interface_proxy.OrderRepositoryInterfaceProxy;
import hello.proxy.config.v1_proxy.interface_proxy.OrderServiceInterfaceProxy;
import hello.proxy.trace.logtrace.LogTrace;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class InterfaceProxyConfig {

    @Bean
    public OrderControllerV1 orderController(LogTrace logTrace) {
        OrderControllerV1Impl controllerImpl = new OrderControllerV1Impl(orderService(logTrace));
        return new OrderControllerInterfaceProxy(controllerImpl, logTrace);
    }

    @Bean
    public OrderServiceV1 orderService(LogTrace logTrace) {
        OrderServiceV1Impl serviceImpl = new
                OrderServiceV1Impl(orderRepository(logTrace));
        return new OrderServiceInterfaceProxy(serviceImpl, logTrace);
    }

    @Bean
    public OrderRepositoryV1 orderRepository(LogTrace logTrace) {
        OrderRepositoryV1Impl repositoryImpl = new OrderRepositoryV1Impl();
        return new OrderRepositoryInterfaceProxy(repositoryImpl, logTrace);
    }
}

✅ V1 프록시 런타임 객체 의존 관계 설정

• 이제 프록시의 런타임 객체 의존 관계를 설정하면 된다.

  • 기존에는 스프링 빈이 OrderControllerV1Impl, orderServiceV1Impl 같은 실제 객체를 반환했다.
  • 하지만 이제는 프록시를 사용해야한다. 따라서 프록시를 생성하고 프록시를 실제 스프링 빈 대신 등록한다.
  • 실제 객체는 스프링 빈으로 등록하지 않는다.

• 프록시는 내부에 실제 객체를 참조하고 있다.

  • 예) OrderServiceInterfaceProxy는 내부에 실제 대상 객체인 OrderServiceV1Impl을 가지고 있다.

• 의존관계

  • proxy → target
  • orderServiceInterfaceProxy → orderServiceV1Impl

• 스프링 빈으로 프록시 객체의 빈을 등록했다. 따라서 앞으로 스프링 빈을 주입 받으면 실제 객체 대신에 프록시 객체가 주입된다.

• 실제 객체가 스프링 빈으로 등록되지 않는다고 해서 사라지는 것은 아님. 프록시 객체가 실제 객체를 참조하기 때문에 프록시를 통해서 실제 객체를 호출할 수 있다.

  • 즉, 프록시 객체 안에 실제 객체가 있는 것이다.

• AppV1Config를 통해 프록시를 적용하기 전

• InterfaceProxyConfig를 통해 프록시를 적용한 후
  • 스프링 컨테이너에 프록시 객체가 등록된다. 스프링 컨테이너는 이제 실제 객체가 아니라 프록시 객체를 스프링 빈으로 관리한다.
  • 이제 실제 객체는 스프링 컨테이너와는 상관이 없다. 실제 객체는 프록시 객체를 통해서 참조될 뿐이다.
  • 프록시 객체는 스프링 컨테이너가 관리하고 자바 힙 메모리에도 올라간다. 반면에 실제 객체는 자바 힙 메모리에는 올라가지만 스프링 컨테이너가 관리하지 않는다.

➡️ ProxyApplication

• @bean : 먼저 LogTrace 스프링 빈 추가를 먼저 해주어야 한다. 이것을 여기에 등록한 이유는 앞으로 사용할 모든 예제에서 함께 사용하기 위해서다.
• @import(InterfaceProxyConfig.class) : 프록시를 적용한 설정 파일을 사용하자.

package hello.proxy;

import hello.proxy.config.AppV1Config;
import hello.proxy.config.AppV2Config;
import hello.proxy.config.v1_proxy.InterfaceProxyConfig;
import hello.proxy.trace.logtrace.LogTrace;
import hello.proxy.trace.logtrace.ThreadLocalLogTrace;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;

//@Import({AppV1Config.class, AppV2Config.class})
@Import(InterfaceProxyConfig.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();
	}

}

✅ 정리

• 추가된 요구사항을 다시 확인

• 추가된 요구사항

  • 원본 코드를 전혀 수정하지 않고, 로그 추적기를 적용해라.
  • 특정 메서드는 로그를 출력하지 않는 기능
    • 보안상 일부는 로그를 출력하면 안된다.
  • 다음과 같은 다양한 케이스에 적용할 수 있어야 한다.
    • v1 - 인터페이스가 있는 구현 클래스에 적용
    • v2 - 인터페이스가 없는 구체 클래스에 적용
    • v3 - 컴포넌트 스캔 대상에 기능 적용

1️⃣4️⃣ 구체 클래스 기반 프록시 - 예제1

➡️ ConcreteLogic

• ConcreteLogic은 인터페이스가 없고, 구체 클래스만 있음 → 여기에 프록시를 도입해야한다.

package hello.proxy.pureproxy.proxy.pureproxy.concreteproxy.code;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class ConcreteLogic {

    public String operation() {
        log.info("ConcreteLogic 실행");
        return "data";
    }

}

➡️ ConcreteClient

package hello.proxy.pureproxy.proxy.pureproxy.concreteproxy.code;

public class ConcreteClient {
    
    private ConcreteLogic concreteLogic;

    public ConcreteClient(ConcreteLogic concreteLogic) {
        this.concreteLogic = concreteLogic;
    }
    
    public void execute() {
        concreteLogic.operation()
    }
}

➡️ConcreteProxyTest

package hello.proxy.pureproxy.proxy.pureproxy.concreteproxy;

import hello.proxy.pureproxy.proxy.pureproxy.concreteproxy.code.ConcreteClient;
import hello.proxy.pureproxy.proxy.pureproxy.concreteproxy.code.ConcreteLogic;
import org.junit.jupiter.api.Test;

public class ConcreteProxyTest {

    @Test
    void noProxy() {
        ConcreteLogic concreteLogic = new ConcreteLogic();
        ConcreteClient client = new ConcreteClient(concreteLogic);
        client.execute();
    }
}

1️⃣5️⃣ 구체 클래스 기반 프록시 - 예제2

➡️ TimeProxy

• TimeProxy 프록시는 시간을 측정하는 부가 기능을 제공한다. 그리고 인터페이스가 아니라 클래스인
  ConcreteLogic 를 상속 받아서 만든다.

package hello.proxy.pureproxy.proxy.pureproxy.concreteproxy.code;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class TimeProxy extends ConcreteLogic{
    
    private ConcreteLogic realLogic;

    public TimeProxy(ConcreteLogic realLogic) {
        log.info("TimeDecorator 실행");
        this.realLogic = realLogic;
    }
    
    public String operation() {
        log.info("TimeDecoration 실행");
        long startTime = System.currentTimeMillis();
        
        String result = realLogic.operation();
        
        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("TimeDecorator 종료 resultTime = {}", resultTime);
        return result;
    }
    
}

➡️ConcreateClient

package hello.proxy.pureproxy.proxy.pureproxy.concreteproxy.code;

public class ConcreteClient {

    private ConcreteLogic concreteLogic;

    public ConcreteClient(ConcreteLogic concreteLogic) {
        this.concreteLogic = concreteLogic;
    }

    public void execute() {
        concreteLogic.operation();
    }
}

참고

자바 언어에서 다형성은 인터페이스나 클래스를 구분하지 않고 모두 적용된다. 해당 타입과 그 타입의 하위
타입은 모두 다형성의 대상이 된다. 자바 언어의 너무 기본적인 내용을 이야기했지만, 인터페이스가 없어도 프록시가 가능하다는 것을 확실하게 깊고 넘어갈 필요가 있어서 자세히 설명했다.

1️⃣6️⃣ 구체 클래스 기반 프록시 - 적용

1️⃣7️⃣ 인터페이스 기반 프록시와 클래스 기반 프록시