Prototype Pattern

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

+----------------+        +------------------+
|   Prototype    ||   Client         |
+----------------+        +------------------+
| +clone()       |        |                  |
+----------------+        +------------------+
        ^
        |
+----------------+
|ConcretePrototype|
+----------------+

1

[Client] → [Prototype/PrototypeRegistry] → [clone()] → [ConcretePrototype]

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

import copy

class Prototype:
    def clone(self):
        return copy.deepcopy(self)

class Employee(Prototype):
    def __init__(self, name, position):
        self.name = name
        self.position = position

    def __str__(self):
        return f"Employee({self.name}, {self.position})"

# 프로토타입 등록
employee_proto = Employee("Alice", "Developer")
employee_clone = employee_proto.clone()
employee_clone.name = "Bob"

print(employee_proto)  # Employee(Alice, Developer)
print(employee_clone)  # Employee(Bob, Developer)

1

[Client] → [PrototypeRegistry] → [Warrior.clone()] → [NewWarrior]

 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

from copy import deepcopy
from typing import Dict, Any

class Character:
    def __init__(self, name: str, level: int, stats: Dict[str, int]):
        self.name = name
        self.level = level
        self.stats = stats
        
    def clone(self) -> 'Character':
        """Create a deep copy of the character"""
        return deepcopy(self)
    
    def __str__(self) -> str:
        return f"Character(name={self.name}, level={self.level}, stats={self.stats})"

class CharacterPrototype:
    """Prototype manager class that stores and creates character templates"""
    def __init__(self):
        self._characters: Dict[str, Character] = {}
    
    def register_character(self, name: str, character: Character):
        """Register a character template"""
        self._characters[name] = character
    
    def unregister_character(self, name: str):
        """Remove a character template"""
        del self._characters[name]
        
    def clone(self, name: str, **kwargs: Any) -> Character:
        """Clone a character and optionally modify its attributes"""
        prototype = self._characters.get(name)
        if not prototype:
            raise ValueError(f"Character prototype '{name}' not found")
            
        character = prototype.clone()
        
        # Update any attributes specified in kwargs
        for key, value in kwargs.items():
            if hasattr(character, key):
                setattr(character, key, value)
                
        return character

# Usage example
if __name__ == "__main__":
    # Create prototype manager
    prototype_manager = CharacterPrototype()
    
    # Register base warrior template
    warrior = Character(
        name="Warrior",
        level=1,
        stats={"strength": 15, "agility": 10, "intelligence": 5}
    )
    prototype_manager.register_character("warrior", warrior)
    
    # Clone warriors with different names and levels
    warrior1 = prototype_manager.clone("warrior", name="Bob", level=5)
    warrior2 = prototype_manager.clone("warrior", name="Alice", level=7)
    
    print(warrior1)  # Character(name=Bob, level=5, stats={'strength': 15, 'agility': 10, 'intelligence': 5})
    print(warrior2)  # Character(name=Alice, level=7, stats={'strength': 15, 'agility': 10, 'intelligence': 5})

 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

class DocumentTemplate {
    constructor(type, content, metadata) {
        this.type = type;
        this.content = content;
        this.metadata = metadata;
    }

    clone() {
        // Deep clone the object
        const clonedMetadata = JSON.parse(JSON.stringify(this.metadata));
        return new DocumentTemplate(this.type, this.content, clonedMetadata);
    }

    customize(updates) {
        Object.assign(this, updates);
        return this;
    }
}

class DocumentPrototypeRegistry {
    constructor() {
        this.prototypes = new Map();
    }

    registerTemplate(name, template) {
        this.prototypes.set(name, template);
    }

    unregisterTemplate(name) {
        this.prototypes.delete(name);
    }

    createDocument(templateName, customization = {}) {
        const template = this.prototypes.get(templateName);
        if (!template) {
            throw new Error(`Template '${templateName}' not found`);
        }

        return template.clone().customize(customization);
    }
}

// Usage example
const registry = new DocumentPrototypeRegistry();

// Register some document templates
const letterTemplate = new DocumentTemplate(
    'letter',
    'Dear {recipient},\n\n{body}\n\nBest regards,\n{sender}',
    {
        created: new Date(),
        version: '1.0',
        style: 'formal'
    }
);

registry.registerTemplate('business_letter', letterTemplate);

// Create customized documents from template
const myLetter1 = registry.createDocument('business_letter', {
    content: 'Dear John,\n\nThank you for your inquiry.\n\nBest regards,\nJane'
});

const myLetter2 = registry.createDocument('business_letter', {
    content: 'Dear Mary,\n\nPlease find attached our proposal.\n\nBest regards,\nBob',
    metadata: {
        version: '1.1',
        style: 'semiformal'
    }
});

console.log(myLetter1);
console.log(myLetter2);

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

        +--------------------+
        | Prototype | <----------------+ |
        | --------- ||
        | +clone(): Prototype|                |
        +--------------------+                |
                 ^                            |
                 |                            |
   +---------------------------+    +----------------------------+
   | ConcretePrototypeA |  | ConcretePrototypeB |
   | ------------------ ||----------------------------|
   | +clone(): Prototype       |    | +clone(): Prototype        |
   +---------------------------+    +----------------------------+
                 ^                            ^
                 |                            |
         +-------------------------+   +-------------------------+
         |       Client            |   |    Prototype Registry   |
         +-------------------------+   +-------------------------+

 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

public abstract class Character implements Cloneable {
    protected String type;
    protected int health;
    protected int attack;

    public Character clone() {
        try {
            return (Character) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

public class Knight extends Character {
    public Knight() {
        this.type = "Knight";
        this.health = 150;
        this.attack = 20;
    }
}

public class CharacterRegistry {
    private Map<String, Character> prototypes = new HashMap<>();

    public void register(String key, Character prototype) {
        prototypes.put(key, prototype);
    }

    public Character getClone(String key) {
        return prototypes.get(key).clone();
    }
}

 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

// Prototype 인터페이스
public interface Character extends Cloneable {
    Character clone();
    void displayInfo();
}

// 구체적인 Prototype
public class Warrior implements Character {
    private String weapon;

    public Warrior(String weapon) {
        this.weapon = weapon;
    }

    @Override
    public Character clone() {
        return new Warrior(this.weapon);
    }

    @Override
    public void displayInfo() {
        System.out.println("Warrior with " + weapon);
    }
}

public class Mage implements Character {
    private String spell;

    public Mage(String spell) {
        this.spell = spell;
    }

    @Override
    public Character clone() {
        return new Mage(this.spell);
    }

    @Override
    public void displayInfo() {
        System.out.println("Mage using " + spell);
    }
}

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

import java.util.HashMap;
import java.util.Map;

public class CharacterRegistry {
    private Map<String, Character> registry = new HashMap<>();

    public void register(String key, Character prototype) {
        registry.put(key, prototype);
    }

    public Character getClone(String key) {
        return registry.get(key).clone();
    }
}

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

public class Game {
    public static void main(String[] args) {
        CharacterRegistry registry = new CharacterRegistry();

        // 프로토타입 등록
        registry.register("warrior", new Warrior("Sword"));
        registry.register("mage", new Mage("Fireball"));

        // 복제 및 사용
        Character clone1 = registry.getClone("warrior");
        clone1.displayInfo(); // Warrior with Sword

        Character clone2 = registry.getClone("mage");
        clone2.displayInfo(); // Mage using Fireball
    }
}

1
2
3

클라이언트 → PrototypeRegistry → Prototype.clone() → ConcretePrototype
              ↓                       ↓
         프로토타입 조회          복제된 새 객체 반환

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

┌─────────────────┐
│    <<Client>>   │
└─────────┬───────┘
          │ uses
          ▼
┌─────────────────┐ creates ┌─────────────────┐
│PrototypeRegistry│ ────────│    Prototype    │
│                 │         │  (Interface)    │
├─────────────────┤         ├─────────────────┤
│+ getPrototype() │         │+ clone(): Self  │
│+ register()     │         └─────────┬───────┘
└─────────────────┘                   △
                                      │ implements
                    ┌─────────────────┼─────────────────┐
                    │                 │                 │
          ┌─────────┴───────┐ ┌───────┴───────┐ ┌───────┴───────┐
          │ConcretePrototype│ │ConcretePrototype│ │ConcretePrototype│
          │       A         │ │       B         │ │       C         │
          ├─────────────────┤ ├─────────────────┤ ├─────────────────┤
          │+ clone(): Self  │ │+ clone(): Self  │ │+ clone(): Self  │
          │+ specificOp()   │ │+ specificOp()   │ │+ specificOp()   │
          └─────────────────┘ └─────────────────┘ └─────────────────┘

1
2
3

public interface Prototype {
    Prototype clone();
}

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

public class Document implements Prototype {
    private String content;
    private List<String> tags;
    
    @Override
    public Document clone() {
        Document cloned = new Document();
        cloned.content = this.content;
        cloned.tags = new ArrayList<>(this.tags); // 깊은 복사
        return cloned;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class PrototypeRegistry {
    private Map<String, Prototype> prototypes = new HashMap<>();
    
    public void register(String key, Prototype prototype) {
        prototypes.put(key, prototype);
    }
    
    public Prototype getPrototype(String key) {
        return prototypes.get(key).clone();
    }
}

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

시퀀스 다이어그램: Prototype Pattern 동작 흐름

Client          Registry        Prototype       ConcretePrototype
  │                │               │                    │
  │ getPrototype() │               │                    │
  ├───────────────→│               │                    │
  │                │ lookup        │                    │
  │                ├──────────────→│                    │
  │                │               │     clone()        │
  │                │               ├───────────────────→│
  │                │               │                    │
  │                │               │  new instance      │
  │                │               │←───────────────────┤
  │                │   prototype   │                    │
  │                │←──────────────┤                    │
  │  cloned object │               │                    │
  │←───────────────┤               │                    │
  │                │               │                    │
  │ modify object  │               │                    │
  ├──────────────────────────────────────────────────→│
  │                │               │                    │

 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 Shape implements Cloneable {
    private String color;
    private int x, y;
    
    public Shape(String color, int x, int y) {
        this.color = color;
        this.x = x;
        this.y = y;
    }
    
    @Override
    public Shape clone() {
        try {
            return (Shape) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError("Cloning not supported", e);
        }
    }
}

// 사용 예시
Shape originalCircle = new Shape("red", 10, 20);
Shape clonedCircle = originalCircle.clone();

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

public class Employee {
    private String name;
    private Address address;
    private List<String> skills;
    
    // 일반 생성자
    public Employee(String name, Address address, List<String> skills) {
        this.name = name;
        this.address = address;
        this.skills = new ArrayList<>(skills);
    }
    
    // Copy Constructor
    public Employee(Employee other) {
        this.name = other.name;
        this.address = new Address(other.address); // Address도 복사 생성자 필요
        this.skills = new ArrayList<>(other.skills);
    }
    
    // Factory 메서드로 래핑
    public Employee createCopy() {
        return new Employee(this);
    }
}

 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

import java.io.*;

public class DeepCloneUtil {
    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T deepClone(T original) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(original);
            
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            
            return (T) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException("Deep clone failed", e);
        }
    }
}

// 사용 예시
public class ComplexObject implements Serializable {
    private List<Map<String, Object>> data;
    
    public ComplexObject createDeepCopy() {
        return DeepCloneUtil.deepClone(this);
    }
}

 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

public class DatabaseConfig {
    private String host;
    private int port;
    private String database;
    private String username;
    private boolean ssl;
    
    private DatabaseConfig(Builder builder) {
        this.host = builder.host;
        this.port = builder.port;
        this.database = builder.database;
        this.username = builder.username;
        this.ssl = builder.ssl;
    }
    
    // 기존 객체로부터 Builder 생성 (프로토타입 기능)
    public Builder toBuilder() {
        return new Builder()
                .host(this.host)
                .port(this.port)
                .database(this.database)
                .username(this.username)
                .ssl(this.ssl);
    }
    
    public static class Builder {
        private String host = "localhost";
        private int port = 3306;
        private String database;
        private String username;
        private boolean ssl = false;
        
        public Builder host(String host) {
            this.host = host;
            return this;
        }
        
        public Builder port(int port) {
            this.port = port;  
            return this;
        }
        
        // … 다른 setter 메서드들
        
        public DatabaseConfig build() {
            return new DatabaseConfig(this);
        }
    }
}

// 사용 예시
DatabaseConfig prodConfig = new DatabaseConfig.Builder()
    .host("prod-server")
    .port(3306)
    .database("prod_db")
    .username("prod_user")
    .ssl(true)
    .build();

// 프로토타입을 기반으로 테스트 환경 설정 생성
DatabaseConfig testConfig = prodConfig.toBuilder()
    .host("test-server")
    .database("test_db")
    .username("test_user")
    .build();

 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

                    ┌─────────────────────┐
                    │   GameClient        │
                    │ (캐릭터 생성 요청)   │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │ CharacterFactory    │
                    │ (캐릭터 생성 관리자) │
                    └──────────┬──────────┘
                               │
                               ▼
            ┌─────────────────────────────────────────┐
            │        CharacterRegistry                │
            │    (캐릭터 프로토타입 레지스트리)        │
            ├─────────────────────────────────────────┤
            │ - warriorPrototype: WarriorCharacter    │
            │ - magePrototype: MageCharacter          │  
            │ - archerPrototype: ArcherCharacter      │
            │ - npcPrototype: NPCCharacter            │
            └──────────┬──────────────────────────────┘
                       │
                       ▼
            ┌─────────────────────┐
            │     Character       │
            │   (Abstract Base)   │
            ├─────────────────────┤
            │ + clone(): Character│
            │ + initialize()      │
            │ + render()          │
            └──────────┬──────────┘
                       △
                       │
         ┌─────────────┼─────────────┐
         │             │             │
┌────────┴───────┐ ┌───┴────────┐ ┌──┴─────────┐
│WarriorCharacter│ │MageCharacter│ │ArcherCharacter│
├────────────────┤ ├────────────┤ ├───────────────┤
│+ clone()       │ │+ clone()   │ │+ clone()      │
│+ swordAttack() │ │+ castSpell()│ │+ bowAttack()  │
└────────────────┘ └────────────┘ └───────────────┘

 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

// 캐릭터 프로토타입 인터페이스
public abstract class Character implements Cloneable {
    protected String name;
    protected int level;
    protected int hp, mp;
    protected Map<String, Integer> stats;
    protected List<Skill> skills;
    protected Equipment equipment;
    
    public abstract Character clone();
    public abstract void performSpecialAttack();
}

// 전사 캐릭터 구체 구현
public class WarriorCharacter extends Character {
    @Override
    public WarriorCharacter clone() {
        WarriorCharacter cloned = new WarriorCharacter();
        cloned.level = this.level;
        cloned.hp = this.hp;
        cloned.mp = this.mp;
        cloned.stats = new HashMap<>(this.stats);
        cloned.skills = new ArrayList<>(this.skills);
        cloned.equipment = this.equipment.deepCopy();
        return cloned;
    }
    
    @Override
    public void performSpecialAttack() {
        // 전사 고유의 특수 공격
    }
}

// 캐릭터 레지스트리
public class CharacterRegistry {
    private static final Map<String, Character> prototypes = new HashMap<>();
    
    static {
        // 기본 프로토타입들 초기화
        WarriorCharacter warrior = new WarriorCharacter();
        warrior.setLevel(1);
        warrior.setHp(100);
        warrior.getStats().put("strength", 15);
        warrior.getStats().put("dexterity", 10);
        prototypes.put("WARRIOR", warrior);
        
        MageCharacter mage = new MageCharacter();
        mage.setLevel(1);
        mage.setHp(60);
        mage.setMp(100);
        mage.getStats().put("intelligence", 15);
        mage.getStats().put("wisdom", 12);
        prototypes.put("MAGE", mage);
    }
    
    public static Character getCharacter(String type) {
        Character prototype = prototypes.get(type);
        return prototype != null ? prototype.clone() : null;
    }
}

// 캐릭터 팩토리
public class CharacterFactory {
    public Character createPlayerCharacter(String characterClass, String playerName) {
        Character character = CharacterRegistry.getCharacter(characterClass);
        character.setName(playerName);
        character.setLevel(1); // 새 플레이어는 1레벨부터 시작
        return character;
    }
    
    public List<Character> createNPCs(String npcType, int count) {
        List<Character> npcs = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            Character npc = CharacterRegistry.getCharacter(npcType);
            npc.setName("NPC_" + npcType + "_" + (i + 1));
            // NPC별 고유 설정 추가
            npcs.add(npc);
        }
        return npcs;
    }
}