디자인 패턴 2025 실전 가이드: GoF 23개 패턴을 현대 언어(TypeScript/Python/Go)로 재해석

class AppConfig {
  private static instance: AppConfig;
  private config: Map<string, string> = new Map();

  private constructor() {
    // 외부 생성 차단
  }

  static getInstance(): AppConfig {
    if (!AppConfig.instance) {
      AppConfig.instance = new AppConfig();
    }
    return AppConfig.instance;
  }

  get(key: string): string | undefined {
    return this.config.get(key);
  }

  set(key: string, value: string): void {
    this.config.set(key, value);
  }
}

// 사용
const config = AppConfig.getInstance();
config.set('API_URL', 'https://api.example.com');

# config.py - Python에서는 모듈 자체가 싱글턴
class _AppConfig:
    def __init__(self):
        self._config: dict[str, str] = {}

    def get(self, key: str) -> str | None:
        return self._config.get(key)

    def set(self, key: str, value: str) -> None:
        self._config[key] = value

# 모듈 레벨 인스턴스 = 싱글턴
app_config = _AppConfig()

// 알림 시스템 팩토리
interface Notification {
  send(message: string): Promise<void>;
}

class EmailNotification implements Notification {
  async send(message: string) {
    console.log(`Email: ${message}`);
  }
}

class SlackNotification implements Notification {
  async send(message: string) {
    console.log(`Slack: ${message}`);
  }
}

class SMSNotification implements Notification {
  async send(message: string) {
    console.log(`SMS: ${message}`);
  }
}

// 팩토리 함수 (현대적 접근)
type NotificationType = 'email' | 'slack' | 'sms';

function createNotification(type: NotificationType): Notification {
  const notificationMap: Record<NotificationType, () => Notification> = {
    email: () => new EmailNotification(),
    slack: () => new SlackNotification(),
    sms: () => new SMSNotification(),
  };

  const creator = notificationMap[type];
  if (!creator) throw new Error(`Unknown notification type: ${type}`);
  return creator();
}

// 사용
const notifier = createNotification('slack');
await notifier.send('배포 완료!');

from abc import ABC, abstractmethod

class Notification(ABC):
    @abstractmethod
    async def send(self, message: str) -> None: ...

class EmailNotification(Notification):
    async def send(self, message: str) -> None:
        print(f"Email: {message}")

class SlackNotification(Notification):
    async def send(self, message: str) -> None:
        print(f"Slack: {message}")

def create_notification(ntype: str) -> Notification:
    factories = {
        "email": EmailNotification,
        "slack": SlackNotification,
    }
    cls = factories.get(ntype)
    if not cls:
        raise ValueError(f"Unknown type: {ntype}")
    return cls()

// UI 테마 Abstract Factory
interface Button {
  render(): string;
}

interface Input {
  render(): string;
}

interface UIFactory {
  createButton(): Button;
  createInput(): Input;
}

class DarkButton implements Button {
  render() { return '<button class="dark-btn">Click</button>'; }
}

class DarkInput implements Input {
  render() { return '<input class="dark-input" />'; }
}

class DarkThemeFactory implements UIFactory {
  createButton() { return new DarkButton(); }
  createInput() { return new DarkInput(); }
}

class LightButton implements Button {
  render() { return '<button class="light-btn">Click</button>'; }
}

class LightInput implements Input {
  render() { return '<input class="light-input" />'; }
}

class LightThemeFactory implements UIFactory {
  createButton() { return new LightButton(); }
  createInput() { return new LightInput(); }
}

// 사용 — 팩토리만 바꾸면 전체 테마 변경
function buildUI(factory: UIFactory) {
  const button = factory.createButton();
  const input = factory.createInput();
  return { button: button.render(), input: input.render() };
}

// Fluent Builder 패턴
class QueryBuilder {
  private table = '';
  private conditions: string[] = [];
  private orderByField = '';
  private limitCount = 0;

  from(table: string): this {
    this.table = table;
    return this;
  }

  where(condition: string): this {
    this.conditions.push(condition);
    return this;
  }

  orderBy(field: string): this {
    this.orderByField = field;
    return this;
  }

  limit(count: number): this {
    this.limitCount = count;
    return this;
  }

  build(): string {
    let query = `SELECT * FROM ${this.table}`;
    if (this.conditions.length > 0) {
      query += ` WHERE ${this.conditions.join(' AND ')}`;
    }
    if (this.orderByField) {
      query += ` ORDER BY ${this.orderByField}`;
    }
    if (this.limitCount > 0) {
      query += ` LIMIT ${this.limitCount}`;
    }
    return query;
  }
}

// 사용 — 가독성 극대화
const query = new QueryBuilder()
  .from('users')
  .where('age > 18')
  .where('status = "active"')
  .orderBy('created_at DESC')
  .limit(10)
  .build();

from dataclasses import dataclass, field

@dataclass
class HttpRequest:
    method: str = "GET"
    url: str = ""
    headers: dict[str, str] = field(default_factory=dict)
    body: str | None = None
    timeout: int = 30

    class Builder:
        def __init__(self):
            self._request = HttpRequest()

        def method(self, m: str) -> "HttpRequest.Builder":
            self._request.method = m
            return self

        def url(self, u: str) -> "HttpRequest.Builder":
            self._request.url = u
            return self

        def header(self, k: str, v: str) -> "HttpRequest.Builder":
            self._request.headers[k] = v
            return self

        def body(self, b: str) -> "HttpRequest.Builder":
            self._request.body = b
            return self

        def build(self) -> "HttpRequest":
            return self._request

# 사용
req = (HttpRequest.Builder()
    .method("POST")
    .url("https://api.example.com/users")
    .header("Content-Type", "application/json")
    .body('{"name": "Kim"}')
    .build())

interface Cloneable<T> {
  clone(): T;
}

class GameCharacter implements Cloneable<GameCharacter> {
  constructor(
    public name: string,
    public health: number,
    public inventory: string[],
    public position: { x: number; y: number }
  ) {}

  clone(): GameCharacter {
    return new GameCharacter(
      this.name,
      this.health,
      [...this.inventory],  // 깊은 복사
      { ...this.position }   // 깊은 복사
    );
  }
}

// 프로토타입 레지스트리
const templates = {
  warrior: new GameCharacter('Warrior', 100, ['sword', 'shield'], { x: 0, y: 0 }),
  mage: new GameCharacter('Mage', 70, ['staff', 'potion'], { x: 0, y: 0 }),
};

const player = templates.warrior.clone();
player.name = 'Hero Kim';

// 기존 외부 라이브러리 (변경 불가)
class LegacyPaymentGateway {
  processPaymentInCents(amountCents: number, curr: string): boolean {
    console.log(`Processing ${amountCents} cents in ${curr}`);
    return true;
  }
}

// 우리가 원하는 인터페이스
interface PaymentProcessor {
  pay(amount: number, currency: string): Promise<boolean>;
}

// Adapter
class PaymentAdapter implements PaymentProcessor {
  constructor(private legacy: LegacyPaymentGateway) {}

  async pay(amount: number, currency: string): Promise<boolean> {
    const cents = Math.round(amount * 100);
    return this.legacy.processPaymentInCents(cents, currency);
  }
}

// 사용 — 클라이언트는 레거시를 모른다
const processor: PaymentProcessor = new PaymentAdapter(
  new LegacyPaymentGateway()
);
await processor.pay(29.99, 'USD');

// 미들웨어 스타일 Decorator
interface HttpHandler {
  handle(request: Request): Promise<Response>;
}

class BaseHandler implements HttpHandler {
  async handle(req: Request): Promise<Response> {
    return new Response('OK', { status: 200 });
  }
}

// 로깅 데코레이터
class LoggingDecorator implements HttpHandler {
  constructor(private inner: HttpHandler) {}

  async handle(req: Request): Promise<Response> {
    console.log(`[LOG] ${req.method} ${req.url}`);
    const start = Date.now();
    const response = await this.inner.handle(req);
    console.log(`[LOG] Completed in ${Date.now() - start}ms`);
    return response;
  }
}

// 인증 데코레이터
class AuthDecorator implements HttpHandler {
  constructor(private inner: HttpHandler) {}

  async handle(req: Request): Promise<Response> {
    const token = req.headers.get('Authorization');
    if (!token) {
      return new Response('Unauthorized', { status: 401 });
    }
    return this.inner.handle(req);
  }
}

// 데코레이터 체이닝 — 순서 중요!
const handler = new LoggingDecorator(
  new AuthDecorator(
    new BaseHandler()
  )
);

import functools
import time

def log_execution(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"[LOG] {func.__name__} took {elapsed:.3f}s")
        return result
    return wrapper

def retry(max_attempts: int = 3):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts - 1:
                        raise
                    print(f"Retry {attempt + 1}/{max_attempts}")
        return wrapper
    return decorator

@log_execution
@retry(max_attempts=3)
def fetch_data(url: str) -> dict:
    # API 호출 로직
    ...

// 캐싱 프록시
interface DataService {
  fetchUser(id: string): Promise<User>;
}

class RealDataService implements DataService {
  async fetchUser(id: string): Promise<User> {
    // 실제 API 호출 (느림)
    const response = await fetch(`/api/users/${id}`);
    return response.json();
  }
}

class CachingProxy implements DataService {
  private cache = new Map<string, { data: User; expiry: number }>();

  constructor(
    private real: DataService,
    private ttlMs: number = 60000
  ) {}

  async fetchUser(id: string): Promise<User> {
    const cached = this.cache.get(id);
    if (cached && cached.expiry > Date.now()) {
      console.log(`Cache HIT for user ${id}`);
      return cached.data;
    }

    console.log(`Cache MISS for user ${id}`);
    const data = await this.real.fetchUser(id);
    this.cache.set(id, { data, expiry: Date.now() + this.ttlMs });
    return data;
  }
}

// 복잡한 서브시스템들
class VideoEncoder { encode(file: string) { /* ... */ } }
class AudioEncoder { encode(file: string) { /* ... */ } }
class Uploader { upload(file: string, dest: string) { /* ... */ } }
class Notifier { notify(userId: string, msg: string) { /* ... */ } }

// Facade — 단순한 인터페이스
class MediaPublisher {
  private videoEncoder = new VideoEncoder();
  private audioEncoder = new AudioEncoder();
  private uploader = new Uploader();
  private notifier = new Notifier();

  async publish(videoFile: string, userId: string): Promise<string> {
    const encoded = this.videoEncoder.encode(videoFile);
    const audioProcessed = this.audioEncoder.encode(videoFile);
    const url = this.uploader.upload(videoFile, 'cdn-bucket');
    this.notifier.notify(userId, '영상 업로드 완료!');
    return url;
  }
}

// 클라이언트는 내부 복잡성을 모른다
const publisher = new MediaPublisher();
await publisher.publish('video.mp4', 'user-123');

// 파일 시스템 예시
interface FileSystemNode {
  name: string;
  getSize(): number;
  print(indent?: string): void;
}

class File implements FileSystemNode {
  constructor(public name: string, private size: number) {}

  getSize(): number { return this.size; }

  print(indent = ''): void {
    console.log(`${indent}📄 ${this.name} (${this.size}B)`);
  }
}

class Directory implements FileSystemNode {
  private children: FileSystemNode[] = [];

  constructor(public name: string) {}

  add(node: FileSystemNode): void { this.children.push(node); }

  getSize(): number {
    return this.children.reduce((sum, child) => sum + child.getSize(), 0);
  }

  print(indent = ''): void {
    console.log(`${indent}📁 ${this.name} (${this.getSize()}B)`);
    this.children.forEach(child => child.print(indent + '  '));
  }
}

// 사용
const root = new Directory('src');
const components = new Directory('components');
components.add(new File('Button.tsx', 1200));
components.add(new File('Modal.tsx', 2400));
root.add(components);
root.add(new File('index.ts', 500));
root.print();
// 📁 src (4100B)
//   📁 components (3600B)
//     📄 Button.tsx (1200B)
//     📄 Modal.tsx (2400B)
//   📄 index.ts (500B)

// 결제 전략
interface PaymentStrategy {
  pay(amount: number): Promise<PaymentResult>;
  validate(): boolean;
}

class CreditCardPayment implements PaymentStrategy {
  constructor(private cardNumber: string) {}
  validate() { return this.cardNumber.length === 16; }
  async pay(amount: number) {
    return { success: true, method: 'credit_card', amount };
  }
}

class KakaoPayPayment implements PaymentStrategy {
  constructor(private userId: string) {}
  validate() { return this.userId.length > 0; }
  async pay(amount: number) {
    return { success: true, method: 'kakao_pay', amount };
  }
}

class NaverPayPayment implements PaymentStrategy {
  constructor(private token: string) {}
  validate() { return this.token.length > 0; }
  async pay(amount: number) {
    return { success: true, method: 'naver_pay', amount };
  }
}

// Context
class PaymentProcessor {
  constructor(private strategy: PaymentStrategy) {}

  setStrategy(strategy: PaymentStrategy) {
    this.strategy = strategy;
  }

  async checkout(amount: number) {
    if (!this.strategy.validate()) {
      throw new Error('Invalid payment method');
    }
    return this.strategy.pay(amount);
  }
}

// 런타임에 전략 교체
const processor = new PaymentProcessor(new CreditCardPayment('1234567890123456'));
await processor.checkout(50000);

processor.setStrategy(new KakaoPayPayment('user-kim'));
await processor.checkout(30000);

// 타입 안전한 이벤트 버스
type EventMap = {
  'user:login': { userId: string; timestamp: Date };
  'user:logout': { userId: string };
  'order:created': { orderId: string; total: number };
  'order:shipped': { orderId: string; trackingNumber: string };
};

class TypedEventBus {
  private listeners = new Map<string, Set<Function>>();

  on<K extends keyof EventMap>(
    event: K,
    callback: (data: EventMap[K]) => void
  ): () => void {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    this.listeners.get(event)!.add(callback);

    // unsubscribe 함수 반환
    return () => this.listeners.get(event)?.delete(callback);
  }

  emit<K extends keyof EventMap>(event: K, data: EventMap[K]): void {
    this.listeners.get(event)?.forEach(cb => cb(data));
  }
}

// 사용
const bus = new TypedEventBus();

const unsubscribe = bus.on('order:created', (data) => {
  console.log(`새 주문: ${data.orderId}, 금액: ${data.total}원`);
});

bus.on('order:created', (data) => {
  // 재고 업데이트
  console.log(`재고 업데이트 for 주문 ${data.orderId}`);
});

bus.emit('order:created', { orderId: 'ORD-001', total: 50000 });

// 구독 해제
unsubscribe();

interface Command {
  execute(): void;
  undo(): void;
}

class TextEditor {
  private content = '';
  private history: Command[] = [];
  private undone: Command[] = [];

  getContent() { return this.content; }

  executeCommand(command: Command) {
    command.execute();
    this.history.push(command);
    this.undone = []; // redo 스택 초기화
  }

  undo() {
    const command = this.history.pop();
    if (command) {
      command.undo();
      this.undone.push(command);
    }
  }

  redo() {
    const command = this.undone.pop();
    if (command) {
      command.execute();
      this.history.push(command);
    }
  }
}

class InsertTextCommand implements Command {
  constructor(
    private editor: { content: string },
    private text: string,
    private position: number
  ) {}

  execute() {
    const before = this.editor.content.slice(0, this.position);
    const after = this.editor.content.slice(this.position);
    this.editor.content = before + this.text + after;
  }

  undo() {
    const before = this.editor.content.slice(0, this.position);
    const after = this.editor.content.slice(this.position + this.text.length);
    this.editor.content = before + after;
  }
}

// 주문 상태 FSM
interface OrderState {
  name: string;
  confirm(order: Order): void;
  ship(order: Order): void;
  deliver(order: Order): void;
  cancel(order: Order): void;
}

class PendingState implements OrderState {
  name = 'PENDING';
  confirm(order: Order) { order.setState(new ConfirmedState()); }
  ship(_order: Order) { throw new Error('결제 전에는 배송 불가'); }
  deliver(_order: Order) { throw new Error('결제 전에는 수령 불가'); }
  cancel(order: Order) { order.setState(new CancelledState()); }
}

class ConfirmedState implements OrderState {
  name = 'CONFIRMED';
  confirm(_order: Order) { throw new Error('이미 결제 완료'); }
  ship(order: Order) { order.setState(new ShippedState()); }
  deliver(_order: Order) { throw new Error('배송 전에는 수령 불가'); }
  cancel(order: Order) { order.setState(new CancelledState()); }
}

class ShippedState implements OrderState {
  name = 'SHIPPED';
  confirm(_order: Order) { throw new Error('이미 결제 완료'); }
  ship(_order: Order) { throw new Error('이미 배송 중'); }
  deliver(order: Order) { order.setState(new DeliveredState()); }
  cancel(_order: Order) { throw new Error('배송 중에는 취소 불가'); }
}

class DeliveredState implements OrderState {
  name = 'DELIVERED';
  confirm() { throw new Error('완료된 주문'); }
  ship() { throw new Error('완료된 주문'); }
  deliver() { throw new Error('완료된 주문'); }
  cancel() { throw new Error('완료된 주문'); }
}

class CancelledState implements OrderState {
  name = 'CANCELLED';
  confirm() { throw new Error('취소된 주문'); }
  ship() { throw new Error('취소된 주문'); }
  deliver() { throw new Error('취소된 주문'); }
  cancel() { throw new Error('이미 취소됨'); }
}

class Order {
  private state: OrderState = new PendingState();

  setState(state: OrderState) { this.state = state; }
  getStateName() { return this.state.name; }

  confirm() { this.state.confirm(this); }
  ship() { this.state.ship(this); }
  deliver() { this.state.deliver(this); }
  cancel() { this.state.cancel(this); }
}

// 커스텀 이터레이터 — 페이지네이션
class PaginatedIterator<T> {
  private currentPage = 0;
  private buffer: T[] = [];
  private done = false;

  constructor(
    private fetchPage: (page: number) => Promise<T[]>,
    private pageSize: number = 20
  ) {}

  async *[Symbol.asyncIterator](): AsyncIterableIterator<T> {
    while (!this.done) {
      const items = await this.fetchPage(this.currentPage);
      if (items.length < this.pageSize) {
        this.done = true;
      }
      for (const item of items) {
        yield item;
      }
      this.currentPage++;
    }
  }
}

// 사용
const userIterator = new PaginatedIterator<User>(
  (page) => fetch(`/api/users?page=${page}`).then(r => r.json())
);

for await (const user of userIterator) {
  console.log(user.name);
}

abstract class DataProcessor {
  // 템플릿 메서드 — 알고리즘 뼈대
  async process(): Promise<void> {
    const raw = await this.extract();
    const transformed = this.transform(raw);
    await this.validate(transformed);
    await this.load(transformed);
  }

  abstract extract(): Promise<string[]>;
  abstract transform(data: string[]): Record<string, unknown>[];

  // 기본 구현 제공 (선택적 오버라이드)
  async validate(data: Record<string, unknown>[]): Promise<void> {
    if (data.length === 0) throw new Error('No data');
  }

  abstract load(data: Record<string, unknown>[]): Promise<void>;
}

class CSVProcessor extends DataProcessor {
  async extract() { return ['name,age', 'Kim,30', 'Lee,25']; }
  transform(data: string[]) {
    const headers = data[0].split(',');
    return data.slice(1).map(row => {
      const values = row.split(',');
      return Object.fromEntries(headers.map((h, i) => [h, values[i]]));
    });
  }
  async load(data: Record<string, unknown>[]) {
    console.log('DB 저장:', data);
  }
}

// Express 미들웨어 스타일
interface Middleware {
  handle(req: Request, next: () => Promise<Response>): Promise<Response>;
}

class CorsMiddleware implements Middleware {
  async handle(req: Request, next: () => Promise<Response>) {
    const response = await next();
    response.headers.set('Access-Control-Allow-Origin', '*');
    return response;
  }
}

class RateLimitMiddleware implements Middleware {
  private requests = new Map<string, number[]>();

  async handle(req: Request, next: () => Promise<Response>) {
    const ip = req.headers.get('x-forwarded-for') || 'unknown';
    const now = Date.now();
    const windowMs = 60000;
    const maxRequests = 100;

    const timestamps = (this.requests.get(ip) || [])
      .filter(t => t > now - windowMs);

    if (timestamps.length >= maxRequests) {
      return new Response('Too Many Requests', { status: 429 });
    }

    timestamps.push(now);
    this.requests.set(ip, timestamps);
    return next();
  }
}

// 미들웨어 체인 빌더
class MiddlewareChain {
  private middlewares: Middleware[] = [];

  use(middleware: Middleware): this {
    this.middlewares.push(middleware);
    return this;
  }

  async execute(req: Request, finalHandler: () => Promise<Response>): Promise<Response> {
    let index = 0;
    const next = async (): Promise<Response> => {
      if (index >= this.middlewares.length) {
        return finalHandler();
      }
      const mw = this.middlewares[index++];
      return mw.handle(req, next);
    };
    return next();
  }
}

// Strategy를 함수형으로
type SortStrategy<T> = (a: T, b: T) => number;

const byName: SortStrategy<User> = (a, b) => a.name.localeCompare(b.name);
const byAge: SortStrategy<User> = (a, b) => a.age - b.age;
const byCreatedAt: SortStrategy<User> = (a, b) =>
  a.createdAt.getTime() - b.createdAt.getTime();

// 전략 교체 = 함수 인자 변경
const sorted = users.sort(byAge);

// Decorator를 함수형으로
const withLogging = <T extends (...args: any[]) => any>(fn: T): T => {
  return ((...args: any[]) => {
    console.log(`Calling ${fn.name} with`, args);
    const result = fn(...args);
    console.log(`Result:`, result);
    return result;
  }) as T;
};

const add = (a: number, b: number) => a + b;
const loggedAdd = withLogging(add);
loggedAdd(1, 2); // Calling add with [1, 2], Result: 3

// 수동 DI (프레임워크 없이)
interface Logger { log(msg: string): void; }
interface Database { query(sql: string): Promise<any[]>; }

class UserService {
  constructor(
    private logger: Logger,
    private db: Database
  ) {}

  async getUser(id: string) {
    this.logger.log(`Fetching user ${id}`);
    return this.db.query(`SELECT * FROM users WHERE id = '${id}'`);
  }
}

// 테스트에서 Mock 주입
const mockLogger: Logger = { log: jest.fn() };
const mockDb: Database = { query: jest.fn().mockResolvedValue([{ id: '1', name: 'Kim' }]) };
const service = new UserService(mockLogger, mockDb);

// BAD - 신 객체
class AppManager {
  // 사용자 관리
  createUser() { /* ... */ }
  deleteUser() { /* ... */ }
  // 결제 관리
  processPayment() { /* ... */ }
  refund() { /* ... */ }
  // 이메일 관리
  sendEmail() { /* ... */ }
  // 로깅
  log() { /* ... */ }
  // 설정
  getConfig() { /* ... */ }
  // ... 500줄 이상
}

// GOOD - 단일 책임 원칙
class UserService { /* 사용자만 */ }
class PaymentService { /* 결제만 */ }
class EmailService { /* 이메일만 */ }

// BAD - 테스트 불가능한 싱글턴 의존
class OrderService {
  processOrder(orderId: string) {
    const db = DatabaseConnection.getInstance(); // 하드코딩된 의존
    const logger = Logger.getInstance();         // 테스트에서 교체 불가
    // ...
  }
}

// GOOD - 의존성 주입
class OrderService {
  constructor(
    private db: DatabaseConnection,
    private logger: Logger
  ) {}

  processOrder(orderId: string) {
    // db와 logger는 외부에서 주입
  }
}

// BAD - 과도한 추상화 (YAGNI 위반)
interface IStringFormatter { format(s: string): string; }
class UpperCaseFormatter implements IStringFormatter {
  format(s: string) { return s.toUpperCase(); }
}
class FormatterFactory {
  static create(type: string): IStringFormatter { /* ... */ }
}

// GOOD - KISS 원칙
const toUpper = (s: string) => s.toUpperCase();