스프링 핵심 원리 - 고급편 > 전략 패턴 (예제 2, 예제 3)

전략 패턴 - 예제 2

전략 패턴도 익명 내부 클래스를 사용할 수 있다.

  @Test
  void strategyV2() {
    Strategy strategy1 = new Strategy() {
      @Override
      public void call() {
        log.info("logic 1 execute");
      }
    };
    log.info("strategyLogic1={}", strategy1.getClass());
    ContextV1 context1 = new ContextV1(strategy1);
    context1.execute();

    Strategy strategy2 = new Strategy() {
      @Override
      public void call() {
        log.info("logic 2 execute");
      }
    };
    log.info("strategyLogic2={}", strategy1.getClass());
    ContextV1 context2 = new ContextV1(strategy2);
    context2.execute();
  }

Strategy 구현체를 따로 변수에 담지 않고, Context 생성 시 바로 전달할 수 있다.

  @Test
  void strategyV3() {
    ContextV1 contextV1 = new ContextV1(new Strategy() {
      @Override
      public void call() {
        log.info("logic 1 execute");
      }
    });
    contextV1.execute();

    ContextV1 contextV2 = new ContextV1(new Strategy() {
      @Override
      public void call() {
        log.info("logic 2 execute");
      }
    });
    contextV2.execute();
  }

람다로 변경할 수 있다.
단, 인터페이스에 메서드가 하나만 있어야 한다.

  @Test
  void strategyV4() {
    ContextV1 context1 = new ContextV1(() -> log.info("logic 1 execute"));
    context1.execute();
    ContextV1 context2 = new ContextV1(() -> log.info("logic 2 execute"));
    context2.execute();
  }

선 조립, 후 실행

위에서 사용한 방식은 이미 조립을 모두 해두었기 때문에 이미 준비가 된 상태이며 실행할 준비만 남은 상태가 된다.
이 방식은 Context와 Strategy를 실행 전에 원하는 모양으로 조립해두고, 그 다음에 Context를 실행하는 선 조립, 후 실행 방식에서 매우 유용하다.
Context와 Strategy를 한번 조립하고 나면 이후로는 Context를 실행하기만 하면 된다.
우리가 스프링으로 애플리케이션을 개발할 때 애플리케이션 로딩 시점에 의존관계 주입을 통해 필요한 의존관계를 모두 맺어두고 난 다음 실제 요청을 처리하는 것과 같은 원리이다.
이 방식의 단점은 Context와 Strategy를 조립한 이후에는 전략을 변경하기가 번거롭다는 점이다.
물론 Context에 setter를 제공해서 Strategy를 넘겨 받아 변경하면 되지만, Context를 싱글톤으로 사용할 때는 동시성 이슈 등 고려할 점이 많다.
그래서 전략을 실시간으로 변경해야 하면 차라리 이전에 개발한 테스트 코드 처럼 Context를 하나 더 생성하고 그곳에 다른 Strategy를 주입하는 것이 더 나은 선택일 수 있다.

전략 패턴 - 예제 3

이전에는 Context 의 필드에 Strategy 를 주입해서 사용했는데, 이제는 실행 시 필요한 Strategy를 전달하여 실행하자.

• ContextV2

@Slf4j
public class ContextV2 {

  public void execute(Strategy strategy) {
    long startTime = System.currentTimeMillis();
    // logic start
    strategy.call();
    // logic end
    long endTime = System.currentTimeMillis();
    long resultTime = endTime - startTime;
    log.info("resultTime = {}", resultTime);
  }

}

ContextV2는 전략을 필드로 가지지 않는다. 대신에 전략을 execute(..)가 호출될 때 마다 항상 파라미터로 전달 받는다.

• ContextV2Test

  @Test
  void strategyV1() {
    ContextV2 context = new ContextV2();
    context.execute(new StrategyLogic1());
    context.execute(new StrategyLogic2());
  }

Context와 Strategy를 선 조립 후 실행 하는 방식이 아니라 Context를 실행할 때 마다 전략을 인수로 전달한다.
클라이언트는 Context를 실행하는 시점에 원하는 Strategy를 전달할 수 있다.
따라서 이전 방식과 비교해서 원하는 전략을 더욱 유연하게 변경할 수 있다.
테스트 코드를 보면 하나의 Context만 생성한다. 그리고 하나의 Context에 실행 시점에 여러 전략을 인수로 전달 해서 유연하게 실행하는 것을 확인할 수 있다.

위 코드에 익명 내부 클래스, 람다 모두 사용 가능하다.

전략 패턴 파라미터 실행 도식

1. 클라이언트는 Context를 실행하면서 인수로 Strategy를 전달
2. Context는 execute()로직을 실행
3. Context는 파라미터로 넘어온 strategy.call() 로직을 실행한다.
4. Context의 execute()로직이 종료된다.

정리

• ContextV1은 필드에 Strategy를 저장하는 방식으로 전략 패턴을 구사
  • 선 조립, 후 실행 방법에 적합하다.
  • Context를 실행하는 시점에는 이미 조립이 끝났기 때문에 전략을 신경쓰지 않고 단순히 실행만 하면 된다.
• ContextV2는 파라미터에 Strategy를 전달받는 방식으로 전략 패턴을 구사
  • 실행할 때 마다 전략을 유연하게 변경할 수 있다.
  • 단점 역시 실행할 때 마다 전략을 계속 지정해주어야 한다는 점

어떤 것이 좋은 설계인가

현재 해결할 문제는 변하는 부분과 변하지 않는 부분을 분리하는 것이다.
변하지 않는 부분을 템플릿이라 가정하고, 템플릿 안에서 변하는 부분에 다른 코드를 수행시키는 것이 목적이 된다.
지금 우리가 원하는 것은 애플리케이션 의존 관계를 설정하는 것 처럼 선 조립, 후 실행이 아니라, 단순히 코드를 실행할 때 변하지 않는 템플릿이 있고, 그 템플릿 안에서 원하는 부분만 살짝 다른 코드를 실행하고 싶을 뿐이다.
ContextV1, ContextV2 모두 문제 해결은 가능하지만, 우리가 고민하는 문제에 대한 해답은 실행 시점에 원하는 부분을 유연하게 실행할 수 있는 V2가 더 적합하고 좋아 보인다.

 

출처: 김영한 지식공유자님의 스프링 핵심 원리 고급편