Ch03. 템플릿 메서드 패턴과 콜백 패턴

스프링 핵심 원리(고급편)

Ch03. 템플릿 메서드 패턴과 콜백 패턴 - 전략 패턴

webmaster 2022. 4. 10. 00:11

728x90

Test

@Slf4j
public class ContextV1Test {
    @Test
    public void strategyV0(){
        logic1();
        logic2();
    }

    private void logic1(){
        long startTime = System.currentTimeMillis();
        //비지니스 로직 실행
        log.info("비지니스 로직1 실행");
        //비지니스 로직 종료
        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("resultTime = {}", resultTime);
    }

    private void logic2(){
        long startTime = System.currentTimeMillis();
        //비지니스 로직 실행
        log.info("비지니스 로직2 실행");
        //비지니스 로직 종료
        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("resultTime = {}", resultTime);
    }

}

전략 패턴은 변하지 않는 부분을 Context라는 곳에 두고, 변하는 부분을 Strategy라는 인터페이스를 만들고 해당 인터페이스를 구현하도록 해서 문제를 해결한다. 상속이 아니라 위임으로 문제를 해결하는 것이다.
전략 패턴에서 Context 는 변하지 않는 템플릿 역할을 하고, Strategy는 변하는 알고리즘 역할을 한다.
GOF 디자인 패턴에서 정의한 전략 패턴의 의도는 다음과 같다.
- 알고리즘 제품군을 정의하고 각각을 캡슐화하여 상호 교환 가능하게 만들자. 전략을 사용하면 알고리즘을 사용하는 클라이언트와 독립적으로 알고리즘을 변경할 수 있다.

Strategy( 변하는 부분 인터페이스)

public interface Strategy {
    void call();
}

변하는 부분 구현 코드

@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(변하지 않는 코드, 변하는 부분을 주입 받아서 사용한다)

@Slf4j
public class ContextV1 {
    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);
    }
}

ContextV1 은 변하지 않는 로직을 가지고 있는 템플릿 역할을 하는 코드이다. 전략 패턴에서는 이것을 컨텍스트(문맥)이라 한다
컨텍스트(문맥)는 크게 변하지 않지만, 그 문맥 속에서 strategy를 통해 일부 전략이 변경된다 생각하면 된다.
Context는 내부에 Strategy strategy 필드를 가지고 있다. 이 필드에 변하는 부분인 Strategy의 구현체를 주입하면 된다.
- 전략 패턴의 핵심은 Context는 Strategy 인터페이스에만 의존한다는 점이다. 덕분에 Strategy의 구현체를 변경하거나 새로 만들어도 Context 코드에는 영향을 주지 않는다.
- 스프링에서 의존관계 주입에서 사용하는 방식이 바로 전략 패턴이다

Test

/**
 * 전략패턴 사용
 */
@Test
public void strategyV1(){
    StrategyLogic1 strategyLogic1 = new StrategyLogic1();
    ContextV1 context1 = new ContextV1(strategyLogic1);
    context1.execute();

    StrategyLogic2 strategyLogic2 = new StrategyLogic2();
    ContextV1 context2 = new ContextV1(strategyLogic2);
    context2.execute();
}

의존관계 주입을 통해 ContextV1 에 Strategy의 구현체인 strategyLogic1을 주입하는 것을 확인
Context 안에 원하는 전략을 주입한다.
원하는 모양으로 조립을 완료하고 난 다음에 context1.execute()를 호출해서 context를 실행한다

전략 패턴 : 익명 내부 클래스

/**
 * 전략패턴 익명 내부 클래스
 */
@Test
public void strategyV2() {
    Strategy strategyLogic1 = new Strategy() {
        @Override
        public void call() {
            log.info("비지니스 로직1 실행");
        }
    };
    ContextV1 context1 = new ContextV1(strategyLogic1);
    log.info("strategyLogic1={}", strategyLogic1.getClass());
    context1.execute();

    Strategy strategyLogic2 = new Strategy() {
        @Override
        public void call() {
            log.info("비지니스 로직2 실행");
        }
    };
    ContextV1 context2 = new ContextV1(strategyLogic2);
    log.info("strategyLogic2={}", strategyLogic2.getClass());
    context2.execute();
}

전략 패턴 : 변수 선언 하지 않은 익명 내부 클래스

@Test
public void strategyV3() {
    ContextV1 context1 = new ContextV1(new Strategy() {
        @Override
        public void call() {
            log.info("비지니스 로직1 실행");
        }
    });
    context1.execute();

    ContextV1 context2 = new ContextV1(new Strategy() {
        @Override
        public void call() {
            log.info("비지니스 로직2 실행");
        }
    });
    context2.execute();
}

전략 패턴 : 람다(인터페이스 메서드가 하나이기 때문 가능)

@Test
public void strategyV4() {
    ContextV1 context1 = new ContextV1(() -> log.info("비지니스 로직1 실행"));
    context1.execute();
    ContextV1 context2 = new ContextV1(() -> log.info("비지니스 로직2 실행"));
    context2.execute();
}

람다로 변경하려면 인터페이스에 메서드가 1개만 있으면 되는데, 여기에서 제공하는 Strategy 인터페이스는 메서드가 1개만 있으므로 람다로 사용할 수 있다.

선 조립, 후 실행

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

실행 시 파라미터로 인터페이스를 받는다.

/**
 * 파라미터에 전략을 보관하는 방식
 */
@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(..) 가 호출될 때마다 항상 파라미터로 전달받는다.

Test

/**
 * 전략 패턴 적용 (파라미터 방식)
 */
@Test
public void strategyV1(){
    ContextV2 context = new ContextV2();
    context.execute(new StrategyLogic1());
    context.execute(new StrategyLogic2());
}

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

익명 내부 클래스 전략 패턴

/**
 * 전략 패턴 익명 내부 클래스
 */
@Test
public void strategyV2(){
    ContextV2 context = new ContextV2();
    context.execute(new Strategy() {
        @Override
        public void call() {
            //execute 안의 실행시킬 코드 조각을 실행 시킨다고 생각하면 된다.
            log.info("비지니스 로직1 실행");
        }
    });
    context.execute(new Strategy() {
        @Override
        public void call() {
            log.info("비지니스 로직2 실행");
        }
    });
}

익명 내부 클래스 람다 전략 패턴

/**
 * 전략 패턴 람다
 */
@Test
public void strategyV3(){
    ContextV2 context = new ContextV2();
    context.execute(() -> log.info("비지니스 로직1 실행"));
    context.execute(() -> log.info("비지니스 로직2 실행"));
}

템플릿

지금 우리가 해결하고 싶은 문제는 변하는 부분과 변하지 않는 부분을 분리하는 것이다.
변하지 않는 부분을 템플릿이라고 하고, 그 템플릿 안에서 변하는 부분에 약간 다른 코드 조각을 넘겨서 실행하는 것이 목적이다.
ContextV1 , ContextV2 두 가지 방식 다 문제를 해결할 수 있지만, 어떤 방식이 조금 더 나아 보이는가? 지금 우리가 원하는 것은 애플리케이션 의존 관계를 설정하는 것처럼 선 조립, 후 실행이 아니다. 단순히 코드를 실행할 때 변하지 않는 템플릿이 있고, 그 템플릿 안에서 원하는 부분만 살짝 다른 코드를 실행하고 싶을 뿐이다.
따라서 우리가 고민하는 문제는 실행 시점에 유연하게 실행 코드 조각을 전달하는 ContextV2 가 더 적합하다

참고 : 디자인 패턴의 볼 떄에는 의도가 매우 중요하다. 이전 템플릿 내부에 인터페이스를 가지고 이를 실행시키는 방식도 같은 모양을 디자인 패턴 그림을 가진다. 이런 것들의 구분하고, 완벽하게 이해 하기 위해서는 반드시 디자인 패턴의 의도를 파악하고, 이를 공부하는 것이 좋다

728x90

'스프링 핵심 원리(고급편)' 카테고리의 다른 글

Ch04. 프록시 패턴과 데코레이터 패턴 - 예제 프로젝트 만들기 (0)	2022.04.10
Ch03. 템플릿 메서드 패턴과 콜백 패턴 - 템플릿 콜백 패턴 (0)	2022.04.10
Ch03. 템플릿 메서드 패턴과 콜백 패턴 - 템플릿 메서드 패턴(적용) (0)	2022.04.09
Ch03. 템플릿 메서드 패턴과 콜백 패턴 - 템플릿 메서드 패턴(예제) (0)	2022.04.09
Ch03. 템플릿 메서드 패턴과 콜백 패턴 - 템플릿 메서드 패턴(시작) (0)	2022.04.09

현재글Ch03. 템플릿 메서드 패턴과 콜백 패턴 - 전략 패턴

98\, JdbcTemplate, +, 마우스잡기,

Today :
Yesterday :

일	월	화	수	목	금	토
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28

WebMaster