[스프링 핵심원리 - 고급편] #4. 템플릿 메서드 패턴과 콜백 패턴

[YuDeokRin]

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

1️⃣ 템플릿 메서드 패턴 - 시작

• 로그 추적기 도입 전(V0)과 로그 추적기 도입 후(V3)를 비교해보기

• 로그 추적기 도입 전 - V0 코드

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

//OrderServiceV0 코드
public void orderItem(String itemId) {
		orderRepository.save(itemId);
}

• 로그 추적기 도입 후 - V3 코드

//OrderControllerV3 코드
@GetMapping("/v3/request")
public String request(String itemId) {
		TraceStatus status = null;
		try {
				status = trace.begin("OrderController.request()");
				orderService.orderItem(itemId); //핵심 기능
				trace.end(status);
		} catch (Exception e) {
				trace.exception(status, e);
				throw e;
		}
		return "ok";
}

//OrderServiceV3 코드
public void orderItem(String itemId) {
		TraceStatus status = null;
		try {
				status = trace.begin("OrderService.orderItem()");
				orderRepository.save(itemId); //핵심 기능
				trace.end(status);
		} catch (Exception e) {
				trace.exception(status, e);
				throw e;
		}
}

• 위의 V0, V3를 비교해보자.

  • V0는 핵심기능만 있음. 반면에 V3는 핵심 기능 + 로그 출력하는 부가 기능 코드가 더 있음

• V3 코드에서 동일한 패턴 - 아래 코드

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

• ➡️ Controller, Service, Repository의 코드를 보면, 로그 추적기를 사용하는 구조는 모두 동일하다. 중간에 핵심 기능을 사용하는 코드만 다름
  • 부가 기능과 관련된 코드가 중복이므로 메서드로 추출하려고한다. 하지만 try ~ catch 구문에 핵심기능이 중간에 있다 → 메서드 추출하기 어렵다.

✅ 변하는 것과 변하지 않는 것을 분리

• 좋은 설계는 변하는 것과 변하지 않는 것을 분리하는 것
• 핵심 기능 부분 변하고 로그 추적기를 사용하는 부분은 변하지 않는다.
• 이 둘을 분리하여 모듈화해야 한다.

🚨 해결책

• 템플릿 메서드 패턴

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

• 템플릿 메서드 패턴을 이해하기 위한 예제

• TemplateMethodTest

package hello.advanced.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 = {}", resultTime);
    }

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

}

• 결과

hello.advanced.trace.template.TemplateMethodTest -- 비즈니스 로직1 실행 
hello.advanced.trace.template.TemplateMethodTest -- resultTime = 3
hello.advanced.trace.template.TemplateMethodTest -- 비즈니스 로직2 실행 
hello.advanced.trace.template.TemplateMethodTest -- resultTime = 0

• logic1()과 logic2()는 시간을 측정하는 부분과 비즈니스 로직을 실행하는 부분이 함께 존재한다.

• 변하는 부분 : 비즈니스 로직

• 변하지 않는 부분 : 시간 측정

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

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

• 템플릿 메서드 패턴 구조

• AbstractTemplate

package hello.advanced.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={}", resultTime);
		}
		protected abstract void call();
}

• 템플릿 메서드 패턴은 이름 그대로 템플릿을 사용하는 방식이다. 템플릿은 기준이 되는 거대한 틀이다.

• 템플릿에 변하지 않는 부분을 몰아둔다.

• 일부 변하는 부분을 별도로 호출해서 해결한다.

• AbstractTemplate 코드 분석

  • 변하지 않는 부분인 시간 측정 로직을 몰아둔 것을 확인할 수 있다. → 하나의 템플릿
  • 템플릿 안에 변하는 부분 → call() 메서드를 호출해서 처리
  • 템플릿 메서드 패턴은 부모 클래스에 변하지 않는 템플릿 코드를 둔다.
  • 변하는 부분은 자식 클래스에 두고 상속과 오버라이딩을 사용해서 처리

• SubClassLogic1

@Slf4j
public class SubClassLogic1 extends AbstractTemplate {
    @Override
    protected void call() {
        log.info("비즈니스 로직1 실행");
    }
}

• SubClassLogic2

@Slf4j
public class SubClassLogic2 extends AbstractTemplate {
    @Override
    protected void call() {
        log.info("비즈니스 로직2 실행");
    }
}

• templateMethodV1
  • 템플릿 메서드 패턴으로 구현한 코드 실행

/**
* 템플릿 메서드 패턴 적용
*/
@Test
void templateMethodV1() {
		AbstractTemplate template1 = new SubClassLogic1();
		template1.execute();

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

• 실행 결과

hello.advanced.trace.template.code.SubClassLogic1 -- 비즈니스 로직1 실행
hello.advanced.trace.template.code.AbstractTemplate -- resultTime=2
hello.advanced.trace.template.code.SubClassLogic2 -- 비즈니스 로직2 실행
hello.advanced.trace.template.code.AbstractTemplate -- resultTime=0

• 템플릿 메서드 패턴 인스턴스 호출
  1. template1.execute()를 호출
  2. 템플릿 로직인 AbstractTemplate.execute() 실행
  3. call() 메서드 호출
  4. call() 메서드 오버라이딩
  5. SubClassLogic1 인스턴스의 SubClassLogic1.call() 메서드가 호출

템플릿 메서드 패턴

• 다형성을 사용해서 변하는 부분과 변하지 않는 부분을 분리하는 방법이다.

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

✅ 익명 내부 클래스 사용하기

• 템플릿 메서드 패턴은 SubClassLogic1, SubClassLogic2처럼 클래스를 계속 만들어야 하는 단점있다.

• 단점을 보완할 수 있는 방법 : 익명 내부 클래스

• 익명 내부 클래스를 사용하면 객체 인스턴스를 생성하면서 동시에 생성할 클래스를 상속 받은 자식 클래스를 정의할 수 있다.

• templateMethodV2()

/**
 * 템플릿 메서드 패턴, 익명 내부 클래스 사용
 */
@Test
void templateMethodV2() {
		AbstractTemplate template1 = new AbstractTemplate() {
			@Override
			protected void call() {
				log.info("비즈니스 로직1 실행");
			}
		};
		log.info("클래스 이름1={}", template1.getClass());
		template1.execute();

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

• 실행 결과

클래스 이름1 class hello.advanced.trace.template.TemplateMethodTest$1
비즈니스 로직1 실행
resultTime=3
클래스 이름2 class hello.advanced.trace.template.TemplateMethodTest$2
비즈니스 로직2 실행
resultTime=0

• 실행 결과를 보면 자바가 임의로 만들어주는 익명 내부 클래스 이름은 TemplateMethodTest$1 ,
  TemplateMethodTest$2 인 것을 확인할 수 있다.

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

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

• AbstractTemplate

public abstract class AbstractTemplate<T> {
		private final LogTrace trace;

		public 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) {
				trace.exception(status, e);
				throw e;
			}
		}

		protected abstract T call();
}

• AbstractTemplate 코드 설명

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

• OrderControllerV4

package hello.advanced.app.V4;

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

@RestController // @Controller + @ResponseBody
@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";
            }
        };

        try { // try-catch 하는 이유 : 예외가 터지는 경우에도 로그를 출력해주어야하기 때문에
            status = trace.begin("OrderController.request()");
            orderService.orderItem(itemId);
            trace.end(status);
            return "ok";
        } catch (Exception e) {
            trace.exception(status, e);
            throw e; // 에외를 꼭 다시 던져주어야 한다.
        }

    }

}

• OrderControllerV4 코드 분석

  • AbstractTemplate
    • 제네릭을 String으로 설정 → AbstractTemplate의 반환 타입은 String이 된다.
  • 익명 내부 클래스
    • 익명 내부 클래스를 사용한다. 객체를 생성하면서 AbstractTemplate를 상속받은 자식 클래스를 정의 → 별도로 자식 클래스를 생성하지 않아도됨.

• template.execute(”OrderController.request()”)

  • 템플릿을 실행하면서 로그로 남길 message를 전달

• OrderServiceV4

  • AbstractTemplate
    • 제네릭에서 반환타입이 필요한데, 반환할 내용이 없으면 Void타입을 사용하고 null을 반환
    • 참고로 제네릭은 기본 타입인 void, int 등을 선언할 수 없다.

package hello.advanced.app.V4;

import hello.advanced.trace.TraceStatus;
import hello.advanced.trace.logtrace.LogTrace;
import hello.advanced.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<Void>(trace) {

            @Override
            protected Void call() {
                orderRepository.save(itemId);
                return null;
            }
        };
        template.execute("OrderService.orderItem()");
    }

}

• OrderRepositoryV4

package hello.advanced.app.V4;

import hello.advanced.trace.TraceStatus;
import hello.advanced.trace.logtrace.LogTrace;
import hello.advanced.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<Void>(trace) {

            @Override
            protected Void call() {
                
                //저장 로직
                if (itemId.equals("ex")) {
                    throw new IllegalArgumentException("예외 발생!");
                }
                sleep(1000);
                return null;
            }
        };
       
    }

    private void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

• 실행 결과

[aaaaaaaa] OrderController.request()
[aaaaaaaa] |-->OrderService.orderItem()
[aaaaaaaa] | |-->OrderRepository.save()
[aaaaaaaa] | |<--OrderRepository.save() time=1004ms
[aaaaaaaa] |<--OrderService.orderItem() time=1006ms
[aaaaaaaa] OrderController.request() time=1007ms

6️⃣ 템플릿 메서드 패턴 - 적용 2

• 템플릿 메서드 패턴 덕분에 변하는 코드와 변하지 않는 코드를 명확하게 분리했다.

//OrderServiceV0 코드
public void orderItem(String itemId) {
		orderRepository.save(itemId);
}

//OrderServiceV3 코드
public void orderItem(String itemId) {
		TraceStatus status = null;
		try {
				status = trace.begin("OrderService.orderItem()");
				orderRepository.save(itemId); //핵심 기능
				trace.end(status);
		} catch (Exception e) {
				trace.exception(status, e);
				throw e;
		}
}

//OrderServiceV4 코드
AbstractTemplate<Void> template = new AbstractTemplate<>(trace) {
		@Override
		protected Void call() {
				orderRepository.save(itemId);
				return null;
		}
};

template.execute("OrderService.orderItem()");

• OrderServiceV0 : 핵심 기능
• OrderServiceV3 : 핵심 기능 + 부가 기능
• OrderServiceV4 : 핵심 기능 + 템플릿을 호출하는 코드가 섞임

✅ 좋은 설계란?

• 좋은 설계라는 것은 무엇일까? 진정한 좋은 설계는 바로 변경이 일어날 때 자연스럽게 드러난다.
• 지금까지 로그를 남기는 부분을 모아서 하나로 모듈화하고, 비즈니스 로직 부분을 분리했다. 여기서 만약 로그를 남기는로직을 변경해야 한다고 생각해보자. 그래서 AbstractTemplate 코드를 변경해야 한다 가정해보자. 단순히AbstractTemplate 코드만 변경하면 된다.

✅ 단일 책임 원칙(SRP)

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

7️⃣ 템플릿 메서드 패턴 - 정의

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

• 템플릿 메서드 디자인 패턴의 목적은 다음과 같습니다.

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

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

• But

  • 템플릿 메서드 패턴은 상속을 사용한다. 따라서 상속에서 오는 단점들을 그대로 가져간다. 특히 자식 클래스가 부모 클래스와 컴파일 시점에 강하게 결합되는 문제가 있음 → 의존 관계에 대한 문제

  • 자식 클래스 입장에서는 부모 클래스의 기능을 전혀 사용하지 않는다.

  • 상속을 받는 다는 것은 특정 부모 클래스를 의존하고 있다는 것.

  • extends 다음에 바로 부모클래스가 코드상에 지정되어 있다. → 부모 클래스의 기능을 사용하든 사용

7️⃣ 전략 패턴 - 시작

• 전략 패턴는 예전에 만들어 놓은 템플릿 메서드 패턴의 예제를 사용해보자.

• ContextV1Test

package hello.advanced.trace.strategy;

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

@Slf4j
public class ContextV1Test {

    @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 = {}", resultTime);
    }

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

• 실행 결과

21:13:12.930 [Test worker] INFO hello.advanced.trace.strategy.ContextV1Test -- 비즈니스 로직1 실행 
21:13:12.933 [Test worker] INFO hello.advanced.trace.strategy.ContextV1Test -- resultTime = 3
21:13:12.934 [Test worker] INFO hello.advanced.trace.strategy.ContextV1Test -- 비즈니스 로직2 실행 
21:13:12.934 [Test worker] INFO hello.advanced.trace.strategy.ContextV1Test -- resultTime = 0

8️⃣ 전략 패턴 - 예제 1

• 템플릿 메서드 패턴에서의 문제를 전략 패턴으로 해결해보자.
• 그 전에 템플릿 메서드 패턴은 부모 클래스에 변하지 않는 템플릿을 두고, 변하는 부분을 자식 클래스에 두어서 상속을 사용해서 문제 해결했다.
• 전략 패턴에서
  • Context는 변하지 않는 부분
  • Strategy 인터페이스를 활용해서 문제 해결해보자. → 상속이 아닌 위임으로 해결

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

package hello.advanced.trace.strategy.code.strategy;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class StrategyLogic1 implements Strategy {

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

• ContextV1

package hello.advanced.trace.strategy.code.strategy;

import lombok.extern.slf4j.Slf4j;

@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 코드 설명
  • 변하지 않는 로직을 가지고 있는 템플릿 역할하는 코드 = 전략 패턴에서는 이것을 컨텍스트(문맥)이라고한다.
  • Context는 내부에 Stratedy 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에 Stategy의 구현체인 strategyLogic1를 주입하는 것을 확인할 수 있다.

• 이렇게 Context 안에 원하는 전략을 주입한다. 이렇게 원하는 모양으로 조립을 완료하고 난 다음에 context1.execute() 호출해서 context를 실행한다.

• 전략 패턴 실행 그림

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

9️⃣ 전략 패턴 - 예제 2

• ContextV1Test - 추가

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

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

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

ContextV1Test - strategyLogic1=class
hello.advanced.trace.strategy.ContextV1Test$1
ContextV1Test - 비즈니스 로직1 실행
ContextV1 - resultTime=0
ContextV1Test - strategyLogic2=class
hello.advanced.trace.strategy.ContextV1Test$2
ContextV1Test - 비즈니스 로직2 실행
ContextV1 - resultTime=0

• ContextV1Test - 추가

    @Test
    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();
    }

• ContextV1Test - 추가

    /**
     *  전략 패턴, 람다
     */
    @Test
    void strategyV4() {
        ContextV1 context1 = new ContextV1(() -> log.info("비즈니스 로직1 실행"));
        context1.execute();
        ContextV1 context2 = new ContextV1(() -> log.info("비즈니스 로직2 실행"));
        context2.execute();
    }

• strategyV4 코드설명
  • 익명 내부 클래스를 람다를 이용해서 바꿔줄 수 있다 그럼 코드가 더 간결해진다.
  • 람다로 변경하려면 인터페이스에 메서드가 1개만 있으면 된다. 여가에서 제공하는 ‘Strategy’인터페이스는 메서드가 1개만 있으므로 람다로 바꿀 수 있다.

➡️선 조립, 후 실행

• Context와 Strategy를 실행 전에 원하는 모양으로 조립해두고, 가 다음에 Context를 실행하는 선 조립, 후 실행 방식에서 매우 유용하다.
• Context와 Strategy를 한번 조립하고 나면 이후로는 Context를 실행하기만 하면된다.
• 스프링으로 애플리케이션을 개발할 때 애플리케이션 로딩 시점에 의존관계 주입을 통해 필요한 의존관계를 모두 맺어두고 난 다음에 실제 요청을 처리하는 것과 같은 원리
• 단점
  • Context와 Strategy를 조립한 이후에는 전략을 변경하기가 어렵다는 점
  • Context를 싱글톤으로 사용할 때는 동시성 이슈 등 고려할 점이 많음

선 조립 사용하는 방식보다 더 유연하게 전략 패턴을 사용하는 방법은?
다음 챕터로 알아보자

1️⃣0️⃣ 전략 패턴 - 예제 3

• 이번에는 전략 패턴을 다르게 사용

• 이전에는 Context의 필드에 Strategy를 주입해서 사용함

• 새로운 방법 : 전략을 실행할 때 직접 파라민터로 전달해서 사용

• ContextV2Test

package hello.advanced.trace.strategy;

import hello.advanced.trace.strategy.code.strategy.ContextV2;
import hello.advanced.trace.strategy.code.strategy.StrategyLogic1;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

@Slf4j
public class ContextV2Test {
   
    @Test
    void strategyV1() {
        ContextV2 context = new ContextV2();
        context.execute(new StrategyLogic1());
        context.execute(new StrategyLogic2());
        
    }
}

• ContextV2Test 코드 설명

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

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

1. 클라이언트는 Context를 실행하면서 인수로 Strategy를 전달한다.
2. Context는 execute() 로직을 실행한다.
3. Context는 파라미터로 넘어온 strategy.call() 로직을 실행한다.
4. 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 실행");
            }
        });
    }

• ContextV2Test - 추가

/**
* 전략 패턴 익명 내부 클래스2, 람다
*/ 
@Test
void strategyV3() {
     ContextV2 context = new ContextV2();
     context.execute(() -> log.info("비즈니스 로직1 실행"));
     context.execute(() -> log.info("비즈니스 로직2 실행"));
}

✅ 정리

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

➡️ 템플릿

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

1️⃣1️⃣ 템플릿 콜백 패턴 - 시작

• 앞서 배운 것에서 ContextV2는 변하지 않는 템플릿이였다. 그리고 변하는 부분은 파라미터로 넘어온 Strategy의 코드를 실행해서 처리한다. → 다른 코드의 인수로서 넘겨주는 실행 가능한 코드를 콜백(callback)이라고 한다.

콜백이란?

프로그래밍에서 콜백(callback) 또는 콜애프터 함수(call-after function)는 다른 코드의 인수로서 넘겨주는 실행 가능한 코드를 말한다. 콜백을 넘겨받는 코드는 이 콜백을 필요에 따라 즉시 실행할 수도 있고, 아니면 나중에 실행할 수도 있다. (위키백과 참고)

• 쉽게 이야기해서 callback은 코드가 호출(call)은 되는데 코드를 넘겨준 곳의 뒤(back)에서 실행된다는 뜻
  • ContextV2 → 콜백은 Strategy
  • 여기서는 클라이언트가 직접 Strategy를 실행하는 것이 아니라, 클라이언트가 ContextV2.execute(…)를 실행할 때 Strategy를 넘겨주고, ContextV2 뒤에서 Strategy가 실행된다.

✅ 자바 언어에서 콜백

• 자바 언어에서 실행 가능한 코드를 인수로 넘기려면 객체가 필요하다. 자바8부터는 람다를 사용할 수 있다.
• 자바 8 이전에는 보통 하나의 메소드를 가진 인터페이스를 구현하고, 주로 익명 내부 클래스를 사용했다.
• 최근에는 주로 람다를 사용한다.

템플릿 콜백 패턴

• 스프링에서는 ContextV2 와 같은 방식의 전략 패턴을 템플릿 콜백 패턴이라 한다. 전략 패턴에서 Context 가 템플릿 역할을 하고, Strategy 부분이 콜백으로 넘어온다 생각하면 된다.
• 참고로 템플릿 콜백 패턴은 GOF 패턴은 아니고, 스프링 내부에서 이런 방식을 자주 사용하기 때문에, 스프링 안에서만 이렇게 부른다. 전략 패턴에서 템플릿과 콜백 부분이 강조된 패턴이라 생각하면 된다.
• 스프링에서는 JdbcTemplate , RestTemplate, TransactionTemplate, RedisTemplate 처럼 다양한 템플릿 콜백 패턴이 사용된다. 스프링에서 이름에 XxxTemplate 가 있다면 템플릿 콜백 패턴으로 만들어져있다 생각하면 된다.

1️⃣2️⃣ 템플릿 콜백 패턴 - 예제

• 템플릿 콜백 패턴을 구현해보자.

• ContextV2와 내용이 같고 이름만 다름

  • Context → Template
  • Strategy → Callback

• Calback

package hello.advanced.trace.strategy.code.template;

public interface Callback {
    void call();
}

• TimeLogTemplate

package hello.advanced.trace.strategy.code.template;

import lombok.extern.slf4j.Slf4j;

@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("resultTime={}", resultTime);
    }
}

• TemplateCallbackTest

package hello.advanced.trace.strategy;

import hello.advanced.trace.strategy.code.template.Callback;
import hello.advanced.trace.strategy.code.template.TimeLogTemplate;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

@Slf4j
public class TemplateCallbackTest {

    @Test
    void callbackV1() {
        TimeLogTemplate template = new TimeLogTemplate();

        template.execute(new Callback() {

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

        template.execute(new Callback() {

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

    /**
     * 템플릿 콜백 패턴 - 람다
     */
    @Test
    void callbackV2() {
        TimeLogTemplate template = new TimeLogTemplate();
        template.execute(() -> log.info("비즈니스 로직1 실행"));
        template.execute(() -> log.info("비즈니스 로직2 실행"));
    }
}

1️⃣3️⃣ 템플릿 콜백 패턴 - 적용

• TraceCallback
  • 콜백을 전달하는 인터페이스이다.
  • <T> 제네릭을 사용했다. 콜백의 반환 타입을 정의한다.

package hello.advanced.trace.callback;

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

• TraceTemplate
  • TraceTemplate는 템플릿 역할을 한다.
  • execute(..)를 보면message데이터와 콜백인TraceCallback callback을 전달 받는다.
  • 제네릭을 사용했다. 반환 타입을 정의한다.

package hello.advanced.trace.callback;

import hello.advanced.trace.TraceStatus;
import hello.advanced.trace.logtrace.LogTrace;

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

    public <T> T execute(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) {
            trace.exception(status, e);
            throw e;
        }
    }

    
}

• OrderControllerV5

package hello.advanced.app.V5;

import hello.advanced.trace.callback.TraceCallback;
import hello.advanced.trace.callback.TraceTemplate;
import hello.advanced.trace.logtrace.LogTrace;
import hello.advanced.trace.template.AbstractTemplate;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController // @Controller + @ResponseBody
public class OrderControllerV5 {

    private final OrderServiceV5 orderService;
    private final TraceTemplate template;

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

    @GetMapping("/v5/request")
    public String request(String itemId) {
        return template.execute("OrderController.request()", new
                TraceCallback<>() {
                    @Override
                    public String call() {
                        orderService.orderItem(itemId);
                        return "ok";
                    }
        });
    }
}

• OrderServiceV5

package hello.advanced.app.V5;

import hello.advanced.trace.callback.TraceCallback;
import hello.advanced.trace.callback.TraceTemplate;
import hello.advanced.trace.logtrace.LogTrace;
import hello.advanced.trace.template.AbstractTemplate;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

@Service
public class OrderServiceV5 {

    private final OrderRepositoryV5 orderRepository;
    private final TraceTemplate template;

    public OrderServiceV5(OrderRepositoryV5 orderRepository, LogTrace trace) {
        this.orderRepository = orderRepository;
        this.template = new TraceTemplate(trace);
    }

    public void orderItem(String itemId) {

        template.execute("OrderService.orderItem()", () -> {
            orderRepository.save(itemId);
            return null;
        });
    }

}

• OrderRepositoryV5

package hello.advanced.app.V5;

import hello.advanced.trace.callback.TraceTemplate;
import hello.advanced.trace.logtrace.LogTrace;
import hello.advanced.trace.template.AbstractTemplate;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Repository;

@Repository
public class OrderRepositoryV5 {

    private final TraceTemplate template;

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

    public void save(String itemId) {

        template.execute("OrderRepository.save()", () ->{
            //저장 로직
            if (itemId.equals("ex")) {
                throw new IllegalArgumentException("예외 발생!");
            }
            sleep(1000);
            return null;
        });
        
    }

    private void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

• 실행 결과

2025-03-15T00:00:36.762+09:00  INFO 54420 --- [advanced] [nio-8080-exec-1] h.advanced.trace.logtrace.FieldLogTrace  : [b6bb7abf] OrderController.request()
2025-03-15T00:00:36.763+09:00  INFO 54420 --- [advanced] [nio-8080-exec-1] h.advanced.trace.logtrace.FieldLogTrace  : [b6bb7abf] |-->OrderService.orderItem()
2025-03-15T00:00:36.763+09:00  INFO 54420 --- [advanced] [nio-8080-exec-1] h.advanced.trace.logtrace.FieldLogTrace  : [b6bb7abf] |   |-->OrderRepository.save()
2025-03-15T00:00:37.768+09:00  INFO 54420 --- [advanced] [nio-8080-exec-1] h.advanced.trace.logtrace.FieldLogTrace  : [b6bb7abf] |   |<--OrderRepository.save() time=1005ms
2025-03-15T00:00:37.770+09:00  INFO 54420 --- [advanced] [nio-8080-exec-1] h.advanced.trace.logtrace.FieldLogTrace  : [b6bb7abf] |<--OrderService.orderItem() time=1008ms
2025-03-15T00:00:37.770+09:00  INFO 54420 --- [advanced] [nio-8080-exec-1] h.advanced.trace.logtrace.FieldLogTrace  : [b6bb7abf] OrderController.request() time=1008ms