스프링 고급편 - 템플릿 메서드 패턴과 콜백 패턴

✔️ 템플릿 메서드 패턴

---

이전에 만들었던 로그 추적기를 더 향상시켜보자

 

템플릿 메서드 패턴은 변하지 않는 부분과 변하는 부분을 분리해서 

변하지않는 부분을 템플릿(기본 틀)로 정의하고, 변하는 부분은 하위 클래스에서 정의하는 패턴이다. 

 

로그 추적기의 변하지 않는 부분

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

이 부분을 템플릿으로 정의한다.

 

추상 템플릿 클래스

public abstract class AbstractTemplate<T> {

    private final LogTrace trace;

    protected AbstractTemplate(LogTrace trace) {
        this.trace = 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) {
            throw e;
        }
    }

    protected abstract T call();

}

 

우리는 추상 메서드인 call을 사용할 자식 클래스에서 정의하여 사용한다. 

 

@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("OrderController.request()");
}

익명 내부 클래스를 사용하여 call을 정의하고 사용한다. 

 

 

 

템플릿 메서드의 한계

• 상속
  • 자식 클래스 입장에서 사용하지 않는 부분도 다 상속받는다. (컴파일 시점 강한 결합)
• 별도 클래스 생성, 익명 내부 클래스 생성 등 복잡

 

개선 : 전략 패턴

 

 

✔️ 전략 패턴

---

변하지 않는 부분을 Context 에 두고 

변하는 부분을 Strategy 라는 인터페이스를 만들고 해당 인터페이스에서 구현

 

상속이 아닌 위임

 

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

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

 

전략 인터페이스

public interface Strategy {
 void call();
}

 

필드에 전략 보관 방식

/**
 * 필드에 전략을 보관하는 방식
 */
@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("resulTime={}", resultTime);

    }
}

 

 

전략 패턴의 핵심은 Context 는 Strategy 인터페이스에만 의존 

Strategy 구현체를 변경해도 Context 코드에는 영향 X

 

Context 에 Strategy를 주입해서 사용

 

 

사용방법 

1. Strategy를 구현한 클래스를 Context에 주입 한 후 execute로 실행
2. 익명 내부 클래스
3. 람다 사용 (Strategy 인터페이스에 메서드가 1개이기에 가능)

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

 

선 조립, 후 실행

Context를 싱글톤으로 사용시 동시성 이슈등 고려할 점이 많음.

전략을 실시간으로 변경해야하면 Context를 하나 더 생성하고 다른 Straregy를 주입하는 것이 나은 선택일 수 있음

 

 

 

 

파라미터 전달 방식

 

/**
 * 전략을 파라미터로 전달 받는 방식
 */
@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("resulTime={}", resultTime);

    }
}

 

Context를 실행할 때 마다 전략을 인수로 전달 

이로써 하나의 Context만 생성하고 여러 전략을 인수로 전달 가능 (유연성)

 

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

 

 

ps. 익명 내부 클래스 , 상속 받아 사용하는 방법은 따로 적지 않았다. 필요하다면 강의자료를 참고하자.

 

 

 

✔️ 템플릿 콜백 패턴

---

콜백 정의

프로그래밍에서 콜백은 다른 코드의 인수로서 넘겨주는 실행 가능한 코드를 말함

콜백을 넘겨받은 코드는 이 콜백을 필요에 따라 즉시 실행 가능하며, 나중에 실행해도 된다.

 

 

전략패턴 파라미터 방식을 보면 Strategy는 콜백이다. 

• 클라이언트가 Context.execute()를 실행할 때 Strategy를 넘겨주고,
• Context가 뒤에 Strategy를 실행

 

자바 언어에서 콜백

• 자바 언어에서 실행 가능한 코드를 인수로 넘기려면 객체가 필요, 단 자바 8부터 람다 사용 가능
• 주로 람다를 사용

 

템플릿 콜백 패턴

스프링에서는 파라미터 전략패턴을 템플릿 콜백 패턴이라 하며

Cotnext가 템플릿, Strategy 부분이 콜백이라고 생각하면 된다. 

 

템플릿 콜백 패턴은 GOF 패턴은 아니고 스프링 내부에서 이런 방식을 자주 사용

 

스프링의 템플릿

JdbcTemplate, RestTemplate, RedisTemplate 등.. 

 

 

 

콜백 인터페이스

public interface Callback {
	void call();
}

 

Template

@Slf4j
public class TimeLogTemplate {

    public void execute(Callback callback) {
        long startTime = System.currentTimeMillis();

        // 비지니스 로직 실행
        callback.call(); // 위임

        // 비지니스 로직 종료
        long endTime = System.currentTimeMillis();
        long resultTime = endTime - startTime;
        log.info("resulTime={}", resultTime);

    }
}

 

애플리케이션 적용

콜백 인터페이스

public interface TraceCallback<T> {
    T call();
}

 

 

콜백 반환 타입을 위해 <T> 제네릭 사용

 

Template

@Slf4j
public class TraceTemplate {

    private final LogTrace trace;

    public TraceTemplate(LogTrace trace) {
        this.trace = trace;
    }

    public <T> T excute(String message, TraceCallback<T> callback) {
        TraceStatus status = null;

        try {
            status = trace.begin(message);

            // 로직 호출
            T result = callback.call();

            trace.end(status);
            return result;
        } catch (Exception e) {
            throw e;
        }
    }
}

참고 

<T> : 제네릭 타입

T : 반환 타입

(T t) : 파라미터 타입

 

 

사용

@RestController
public class OrderControllerV5 {

    private final OrderServiceV5 orderService;
    private final TraceTemplate template;

    public OrderControllerV5(OrderServiceV5 orderService, LogTrace logTrace) {
        this.orderService = orderService;
        this.template = new TraceTemplate(logTrace);
    }

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

        return template.excute("OrderController.request()", () -> {
            orderService.orderItem(itemId);
            return "ok";
        });
    }
}

 

 

실제로 스프링에서 템플릿 콜백 패턴은 많이 사용

 

 

🔖 학습내용 출처

---

스프링 핵심 원리 - 고급편 / 김영한