[Spring] 예제로 알아보는 [ 전략 패턴 ]

이전 포스팅에서 템플릿 메서드 패턴을 알아봤고, 템플릿 메서드 패턴의 상속이라는 한계를 해결하기 위해 전략 패턴을 활용하기로 했다.

 

전략 패턴 

템플릿 패턴은 부모 클래스에 변하지 않는 템플릿을 두고, 변하는 부분을 자식 클래스에서 상속하여 문제를 해결했다. 

전략 패턴은 변하지 않는 부분을 Context 라는 개념에 두고, 변하는 부분은 Strategy 라는 인터페이스를 만들어 구현해 문제를 해결한다. 즉 상속이 아니라 위임 / 구현으로 문제를 해결하는 것이다.

그림 1.0

전략패턴에서 Context 는 무엇일까? 바로 템플릿 메서드 패턴의 템플릿에 해당되는 개념으로, 여기서는 문맥 정도로 이해하면 된다. 개별 비즈니스 로직은 변할 수 있지만, 그걸 구현해야하는 전체적인 문맥은 잘 변하지 않기 때문에, 변하지 않는 로직을 Context 에 구현한다.

 

Strategy 인터페이스

여기의 call() 추상 메서드가 바로 핵심 로직, 즉 변하는 부분에 해당된다. (이전 포스팅 - 변하는 부분/ 변하지 않는 부분 을 분리하라)

Strategy 를 구현할 클래스는 call() 메서드를 오버라이딩 하여 자신만의 비즈니스 로직을 구현하면 된다.

public interface Strategy {
    void call();
}

 

전략을 구현한 StrategyLogic1, StrategyLogic2 클래스

@Slf4j
public class StrategyLogic1 implements Strategy {

    @Override
    public void call() {
        log.info("비즈니스 로직 1 실행");
    }
}


@Slf4j
public class StrategyLogic2 implements Strategy {

    @Override
    public void call() {
        log.info("비즈니스 로직 2 실행");
    }
}

 

Context 클래스

Context 클래스 내부에 Strategy strategy 라는 필드를 가지고 있는데, 이 부분에 Strategy 인터페이스의 구현체를 주입하면 된다. 

즉 내부 필드에 전략을 보관하는 방식으로, Context 는 Strategy 인터페이스에만 의존한다. 그말은 즉슨, Strategy 의 구현체를 변경하거나 새로 생성해도 Context 코드에는 영향을 주지 않는다. OCP 를 지킨 것이다. 

이러한 형태는 스프링에서 의존관계 주입(DI)에서 사용하는 방식과 상통한다. 즉 스프링의 의존 관계 주입은 전략 패턴의 일종으로 볼 수 있다. 

@Slf4j
public class ContextV1 {

    final private Strategy strategy;

    // 생성자 주입
    public ContextV1(Strategy strategy) {
        this.strategy = strategy;
    }

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

그림 1. 1

Context1 이라는 인스턴스에 strategyLogic1 이라는 구현체를 주입해버린다. 의존성을 주입했지만 템플릿 메서드 패턴의 상속처럼, 자식 클래스와 부모 클래스간의 강력한 결합을 강제하지 않는다.

 

그림 1.2

 

 

선 조립, 후 실행

Context 의 내부 필드에 Strategy 를 두고 사용하는 형태로, Context 와 Strategy 를 한번 조립하고 나면 이후로는 Context 를 실행하기만 하면 된다. 스프링 애플리케이션 로딩 시점에 의존관계 주입을 통해 필요한 의존관계를 모두 맺어두고 남 후에 실제 요청을 처리하는 것과 같은 원리다. 

 

다만 이 방식의 단점은, 한번 조립한 후에는 전략을 바꾸기 함들다는 것이다. context1 에 이미 "비즈니스 로직1 실행" 이라는 전략이 조립됐기 때문에, 새로운 전략을 사용하려면 또 다른 context 를 생성해야 한다.

그림 1.3

< 람다식을 사용하면 그림 1. 1  처럼 번거롭게 클래스를 생성할 필요없이 곧 바로 의존성을 주입할 수 있을 뿐더러, 비즈니스 로직이 포함된 클래스를 매번 생성할 필요가 없어진다 >

 

 

파라미터 전달을 활용한 전략 패턴 

즉 "선조립 후실행" 패턴을 벗어나, 이전엔 생성자로 주입받은 전략을 메서드의 파라미터로 전달 받는 형태로 변경한 것이다.

/*
전략을 필드로 가지지 않는다.
 */
 
@Slf4j
public class ContextV2 {

    // 파라미터로 전략을 전달받는다.
    public void execute(Strategy strategy) {
        long startTime = System.currentTimeMillis();
        strategy.call(); // 위임
        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("resultTime = {}", resultTime);
    }
}

 

전략 패턴 적용 : 파라미터 활용

이 방법의 장점은 execute() 시점, 즉 문맥이 실행되는 시점에 필요한 전략을 적절히 교체할 수 있다. 이전 방식과 비교해서 원하는 전략을 더욱 유연하게 변경할 수 있는 장점이 있다. 

@Slf4j
public class ContextV2Test {


    @Test
    void strategyV1() {
        ContextV2 contextV2 = new ContextV2();  // 조립하지 않아요
        contextV2.execute(new StrategyLogic1());
        contextV2.execute(new StrategyLogic2());
    } // Context, Strategy 를 선조립 후 실행 이 아닌, Context 를 실행할 때마다 전략을 인수로 전달한다.
    // execute 시점에 여러 전략을 인수로 전달하여 유연하게 실행 가능.


    @Test
    @DisplayName("익명 클래스 사용")
    void strategyV2() {
        ContextV2 contextV2 = new ContextV2();
        contextV2.execute(new Strategy() {
            @Override
            public void call() {
                log.info("비즈니스 로직 1 실행");
            }
        });
        contextV2.execute(new Strategy() {
            @Override
            public void call() {
                log.info("비즈니스 로직 2 실행");
            }
        });
    }


    @Test
    @DisplayName("람다식 사용")
    void strategyV3() {
        ContextV2 contextV3 = new ContextV2();
        contextV3.execute(() -> log.info("비즈니스 로직 1 실행"));
        contextV3.execute(() -> log.info("비즈니스 로직 2 실행"));
    }
}

그림 1.4

 

 

정리 

두가지 방식으로 전략 패턴을 확인해봤다. 두 방식 중 어느 것 하나가 우월히 좋다는 건 아니고, 개발자가 처한 상황에서 적절한 방법을 채택하면 된다.

 

1) 생성자 주입을 통한 전략 패턴

- 선 조립, 후 실행 방식으로 Context 를 실행하는 시점에 이미 조립이 끝났기에, 전략을 신경쓰지 않고 단순 실행만 하면 된다.

 

2) 파라미터 주입을 통한 전략 패턴.

- 실행할 때 마다 전략을 유연하게 변겨할 수 있다.

- 실행할 때 마다 전략을 계속 지정해줘야 하는 것이 단점일 수도 있다 (번거로움)

 

 

 

 

코드 및 자료 출처 :https://inf.run/5BUY

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