Template Method Pattern

Template Method Pattern

알고리즘의 구조를 정의하고 일부 단계를 서브클래스에서 구현할 수 있도록 하는 행동 디자인 패턴

특징

• 알고리즘의 골격을 정의하고 일부 단계를 서브클래스에서 구현할 수 있게 합니다.
• 공통 로직은 상위 클래스에서 정의하고, 변화가 필요한 부분만 하위 클래스에서 구현합니다.
• 알고리즘의 구조를 변경하지 않고 특정 단계를 재정의할 수 있습니다.

두 가지 주요 부분으로 구성된다.

1. 추상 클래스 (Abstract Class):
   • 알고리즘의 골격을 정의하는 템플릿 메서드를 포함
   • 서브클래스에서 구현해야 하는 추상 메서드 정의
   • 선택적으로 오버라이드할 수 있는 훅 (hook) 메서드 제공
2. 구체 클래스 (Concrete Class):
   • 추상 클래스를 상속받아 추상 메서드를 실제로 구현
   • 필요한 경우 훅 메서드를 오버라이드하여 알고리즘을 커스터마이즈

사용사례

• 프레임워크에서 기본 동작을 정의하고 사용자가 일부를 커스터마이즈해야 할 때
• 데이터 마이닝 작업에서 데이터 처리 파이프라인을 구현할 때
• 리포트 생성 시스템에서 다양한 형식의 리포트를 생성할 때

장점

• 코드 재사용성이 높아집니다
• 알고리즘의 공통 부분을 한 곳에서 관리할 수 있습니다
• 확장성이 좋아 새로운 변형을 쉽게 추가할 수 있습니다

단점

• 템플릿 메소드가 복잡해질수록 유지보수가 어려워질 수 있습니다
• 하위 클래스에서 상위 클래스의 메소드를 실수로 오버라이드할 수 있습니다
• 알고리즘 단계가 많아지면 클래스 계층 구조가 복잡해질 수 있습니다

주의사항 및 고려사항

• 템플릿 메소드는 final 로 선언하여 하위 클래스가 override 하지 못하도록 해야 합니다. Python 에서는 관례적으로 메소드 이름 앞에 언더스코어를 붙여 protected 임을 나타냅니다.
• 추상 메소드 (반드시 구현해야 하는 메소드) 와 훅 메소드 (선택적으로 구현할 수 있는 메소드) 를 명확히 구분해야 합니다.
• 상속 계층이 깊어지지 않도록 주의해야 합니다. 일반적으로 추상 클래스와 구체 클래스의 2 단계 정도가 적절합니다.
• 템플릿 메소드가 너무 많은 단계를 가지지 않도록 해야 합니다. 복잡한 알고리즘은 더 작은 단위로 분리하는 것이 좋습니다.

예시

Python

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

from abc import ABC, abstractmethod

class DataMiner(ABC):
    """데이터 마이닝을 위한 템플릿 메소드 패턴 구현"""
    
    def mine_data(self, path: str) -> None:
        """템플릿 메소드: 데이터 마이닝의 전체 프로세스를 정의"""
        raw_data = self._read_file(path)
        cleaned_data = self._clean_data(raw_data)
        analyzed_data = self._analyze_data(cleaned_data)
        self._send_report(analyzed_data)
    
    @abstractmethod
    def _read_file(self, path: str) -> list:
        """파일을 읽어오는 추상 메소드"""
        pass
    
    def _clean_data(self, data: list) -> list:
        """데이터 정제를 위한 훅 메소드"""
        return data
    
    @abstractmethod
    def _analyze_data(self, data: list) -> dict:
        """데이터 분석을 위한 추상 메소드"""
        pass
    
    def _send_report(self, data: dict) -> None:
        """분석 결과 보고를 위한 훅 메소드"""
        print("기본 보고서 생성:", data)

class PDFDataMiner(DataMiner):
    """PDF 파일용 데이터 마이너"""
    
    def _read_file(self, path: str) -> list:
        print(f"PDF 파일 읽기: {path}")
        return ["PDF 데이터 1", "PDF 데이터 2"]
    
    def _analyze_data(self, data: list) -> dict:
        return {"type": "PDF", "results": data}
    
    def _clean_data(self, data: list) -> list:
        # PDF 특화 데이터 정제 로직
        return [item.strip() for item in data]

class CSVDataMiner(DataMiner):
    """CSV 파일용 데이터 마이너"""
    
    def _read_file(self, path: str) -> list:
        print(f"CSV 파일 읽기: {path}")
        return ["CSV 데이터 1", "CSV 데이터 2"]
    
    def _analyze_data(self, data: list) -> dict:
        return {"type": "CSV", "results": data}

# 사용 예시
if __name__ == "__main__":
    pdf_miner = PDFDataMiner()
    csv_miner = CSVDataMiner()
    
    pdf_miner.mine_data("sample.pdf")
    csv_miner.mine_data("sample.csv")

Javascript

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

class BeverageMaker {
  /**
   * 음료 제조를 위한 템플릿 메소드
   * @returns {void}
   */
  prepare() {
    this.boilWater();
    this.brew();
    this.pourInCup();
    if (this.customerWantsCondiments()) {
      this.addCondiments();
    }
    this.serve();
  }

  /**
   * 물을 끓이는 공통 메소드
   * @private
   */
  boilWater() {
    console.log('물을 끓입니다');
  }

  /**
   * 음료를 우리는 추상 메소드
   * @abstract
   * @private
   */
  brew() {
    throw new Error('brew 메소드를 구현해야 합니다');
  }

  /**
   * 컵에 따르는 공통 메소드
   * @private
   */
  pourInCup() {
    console.log('컵에 따릅니다');
  }

  /**
   * 고객이 첨가물을 원하는지 확인하는 훅 메소드
   * @returns {boolean}
   */
  customerWantsCondiments() {
    return true;
  }

  /**
   * 첨가물을 추가하는 추상 메소드
   * @abstract
   * @private
   */
  addCondiments() {
    throw new Error('addCondiments 메소드를 구현해야 합니다');
  }

  /**
   * 음료를 서빙하는 공통 메소드
   * @private
   */
  serve() {
    console.log('음료가 준비되었습니다');
  }
}

class CoffeeMaker extends BeverageMaker {
  brew() {
    console.log('커피를 우립니다');
  }

  addCondiments() {
    console.log('설탕과 우유를 추가합니다');
  }

  customerWantsCondiments() {
    // 고객 선호도에 따라 첨가물 추가 여부 결정
    return Math.random() > 0.5;
  }
}

class TeaMaker extends BeverageMaker {
  brew() {
    console.log('차를 우립니다');
  }

  addCondiments() {
    console.log('레몬을 추가합니다');
  }
}

// 사용 예시
const coffee = new CoffeeMaker();
const tea = new TeaMaker();

console.log('=== 커피 준비 ===');
coffee.prepare();

console.log('\n=== 차 준비 ===');
tea.prepare();

용어 정리

참고 및 출처

1. 주제의 분류가 적절한지에 대한 조사

Template Method Pattern(템플릿 메서드 패턴) 은 “Computer Science and Engineering > Software Design and Architecture > Software Design Patterns > GoF > Behavioral Design Patterns” 분류에 정확히 속합니다. GoF(Gang of Four) 에서 정의한 대표적인 행동 (Behavioral) 패턴 중 하나로, 알고리즘 구조의 재사용성과 확장성을 높이는 데 중점을 둡니다 [1][2][3][8].

2. 200 자 요약

템플릿 메서드 패턴은 알고리즘의 전체 구조 (골격) 는 상위 클래스 (추상 클래스) 에 정의하고, 세부 단계는 하위 클래스에서 오버라이딩해 구현하는 디자인 패턴입니다. 코드 중복 최소화, 공통 로직 재사용, 알고리즘 확장성 및 유지보수성을 높일 수 있습니다 [2][3][5][17].

3. 250 자 개요

템플릿 메서드 패턴은 알고리즘의 전체 흐름 (프로세스) 을 상위 클래스의 템플릿 메서드로 고정하고, 각 단계의 세부 구현은 하위 클래스에서 오버라이딩하도록 하는 구조적 설계 방식입니다. 변하지 않는 공통 로직은 상위 클래스에, 자주 변경되는 부분은 하위 클래스에 위임함으로써 코드 중복을 줄이고, 유지보수성과 확장성을 높입니다. 프레임워크, 데이터 처리, 게임, 워크플로우 등 다양한 분야에서 활용되며, 단일 책임 원칙 (SRP) 과 개방/폐쇄 원칙 (OCP) 을 실현합니다 [2][3][5][14][17].

핵심 개념

• 정의: 템플릿 메서드 패턴은 알고리즘의 골격을 상위 클래스에 정의하고, 일부 단계는 하위 클래스에서 오버라이딩하여 구현하도록 하는 행동 패턴입니다 [1][2][3][5][14].
• 목적 및 필요성: 코드 중복 최소화, 알고리즘의 구조적 일관성 유지, 확장성 및 유지보수성 향상 [2][3][17].
• 주요 기능 및 역할:
  • 알고리즘의 전체 흐름 (템플릿 메서드) 은 상위 클래스에 고정
  • 세부 단계 (추상 메서드, 훅 메서드) 는 하위 클래스에서 구현/확장
• 특징:
  • 상속 기반 (추상 클래스)
  • 공통 로직과 변동 로직의 분리
  • 후크 (Hook) 메서드로 유연성 확보
• 핵심 원칙: 단일 책임 원칙 (SRP), 개방/폐쇄 원칙 (OCP), 코드 중복 최소화 [6][14][19].

주요 내용 정리

패턴 이름과 분류

의도 (Intent)

알고리즘의 구조 (골격) 는 상위 클래스에 정의하고, 세부 단계는 하위 클래스에서 오버라이딩하여 구현할 수 있도록 한다 [1][2][3][5].

다른 이름 (Also Known As)

• 헐크 메서드 (Hook Method, 훅 메서드)[19]
• 프레임워크 메서드

동기 (Motivation / Forces)

• 알고리즘의 구조는 동일하지만, 일부 단계만 다르게 구현해야 할 때
• 코드 중복 최소화 및 일관성 유지, 유지보수성 향상 [2][3][5][17]

적용 가능성 (Applicability)

• 여러 클래스에서 알고리즘의 구조는 같지만, 일부 단계만 다르게 구현해야 할 때
• 프레임워크, 데이터 처리, 게임, 워크플로우 등 다양한 분야 [5][17]

구조 및 아키텍처

구조 다이어그램

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

+-------------------+
|  AbstractClass    |
+-------------------+
| templateMethod()  | <--- 알고리즘의 골격(고정)
| + step1()         | <--- (구현/추상/훅)
| + step2()         | <--- (구현/추상/훅)
+-------------------+
        ^
        |
+-------------------+
|  ConcreteClass    |
+-------------------+
| step1()           | <--- 세부 단계 구현
| step2()           |
+-------------------+

구성 요소 및 역할

필수/선택 구성요소

주요 원리 및 작동 원리

1. 상위 클래스의 템플릿 메서드가 알고리즘 전체 흐름을 정의
2. 템플릿 메서드는 각 단계를 메서드로 분리해 호출 (일부는 추상/훅 메서드)
3. 하위 클래스는 필요한 단계만 오버라이딩해 세부 구현
4. 클라이언트는 상위 클래스의 템플릿 메서드만 호출하면 일관된 알고리즘 실행

작동 원리 다이어그램

1
2
3
4
5

[Client] → [AbstractClass.templateMethod()]
                |
                +-- step1() (구현/추상/훅)
                +-- step2() (구현/추상/훅)
                ...

구현 기법

• 상위 클래스 (추상 클래스) 정의: 템플릿 메서드와 추상/훅 메서드 선언
• 하위 클래스 (구체 클래스) 구현: 필요한 단계만 오버라이딩
• 템플릿 메서드 final 선언: 알고리즘 구조 변경 방지 (권장)
• 익명 내부 클래스/람다 활용: 자바, 파이썬 등에서 간단한 구현에 활용 가능 [6][17]
• 후크 메서드: 기본 구현 제공, 필요시 오버라이딩 [19]

예시 코드 (Python)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

from abc import ABC, abstractmethod

class AbstractClass(ABC):
    def template_method(self):
        self.step1()
        self.step2()
        self.step3()

    @abstractmethod
    def step1(self):
        pass

    def step2(self):
        print("공통 로직 step2")

    @abstractmethod
    def step3(self):
        pass

class ConcreteClassA(AbstractClass):
    def step1(self):
        print("A: step1 구현")
    def step3(self):
        print("A: step3 구현")

class ConcreteClassB(AbstractClass):
    def step1(self):
        print("B: step1 구현")
    def step3(self):
        print("B: step3 구현")

obj = ConcreteClassA()
obj.template_method()

장점과 단점

도전 과제 및 해결책

• 문제: 하위 클래스 증가, 상속 구조 복잡성
  해결책: 익명 클래스/람다 활용, 전략 패턴 등 위임 구조로 대체
• 문제: 상속 기반 결합
  해결책: 위임 (Composition) 기반 구조 검토, 전략 패턴 병행 [6][16]
• 문제: 알고리즘 구조 변경 어려움
  해결책: 알고리즘 구조는 최대한 안정적으로 설계, 변경 필요시 리팩터링

분류에 따른 종류 및 유형

실무 적용 예시

활용 사례 (시나리오 기반)

상황 가정: 데이터 마이닝 파일 파서

• 시스템 구성:
  • AbstractParser(상위 클래스) → CSVParser, PDFParser, DOCParser(하위 클래스)
• Workflow:
  1. AbstractParser 의 parse() 메서드 (템플릿 메서드) 호출
  2. 공통 처리 (파일 열기, 데이터 정규화, 결과 반환) 는 상위 클래스 구현
  3. 파일별 파싱 로직은 하위 클래스에서 오버라이딩
• 역할: 알고리즘 구조 (파일 열기→파싱→정규화→반환) 는 고정, 세부 파싱만 하위 클래스에서 구현

실무에서 효과적으로 적용하기 위한 고려사항 및 주의할 점

최적화하기 위한 고려사항 및 주의할 점

2025 년 기준 최신 동향

주제와 관련하여 주목할 내용

앞으로의 전망

하위 주제별 추가 학습 필요 내용

추가 학습/알아야 할 내용

용어 정리

참고 및 출처

• Refactoring.Guru - 템플릿 메서드 패턴 설명
• ENFJ.dev - Template Method Pattern
• CKDDN9496 - 템플릿 메서드 패턴 구조와 적용법
• limdongjin - 템플릿 메소드 패턴 (Java)
• YABOONG - 템플릿 메소드 패턴 예제
• 기계인간 John Grib - Template Method Pattern 실무 주의점
• velog - 템플릿 메서드 패턴과 콜백 패턴
• Python101 - 템플릿 메서드 패턴 파이썬 예제
• jngsngjn - Template Method Pattern 장단점
• steady-coding - 템플릿 메서드 패턴 개념
• song-ift - Template Method Pattern
• inpa - 템플릿 메소드 패턴 완벽 마스터

템플릿 메서드 패턴 (Template Method Pattern) 은 알고리즘의 구조를 상위 클래스에서 정의하고, 세부 단계는 하위 클래스에서 구현하도록 하여 알고리즘의 일관성을 유지하면서도 유연한 확장을 가능하게 하는 행동 (Behavioral) 디자인 패턴입니다.(Medium)

1. 주제의 분류 검토

• 현재 분류: “Computer Science and Engineering” > “Software Design and Architecture” > “Software Design Patterns” > “GoF” > “Behavioral Design Patterns”

• 검토 결과: 적절한 분류입니다. 템플릿 메서드 패턴은 GoF(Gang of Four) 에서 정의한 23 가지 디자인 패턴 중 하나로, 행동 패턴 (Behavioral Design Patterns) 에 속합니다.

2. 주제 요약 (200 자 내외)

템플릿 메서드 패턴은 알고리즘의 뼈대를 상위 클래스에서 정의하고, 일부 단계를 하위 클래스에서 구현하도록 하여 알고리즘의 구조를 유지하면서도 세부 구현을 유연하게 변경할 수 있도록 하는 디자인 패턴입니다.(scholarhat.com)

3. 전체 개요 (250 자 내외)

템플릿 메서드 패턴은 상위 클래스에서 알고리즘의 전체 구조를 정의하고, 하위 클래스에서 일부 단계를 구현하도록 하여 알고리즘의 일관성을 유지하면서도 세부 구현을 다양화할 수 있도록 합니다. 이는 코드 재사용성을 높이고, 유지보수를 용이하게 하며, 프레임워크나 라이브러리 설계에서 자주 활용됩니다.

4. 핵심 개념

• 정의: 알고리즘의 구조를 상위 클래스에서 정의하고, 세부 단계는 하위 클래스에서 구현하도록 하여 알고리즘의 일관성을 유지하면서도 유연한 확장을 가능하게 하는 디자인 패턴입니다.

• 주요 특징:

  • 템플릿 메서드: 알고리즘의 전체 구조를 정의하는 메서드로, 상속을 통해 재정의되지 않도록 final 로 선언하는 것이 일반적입니다.

  • 추상 메서드 (Primitive Operations): 하위 클래스에서 반드시 구현해야 하는 메서드로, 알고리즘의 세부 단계를 담당합니다.

  • 훅 메서드 (Hook Methods): 하위 클래스에서 선택적으로 오버라이드할 수 있는 메서드로, 기본 구현은 비어있거나 간단한 동작을 수행합니다.

• 적용 사례:

  • 프레임워크에서 공통된 처리 흐름을 정의하고, 세부 구현은 사용자에게 위임할 때

  • 알고리즘의 구조는 동일하지만, 일부 단계의 구현이 다양한 경우 (scholarhat.com)

5. 상세 조사 내용

핵심 개념

• 정의: 템플릿 메서드 패턴은 알고리즘의 뼈대를 상위 클래스에서 정의하고, 세부 단계는 하위 클래스에서 구현하도록 하여 알고리즘의 구조를 유지하면서도 세부 구현을 유연하게 변경할 수 있도록 하는 디자인 패턴입니다.

• 배경: 객체지향 프로그래밍에서 코드의 재사용성과 유지보수성을 높이기 위해 알고리즘의 공통된 구조를 상위 클래스에 정의하고, 변하는 부분은 하위 클래스에서 구현하도록 하는 필요성에서 출발하였습니다.

• 목적 및 필요성: 알고리즘의 구조를 변경하지 않고도 세부 구현을 다양화할 수 있도록 하여, 코드의 재사용성과 유지보수성을 높이는 것이 목적입니다.

• 주요 기능 및 역할: 알고리즘의 전체 구조를 정의하고, 세부 단계의 구현을 하위 클래스에 위임함으로써 알고리즘의 일관성을 유지하면서도 유연한 확장을 가능하게 합니다.

• 특징:

  • 상위 클래스에서 알고리즘의 구조를 정의

  • 하위 클래스에서 세부 단계 구현

  • 코드 재사용성 및 유지보수성 향상

• 핵심 원칙: 상위 클래스에서 알고리즘의 구조를 정의하고, 하위 클래스에서 세부 단계를 구현하도록 하여 알고리즘의 일관성을 유지하면서도 세부 구현을 다양화할 수 있도록 합니다.

• 구조 및 아키텍처:

  • 구성 요소:

    • AbstractClass: 템플릿 메서드를 정의하고, 추상 메서드와 훅 메서드를 선언합니다.

    • ConcreteClass: AbstractClass 를 상속받아 추상 메서드와 훅 메서드를 구현합니다.

  • 다이어그램:

    • UML 클래스 다이어그램을 통해 AbstractClass 와 ConcreteClass 의 관계를 시각화할 수 있습니다.

• 구현 기법:

  • 상위 클래스에서 템플릿 메서드를 정의하고, 하위 클래스에서 추상 메서드와 훅 메서드를 구현합니다.

  • 템플릿 메서드는 일반적으로 final 로 선언하여 하위 클래스에서 재정의되지 않도록 합니다.

• 장점과 단점:

• 도전 과제:

  • 상속을 기반으로 하기 때문에 다중 상속이 불가능한 언어에서는 제약이 있을 수 있습니다.

  • 해결책: 구성 (Composition) 을 활용하여 유연성을 높일 수 있습니다.

• 분류에 따른 종류 및 유형:

• 실무 적용 예시:

• 활용 사례:

  • 상황: 웹 프레임워크에서 공통된 요청 처리 흐름을 정의하고, 세부 동작은 사용자에 따라 다르게 구현해야 하는 경우

  • 시스템 구성:

    • AbstractClass: 요청 처리 흐름을 정의하는 상위 클래스

    • ConcreteClass: 사용자에 따라 다른 동작을 구현하는 하위 클래스

  • 워크플로우:

    1. 요청 수신

    2. 공통된 전처리 수행

    3. 하위 클래스에서 정의한 세부 동작 수행

    4. 공통된 후처리 수행

  • 역할: 공통된 요청 처리 흐름을 유지하면서도 사용자에 따라 다른 동작을 유연하게 구현할 수 있습니다.

• 실무에서 효과적으로 적용하기 위한 고려사항 및 주의할 점:

최적화하기 위한 고려사항 및 주의할 점

8. 2025 년 기준 최신 동향

9. 주제와 관련하여 주목할 내용

10. 앞으로의 전망

11. 주제의 하위 학습 분류

12. 관련 분야 및 추가 학습 주제

용어 정리

참고 및 출처

• Refactoring Guru – Template Method Pattern

• GeeksforGeeks – Template Method Pattern

• Baeldung – Template Method Pattern in Java

• DoFactory GoF Patterns

이후 필요한 내용으로 샘플 코드 구현, UML 다이어그램, 또는 템플릿 메서드와 전략 패턴 비교 등 심화 학습 자료가 필요하면 이어서 제공하겠습니다.

템플릿 메서드 패턴 (Template Method Pattern) 에 대해 체계적으로 조사하여 정리해드리겠습니다.

이제 템플릿 메서드 패턴 (Template Method Pattern) 에 대해 체계적으로 정리해 드리겠습니다.

1. 주제 분류의 적절성 검토

제시된 분류 “Computer Science and Engineering” > “Software Design and Architecture” > “Software Design Patterns” > “GoF” > “Behavioral Design Patterns” 는 완전히 적절합니다. 템플릿 메서드 패턴은 Gang of Four (GoF) 가 정의한 23 개의 디자인 패턴 중 행동 패턴 (Behavioral Pattern) 범주에 속하는 대표적인 패턴입니다.

2. 요약 설명

템플릿 메서드 패턴은 알고리즘의 골격을 상위 클래스에서 정의하고, 하위 클래스가 알고리즘의 구조를 변경하지 않고 특정 단계만을 재정의할 수 있도록 하는 행동 디자인 패턴입니다. 코드 재사용성을 높이고 중복을 제거하며 프레임워크 개발에 널리 활용됩니다.

3. 전체 개요

템플릿 메서드 패턴은 상속을 기반으로 알고리즘의 뼈대를 정의하며, 공통된 부분은 추상 클래스에서 구현하고 변화하는 부분만 하위 클래스에서 구현하도록 합니다. 할리우드 원칙 " 우리가 호출할게, 당신이 호출하지 마세요 " 를 적용하여 제어의 역전을 구현하며, 프레임워크와 라이브러리 개발에서 핵심적인 역할을 담당합니다.

4. 핵심 개념

템플릿 메서드 (Template Method)

• 알고리즘의 단계들을 정의하고 호출하는 메서드
• 일반적으로 final 로 선언하여 오버라이드 방지
• 추상 메서드와 훅 메서드들을 특정 순서로 호출

추상 메서드 (Abstract Methods)

• 하위 클래스에서 반드시 구현해야 하는 메서드
• 알고리즘의 가변적인 부분을 담당

훅 메서드 (Hook Methods)

• 기본 구현을 가지지만 하위 클래스에서 선택적으로 오버라이드 가능
• 알고리즘의 선택적 확장 지점 제공

할리우드 원칙 (Hollywood Principle)

• “Don’t call us, we’ll call you”
• 상위 클래스가 제어 흐름을 관리하고 하위 클래스 메서드를 호출

5. 조사 내용 정리

5.1 배경 및 목적

템플릿 메서드 패턴은 여러 클래스가 유사한 알고리즘을 가지지만 세부 구현이 다를 때 코드 중복을 제거하고 유지보수성을 향상시키기 위해 개발되었습니다. 프레임워크 개발에서 핵심적인 역할을 하며, 알고리즘의 구조는 유지하면서도 특정 단계만을 커스터마이징할 수 있는 유연성을 제공합니다.

5.2 주요 기능 및 역할

핵심 기능:

• 알고리즘 골격 정의
• 코드 재사용성 향상
• 중복 코드 제거
• 제어 흐름 관리

주요 역할:

• 공통 로직의 중앙 집중화
• 변화하는 부분의 캡슐화
• 프레임워크의 확장점 제공
• 알고리즘 구조의 일관성 보장

5.3 특징

• 상속 기반: 클래스 수준에서 작동하는 정적 패턴
• 구조 고정: 알고리즘의 전체 구조는 변경 불가
• 단계별 커스터마이징: 특정 단계만 하위 클래스에서 재정의
• 제어 역전: 상위 클래스가 전체 제어 흐름을 관리

5.4 핵심 원칙

1. 단일 책임 원칙: 각 클래스는 알고리즘의 특정 부분만 담당
2. 개방 - 폐쇄 원칙: 확장에는 열려있고 수정에는 닫혀있음
3. 의존성 역전 원칙: 고수준 모듈이 저수준 모듈에 의존하지 않음
4. 할리우드 원칙: 상위 클래스가 하위 클래스를 호출

5.5 구조 및 아키텍처

필수 구성요소

1. Abstract Class (추상 클래스)

• 기능: 템플릿 메서드와 추상 메서드 정의
• 역할: 알고리즘의 골격 제공 및 공통 로직 구현
• 특징: 하나 이상의 추상 메서드 포함

2. Template Method (템플릿 메서드)

• 기능: 알고리즘의 단계들을 정의된 순서로 호출
• 역할: 전체 알고리즘의 제어 흐름 관리
• 특징: 일반적으로 final 로 선언

3. Concrete Class (구체 클래스)

• 기능: 추상 메서드의 구체적 구현 제공
• 역할: 알고리즘의 특화된 부분 구현
• 특징: 여러 개의 구체 클래스 존재 가능

선택 구성요소

1. Hook Methods (훅 메서드)

• 기능: 기본 구현을 가진 선택적 확장점
• 역할: 알고리즘의 선택적 커스터마이징 지원
• 특징: 오버라이드하지 않아도 동작

2. Concrete Methods (구체 메서드)

• 기능: 모든 하위 클래스에서 공통으로 사용되는 로직
• 역할: 코드 재사용성 제공
• 특징: 하위 클래스에서 오버라이드 불가능 (protected 또는 private)

5.6 주요 원리 및 작동 원리

1
2
3
4
5
6
7
8
9

[클라이언트] → [구체 클래스 인스턴스]
                      ↓
                [템플릿 메서드 호출]
                      ↓
              [단계별 메서드 실행]
               ↓      ↓      ↓
          [공통메서드] [추상메서드] [훅메서드]
               ↓      ↓      ↓
          [기본구현] [하위구현] [선택구현]

5.7 구현 기법

5.7.1 기본 구현 기법

• 정의: 추상 클래스에서 템플릿 메서드를 정의하고 하위 클래스에서 추상 메서드 구현
• 구성: Abstract Class + Template Method + Abstract Methods + Concrete Classes
• 목적: 알고리즘의 기본 구조 제공 및 코드 재사용
• 예시: 데이터 마이닝 애플리케이션에서 문서 형식별 파싱 알고리즘

5.7.2 훅 메서드 기법

• 정의: 기본 구현을 가진 메서드를 제공하여 선택적 오버라이드 허용
• 구성: Hook Methods + Default Implementation + Optional Override
• 목적: 알고리즘의 유연성 증대 및 선택적 커스터마이징
• 예시: 로깅 시스템에서 콘솔 출력 옵션

5.7.3 Final 템플릿 메서드 기법

• 정의: 템플릿 메서드를 final 로 선언하여 오버라이드 방지
• 구성: final Template Method + Protected Abstract Methods
• 목적: 알고리즘 구조의 안정성 보장
• 예시: 프레임워크의 생명주기 메서드

5.8 장점과 단점

5.9 도전 과제

1. 과도한 상속 계층

• 설명: 복잡한 알고리즘에서 깊은 상속 계층 구조 발생
• 해결책: 컴포지션과 전략 패턴의 조합 사용, 인터페이스 분리

2. 알고리즘 진화의 제약

• 설명: 기존 구조를 크게 벗어나는 변경 시 전체 설계 재검토 필요
• 해결책: 브리지 패턴 적용, 모듈식 설계 도입

3. 테스트 복잡성

• 설명: 추상 클래스와 상속 관계로 인한 단위 테스트 어려움
• 해결책: 의존성 주입 활용, 테스트용 구체 클래스 생성

5.10 분류에 따른 종류 및 유형

5.11 실무 적용 예시

5.12 활용 사례

전자상거래 주문 처리 시스템

시나리오: 온라인 쇼핑몰에서 다양한 결제 방식 (신용카드, PayPal, 계좌이체) 을 지원하는 주문 처리 시스템

시스템 구성:

• OrderProcessor (추상 클래스)
• CreditCardOrderProcessor (구체 클래스)
• PayPalOrderProcessor (구체 클래스)
• BankTransferOrderProcessor (구체 클래스)

시스템 구성도:

1
2
3
4
5
6
7

[고객] → [주문 요청] → [OrderProcessor Factory]
                              ↓
                    [결제 방식별 Processor 선택]
                              ↓
                    [processOrder() 템플릿 메서드 실행]
                              ↓
            [검증] → [결제] → [재고확인] → [배송준비] → [알림]

Workflow:

1. 고객이 주문 및 결제 방식 선택
2. Factory 에서 해당 Processor 인스턴스 생성
3. processOrder() 템플릿 메서드 호출
4. 각 단계별로 공통/특화 로직 실행
5. 주문 완료 및 고객 알림

역할:

• 주문 처리의 전체 흐름 표준화
• 결제 방식별 특화 로직 캡슐화
• 새로운 결제 방식 추가 시 확장 용이성 제공
• 비즈니스 로직의 일관성 보장

5.13 실무에서 효과적으로 적용하기 위한 고려사항 및 주의할 점

5.14 성능을 최적화하기 위한 고려사항 및 주의할 점

6. 추가 조사 내용 (GoF 패턴 관점)

6.1 패턴 이름과 분류

• 이름: Template Method Pattern (템플릿 메서드 패턴)
• 분류: Behavioral Pattern (행동 패턴)
• GoF 카테고리: Class Behavioral Pattern

6.2 의도 (Intent)

알고리즘의 골격을 연산에서 정의하고, 일부 단계들을 서브클래스로 연기합니다. 템플릿 메서드는 알고리즘의 구조를 변경하지 않고 서브클래스가 알고리즘의 특정 단계들을 재정의할 수 있게 합니다.

6.3 다른 이름 (Also Known As)

• Hollywood Principle Pattern
• Framework Pattern
• Skeleton Pattern

6.4 동기 (Motivation / Forces)

• 여러 클래스가 유사한 알고리즘을 가지지만 세부사항이 다름
• 코드 중복을 제거하고 싶음
• 알고리즘의 구조는 유지하면서 특정 부분만 변경하고 싶음
• 프레임워크에서 클라이언트 코드를 호출할 지점이 필요함

6.5 적용 가능성 (Applicability)

• 알고리즘의 불변 부분을 한 번 구현하고 가변 부분은 서브클래스에 맡길 때
• 서브클래스 간의 공통 행동을 추출하여 공통 클래스에 집중시킬 때
• 서브클래스의 확장을 제어할 때

6.6 참여자 (Participants)

• AbstractClass: 템플릿 메서드와 추상 연산들을 정의
• ConcreteClass: 서브클래스별 단계들을 구현

6.7 협력 (Collaboration)

ConcreteClass 는 AbstractClass 의 템플릿 메서드나 다른 연산들을 수행하기 위해 AbstractClass 를 의존합니다.

6.8 결과 (Consequences)

• 긍정적: 코드 재사용 촉진, 제어의 역전 구조
• 부정적: 상속의 제약, 런타임 유연성 부족

6.9 알려진 사용 (Known Uses)

• Java Collections Framework (AbstractList, AbstractSet)
• Servlet API (HttpServlet)
• Spring Framework (JdbcTemplate, RestTemplate)
• Android Framework (Activity, Fragment 생명주기)

6.10 관련 패턴 (Related Patterns)

• Strategy: 전체 알고리즘을 교체 vs 일부 단계만 변경
• Factory Method: 객체 생성에 템플릿 메서드 적용
• Observer: 템플릿 메서드에서 알림 발송
• Command: 단계별 명령 객체 활용

7. 추가 학습 내용

7.1 템플릿 메서드와 람다 식의 조합

현대 Java 에서는 함수형 프로그래밍과 템플릿 메서드 패턴을 조합하여 더 유연한 구조를 만들 수 있습니다.

7.2 제네릭과의 활용

제네릭을 활용하여 타입 안전성을 보장하면서 템플릿 메서드 패턴을 구현할 수 있습니다.

7.3 애노테이션 기반 확장

Spring Framework 처럼 애노테이션을 활용하여 템플릿 메서드의 단계를 정의하는 방법입니다.

8. 2025 년 기준 최신 동향

9. 주제와 관련하여 주목할 내용

10. 앞으로의 전망

11. 하위 주제별 추가 학습 내용

12. 관련 분야별 추가 학습 내용

용어 정리

참고 및 출처

• Refactoring Guru - Template Method Pattern
• GeeksforGeeks - Template Method Design Pattern
• Spring Framework Guru - Template Method Pattern
• Baeldung - Implementing the Template Method Pattern in Java
• DigitalOcean - Template Method Design Pattern in Java
• Wikipedia - Template method pattern
• SourceMaking - Template Method Design Pattern
• DZone - Template Method Pattern Tutorial with Java Examples
• Visual Paradigm - GoF Design Pattern Template Method
• KapreSoft - Choosing the Right Pattern: Template Method and Strategy Pattern