Memento Pattern

Memento Pattern

Memento Pattern 은 행위 디자인 패턴 중 하나로, 객체의 상태를 저장하고 이전 상태로 복원할 수 있게 해주는 패턴이다.

메멘토 패턴 (Memento Pattern) 은 소프트웨어 디자인 패턴 중 하나로, 객체의 상태를 저장하고 나중에 복원할 수 있는 메커니즘을 제공한다.
이 패턴의 주요 목적은 객체의 내부 상태를 캡슐화하면서도 외부에서 해당 상태를 저장하고 복원할 수 있게 하는 것이다.

메멘토 패턴은 객체의 상태 관리와 복원이 중요한 애플리케이션에서 매우 유용한 디자인 패턴이다.
이 패턴을 적절히 활용하면 코드의 유연성과 유지보수성을 크게 향상시킬 수 있다.

주요 구성 요소

메멘토 패턴은 세 가지 주요 구성 요소로 이루어져 있다:

• Originator: 상태를 저장하고 복원하려는 객체.
• Memento: 상태를 저장하는 객체.
• Caretaker: Memento 를 저장하고 관리하는 객체.

동작 방식

Originator 객체의 상태를 Memento 에 저장하고, 이후에 복원할 수 있다.
Memento 객체는 Originator 객체 외부에서 직접적으로 접근할 수 없으며, Caretaker 객체를 통해서만 접근할 수 있다.
따라서, 상태를 안전하게 보호하면서도 필요한 경우에만 복원할 수 있다.

기본적인 Memento 패턴의 구조

 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

# Memento: 상태를 저장하는 클래스
class EditorMemento:
    def __init__(self, content: str):
        # 에디터의 상태를 저장
        self._content = content
    
    def get_saved_content(self) -> str:
        return self._content

# Originator: 상태를 가지고 있는 원본 객체
class TextEditor:
    def __init__(self):
        self._content = ""
    
    def write(self, text: str) -> None:
        self._content += text
    
    def get_content(self) -> str:
        return self._content
    
    # 현재 상태를 저장
    def save(self) -> EditorMemento:
        return EditorMemento(self._content)
    
    # 이전 상태로 복원
    def restore(self, memento: EditorMemento) -> None:
        self._content = memento.get_saved_content()

# Caretaker: Memento 객체들을 관리
class History:
    def __init__(self):
        self._mementos = []
    
    def push(self, memento: EditorMemento) -> None:
        self._mementos.append(memento)
    
    def pop(self) -> EditorMemento:
        return self._mementos.pop()

실제 사용 예시:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 텍스트 에디터에서의 실행 취소 기능 구현
def editor_example():
    editor = TextEditor()
    history = History()
    
    # 텍스트 작성 및 상태 저장
    editor.write("First sentence. ")
    history.push(editor.save())
    
    editor.write("Second sentence. ")
    history.push(editor.save())
    
    editor.write("Third sentence. ")
    print("Current content:", editor.get_content())
    
    # 실행 취소 (이전 상태로 복원)
    editor.restore(history.pop())
    print("After first undo:", editor.get_content())
    
    editor.restore(history.pop())
    print("After second undo:", editor.get_content())

장점

• 캡슐화를 위반하지 않고 객체의 state 스냅샷을 생성할 수 있다.
• Caretaker 가 Originator 의 State 기록을 유지하므로 Originator 의 코드가 단순화된다.
• 객체 상태 저장 및 복원하는 역할을 Caretaker 에게 위임할 수 있다.
• 객체 상태가 바뀌어도 클라이언트 코드는 변경되지 않는다 (SOLID 의 OCP 원칙).

단점

• 클라이언트가 Memento 객체를 너무 많이 생성하면 메모리가 많이 사용된다.
• Caretaker 는 오래된 memento 객체를 삭제할 수 있도록 Originator 의 생명 주기를 추적해야 한다. 즉 자원을 소비해야 한다.
• 몇몇 언어에서는 Originator 만 Memento 객체에 접근할 수 있도록 만드는 것이 어려울 수 있다.

사용 사례

이 패턴은 복잡한 상태를 가진 객체에서 매우 유용하다.
예를 들어, 텍스트 편집기에서 사용자가 작성한 문서의 상태를 저장하고 이전 상태로 복원하는 경우, 메멘토 패턴을 사용할 수 있다. 또한, 게임에서 플레이어의 게임 상태를 저장하고 이전 상태로 복원하는 경우에도 이 패턴을 사용할 수 있다.

구현 시 고려사항

• 메멘토 객체의 크기와 생성 빈도를 고려하여 메모리 사용을 최적화해야 한다.
• Originator 의 상태 변화를 추적하고 관리하는 방법을 신중히 설계해야 한다.
• 복잡한 객체의 경우, 부분적인 상태 저장 및 복원 전략을 고려할 수 있다.
• 멀티스레드 환경에서는 동시성 문제를 고려해야 한다.

용어 정리

참고 및 출처

1. 주제의 분류 적절성

Memento Pattern(메멘토 패턴) 은 “Computer Science and Engineering > Software Design and Architecture > Software Design Patterns > GoF > Behavioral Design Patterns” 분류에 정확히 해당합니다. GoF(Gang of Four) 에서 정의한 대표적인 행동 (Behavioral) 패턴 중 하나로, 객체의 상태 관리와 복원에 초점을 둡니다 [1][2][4].

2. 200 자 요약

메멘토 패턴은 객체의 내부 상태를 외부에 노출하지 않고 저장 및 복원할 수 있도록 하는 디자인 패턴입니다. 주로 Undo/Redo, 스냅샷, 버전 관리 등 상태 복원이 필요한 시스템에서 활용되며, 캡슐화 원칙을 지키면서 객체의 상태 이력을 관리할 수 있습니다 [1][2][4][7].

3. 250 자 개요

메멘토 패턴은 객체의 내부 구현을 외부에 노출하지 않고, 특정 시점의 상태를 저장 (Memento) 하고 필요시 복원할 수 있도록 하는 행동 패턴입니다. Originator(원본 객체) 가 상태를 캡처해 Memento(메멘토) 에 저장하고, Caretaker(관리자) 가 이를 보관합니다. Undo/Redo, 트랜잭션 롤백, 버전 관리 등 다양한 분야에서 활용되며, 캡슐화와 단일 책임 원칙을 지키면서 객체의 상태 이력을 안전하게 관리할 수 있습니다 [1][2][4][12].

핵심 개념

• 정의: 메멘토 패턴은 객체의 내부 상태를 외부에 노출하지 않고 저장 및 복원할 수 있도록 하는 행동 패턴입니다 [1][2][4].
• 목적: 캡슐화를 위반하지 않고 객체의 상태를 저장·복원하여 Undo/Redo, 롤백 등 상태 복원이 필요한 기능을 안전하게 구현 [1][4][12].
• 주요 기능 및 역할:
  • 상태 스냅샷 저장 및 복원
  • Undo/Redo, 버전 관리, 트랜잭션 롤백 등 지원
• 특징:
  • 캡슐화 보장
  • Caretaker 는 Memento 의 내부 상태를 알 수 없음
  • 메멘토 객체는 불변 (immutable) 으로 설계하는 것이 일반적
• 핵심 원칙: 캡슐화 (Encapsulation), 단일 책임 원칙 (SRP), 객체의 책임 분리
• 실무 활용: 텍스트 에디터, 게임 세이브, 데이터베이스 트랜잭션, 워크플로우 롤백 등

주요 내용 정리

패턴 이름과 분류

의도 (Intent)

캡슐화를 위반하지 않고 객체의 내부 상태를 외부에 저장·복원할 수 있도록 하여, 객체를 이전 상태로 되돌릴 수 있게 한다 [1][2][4].

다른 이름 (Also Known As)

• Snapshot Pattern(스냅샷 패턴)
• Token Pattern(토큰 패턴)

동기 (Motivation / Forces)

• Undo/Redo, 롤백, 버전 관리 등 상태 복원이 필요한 기능에서 객체의 내부 상태를 안전하게 저장·복원해야 할 때 [2][4][7].

적용 가능성 (Applicability)

• 객체의 상태를 외부에 노출하지 않고 저장 및 복원해야 할 때
• Undo/Redo, 트랜잭션 롤백, 버전 관리 등 상태 이력 관리가 필요한 경우
• 복잡한 객체의 내부 구현을 외부에 드러내지 않고 상태 복원을 지원해야 할 때 [1][2][4][12].

구조 및 아키텍처

구조 다이어그램

1
2
3
4
5
6
7
8

+-------------------+         +------------------+
|   Caretaker       ||   Memento        |
+-------------------+         +------------------+
         ^                              ^
         |                              |
+-------------------+         +------------------+
|   Originator      ||   (state)        |
+-------------------+         +------------------+

UML 클래스 다이어그램

1
2
3
4

[Originator]  [Memento]
     ^                   ^
     |                   |
[ Caretaker ]  |

구성 요소 및 역할

필수/선택 구성요소

주요 원리 및 작동 원리

1. 상태 저장: Caretaker 가 Originator 에 상태 저장 요청 → Originator 가 Memento 생성 및 반환 → Caretaker 가 Memento 보관
2. 상태 복원: Caretaker 가 Originator 에 상태 복원 요청 → Originator 가 Memento 를 받아 상태 복원

작동 원리 다이어그램

1
2
3
4
5
6
7

[ Caretaker ]
     |             상태 저장 요청
     v
[ Originator ] --(상태 저장)--> [ Memento ]
     ^                              |
     |             상태 복원 요청    |
     +------------------------------+

구현 기법

• 캡슐화 유지: Memento 의 상태는 Originator 만 접근 가능, Caretaker 는 접근 불가 [1][2][4][12].
• 불변 객체: Memento 는 생성 후 상태 변경 불가 (immutable) 로 설계 [13].
• 상태 관리: Caretaker 가 Memento 객체를 리스트/스택 등으로 관리하여 Undo/Redo, 버전 관리 등 구현 [1][5][7].
• 다형성 활용: 여러 Originator/Memento 조합 지원 가능 [1].

예시 코드 (Python)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Memento:
    def __init__(self, state):
        self._state = state
    def get_state(self):
        return self._state

class Originator:
    def __init__(self):
        self._state = None
    def set_state(self, state):
        self._state = state
    def save(self):
        return Memento(self._state)
    def restore(self, memento):
        self._state = memento.get_state()

class Caretaker:
    def __init__(self):
        self._history = []
    def backup(self, memento):
        self._history.append(memento)
    def undo(self):
        return self._history.pop() if self._history else None

장점과 단점

도전 과제 및 해결책

• 문제: 상태가 크거나 빈번하게 저장되면 메모리 사용량 급증
  해결책: 필요 최소한의 상태만 저장, 오래된 Memento 정리, 압축 저장 등
• 문제: Caretaker 가 Memento 삭제 시점 관리 필요
  해결책: 자동화된 GC, 만료 정책, 참조 카운팅 등 도입
• 문제: 언어에 따라 캡슐화 보장 어려움
  해결책: 접근 제어자, 내부 클래스 등 활용

분류에 따른 종류 및 유형

실무 적용 예시

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

상황 가정: 텍스트 에디터 Undo/Redo

• 시스템 구성:
  • Editor(Originator) → History(Caretaker) → StateSnapshot(Memento)
• Workflow:
  1. 사용자가 입력/삭제 등 편집 작업 수행
  2. 편집 전 상태를 Memento 로 저장, History 에 보관
  3. Undo 시 이전 Memento 를 Editor 에 전달하여 상태 복원
  4. Redo 시 이후 Memento 를 Editor 에 전달하여 상태 복원
• 역할: Editor 는 상태 저장/복원, History 는 이력 관리, StateSnapshot 은 상태 스냅샷 저장

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

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

2025 년 기준 최신 동향

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

앞으로의 전망

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

추가 학습/알아야 할 내용

용어 정리

참고 및 출처

• Refactoring.Guru - Memento Pattern 설명
• Wikipedia - Memento Pattern
• Scaler Topics - Memento Pattern 개념
• DEV.to - Memento Pattern 실무 활용
• Java Design Patterns - Memento Pattern
• Spring Framework Guru - 메멘토 패턴
• Visual Paradigm - Memento Pattern UML
• HackerNoon - Memento Pattern 개요
• LinkedIn - Memento Pattern 활용
• 티스토리 - 메멘토 패턴 구조 및 원리

**Memento Pattern (메멘토 패턴)**에 대해 실무 기반으로 심층 분석한 내용을 다음과 같이 정리하였습니다.

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

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

• 검토 결과
  ✅ 적절합니다. Memento Pattern 은 객체의 이전 상태를 저장하여 나중에 복원할 수 있도록 하는 **행동 패턴 (Behavioral Pattern)**에 해당합니다.

2. 요약 설명 (200 자 내외)

메멘토 패턴은 객체의 상태를 저장하고 복원할 수 있도록 하며, 캡슐화를 유지하면서도 상태 관리 기능을 제공합니다. 실행 취소 (Undo), 버전 관리, 상태 롤백 등에서 활용되며, Caretaker-Originator-Memento 구조로 구현됩니다.

3. 개요 설명 (250 자 내외)

Memento Pattern 은 객체의 내부 상태를 외부에 노출하지 않고도 저장 및 복원이 가능하게 해주는 디자인 패턴입니다. 상태 캡처와 복구를 지원하며, 실행 취소 (Undo), Redo, 상태 백업 등의 기능 구현에 효과적입니다. 이 패턴은 객체의 상태를 저장하는 Memento, 상태를 저장하고 복원하는 Originator, 상태를 관리하는 Caretaker 세 구성요소로 구성됩니다. 개발 실무에서는 텍스트 편집기, 게임 저장, 워크플로우 엔진 등 다양한 분야에 활용됩니다.

4. 핵심 개념

핵심 원칙

• 캡슐화를 유지하며 객체의 상태를 저장

• 상태를 복원할 수 있도록 상태 스냅샷 제공

• Memento 는 불변 객체로 설계하는 것이 일반적

5. 주요 내용 정리

목적 및 필요성

• 객체의 상태를 캡슐화된 방식으로 저장

• Undo/Redo, 상태 롤백 기능을 단순화

주요 기능 및 역할

• Memento: 상태 보존

• Originator: 상태 설정 및 복원

• Caretaker: 상태 관리 및 이력 저장

특징

• 캡슐화된 객체 설계 유지

• 상태 이력 저장이 가능함

• 복원 지점을 자유롭게 설정 가능

주요 원리 및 작동 원리 다이어그램

1
2
3
4
5
6
7

+---------------+     creates     +-------------+
|  Originator   |---------------->|   Memento   |
+---------------+     restores    +-------------+
        ^                               |
        |     stores/retrieves          |
        +-------------------------------+
                    Caretaker

구조 및 아키텍처

필수 구성 요소

• Originator

• Memento

• Caretaker

선택 구성 요소

• 상태 이력 스택 (Undo/Redo 시스템 구현 시)

구현 기법

장단점

도전 과제

분류에 따른 종류 및 유형

실무 적용 예시

다음에는 활용 사례 시나리오, 적용 고려사항, 성능 최적화, 최신 동향, 향후 전망, 학습 주제 분류를 이어서 정리하겠습니다. 계속 진행할까요?
이어서 Memento Pattern (메멘토 패턴) 에 대한 심화 내용을 정리합니다.

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

📌 시나리오: 문서 편집기에서 실행 취소 (Undo) 기능 구현

🧩 시스템 구성 요소

📊 시스템 구성 다이어그램

1
2
3
4
5
6
7

+-------------+        +------------------+         +----------------+
|  History    |<------>|   Editor         |<------->| EditorMemento  |
| (Caretaker) |        | (Originator)     |         |  (Memento)     |
+-------------+        +------------------+         +----------------+
| +push(m)    |        | +createMemento() |         |  getState()    |
| +pop()      |        | +restore(m)      |         |  (read-only)   |
+-------------+        +------------------+         +----------------+

⚙️ 워크플로우

1. 사용자가 문서를 수정하면 Editor 는 EditorMemento 생성

2. HistoryManager 가 해당 상태를 스택에 저장

3. 사용자가 Undo 시 HistoryManager 에서 마지막 상태를 꺼내 Editor 에 복원

7. 실무에서 효과적으로 적용하기 위한 고려사항

8. 성능을 최적화하기 위한 고려사항

9. 2025 년 기준 최신 동향

10. 앞으로의 전망

11. 하위 주제별 학습 분류

12. 확장 학습 주제 (실무 연관)

용어 정리

참고 및 출처

• Refactoring Guru – Memento Pattern

• GeeksforGeeks – Memento Design Pattern

• Baeldung – Java Memento Pattern

• Oracle Java Docs – Serialization

필요하시면 다음과 같은 자료도 추가로 제공 가능합니다:

• ✅ Java, Python 기반 Memento 패턴 샘플 코드

• ✅ Memento vs Command 패턴 비교

• ✅ Undo/Redo 기능의 아키텍처 설계 예제

좋습니다. 아래에 Memento 패턴 vs Command 패턴 비교와 Undo/Redo 기능 아키텍처 설계 예제를 정리했습니다.

✅ Memento 패턴 Vs Command 패턴 비교

🔍 요약

• Memento는 " 데이터 중심 " 이며 객체의 상태를 복원합니다.

• Command는 " 행위 중심 " 이며 요청 자체를 캡슐화하고 실행/취소를 제어합니다.

✅ Undo/Redo 기능의 아키텍처 설계 예제

🎯 요구 사항

• 사용자는 여러 번의 작업을 수행할 수 있어야 하며,

• 이전 상태로 되돌리는 Undo 기능, 이후 상태로 되돌리는 Redo 기능을 제공해야 함

• 예시: 텍스트 편집기, 다이어그램 그리기 앱, 폼 에디터 등

🧱 아키텍처 구성

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

+------------------+
|     Client       |
+------------------+
        |
        v
+------------------+
|   CommandManager |  <-- Invoker
+------------------+
| undoStack        |
| redoStack        |
+------------------+
   |         |
   v         v
Command    Command
(undo)     (redo)
   |           |
   v           v
Receiver <---> Domain Object

📦 구성 요소 설명

📋 시나리오 플로우 예시

1. InsertTextCommand("Hello") 실행

   • execute() 실행 후 undoStack 에 push

2. 사용자 Undo 클릭

   • undoStack.pop().undo() 실행 → redoStack 에 push

3. 사용자 Redo 클릭

   • redoStack.pop().execute() 실행 → 다시 undoStack 에 push

🧪 확장 고려사항

🔁 두 패턴 통합 전략 (하이브리드)

복잡한 Undo/Redo 시스템에서는 Memento + Command 패턴을 함께 사용하는 것이 실무적입니다.

• Command 패턴: " 무엇을 했는가?" (행위의 추상화)

• Memento 패턴: " 언제 어떤 상태였는가?" (상태의 캡처)

✅ 예:
InsertTextCommand 는 실행 시 Editor.createMemento() 를 통해 상태 저장 → Undo 시 restoreMemento()

필요하시면 다음 항목도 추가 제공 가능합니다:

• ✅ Java/Python 기반 Undo/Redo 시스템 샘플 코드

• ✅ Memento + Command 통합 구현 예제

• ✅ React/Vue 기반 상태 롤백 패턴 구조

메모리 패턴 (Memento Pattern) 에 대해 상세히 조사하고 분석해드리겠습니다.

이제 조사한 내용을 바탕으로 메멘토 패턴에 대한 포괄적인 분석을 진행하겠습니다.

메멘토 패턴 (Memento Pattern) 종합 분석

1. 주제 분류 검증

제시된 주제 분류 **“Computer Science and Engineering” > “Software Design and Architecture” > “Software Design Patterns” > “GoF” > “Behavioral Design Patterns”**는 적절합니다. 메멘토 패턴은 Gang of Four(GoF) 에서 정의한 23 가지 디자인 패턴 중 하나로, 행동 디자인 패턴 (Behavioral Design Pattern) 범주에 속합니다.

2. 요약 문장 (200 자 내외)

메멘토 패턴 (Memento Pattern) 은 객체의 내부 상태를 캡슐화를 위반하지 않으면서 외부로 노출시켜 저장하고, 나중에 해당 상태로 복원할 수 있게 하는 행동 디자인 패턴입니다. 실행 취소 (Undo), 롤백 (Rollback), 체크포인트 기능을 구현할 때 주로 사용되며, Originator, Memento, Caretaker 세 가지 핵심 구성요소로 이루어집니다.

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

메멘토 패턴은 토큰 패턴 (Token Pattern) 이라고도 불리며, 객체의 상태를 스냅샷으로 저장하고 복원하는 기능을 제공합니다. 텍스트 에디터의 실행 취소, 게임의 세이브/로드, 데이터베이스 트랜잭션 롤백 등에 활용됩니다. 패턴은 상태를 생성하는 Originator, 상태를 저장하는 Memento, 메멘토를 관리하는 Caretaker 로 구성되어 객체 간의 캡슐화를 유지하면서 상태 관리를 효율적으로 수행합니다.

4. 핵심 개념

기본 개념

• 상태 캡처 (State Capture): 객체의 내부 상태를 특정 시점에서 저장
• 캡슐화 보존 (Encapsulation Preservation): 객체의 내부 구조를 노출하지 않으면서 상태 관리
• 상태 복원 (State Restoration): 저장된 상태로 객체를 되돌리는 기능
• 스냅샷 (Snapshot): 특정 시점에서의 객체 상태를 나타내는 불변 객체

심화 개념

• 좁은 인터페이스 vs 넓은 인터페이스: Caretaker 는 좁은 인터페이스로, Originator 는 넓은 인터페이스로 Memento 에 접근
• 불변성 (Immutability): Memento 객체는 생성 후 변경되지 않는 특성
• 투명한 객체 (Opaque Object): Caretaker 가 Memento 의 내용을 알 수 없는 특성

Part 1: 핵심 이론 및 원리

배경

메멘토 패턴은 1995 년 Gang of Four 가 “Design Patterns: Elements of Reusable Object-Oriented Software” 에서 소개한 23 가지 디자인 패턴 중 하나입니다. 이 패턴의 개발 배경은 다음과 같습니다:

• 캡슐화 위반 문제: 객체의 상태를 외부에서 직접 접근하여 저장하려 할 때 발생하는 캡슐화 위반 문제 해결 필요성
• 실행 취소 기능 요구: 1990 년대 GUI 애플리케이션의 확산으로 실행 취소 (Undo) 기능에 대한 사용자 요구 증가
• 상태 관리 복잡성: 복잡한 객체의 상태를 안전하고 효율적으로 관리하기 위한 표준화된 방법의 필요성

목적 및 필요성

주요 목적

1. 캡슐화 보존: 객체의 내부 구조를 외부에 노출하지 않으면서 상태 저장
2. 상태 복원: 객체를 이전 상태로 안전하게 되돌리는 기능 제공
3. 책임 분리: 상태 저장과 관리 책임을 명확히 분리

필요성

• 사용자 경험 향상: 실행 취소 기능을 통한 사용자 편의성 증대
• 데이터 안전성: 오류 발생 시 이전 상태로 롤백할 수 있는 안전장치
• 디버깅 지원: 프로그램 실행 중 특정 시점의 상태 저장을 통한 디버깅 지원

주요 기능 및 역할

핵심 기능

1. 상태 스냅샷 생성: 특정 시점에서 객체의 상태를 캡처
2. 상태 저장 및 관리: 생성된 스냅샷을 안전하게 저장하고 관리
3. 상태 복원: 저장된 스냅샷을 사용하여 객체 상태를 복원
4. 이력 관리: 여러 상태 변화의 이력을 순차적으로 관리

역할 분담

• Originator: 자신의 상태를 Memento 로 저장하고 복원하는 역할
• Memento: 상태 정보를 안전하게 보관하는 역할
• Caretaker: Memento 객체들을 관리하고 적절한 시점에 복원을 요청하는 역할

특징

주요 특징

1. 캡슐화 유지: 객체의 내부 상태에 직접 접근하지 않음
2. 불변성: Memento 객체는 생성 후 변경되지 않음
3. 투명성: Caretaker 는 Memento 의 내용을 알 수 없음
4. 단일 객체 중심: 한 번에 하나의 객체 상태만 처리

고유 특성

• 이중 인터페이스: 좁은 인터페이스 (Caretaker 용) 와 넓은 인터페이스 (Originator 용) 제공
• 상태 독립성: Memento 는 Originator 와 독립적으로 존재 가능
• 시간적 분리: 상태 저장과 복원이 시간적으로 분리됨

핵심 원칙

기본 원칙

1. 단일 책임 원칙 (SRP): 각 구성 요소가 명확한 단일 책임을 가짐
2. 개방 - 폐쇄 원칙 (OCP): 새로운 상태 관리 요구사항에 대해 확장 가능
3. 캡슐화 원칙: 객체의 내부 상태를 외부로부터 보호

설계 원칙

• 정보 은닉: Memento 의 내용은 Originator 만 접근 가능
• 최소 권한: 각 구성 요소는 필요한 최소한의 권한만 가짐
• 느슨한 결합: 구성 요소 간의 의존성을 최소화

주요 원리 및 작동 원리

작동 메커니즘

1
2
3
4
5

1. 상태 저장 과정:
   Client → Caretaker → Originator.createMemento() → Memento 생성
   
2. 상태 복원 과정:
   Client → Caretaker → Originator.restore(memento) → 상태 복원

상호작용 다이어그램

sequenceDiagram
    participant C as Client
    participant CT as Caretaker
    participant O as Originator
    participant M as Memento
    
    C->>CT: 상태 저장 요청
    CT->>O: createMemento()
    O->>M: new Memento(state)
    M-->>O: memento
    O-->>CT: memento
    CT-->>C: 저장 완료
    
    Note over C,M: 시간 경과 후
    
    C->>CT: 상태 복원 요청
    CT->>O: restore(memento)
    O->>M: getState()
    M-->>O: state
    O-->>CT: 복원 완료
    CT-->>C: 복원 완료

Part 2: 구조 및 아키텍처

구조 및 아키텍처

필수 구성요소

1. Originator (원조자)

• 기능: 자신의 상태를 저장하고 복원하는 객체
• 역할:
  • Memento 객체 생성 (createMemento())
  • Memento 로부터 상태 복원 (restore(memento))
  • 내부 상태 관리
• 특징: Memento 의 모든 내용에 접근 가능한 유일한 객체

2. Memento (메멘토)

• 기능: Originator 의 상태를 저장하는 불변 객체
• 역할:
  • 상태 정보의 안전한 보관
  • Originator 에게만 상태 정보 제공
  • Caretaker 에게는 제한된 인터페이스만 제공
• 특징: 생성 후 내용 변경 불가

3. Caretaker (관리자)

• 기능: Memento 객체들을 관리하는 객체
• 역할:
  • Memento 객체의 저장 및 관리
  • 적절한 시점에 복원 요청
  • 실행 취소/재실행 로직 구현
• 특징: Memento 의 내용을 직접 검사하거나 수정할 수 없음

선택 구성요소

1. Client (클라이언트)

• 기능: 패턴의 전체 흐름을 제어하는 주체
• 역할: Caretaker 를 통해 저장/복원 요청
• 특징: 직접적으로 Memento 나 Originator 와 상호작용하지 않음

아키텍처 다이어그램

classDiagram
    class Originator {
        -state: Object
        +createMemento(): Memento
        +restore(memento: Memento): void
        +setState(state: Object): void
        +getState(): Object
    }
    
    class Memento {
        -state: Object
        +Memento(state: Object)
        <<friend>> +getState(): Object
    }
    
    class Caretaker {
        -mementos: List~Memento~
        +addMemento(memento: Memento): void
        +getMemento(index: int): Memento
        +undo(): void
        +redo(): void
    }
    
    class Client {
        +main(): void
    }
    
    Originator --> Memento : creates
    Caretaker --> Memento : stores
    Client --> Originator : uses
    Client --> Caretaker : uses
    
    note for Memento "불변 객체\n좁은/넓은 인터페이스"
    note for Originator "Memento의 모든 내용 접근 가능"
    note for Caretaker "Memento 내용 접근 불가"

구성요소 간 관계

의존 관계

• Originator → Memento: 생성 및 복원을 위한 의존
• Caretaker → Memento: 저장 및 관리를 위한 의존
• Client → Originator, Caretaker: 사용을 위한 의존

통신 흐름

1. 저장 흐름: Client → Caretaker → Originator → Memento
2. 복원 흐름: Client → Caretaker → Originator ← Memento

Part 3: 구현 및 활용

구현 기법

1. 중첩 클래스 (Nested Class) 기법

정의: Memento 를 Originator 의 내부 클래스로 구현하는 방법

구성:

• Originator 클래스 내부에 private static Memento 클래스 정의
• Memento 클래스는 외부에서 직접 접근 불가
• Originator 만 Memento 의 내부 상태에 접근 가능

목적: 캡슐화를 강화하고 Memento 의 내부 상태를 완전히 숨김

실제 예시:

 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

// 시나리오: 텍스트 에디터의 문서 상태 관리
public class TextEditor {
    private String content;
    private String formatting;
    
    public Memento createMemento() {
        return new Memento(content, formatting);
    }
    
    public void restore(Memento memento) {
        this.content = memento.getContent();
        this.formatting = memento.getFormatting();
    }
    
    // 중첩된 Memento 클래스
    public static class Memento {
        private final String content;
        private final String formatting;
        
        private Memento(String content, String formatting) {
            this.content = content;
            this.formatting = formatting;
        }
        
        private String getContent() { return content; }
        private String getFormatting() { return formatting; }
    }
}

2. 직렬화 (Serialization) 기법

정의: 객체의 상태를 바이트 스트림으로 변환하여 저장하는 방법

구성:

• Originator 클래스는 Serializable 인터페이스 구현
• Memento 는 직렬화된 바이트 배열을 저장
• 복원 시 역직렬화를 통해 객체 상태 복구

목적: 범용적인 상태 저장 메커니즘 제공

실제 예시:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 시나리오: 게임 캐릭터 상태 저장
public class GameCharacter implements Serializable {
    private String name;
    private int level;
    private Map<String, Integer> attributes;
    
    public SerializedMemento createMemento() throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(this);
        return new SerializedMemento(baos.toByteArray());
    }
    
    public void restore(SerializedMemento memento) throws IOException, ClassNotFoundException {
        ByteArrayInputStream bais = new ByteArrayInputStream(memento.getData());
        ObjectInputStream ois = new ObjectInputStream(bais);
        GameCharacter saved = (GameCharacter) ois.readObject();
        
        this.name = saved.name;
        this.level = saved.level;
        this.attributes = saved.attributes;
    }
}

3. 패키지 가시성 (Package Visibility) 기법

정의: 같은 패키지 내에서만 접근 가능한 가시성을 활용하는 방법

구성:

• Originator 와 Memento 를 같은 패키지에 배치
• Memento 의 필드를 package-private 으로 선언
• 외부 패키지에서는 Memento 내용에 접근 불가

목적: 중첩 클래스 없이 제어된 접근 제공

실제 예시:

 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

// 시나리오: 계산기 상태 관리
package calculator;

public class Calculator {
    private double result;
    private String lastOperation;
    
    public CalculatorMemento createMemento() {
        return new CalculatorMemento(result, lastOperation);
    }
    
    public void restore(CalculatorMemento memento) {
        this.result = memento.result;
        this.lastOperation = memento.lastOperation;
    }
}

// 같은 패키지의 Memento 클래스
class CalculatorMemento {
    final double result;           // package-private
    final String lastOperation;    // package-private
    
    CalculatorMemento(double result, String lastOperation) {
        this.result = result;
        this.lastOperation = lastOperation;
    }
}

4. 프록시 (Proxy) 기법

정의: 프록시 객체를 통해 원본 객체의 상태를 저장하고 복원하는 방법

구성:

• MementoProxy 가 원본 객체의 상태 저장/복원을 담당
• 프록시를 통해 접근 제어와 추가 기능 제공
• 복잡한 객체의 부분적 상태 저장 가능

목적: 유연한 상태 관리와 접근 제어

실제 예시:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 시나리오: 복잡한 그래픽 객체의 상태 관리
public class GraphicsObjectProxy {
    private GraphicsObject target;
    
    public GraphicsMemento createMemento() {
        // 선택적으로 일부 상태만 저장
        return new GraphicsMemento(
            target.getPosition(),
            target.getColor(),
            // 복잡한 렌더링 정보는 제외
        );
    }
    
    public void restore(GraphicsMemento memento) {
        target.setPosition(memento.getPosition());
        target.setColor(memento.getColor());
        // 필요시 추가 복원 로직
        target.invalidateCache();
    }
}

장점과 단점

도전 과제

1. 메모리 관리 최적화

설명: 대량의 Memento 객체로 인한 메모리 부족 문제 해결책:

• LRU(Least Recently Used) 캐시 정책으로 오래된 Memento 제거
• 압축 알고리즘을 활용한 상태 데이터 압축
• 차등 백업 (Differential Backup) 방식 도입

2. 대용량 객체 상태 관리

설명: 복잡하고 큰 객체의 상태 저장 시 성능 저하 해결책:

• 부분적 상태 저장 (Selective State Saving)
• Copy-on-Write 기법 활용
• 지연 직렬화 (Lazy Serialization) 적용

3. 동시성 제어

설명: 멀티스레드 환경에서의 상태 일관성 문제 해결책:

• 불변 Memento 객체 사용
• 스레드 안전한 Caretaker 구현
• 락 - 프리 (Lock-free) 자료구조 활용

4. 복잡한 객체 그래프 처리

설명: 상호 참조하는 객체들의 상태 저장 복잡성 해결책:

• 객체 그래프 직렬화 라이브러리 활용
• 참조 무결성을 위한 ID 기반 참조 시스템
• 컴포지트 메멘토 패턴 적용

Part 4: 실무 적용 및 최신 동향

분류에 따른 종류 및 유형

실무 적용 예시

활용 사례

시나리오: 협업 문서 편집 시스템

시스템 구성

• Frontend: React 기반 웹 에디터
• Backend: Node.js + Express
• Database: MongoDB (문서 저장) + Redis (메멘토 캐싱)
• Real-time: Socket.io (실시간 동기화)

시스템 구성 다이어그램

graph TB
    subgraph "Client Layer"
        UI[Web Editor UI]
        CM[Client Memento Manager]
    end
    
    subgraph "Application Layer"
        API[REST API Gateway]
        WS[WebSocket Server]
        MM[Memento Manager Service]
    end
    
    subgraph "Storage Layer"
        RC[Redis Cache]
        DB[(MongoDB)]
        FS[File Storage]
    end
    
    UI --> CM
    CM --> API
    API --> MM
    MM --> RC
    MM --> DB
    WS --> UI
    
    classDef client fill:#e1f5fe
    classDef app fill:#f3e5f5
    classDef storage fill:#e8f5e8
    
    class UI,CM client
    class API,WS,MM app
    class RC,DB,FS storage

활용 사례 Workflow

sequenceDiagram
    participant U as User
    participant E as Editor
    participant MM as MementoManager
    participant C as Cache
    participant DB as Database
    
    U->>E: 문서 편집 시작
    E->>MM: createCheckpoint()
    MM->>C: 현재 상태 저장
    
    Note over U,DB: 편집 작업 수행
    U->>E: 텍스트 입력/수정
    E->>MM: autoSave() 호출
    MM->>C: 자동 저장
    MM->>DB: 주기적 영구 저장
    
    Note over U,DB: 실행 취소 요청
    U->>E: Ctrl+Z (Undo)
    E->>MM: undo()
    MM->>C: 이전 Memento 조회
    C-->>MM: Memento 반환
    MM-->>E: 이전 상태 복원 
    E-->>U: 문서 상태 업데이트
    Note over U,DB: 협업자 변경사항 동기화 
    E->>MM: mergeChanges() 
    MM->>C: 충돌 해결 후 저장 
    MM->>DB: 최종 상태 영구 저장

메멘토 패턴의 역할

1. 문서 상태 관리: 각 편집 단계별로 문서 상태를 Memento 로 저장
2. 실시간 협업 지원: 여러 사용자의 변경사항을 독립적인 Memento 로 관리
3. 충돌 해결: 동시 편집 시 각 사용자의 상태를 별도 Memento 로 보관하여 병합
4. 자동 저장: 주기적으로 Memento 생성하여 데이터 손실 방지

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

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

기타 사항

관련 패턴과의 조합

Command 패턴과의 결합

• 용도: 실행 취소 가능한 명령 시스템 구축
• 구현: Command 객체가 실행 전 Memento 저장, 실행 취소 시 복원
• 장점: 복잡한 역연산 없이 안전한 실행 취소 구현

Observer 패턴과의 결합

• 용도: 상태 변경 시 자동 Memento 생성
• 구현: 상태 변경 이벤트 감지 시 자동으로 스냅샷 생성
• 장점: 개발자가 명시적으로 저장 코드를 작성할 필요 없음

Prototype 패턴과의 비교

• 차이점: Prototype 은 객체 생성에 초점, Memento 는 상태 복원에 초점
• 선택 기준: 객체가 단순하고 외부 참조가 적으면 Prototype 고려
• 조합 사용: Prototype 으로 빠른 복사, Memento 로 상태 관리

현대적 구현 고려사항

함수형 프로그래밍과의 조화

• 불변 객체 활용: 함수형 언어의 불변성과 Memento 의 불변성이 자연스럽게 조화
• 영속 자료구조: Clojure, Scala 등에서 구조적 공유를 통한 효율적 상태 관리
• 예시: Redux 의 상태 관리가 Memento 패턴과 유사한 개념

마이크로서비스 아키텍처에서의 적용

• 이벤트 소싱: 각 이벤트를 Memento 로 취급하여 시스템 상태 재구성
• CQRS 와 결합: Command 와 Query 분리하여 상태 스냅샷 최적화
• 분산 저장: 여러 서비스에 걸친 상태를 분산 Memento 로 관리

2025 년 기준 최신 동향

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

앞으로의 전망

하위 주제로 분류한 추가 학습 내용

관련 분야와 함께 알아야 할 내용

용어 정리

참고 및 출처

• Design Patterns: Elements of Reusable Object-Oriented Software - Gang of Four
• Memento Design Pattern - GeeksforGeeks
• Memento Design Pattern in Java - Baeldung
• Memento Pattern - Wikipedia
• Your Guide to Design Patterns - Memento Pattern - Incus Data
• Memento Design Pattern - HowToDoInJava
• GoF Design Pattern Template: Memento - Visual Paradigm