GoF 디자인 패턴: 행위 패턴(3) - 책임 연쇄, 메멘토 | 타입스크립트 예시

// Handler: 모든 처리기의 공통 인터페이스
abstract class SupportHandler {
  protected nextHandler: SupportHandler | null = null;

  setNext(handler: SupportHandler): SupportHandler {
    this.nextHandler = handler;
    return handler;
  }

  handle(query: { type: string; message: string }): void {
    if (this.nextHandler) {
      this.nextHandler.handle(query);
    } else {
      console.log("아무도 처리할 수 없는 문의입니다.");
    }
  }
}

// ConcreteHandler: 기술 지원팀
class TechSupportHandler extends SupportHandler {
  handle(query: { type: string; message: string }): void {
    if (query.type === "tech") {
      console.log(`[기술 지원팀] "${query.message}" 문의를 처리합니다.`);
    } else {
      super.handle(query); // 처리 못하면 다음으로 넘김
    }
  }
}
// ... 다른 핸들러들 (Billing, General) ...

// 처리될 요청 객체
interface HttpRequest {
  path: string;
  user?: { id: number; name: string }; // 인증 미들웨어가 채워줄 속성
}

// Handler 추상 클래스
abstract class Middleware {
  protected next: Middleware | null = null;

  setNext(middleware: Middleware): Middleware {
    this.next = middleware;
    return middleware;
  }

  // 이제 handle은 항상 다음을 호출하는 구조가 됨
  handle(request: HttpRequest): void {
    if (this.next) {
      this.next.handle(request);
    }
  }
}

// ConcreteHandler 1: 인증 미들웨어
class AuthMiddleware extends Middleware {
  handle(request: HttpRequest): void {
    console.log("1. [인증] 사용자 토큰 검사 완료. 요청에 사용자 정보 추가.");
    request.user = { id: 123, name: "김재현" };
    super.handle(request); // 다음으로 전달
  }
}

// ConcreteHandler 2: 로깅 미들웨어
class LoggingMiddleware extends Middleware {
  handle(request: HttpRequest): void {
    console.log(`2. [로깅] Path: ${request.path}, User: ${request.user?.name}`);
    super.handle(request); // 다음으로 전달
  }
}

// 최종 처리기
class AppController extends Middleware {
  handle(request: HttpRequest): void {
    console.log("3. [컨트롤러] 최종 비즈니스 로직 실행.");
    // 체인의 끝이므로 super.handle()을 호출하지 않음
  }
}

// 클라이언트 코드
const auth = new AuthMiddleware();
const logging = new LoggingMiddleware();
const controller = new AppController();

// 체인 연결: 인증 -> 로깅 -> 컨트롤러
auth.setNext(logging).setNext(controller);

const request: HttpRequest = { path: "/profile" };
console.log("--- 클라이언트 요청 발생 ---");
auth.handle(request);

// Memento: 편집기의 상태(내용)를 저장
class EditorMemento {
  // readonly를 사용하여 외부에서 수정 불가능하도록 함
  constructor(public readonly content: string) {}
}

// Originator: 원본 객체
class Editor {
  private content: string = "";

  write(text: string): void {
    this.content += text;
  }

  getContent(): string {
    return this.content;
  }

  // 현재 상태를 메멘토에 저장
  save(): EditorMemento {
    console.log("상태 저장: ", this.content);
    return new EditorMemento(this.content);
  }

  // 메멘토로부터 상태를 복원
  restore(memento: EditorMemento): void {
    this.content = memento.content;
    console.log("상태 복원: ", this.content);
  }
}

// Caretaker: 메멘토를 보관하지만 내용은 모름
class History {
  private mementos: EditorMemento[] = [];
  private editor: Editor;

  constructor(editor: Editor) {
    this.editor = editor;
  }

  push(): void {
    this.mementos.push(this.editor.save());
  }

  undo(): void {
    // 마지막 상태(현재 상태)를 버리기 위해 pop
    this.mementos.pop();

    // 그 이전 상태를 가져와 복원
    const lastMemento = this.mementos[this.mementos.length - 1];
    if (lastMemento) {
      this.editor.restore(lastMemento);
    } else {
      // 스택에 아무것도 없으면 초기 상태로 복원
      this.editor.restore(new EditorMemento(""));
    }
  }
}

// 클라이언트 코드
const editor = new Editor();
const history = new History(editor);

// 1. 첫 번째 문장 작성 및 저장
editor.write("안녕하세요. ");
history.push(); // "안녕하세요. " 상태 저장

// 2. 두 번째 문장 작성 및 저장
editor.write("메멘토 패턴입니다.");
history.push(); // "안녕하세요. 메멘토 패턴입니다." 상태 저장

// 3. 현재 내용 확인
console.log("현재 내용: ", editor.getContent());
// 출력: 현재 내용:  안녕하세요. 메멘토 패턴입니다.

// 4. 실행 취소 (Undo)
history.undo();
console.log("실행 취소 후 내용: ", editor.getContent());
// 출력:
// 상태 복원:  안녕하세요.
// 실행 취소 후 내용:  안녕하세요.

// 5. 한 번 더 실행 취소 (Undo)
history.undo();
console.log("두 번째 실행 취소 후 내용: ", editor.getContent());
// 출력:
// 상태 복원:
// 두 번째 실행 취소 후 내용: