Spring Core - 전략 패턴(시작, 예제1, 예제2)

FrameWork/Spring&Spring-boot 2024. 3. 7. 10:34

전략 패턴 - 시작

ContextV1Test

package com.spring.core.trace.strategy;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

@Slf4j
public class ContextV1Test {
    @Test
    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("비지니스 로직1 실행");
        //비지니스 로직 종료
        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("resultTime = {}",resultTime);
    }
}

전략패턴으로 코드가 반복되는 문제를 해결해 보자.

실행결과

전략 패턴 - 예제1

템플릿 메서드 패턴으로 해결했던 문제를 이번에 전략 패턴을 사용해서 해결해 보자.

템플릿 메서드 패턴은 부모 클래스에 변하지 않는 템플릿을 두고, 변한는 부분을 자식 클래스에 두어서 상속을 사용해서 문제를 해결했다. 전략 패턴은 변하지 않는 부분을 Context라는 곳에 두고, 변하는 부분을 Strategy라는 인터페이스를 만들어서 인터페이스를 구현하도록 해서 문제를 해결한다. 상속이 아니라 위임(구성)으로 문제를 해결하는 것이다.

전략 패턴에서 Context는 변하지 않는 템플릿 역할을 하고, Strategy는 변하는 알고리즘 역할을 한다.

Context라는 거대한 문맥에 있고 거기에 Strategy가 조금씩 바뀌는 것이라고 생각하면 쉽다.

GOF디자인 패턴에서 정의한 전략 패턴의 의도는 다음과 같다.

알고리즘 제품군을 정의하고 각각을 캡슐화하여 상호 교환 가능하게 만들자. 전력을 사용하면 알고리즘을 사용하는 클라이언트와 독립적으로 알고리즘을 변경할 수 있다.

StrategyLogic1의 call()메서드를 주입할 수도 있고 StrategyLogic2의 call()메서드를 주입할 수도 있다.

StrategyLogic1

@Slf4j
public class StrategyLogic1 implements Strategy{
    @Override
    public void call() {
        log.info("비지니스 로직1 실행");
    }
}

변하는 알고리즘은 Strategy인터페이스를 구현하면 된다. 여기서는 비지니스 로직1을 구현했다.

StrategyLogic2

@Slf4j
public class StrategyLogic2 implements Strategy{
    @Override
    public void call() {
        log.info("비지니스 로직2 실행");
    }
}

비지니스 로직2를 구현했다.

ContextV1

@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코드에는 영향을 주지 않는다.

스프링에서 의존 관계 주입에서 사용하는 방식이 바로 전략 패턴이다.

ContextV1Test - 추가

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

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

전략 패턴을 사용해보자

코드를 보면 의존관계 주입을 통해 ContextV1에 Strategy의 구현체인 strategyLogic1를 주입하는 것을 확인할 수 있다. 이렇게해서 Context안에 원하는 전략을 주입한다. 이렇게 원하는 모양으로 조립을 하고 난 다음에 context.execute()를 호출해서 context를 실행한다.

전략 패턴 실행 그림

Context에는 원하는 Strategy 구현체를 주입한다.
클라이언트에는 context를 실행(context.execute())한다.
context는 context(context.execute())로직을 시작한다.
context는 로직 중간에 strategy.call()을 호출해서 주입 받은 strategy로직을 실행한다.
context는 나머지 로직을 실행한다.

실행 결과

Context 코드가 바뀌어도 Strategy는 영향을 전혀 받지 않는다.

전략 패턴 - 예제2

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

ContextV1Test - 추가

@Test
void strategyV2(){
    Strategy strategyLogic1 = new Strategy() {
        @Override
        public void call() {
            System.out.println("비지니스 로직1 실행");
        }
    };
    ContextV1 context1 = new ContextV1(strategyLogic1);
    log.info("strategyLogic1={}",strategyLogic1.getClass());
    context1.execute();

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

실행결과

실행 결과를 보면 ContextV1$1, ContextV1Test$2와 같이 익명 내부 클래스가 생성된 것을 확인할 수 있다.

ContextV1Test - 추가

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

    ContextV1 context2 = new ContextV1(()-> log.info("비지니스 로직2 실행"));
    context2.execute();
}

익명 내부 클래스를 자바8부터 제공하는 람다로 변경할 수 있다. 람다로 변경하려면 인터페이스에 메서드가 1개만 있으면 되는데, 여기서 제공하는 Strategy 인터페이스는 메서드가 1개만 있으므로 람다로 사용할 수 있다.

정리

지금까지 일반적으로 이야기하는 전략 패턴에 대해서 알아보았다. 변하지 않는 부분을 Context에 두고 변하는 부분을 Strategy를 구현해서 만든다. 그리고 Context의 내부 필드에 Strategy를 주입해서 사용했다.

선 조립, 후 실행

여기서 중요한 부분은 Context의 내부 필드에 Strategy를 두고 사용하는 부분이다.

이 방식은 Context와 Strategy를 실행 전에 원하는 모양으로 조립해두고, 그 다음에 Context를 실행하는 선 조립 후, 실행 방식에서 매우 유용하다.

Context와 Strategy를 한번 조립하고 나면 이후로는 Context를 실행하기만 하면 된다. 스프링 어플리케이션을 개발할 때 애플리케이션 로딩 시점에 의존관계 주입을 통해 필요한 의존 관를 모두 맺어두고 난 다음에 실제 요청을 처리하는 것 과 같은 원리이다.

이 방식의 단점은 Context와 Strategy를 조립한 이후에는 전략을 변경하기가 번거롭다는 점이다. 물론 Context에 setter를제공해서 Strategy를 넘겨 받아 변경하면 되지만, Context를 싱글톤으로 사용할 때는 동시성 이슈 등 고려할 점이 많다. 그래서 전략을 실시간으로 변경해야 한면 차라리 이전에 위에 개발한 테스트 코드 처럼 Context를 하나더 생성하고 그곳에 다른 Strategy를 주입하는 것이 더 나은 선택일 수 있다.

❓이렇게 먼저 조립하고 사용하는 방식보다 더 유연하게 전략 패턴을 사용하는 방법은 없을까?

전략패턴 - 예제3

이번에는 전략 패턴을 조금 다르게 사용해보자. 이전에는 Context의 필드에 Strategy를 주입해서 사용했다. 이번에는 전략을 실행할때 직접 파라미터로 전달해서 사용해보자.

ContextV2

/**
 * 전략을 파라미터로 전달 받는 방식
 */
@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);
    }
}

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

ContextV2Test

package com.spring.core.trace.strategy;

import com.spring.core.trace.strategy.code.strategy.ContextV2;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

@Slf4j
public class ContextV2Test {
    @Test
    void strategyV1(){
        ContextV2 context = new ContextV2();
        context.execute(()-> log.info("비지니스 로직1 실행"));
        context.execute(()->log.info("비지니스 로직2 실행"));
    }
}

Context와 Strategy를 '선 조립 후 실행'하는 방식이 아니라 Context를 실행할 때 마다 전략을 파라미터로 전달한다.클라이언트는 Context를 실행하는 시점에 원하는 Strategy를 전달할 수 있다. 따라서 이전 방식과 비교해서 원하는 전략을 더욱 유연하게 변경할 수 있다.

테스트 코드를 보면 하나의 Context만 생성한다. 그리고 하나의 Context에 실행 시점에 여러 전략을 인수로 전달해서 유연하게 실행하는 것을 확인할 수 있다.

전략 패턴 파라미터 실행 그림

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

ContextV2Test - 추가

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

물론 여기서도 익명 내부 클래스를 사용할 수 있다. 코드 조각을 파라미터로 넘긴다고 생각하면 더 자연스럽다.

하지만 람다를 사용해서 코드를 더 단순하게 만들 수 있다.

정리

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

템플릿

지금 해결하고 싶은 문제는 변하는 부분과 변하지 않는 부분을 분리하는 것이다.

변하지 않는 부분을 템플릿이라고 하고, 그 템플릿 안에서 변하는 부분에 약간 다른 코드 조각을 넘겨서 실행하는 것이 목적이다. ContextV1, ContextV2 두 가지 방식 다 문제를 해력할 수 있지만 어떤 방식이 좀 더 낳은 것일까?

지금의 적합한 것은 애플리케이션 의존 관계를 설정하는 것 처럼 선 조립, 실 행이 아니다. 단순히 코드를 실행할 때 변하지 않는 템플릿이 있고, 그 템플릿 안에서 원하는 부분만 살짝 다른 코드를 실행하고 싶을 뿐이다.

따라서 앞으로 다시 리팩토리할 로그추적기에는 실행 시점에 유연한게 실행 코드 조각을 전달하는 ContextV2가 더 적합하다.

⭐디자인 패턴은 그 해당 패턴을 사용하는 의도(intend)를 기준으로 구분하는 것.

[출처 - 스프링 핵심원리-고급편, 저 김영한]

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%ED%95%B5%EC%8B%AC-%EC%9B%90%EB%A6%AC-%EA%B3%A0%EA%B8%89%ED%8E%B8

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

스프링의 핵심 원리와 고급 기술들을 깊이있게 학습하고, 스프링을 자신있게 사용할 수 있습니다., 핵심 디자인 패턴, 쓰레드 로컬, 스프링 AOP스프링의 3가지 핵심 고급 개념 이해하기 📢 수강

www.inflearn.com

'FrameWork > Spring&Spring-boot' 카테고리의 다른 글

Spring Core - 프록시 패턴(예제 프로젝트) (0)	2024.03.08
Spring Core - 템플릿 콜백 패턴(시작, 적용, 정리) (0)	2024.03.07
Spring Core - 템플릿 메서드 패턴(예제3, 적용1, 적용2) (0)	2024.03.06
Spring Core - 템플릿 메서드 패턴(시작, 예제1, 예제2, 정의) (1)	2024.03.06
Spring Core - 쓰레드 로컬 동기화(적용, 주의사항) (0)	2024.03.06

ABOUT ME

밤 산책 밤 산책

전략 패턴 - 시작

전략 패턴 - 예제2

정리

전략패턴 - 예제3

정리

'FrameWork > Spring&Spring-boot' 카테고리의 다른 글

티스토리툴바

ABOUT ME

전략 패턴 - 시작

전략 패턴 - 예제2

정리

전략패턴 - 예제3

정리

'FrameWork > Spring&Spring-boot' 카테고리의 다른 글

관련글 관련글 더보기

티스토리툴바