디자인 패턴 완전 정리 — 23가지 핵심 개념

디자인 패턴 완전 정리 — 23가지 핵심 개념

디자인 패턴은 소프트웨어 설계에서 반복적으로 나타나는 문제를 해결하기 위한 재사용 가능한 설계 템플릿이다.
GoF(Gang of Four)가 정리한 23가지 패턴이 표준으로, 생성(Creational) / 구조(Structural) / 행위(Behavioral) 3가지로 분류된다.

---

분류 전체 구조

디자인 패턴 (23개)
├── 생성 패턴 (5개) — 객체를 어떻게 만들 것인가
│   ├── Singleton
│   ├── Factory Method
│   ├── Abstract Factory
│   ├── Builder
│   └── Prototype
│
├── 구조 패턴 (7개) — 클래스/객체를 어떻게 조합할 것인가
│   ├── Adapter
│   ├── Bridge
│   ├── Composite
│   ├── Decorator
│   ├── Facade
│   ├── Flyweight
│   └── Proxy
│
└── 행위 패턴 (11개) — 객체 간 상호작용을 어떻게 정의할 것인가
    ├── Chain of Responsibility
    ├── Command
    ├── Interpreter
    ├── Iterator
    ├── Mediator
    ├── Memento
    ├── Observer
    ├── State
    ├── Strategy
    ├── Template Method
    └── Visitor

---

1. 생성 패턴 (Creational) — 5개

객체 생성 방식을 캡슐화해 유연성과 재사용성을 높인다.
암기: 싱팩앱빌프 (싱글턴/팩토리메서드/추상팩토리/빌더/프로토타입)

Singleton (싱글턴)

클래스의 인스턴스를 오직 하나만 생성하고, 전역에서 접근 가능하게 한다.

public class Singleton {
    private static Singleton instance;

    private Singleton() {} // 외부에서 new 불가

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

핵심: 생성자를 private으로 막고, 정적 메서드로만 접근.
예시: DB 커넥션 풀, 로그 관리, 설정 객체

---

Factory Method (팩토리 메서드)

객체 생성을 서브클래스에 위임. 상위 클래스는 인터페이스만 정의, 실제 생성은 하위 클래스가 결정.

Creator (상위)
    └── createProduct() // 추상 메서드
ConcreteCreator (하위)
    └── createProduct() { return new ConcreteProduct(); }

핵심: "어떤 객체를 만들지"는 하위 클래스가 결정.
예시: 로그 기록 방식(파일/DB/콘솔)을 서브클래스에서 결정

---

Abstract Factory (추상 팩토리)

연관된 객체들의 군(family)을 하나의 팩토리로 묶어 생성. 팩토리 자체를 교체해 전체 제품군을 교체.

AbstractFactory
    └── createButton() / createScrollbar()
WinFactory : AbstractFactory
    └── createButton() → WinButton
MacFactory : AbstractFactory
    └── createButton() → MacButton

핵심: 팩토리 메서드의 확장. 여러 종류의 객체를 통째로 교체할 때.
Factory Method vs Abstract Factory: Factory Method는 단일 객체 생성 / Abstract Factory는 관련 객체 묶음 생성

---

Builder (빌더)

복잡한 객체를 단계적으로 생성. 생성 과정과 표현을 분리해 같은 절차로 다른 결과물 생성 가능.

Pizza pizza = new Pizza.Builder()
    .size("large")
    .cheese(true)
    .pepperoni(true)
    .build();

핵심: 생성 단계를 캡슐화. 선택적 매개변수가 많을 때 유용.
예시: StringBuilder, HTTP 요청 빌더

---

Prototype (프로토타입)

기존 객체를 복제(clone) 해서 새 객체를 생성. 객체 생성 비용이 클 때 효율적.

Object copied = original.clone(); // 복제

핵심: new 대신 복사. 원본 객체가 있을 때 복제해서 사용.
예시: 게임에서 몬스터 인스턴스 복제, 설정 객체 복사

---

2. 구조 패턴 (Structural) — 7개

클래스나 객체를 조합해 더 큰 구조를 만든다.
암기: 어브컴데퍼플프 (어댑터/브릿지/컴포지트/데코레이터/퍼사드/플라이웨이트/프록시)

Adapter (어댑터)

호환되지 않는 인터페이스를 연결해주는 변환기. 기존 클래스를 수정하지 않고 다른 인터페이스로 사용.

클라이언트 → Target 인터페이스 → Adapter → Adaptee(기존 클래스)

핵심: 돼지코 어댑터처럼 인터페이스를 변환해 연결.
예시: 110V 플러그를 220V에 쓰는 어댑터, Java의 InputStreamReader

---

Bridge (브릿지)

추상화(기능)와 구현을 분리해 각각 독립적으로 확장 가능하게 한다.

Abstraction (기능 계층)
    └── Implementor (구현 계층, 독립 변화)

핵심: 상속 대신 구성(Composition)으로 분리. 기능과 구현이 각각 독립적으로 확장.
Factory Method vs Bridge: Factory Method는 생성 / Bridge는 구조(기능-구현 분리)

---

Composite (컴포지트)

개별 객체와 복합 객체를 동일하게 취급. 트리 구조로 구성.

Component (공통 인터페이스)
├── Leaf (단말 노드, 개별 객체)
└── Composite (가지 노드, 자식 포함 가능)

핵심: 단일 객체와 그룹 객체를 같은 방식으로 처리.
예시: 파일 시스템(파일=Leaf, 폴더=Composite), HTML DOM 트리

---

Decorator (데코레이터)

객체에 동적으로 기능을 추가. 서브클래스 없이 기능 확장.

기본 커피 → 우유 데코레이터 → 설탕 데코레이터 → 최종 가격/설명

핵심: 래퍼(Wrapper)로 기능을 덧씌움. 소스코드 변경 없이 기능 추가.
예시: Java I/O 스트림 (BufferedInputStream이 InputStream을 감쌈)

---

Facade (퍼사드)

복잡한 서브시스템에 대한 단순화된 인터페이스 제공.

클라이언트 → Facade (단일 창구) → 복잡한 서브시스템들

핵심: 복잡한 내부 구조를 하나의 간단한 인터페이스로 숨김.
예시: 홈씨어터(리모컨 하나로 TV/음향/조명 제어), jQuery

---

Flyweight (플라이웨이트)

대량의 유사 객체를 공유해 메모리 사용량을 줄인다.

공유 가능한 내부 상태(Intrinsic) → 공유 풀에서 재사용
변하는 외부 상태(Extrinsic) → 클라이언트가 관리

핵심: 같은 내부 상태를 가진 객체를 하나만 만들어 공유.
예시: 문서에서 같은 글자 객체 공유, 게임 나무/풀 오브젝트 공유

---

Proxy (프록시)

실제 객체 대신 대리인(Proxy) 객체가 요청을 받아 처리하거나 중계.

클라이언트 → Proxy → RealSubject (실제 객체)
                ↑ 접근 제어, 로깅, 캐싱, 지연 로딩

핵심: 실제 객체 호출을 가로채 부가 기능(캐시, 권한, 로깅) 추가.
예시: 이미지 로딩 지연(가상 프록시), 접근 제어(보호 프록시)

---

3. 행위 패턴 (Behavioral) — 11개

객체들 간의 책임 분배와 상호작용 방식을 정의한다.
암기: 책커인이미메옵스스템비 (책임연쇄/커맨드/인터프리터/이터레이터/미디에이터/메멘토/옵저버/스테이트/스트레티지/템플릿메서드/비지터)

Chain of Responsibility (책임 연쇄)

요청을 처리할 수 있는 객체를 체인으로 연결해 차례로 처리를 시도.

Handler1 → Handler2 → Handler3 → ...
요청을 처리 못하면 다음으로 전달

핵심: 요청 처리 객체들을 연결 고리로 만들어 순차적으로 시도.
예시: 이벤트 버블링, 결재 라인(팀장→부장→임원)

---

Command (커맨드)

요청 자체를 객체로 캡슐화해 매개변수로 넘기거나 저장, 실행 취소 가능하게 한다.

Client → Command 객체 → Receiver (실제 수행)
         invoke()          execute()

핵심: 요청(명령)을 객체로 만들어 큐에 쌓거나 undo/redo 구현.
예시: 텍스트 에디터 Undo/Redo, 작업 큐

---

Interpreter (인터프리터)

언어의 문법 규칙을 클래스로 표현하고 해석하는 패턴.

AbstractExpression
├── TerminalExpression (단말 표현)
└── NonterminalExpression (비단말 표현)

핵심: 간단한 문법 처리나 스크립트 언어 파싱에 사용.
예시: SQL 파싱, 정규표현식, 수식 계산기

---

Iterator (이터레이터)

컬렉션의 내부 구현을 노출하지 않고 순차적으로 접근하는 방법 제공.

Iterator it = collection.iterator();
while (it.hasNext()) {
    Object obj = it.next();
}

핵심: 어떤 자료구조든 동일한 방법으로 순회.
예시: Java의 Iterator, Python의 for-in

---

Mediator (미디에이터)

객체 간 직접 통신을 막고 중재자(Mediator)를 통해 통신하게 한다.

객체A ↘         ↗ 객체C
       Mediator
객체B ↗         ↘ 객체D

핵심: 객체 간 결합도를 낮춤. M:N 관계 → 1:N 관계로 단순화.
예시: 채팅방(방이 중재자), 항공 관제 시스템

---

Memento (메멘토)

객체의 이전 상태를 저장해두었다가 복원할 수 있게 한다.

Originator (상태 보유) → Memento (상태 스냅샷) → Caretaker (보관)
                      ←── restore() ──────────────

핵심: 캡슐화를 유지하면서 상태 저장/복원.
예시: 텍스트 에디터 Undo, 게임 저장/불러오기

---

Observer (옵저버)

한 객체의 상태 변화를 관찰자(Observer)들에게 자동으로 통보.

Subject (발행자)
    ├── attach(Observer)
    ├── detach(Observer)
    └── notify() → 등록된 모든 Observer의 update() 호출

핵심: 1:N 의존 관계. 상태 변화를 구독자들에게 자동 전파.
예시: 이벤트 리스너, React의 상태 변화 → 리렌더링, Redux

---

State (스테이트)

객체의 내부 상태에 따라 행동이 달라지게 한다. 상태를 클래스로 표현.

Context ──→ State (인터페이스)
                 ├── ConcreteStateA
                 └── ConcreteStateB

핵심: 상태를 클래스로 분리해 조건문 제거.
예시: 신호등(빨강/노랑/초록 상태), 주문 상태(결제대기/배송중/완료)

---

Strategy (스트레티지)

알고리즘을 캡슐화해 런타임에 교체 가능하게 한다.

Context ──→ Strategy (인터페이스)
                 ├── ConcreteStrategyA (알고리즘 A)
                 └── ConcreteStrategyB (알고리즘 B)

핵심: 같은 문제를 푸는 여러 알고리즘을 캡슐화해 쉽게 교체.
State vs Strategy: State는 상태에 따라 행동 변화 / Strategy는 알고리즘 교체
예시: 정렬 알고리즘 교체, 결제 방식(카드/페이/계좌이체)

---

Template Method (템플릿 메서드)

알고리즘의 골격을 상위 클래스에 정의하고, 세부 구현은 하위 클래스에 위임.

abstract class DataProcessor {
    // 템플릿 메서드 (골격 고정)
    final void process() {
        readData();    // 추상 메서드 → 하위 클래스 구현
        processData(); // 추상 메서드 → 하위 클래스 구현
        writeData();   // 추상 메서드 → 하위 클래스 구현
    }
}

핵심: 알고리즘 구조는 고정, 세부 단계만 하위 클래스에서 재정의.
Strategy vs Template Method: Strategy는 구성(런타임 교체) / Template Method는 상속(컴파일 타임 결정)

---

Visitor (비지터)

객체 구조를 변경하지 않고 새로운 연산을 추가할 수 있게 한다.

Element.accept(Visitor)
Visitor.visit(ConcreteElement) // 실제 연산 수행

핵심: 데이터 구조와 처리 로직을 분리. 새 연산 추가 시 기존 클래스 수정 불필요.
예시: 컴파일러의 AST 순회, 세금 계산기

---

핵심 비교 — 헷갈리는 패턴 구분

비교 대상	패턴 1	패턴 2
객체 생성, 단일 vs 묶음	Factory Method (단일)	Abstract Factory (묶음)
기능 확장 방법	Decorator (런타임 동적)	Inheritance (컴파일 타임 정적)
알고리즘 교체	Strategy (구성, 런타임)	Template Method (상속, 컴파일)
상태 vs 알고리즘	State (상태에 따라 행동)	Strategy (알고리즘 교체)
Undo 저장	Memento (상태 저장)	Command (명령 저장)
단순 인터페이스 제공	Facade (서브시스템 통합)	Adapter (인터페이스 변환)
대리인	Proxy (접근 제어/부가기능)	Decorator (기능 추가)

---

빠른 암기 정리

생성 5개 (싱팩앱빌프)
  Singleton       : 인스턴스 딱 하나만
  Factory Method  : 하위 클래스가 생성 결정
  Abstract Factory: 관련 객체 묶음을 통째로 생성
  Builder         : 단계적으로 복잡한 객체 생성
  Prototype       : 기존 객체 복제해서 생성

구조 7개 (어브컴데퍼플프)
  Adapter         : 호환 안 되는 인터페이스 연결 (변환기)
  Bridge          : 추상과 구현을 분리해 독립 확장
  Composite       : 개별/복합 객체를 동일하게 취급 (트리)
  Decorator       : 런타임에 객체에 기능 동적 추가 (래퍼)
  Facade          : 복잡한 서브시스템을 단순 인터페이스로
  Flyweight       : 대량 유사 객체 공유로 메모리 절약
  Proxy           : 대리인이 실제 객체 앞에서 요청 처리

행위 11개 (책커인이미메옵스스템비)
  Chain of Resp.  : 처리 객체를 체인으로 연결해 순차 시도
  Command         : 요청을 객체로 캡슐화 (undo/redo 가능)
  Interpreter     : 언어 문법을 클래스로 표현해 해석
  Iterator        : 내부 구현 노출 없이 컬렉션 순차 접근
  Mediator        : 중재자를 통해 객체 간 통신 (결합도 감소)
  Memento         : 상태 스냅샷 저장 후 복원 (게임 저장)
  Observer        : 상태 변화를 구독자에게 자동 통보 (1:N)
  State           : 내부 상태에 따라 행동 변경
  Strategy        : 알고리즘을 캡슐화해 런타임에 교체
  Template Method : 알고리즘 골격 고정, 세부 구현은 하위 클래스
  Visitor         : 구조 변경 없이 새 연산 추가