[TIL / Design Pattern] 템플릿 메서드 패턴, 전략 패턴(템플릿 콜백 패턴)

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

섹션 3. 템플릿 메서드 패턴과 콜백 패턴

 

오늘 공부한 내용을 간단하게 정리해 보자.

1. 템플릿 메서드 패턴
2. 전략 패턴
3. 템플릿 콜백 패턴

 

템플릿 메서드 패턴(Template Method Pattern)

좋은 설계는 변하는 것과 변하지 않는 것을 분리하는 것이다. 이 둘을 분리하여 모듈화를 한다. 

템플릿 메서드 패턴은 이런 문제를 해결한다.

 

GOF 디자인 패턴 - 템플릿 메서드 패턴

작업에서 알고리즘의 골격을 정의하고 일부 단계를 하위 클래스로 연기합니다. 템플릿 메서드를 사용하면 하위 클래스가 알고리즘의 구조를 변경하지 않고도 알고리즘의 특정 단계를 재정의할 수 있습니다.

• 작업에서 ~ 골격을 정의하고 : 템플릿
• 일부 단계를 ~ 연기합니다 : 변하는 부분을 하위 클래스가 구현하도록 함
• 템플릿 메서드를 사용하면 ~ 재정의할 수 있습니다 : 변하지 않는 부분은 템플릿(부모 클래스)에 두고 변하는 부분은 자식 클래스에서 정의함

▶ 상속과 오버라이딩을 통한 다형성으로 문제를 해결!

@Slf4j
public abstract class AbstractTemplate { //추상 클래스

    public void execute() { //변하지 않는 부분
        long startTime = System.currentTimeMillis();
        //비즈니스 로직 실행
        call(); //상속
        //비즈니스 로직 종료
        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("resultTime={}", resultTime);
    }

    protected abstract void call(); //변하는 부분 
}

@Slf4j
public class SubClassLogic extends AbstractTemplate { //템플릿(부모 클래스) 상속

    @Override
    protected void call() { //변하는 부분을 자식 클래스에서 구현(override)
        log.info("비즈니스 로직 실행");
    }
}

@Slf4j
class TemplateMethodTest {

    /**
     * 템플릿 메서드 패턴 적용
     */
    @Test
    void templateMethodV1() {
        AbstractTemplate template = new SubClassLogic(); //템플릿을 상속한 자식 클래스를 받는다.
        template.execute();
    }

    @Test
    void templateMethodV2() { 
        AbstractTemplate template = new AbstractTemplate() { //자식 클래스를 따로 구현하지 않고 익명 함수로 구현
            @Override
            protected void call() {
                log.info("비즈니스 로직 실행");
            }
        };
        template.execute();
    }
}

 

문제점

하지만! 템플릿 메서드 패턴은 상속을 사용하기 때문에 상속에서 오는 단점을 그대로 안고 간다.

• 부모 자식 클래스가 컴파일 시점에 강하게 결합된다.
• 자식 클래스는 부모 클래스의 기능을 전혀 사용하지 않는다.
• 그럼에도 불구하고 해당 패턴을 위해 자식 클래스는 부모 클래스를 상속받는다.

▶ 상속 == 특정 부모 클래스를 의존함 → 부모 클래스에서 무언가 바뀌면 자식 클래스에도 영향이 갈 수 있다.

 

전략 패턴(Strategy Pattern)

전략 패턴은 템플릿 메서드 패턴과 비슷한 역할을 하면서 상속의 단점을 제거할 수 있는 디자인 패턴이다.

전략 패턴은 변하지 않는 부분을 Context라는 곳에 두고, 변하는 부분을 Strategy라는 인터페이스를 만든다. 해당 인터페이스를 구현하도록 해서 문제를 해결한다. 상속이 아니라 위임으로 문제를 해결한다.

 

GOF 디자인 패턴에서 정의한 전략 패턴의 의도

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

@Slf4j
public class Context { //변하지 않는 부분

    private Strategy strategy; 

    public Context(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);
    }
}

public interface Strategy { //변하는 부분(인터페이스)
    void call();
}

@Slf4j
public class StrategyLogic implements Strategy { //Strategy 구현

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

@Slf4j
class ContextTest {

    /**
     * 전략 패턴 사용
     */
    @Test
    void strategy1() { //구현체 적용
        Strategy strategyLogic = new StrategyLogic(); 
        Context context = new Context(strategyLogic);
        context.execute();
    }
     
    @Test
    void strategy2() { //익명 클래스
        Context context = new Context(new Strategy() {
            @Override
            public void call() {
                log.info("비즈니스 로직 실행");
            }
        });
        context.execute();
    }

    @Test
    void strategy3() { //자바8 - 람다
        Context context = new Context(() -> log.info("비즈니스 로직 실행"));
        context.execute();
    }
}

위 코드처럼 필드에 전략을 보관해도 되고, 전략을 실시간으로 변경해야 한다면 직접 파라미터로 전달해서 사용해도 된다. 파라미터로 전달하게 된다면 Context 클래스의 execute()에 Strategy를 넘겨주면 된다.

 

템플릿 콜백 패턴(Template Callback Pattern)

위 전략패턴에서 마지막으로 언급한 방법을 떠올려보자. Context는 변하지 않는 템플릿 역할, 변하는 부분은 파라미터로 넘어온 Strategy의 코드를 실행해서 처리한다. 이렇게 다른 코드의 인수로서 넘겨주는 실행 가능한 코드를 콜백(Callback)이라고 한다.

 

콜백(Callback)

콜백

다른 코드의 인수로서 넘겨주는 실행 가능한 코드

 

자바 언어에서의 콜백

자바언어에서 실행 가능한 코드를 인수로 넘기려면 객체가 필요하다. 자바 8부터는 람다를 사용할 수 있다.

 

스프링에서의 템플릿 콜백 패턴

• 스프링에서는 Context에 Strategy(실행 가능한 코드)를 인수로서 넘겨주는 방식의 전략 패턴을 템플릿 콜백 패턴이라고 한다. Context가 템플릿 역할, Strategy가 콜백으로 넘어온다고 생각하면 된다.
• 템플릿 콜백 패턴은 GOF 패턴이 아니라, 스프링 내부에서 이런 방식을 자주 사용하기 때문에 스프링 안에서만 이렇게 부른다.

@Slf4j
public class TimeLogTemplate { //변하지 않는 부분(템플릿)

    public void execute(Callback callback) { //Strategy(Callback)을 파라미터로 받는다.
        long startTime = System.currentTimeMillis();
        //비즈니스 로직 실행
        callback.call(); //위임
        //비즈니스 로직 종료
        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("resultTime={}", resultTime);
    }
}

public interface Callback { //파라미터로 넘길 실행 가능한 코드(콜백)
    void call();
}

@Slf4j
class TemplateCallbackTest {

    /**
     * 템플릿 콜백 패턴 - 익명 내부 클래스
     */
    @Test
    void callbackV1() {
        TimeLogTemplate template = new TimeLogTemplate();
        template.execute(new Callback() {
            @Override
            public void call() {
                log.info("비즈니스 로직 실행");
            }
        });
    }

    /**
     * 템플릿 콜백 패턴 - 람다
     */
    @Test
    void callbackV2() {
        TimeLogTemplate template = new TimeLogTemplate();
        template.execute(() -> log.info("비즈니스 로직 실행")); //익명 함수보다 람다가 더 자주 사용된다.
    }
}

 

SUMMARY

• 변하지 않는 부분과 변하는 부분을 분리하여 모듈화 하자 → 템플릿 메서드 패턴
• 템플릿 메소드 패턴에서 변하는 부분은 Template(부모 클래스), 변하지 않는 부분은 자식 클래스로 구현한다.
• 템플릿 메소드 패턴을 사용하기 위해 부모 클래스의 기능이 필요 없어도 부모 클래스를 상속받아야 한다 ▶ 의존
• 템플릿 메소드 패턴과 비슷한 역할을 하면서 상속의 단점을 제거한 패턴 → 전략 패턴 ▶ 상속이 아닌 위임
• 전략 패턴에서는 변하지 않는 템플릿을 Context, 변하는 알고리즘을 Strategy(인터페이스)라고 한다. 
• 이때 Strategy(실행 가능한 코드)를 Context에 인수로 넘겨 실시간으로 변경할 수 있게 하는 패턴을 템플릿 콜백 패턴이라고 한다.
• 콜백 패턴에서 Context는 Template 역할, Strategy는 Callback 역할이다.