Template Method Pattern

SMALL

참고자료

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

 

템플릿 메서드 패턴 - 시작

스프링에서 굉장히 자주 사용되는 패턴 중 하나인 템플릿 메서드 패턴에 대해서 알아보자.

템플릿 메서드 패턴은 다형성을 이용하여 공통 부분을 하나로 정의하고 변하는 부분만을 유연하게 변경하게 하는 방법이다.

 

이전 포스팅에서 만들어봤던 로그 추적기를 막상 프로젝트에 도입하려고 하니 개발자들의 반대의 목소리가 높다. 로그 추적기 도입 전과 도입 후의 코드를 비교해보자.

 

로그 추적기 도입 전 - OrderControllerV0

@GetMapping("/v0/request")
public String request(String itemId) {
    orderService.orderItem(itemId);
    return "ok";
}

로그 추적기 도입 전 - OrderServiceV0

public void orderItem(String itemId) {
    orderRepository.save(itemId);
}

로그 추적기 도입 전 - OrderRepositoryV0

public void save(String itemId) {
    if (itemId.equals("ex")) {
        throw new IllegalStateException("예외 발생!");
    }
    sleep(1000);
}

 

로그 추적기 도입 후 - OrderControllerV3

@GetMapping("/v3/request")
public String request(String itemId) {
    TraceStatus status = null;
    try {
        status = trace.begin("OrderControllerV1.request(String itemId)");
        orderService.orderItem(itemId);
        trace.end(status);
        return "ok";
    } catch (Exception e) {
        trace.exception(status, e);
        throw e;
    }
}

로그 추적기 도입 후 - OrderServiceV3

public void orderItem(String itemId) {
    TraceStatus status = null;
    try {
        status = trace.begin("OrderServiceV1.orderItem(String itemId)");
        orderRepository.save(itemId);
        trace.end(status);
    } catch (Exception e) {
        trace.exception(status, e);
        throw e;
    }
}

로그 추적기 도입 후 - OrderRepositoryV3

public void save(String itemId) {
    TraceStatus status = null;
    try {
        status = trace.begin("OrderRepositoryV1.save(String itemId)");
        if (itemId.equals("ex")) {
            throw new IllegalStateException("예외 발생!");
        }
        sleep(1000);
        trace.end(status);
    } catch (Exception e) {
        trace.exception(status, e);
        throw e;
    }
}

• V0 코드와 V3 코드를 비교해보자. V0은 해당 메서드가 실제 처리해야 하는 핵심 기능만 깔끔하게 있다. 반면, V3는 핵심 기능보다 로그를 출력해야 하는 부가 기능 코드가 훨씬 더 많고 복잡하다. 

핵심 기능 vs 부가 기능

• 핵심 기능은 해당 객체가 제공하는 고유의 기능이다. 예를 들어, OrderService의 핵심 기능은 주문 로직이다. 메서드 단위로 보면 orderItem()의 핵심 기능은 주문 데이터를 저장하기 위해 리포지토리를 호출하는 orderRepository.save(itemId) 코드가 핵심 기능이다.
• 부가 기능은 핵심 기능을 보조하기 위해 제공되는 기능이다. 예를 들어, 로그 추적 로직, 트랜잭션 기능이 있다. 이러한 부가 기능은 단독으로 사용되지는 않고, 핵심 기능과 함께 사용된다. 예를 들어서 로그 추적 기능은 어떤 핵심 기능이 호출되었는지 로그를 남기기 위해 사용한다. 그러니까 핵심 기능을 보조하기 위해 존재한다.

V3 코드는 그러니까, 배보다 배꼽이 더 큰 상황이다. 만약 클래스가 수백개고 메서드가 수천개면 어떻게 하겠는가? 개발자들이 반대할만하다.  이 문제를 좀 더 효율적으로 처리할 수 있는 방법이 있을까? V3 코드를 보면 다음과 같이 동일한 패턴이 보인다.

TraceStatus status = null;
try {
    status = trace.begin("메시지 입력");
    // 핵심 기능 호출
    trace.end(status);
} catch (Exception e) {
    trace.exception(status, e);
    throw e;
}

• Controller, Service, Repository의 코드를 보면, 로그 추적기를 사용하는 구조는 모두 동일하다. 중간에 핵심 기능을 사용하는 코드만 다를 뿐이다. 부가 기능과 관련된 코드가 중복이니 중복을 별도의 메서드로 뽑아낼까? 그런데, try - catch는 물론이고 핵심 기능 부분이 중간에 있어서 단순하게 메서드로 추출하는 것은 꽤나 어렵다.
• 따라서, 이럴땐 변하는 것과 변하지 않는 것을 분리하는 것이다! 좋은 설계는 변하는 것과 변하지 않는 것을 분리하는 것이다. 구현체를 아무리 갈아끼우고 사용하는 기술을 바꿔도 인터페이스에만 의존하는 클라이언트 코드는 변하지 않는다. 변하는 것은 구현체일뿐이다. DI는 스프링의 핵심 중 하나인 것이다. 이 코드 또한 마찬가지다. 여기서 핵심 기능 부분은 변하고, 로그 추적기를 사용하는 부분은 변하지 않는 부분이다. 이 둘을 분리해서 모듈화해야 한다. 어디서 많이 들어본 내용같다. 맞다. 템플릿 메서드 패턴이 이 문제를 해결해줄 수 있다!

템플릿 메서드 패턴 - 예제1

TemplateMethodTest

package cwchoiit.springadvanced.trace.template;

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

@Slf4j
public class TemplateMethodTest {

    @Test
    void templateMethodV0() {
        logic1();
        logic2();
    }

    private void logic1() {
        long startTime = System.currentTimeMillis();
        log.info("비즈니스 로직1 실행");
        long endTime = System.currentTimeMillis();

        long resultTime = endTime - startTime;
        log.info("resultTime = {}ms", resultTime);
    }

    private void logic2() {
        long startTime = System.currentTimeMillis();
        log.info("비즈니스 로직2 실행");
        long endTime = System.currentTimeMillis();

        long resultTime = endTime - startTime;
        log.info("resultTime = {}ms", resultTime);
    }
}

• 템플릿 메서드 패턴을 쉽게 이해하기 위해 단순한 예제 코드를 만들었다.
• logic1()과 logic2()는 비즈니스 로직이라는 로그 출력 부분만 다르지 그 외 모든것이 동일하다. 
• 즉, 변하는 부분은 비즈니스 로직이고 변하지 않는 부분은 시간 측정이다. 
• 이걸 템플릿 메서드 패턴을 사용해서 변하는 부분과 변하지 않는 부분을 분리해보자!

 

템플릿 메서드 패턴 - 예제2

• 부모 클래스를 abstract로 하나 만들고, 그 부모 클래스를 상속받는 자식 클래스에서 달라지는 부분을 구현하는 그림이라고 생각하면 된다.

AbstractTemplate

package cwchoiit.springadvanced.trace.template.code;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public abstract class AbstractTemplate {

    public void execute() {
        long startTime = System.currentTimeMillis();
        call();
        long endTime = System.currentTimeMillis();

        long resultTime = endTime - startTime;
        log.info("resultTime = {}ms", resultTime);
    }

    protected abstract void call();
}

• 템플릿 메서드 패턴은 이름 그대로 템플릿을 사용하는 방식이다. 템플릿은 기준이 되는 거대한 틀이다. 템플릿이라는 틀에 변하지 않는 부분을 몰아둔다. 그리고 일부 변하는 부분을 별도로 호출해서 해결한다.
• AbstractTemplate 코드를 보자. 변하지 않는 부분인 시간 측정 로직을 몰아둔 것을 확인할 수 있다. 이제 이것이 하나의 템플릿이 된다. 그리고 템플릿 안에서 변하는 부분은 call() 메서드를 호출해서 처리한다. 템플릿 메서드 패턴은 부모 클래스에 변하지 않는 템플릿 코드를 둔다. 그리고 변하는 부분은 자식 클래스에 두고 상속과 오버라이딩을 사용해서 처리한다.

SubClassLogic1

package cwchoiit.springadvanced.trace.template.code;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class SubClassLogic1 extends AbstractTemplate {

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

 

SubClassLogic2

package cwchoiit.springadvanced.trace.template.code;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class SubClassLogic2 extends AbstractTemplate {

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

• 각각 변하는 부분인 비즈니스 로직을 처리하는 자식 클래스이다. 템플릿이 호출하는 대상인 call() 메서드를 오버라이딩 한다.

TemplateMethodTest

package cwchoiit.springadvanced.trace.template;

import cwchoiit.springadvanced.trace.template.code.AbstractTemplate;
import cwchoiit.springadvanced.trace.template.code.SubClassLogic1;
import cwchoiit.springadvanced.trace.template.code.SubClassLogic2;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

@Slf4j
public class TemplateMethodTest {

    @Test
    void templateMethodV0() {
        logic1();
        logic2();
    }

    private void logic1() {
        long startTime = System.currentTimeMillis();
        log.info("비즈니스 로직1 실행");
        long endTime = System.currentTimeMillis();

        long resultTime = endTime - startTime;
        log.info("resultTime = {}ms", resultTime);
    }

    private void logic2() {
        long startTime = System.currentTimeMillis();
        log.info("비즈니스 로직2 실행");
        long endTime = System.currentTimeMillis();

        long resultTime = endTime - startTime;
        log.info("resultTime = {}ms", resultTime);
    }

    @Test
    void templateMethodV1() {
        AbstractTemplate template = new SubClassLogic1();
        template.execute();

        AbstractTemplate template2 = new SubClassLogic2();
        template2.execute();
    }
}

 

• 위 코드에서 먼저 템플릿 메서드 패턴을 적용하지 않은 코드를 보자. 공통 부분인 메서드의 시작 시간, 종료 시간, 소요 시간을 구하는 코드와 각 메서드 별 가지는 비즈니스 로직을 메서드 별로 만들었다면 logic1(), logic2()처럼 표현된다.
• 그리고 그 메서드를 실행하는 templateMethodV0()이 있다. 단 두개의 메서드만으로도 얼마나 비효율적인지 알 수 있다. 거의 최악의 코드라고 보면 된다. 유지보수성이 '0'에 가까운
• 반면에 템플릿 메서드 패턴을 적용한 templateMethodV1() 메서드를 보자.
• 메서드 별 달리 적용되는 부분을 상속받는 각 클래스가 상속받아 구현하고 부모 클래스가 가지고 있는 execute() 메서드를 실행만 하면 된다. 부모 타입의 변수를 만들었기 때문에 부모 클래스가 가진 메서드execute()를 호출할 수 있고, 그 안에서 call() 메서드를 호출하는데 그 메서드는 자식이 오버라이딩 했다면 무조건 오버라이딩 메서드가 우선순위를 가지는 다형성이 주는 강력함을 이용해서 공통부분과 달라지는 부분을 분리할 수 있다. 추후에 공통 부분에 변경 사항이 생기더라도 딱 한 개의 클래스인 추상 클래스(부모 클래스)만 수정하면 된다.

실행 결과

비즈니스 로직1 실행 
resultTime=0
비즈니스 로직2 실행 
resultTime=1

• 아까와 동일한 결과지만 코드는 천차만별이다. 그러나, 이 코드도 단점이 있다. 메서드가 100개면 100개를 수정하듯, 서로 다른 로직이 필요한 부분이 100개라면 100개의 클래스를 만들어야 한다. 이 부분을 간단하게 해결하려면 익명 내부 클래스를 사용하면 된다.

 

템플릿 메서드 패턴 - 예제3

익명 내부 클래스는 위 문제를 해결해준다. 즉, 클래스를 사전에 정의해서 호출하는 방법이 아니라, 추상 클래스를 만드는 시점에 정의하는 것이다. 이는 100개의 서로 다른 로직이 필요할 때 100개의 클래스 파일을 만들어야 하는게 아니라 그 때마다 익명 내부 클래스를 선언해주면 된다.

@Test
void templateMethodV2() {
    AbstractTemplate template = new AbstractTemplate() {
        @Override
        protected void call() {
            log.info("비즈니스 로직1 실행");
        }
    };
    template.execute();

    AbstractTemplate template2 = new AbstractTemplate() {
        @Override
        protected void call() {
            log.info("비즈니스 로직2 실행");
        }
    };
    template2.execute();
}

 

• 위 templateMethodV2() 메서드를 보자. 추상 클래스인 AbstractTemplate를 구현한 클래스를 호출하는 게 아니라 추상 클래스를 사용하고자 할 때마다 상속받을 클래스를 정의하고 있다. 이렇게 되면 클래스를 하나하나 정의하여 가져다가 사용하지 않아도 된다.

 

템플릿 메서드 패턴 - 적용1

이제 우리가 만든 애플리케이션의 로그 추적기 로직에 템플릿 메서드 패턴을 적용해보자.

 

AbstractTemplate

package cwchoiit.springadvanced.trace.template;

import cwchoiit.springadvanced.trace.TraceStatus;
import cwchoiit.springadvanced.trace.logtrace.LogTrace;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor
public abstract class AbstractTemplate<T> {

    private final LogTrace trace;

    public T execute(String message) {
        TraceStatus status = null;
        try {
            status = trace.begin(message);
            T result = call();
            trace.end(status);
            return result;
        } catch (Exception e) {
            trace.exception(status, e);
            throw e;
        }
    }

    protected abstract T call();
}

• AbstractTemplate은 템플릿 메서드 패턴에서 부모 클래스이고, 템플릿 역할을 한다.
• <T> 제네릭을 사용했다. 반환 타입을 정의한다.
• 객체를 생성할 때 내부에서 사용할 LogTrace trace를 전달받는다.
• 로그에 출력할 message를 외부에서 파라미터로 전달받는다.
• 템플릿 코드 중간에 call() 메서드를 통해서 변하는 부분을 처리한다.
• abstract T call()은 변하는 부분을 처리하는 메서드이다. 이 부분은 상속으로 구현해야 한다.

OrderControllerV4

package cwchoiit.springadvanced.app.v4;

import cwchoiit.springadvanced.trace.TraceStatus;
import cwchoiit.springadvanced.trace.logtrace.LogTrace;
import cwchoiit.springadvanced.trace.template.AbstractTemplate;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequiredArgsConstructor
public class OrderControllerV4 {

    private final OrderServiceV4 orderService;
    private final LogTrace trace;

    @GetMapping("/v4/request")
    public String request(String itemId) {

        AbstractTemplate<String> template = new AbstractTemplate<>(trace) {
            @Override
            protected String call() {
                orderService.orderItem(itemId);
                return "ok";
            }
        };
        return template.execute("OrderControllerV1.request(String itemId)");
    }
}

 

OrderServiceV4

package cwchoiit.springadvanced.app.v4;

import cwchoiit.springadvanced.trace.TraceStatus;
import cwchoiit.springadvanced.trace.logtrace.LogTrace;
import cwchoiit.springadvanced.trace.template.AbstractTemplate;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

@Service
@RequiredArgsConstructor
public class OrderServiceV4 {

    private final OrderRepositoryV4 orderRepository;
    private final LogTrace trace;

    public void orderItem(String itemId) {
        AbstractTemplate<Void> template = new AbstractTemplate<>(trace) {
            @Override
            protected Void call() {
                orderRepository.save(itemId);
                return null;
            }
        };
        template.execute("OrderServiceV1.orderItem(String itemId)");
    }
}

 

OrderRepositoryV4

package cwchoiit.springadvanced.app.v4;

import cwchoiit.springadvanced.trace.TraceStatus;
import cwchoiit.springadvanced.trace.logtrace.LogTrace;
import cwchoiit.springadvanced.trace.template.AbstractTemplate;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;

@Repository
@RequiredArgsConstructor
public class OrderRepositoryV4 {

    private final LogTrace trace;

    public void save(String itemId) {
        AbstractTemplate<Void> template = new AbstractTemplate<>(trace) {
            @Override
            protected Void call() {
                if (itemId.equals("ex")) {
                    throw new IllegalStateException("예외 발생!");
                }
                sleep(1000);
                return null;
            }
        };
        template.execute("OrderRepositoryV1.save(String itemId)");
    }

    private void sleep(int ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

• 템플릿 메서드 패턴을 적용하니, 기존에 지저분한 로그를 남기는 코드들이 깔끔하게 지워졌다. 그런데, 뭐 그렇다고 이 코드가 깔끔해보이냐? 그것은 또 아니다. 템플릿 메서드 패턴을 위한 코드 자체가 있기 때문에 또 코드 라인을 차지하고 가장 보기 싫은 건 저 익명 내부 클래스 부분들이 줄줄이 나열하고 있는게 그렇게 이뻐보이지는 않는다.
• 그래도 그 이전보다는 코드가 좀 더 깔끔해졌다. 

 

좋은 설계란?

좋은 설계라는 것은 무엇일까? 수많은 멋진 정의가 있겠지만, 진정한 좋은 설계는 바로 변경이 일어날 때 자연스럽게 드러난다. 지금까지 로그를 남기는 부분을 모아서 하나로 모듈화하고, 비즈니스 로직 부분을 분리했다. 여기서 만약, 로그를 남기는 로직을 변경해야 한다고 생각해보자. 그래서 AbstractTemplate 코드를 변경해야 한다 가정해보자. 단순히 AbstractTemplate 코드만 변경하면 된다. 템플릿이 없는 V3 상태에서 로그를 남기는 로직을 변경해야 한다고 생각해보자. 이 경우, 모든 클래스를 다 찾아서 고쳐야 한다. 클래스가 수백개라면 생각만해도 끔찍하다.

 

단일 책임 원칙(SRP)

V4는 단순히 템플릿 메서드 패턴을 적용해서 소스코드 몇 줄을 줄인 것이 전부가 아니다. 로그를 남기는 부분에 단일 책임 원칙을 지킨것이다. 변경 지점을 하나로 모아서 변경에 쉽게 대처할 수 있는 구조를 만든 것이다.

 

템플릿 메서드 패턴 - 정의

GOF 디자인 패턴에서는 템플릿 메서드 패턴을 다음과 같이 정의했다.

 

템플릿 메서드 디자인 패턴의 목적은 다음과 같습니다.
"작업에서 알고리즘의 골격을 정의하고 일부 단계를 하위 클래스로 연기합니다. 템플릿 메서드를 사용하면 하위 클래스가 알고리즘의 구조를 변경하지 않고도 알고리즘의 특정 단계를 재정의할 수 있습니다." [GOF]

 

GOF 템플릿 메서드 패턴 정의

위 내용을 풀어서 설명하면 다음과 같다.

• 부모 클래스에 알고리즘의 골격인 템플릿을 정의하고, 일부 변경되는 로직은 자식 클래스에 정의하는 것이다. 이렇게 하면 자식 클래스가 알고리즘의 전체 구조를 변경하지 않고, 특정 부분만 재정의할 수 있다. 결국 상속과 오버라이딩을 통한 다형성으로 문제를 해결하는 것이다. 

하지만,

템플릿 메서드 패턴은 상속을 사용한다. 따라서 상속에서 오는 단점을 그대로 안고간다. 특히 자식 클래스가 부모 클래스와 컴파일 시점에 강하게 결합되는 문제가 있다. 이것은 의존관계에 대한 문제이다. 자식 클래스 입장에서는 부모 클래스의 기능을 전혀 사용하지 않는다. 이번 포스팅에서 지금까지 작성했던 코드를 떠올려보자. 자식 클래스를 작성할 때 부모 클래스의 기능을 사용한 것이 있었던가? 그럼에도 불구하고 템플릿 메서드 패턴을 위해 자식 클래스는 부모 클래스를 상속 받고 있다.

 

상속을 받는다는 것은 특정 부모 클래스를 의존하고 있다는 것이다. 자식 클래스의 extends 다음에 바로 부모 클래스가 코드상에 지정되어 있다. 따라서, 부모 클래스의 기능을 사용하든 사용하지 않든 간에 부모 클래스를 강하게 의존하게 된다. 여기서 강하게 의존한다는 뜻은 자식 클래스의 코드에 부모 클래스의 코드가 명확하게 적혀 있다는 뜻이다. UML에서 상속을 받으면 삼각형 화살표가 자식 -> 부모를 향하고 있는 것은 이런 의존관계를 반영하는 것이다. 참고로 화살표(->)의 방향은 이런 의미다. "내가 얘를 알고 있다."

 

자식 클래스 입장에서는 부모 클래스의 기능을 전혀 사용하지 않는데, 부모 클래스를 알아야 한다. 이것은 좋은 설계라고 할 수 없다. 왜냐하면 지금 같은 경우에도 부모 클래스에 만약, abstract 메서드가 하나 더 추가되면 이 부모 클래스를 상속받은 자식 클래스는 무조건 이 메서드를 구현해야만 컴파일 할 때 문제가 발생하지 않는다. 즉, 부모 클래스의 기능을 전혀 사용하지 않지만 부모 클래스를 수정하는 순간 자식 클래스가 강하게 영향을 받게 된다. 

 

추가로, 템플릿 메서드 패턴은 상속 구조를 사용하기 때문에, 별도의 클래스나 익명 내부 클래스를 만들어야 하는 부분도 복잡하다. 지금까지 설명한 이런 부분들을 더 깔끔하게 개선하려면 어떻게 해야할까? 템플릿 메서드 패턴과 비슷한 역할을 하면서 상속의 단점을 제거할 수 있는 디자인 패턴이 바로 전략 패턴(Strategy Pattern)이다.