设计模式详解05：原型模式(Prototype) - 对象克隆的高效实现

 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
82
83
84
85
86
87
88
89

/**
 * 抽象原型类
 */
public abstract class Prototype implements Cloneable {
    protected String name;

    public Prototype(String name) {
        this.name = name;
    }

    public abstract Prototype clone() throws CloneNotSupportedException;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

/**
 * 具体原型：简历类
 */
public class Resume extends Prototype {
    private String education;
    private String experience;
    private String skills;

    public Resume(String name) {
        super(name);
    }

    public Resume(String name, String education, String experience, String skills) {
        super(name);
        this.education = education;
        this.experience = experience;
        this.skills = skills;
    }

    @Override
    public Resume clone() throws CloneNotSupportedException {
        // 浅克隆：只复制基本类型和String
        return (Resume) super.clone();
    }

    public void display() {
        System.out.println("=== 个人简历 ===");
        System.out.println("姓名: " + name);
        System.out.println("学历: " + education);
        System.out.println("经验: " + experience);
        System.out.println("技能: " + skills);
    }

    // getter和setter方法
    public String getEducation() { return education; }
    public void setEducation(String education) { this.education = education; }

    public String getExperience() { return experience; }
    public void setExperience(String experience) { this.experience = experience; }

    public String getSkills() { return skills; }
    public void setSkills(String skills) { this.skills = skills; }
}

// 使用示例
public class BasicPrototypeDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        System.out.println("=== 原型模式基础示例 ===");

        // 创建原始简历
        Resume originalResume = new Resume("张三", "本科", "3年Java开发", "Spring, MySQL, Redis");
        System.out.println("\n原始简历：");
        originalResume.display();

        // 克隆简历并修改
        Resume clonedResume = originalResume.clone();
        clonedResume.setName("李四");
        clonedResume.setExperience("5年Java开发");

        System.out.println("\n克隆后的简历：");
        clonedResume.display();

        // 验证是不同的对象
        System.out.println("\n对象比较：");
        System.out.println("originalResume == clonedResume: " + (originalResume == clonedResume));
        System.out.println("originalResume.equals(clonedResume): " + originalResume.equals(clonedResume));
    }
}

  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
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

/**
 * 需要深克隆的复杂对象
 */
public class Address implements Cloneable {
    private String country;
    private String city;
    private String street;

    public Address(String country, String city, String street) {
        this.country = country;
        this.city = city;
        this.street = street;
    }

    @Override
    public Address clone() throws CloneNotSupportedException {
        return (Address) super.clone();
    }

    @Override
    public String toString() {
        return country + " " + city + " " + street;
    }

    // getter和setter方法
    public String getCountry() { return country; }
    public void setCountry(String country) { this.country = country; }

    public String getCity() { return city; }
    public void setCity(String city) { this.city = city; }

    public String getStreet() { return street; }
    public void setStreet(String street) { this.street = street; }
}

/**
 * 员工类 - 演示深克隆
 */
public class Employee implements Cloneable {
    private String name;
    private int age;
    private Address address; // 引用类型，需要深克隆
    private List<String> projects; // 集合类型，需要深克隆

    public Employee(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.projects = new ArrayList<>();
    }

    // 浅克隆 - 只克隆基本类型，引用类型共享
    public Employee shallowClone() throws CloneNotSupportedException {
        return (Employee) super.clone();
    }

    // 深克隆 - 递归克隆所有引用类型
    public Employee deepClone() throws CloneNotSupportedException {
        Employee cloned = (Employee) super.clone();

        // 深克隆Address对象
        cloned.address = this.address.clone();

        // 深克隆List对象
        cloned.projects = new ArrayList<>(this.projects);

        return cloned;
    }

    // 使用序列化实现深克隆（更通用的方法）
    public Employee deepCloneBySerializable() {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (Employee) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public void addProject(String project) {
        this.projects.add(project);
    }

    public void display() {
        System.out.println("员工信息:");
        System.out.println("  姓名: " + name);
        System.out.println("  年龄: " + age);
        System.out.println("  地址: " + address);
        System.out.println("  项目: " + projects);
        System.out.println("  对象哈希: " + this.hashCode());
        System.out.println("  地址对象哈希: " + address.hashCode());
        System.out.println("  项目列表哈希: " + projects.hashCode());
    }

    // getter和setter方法
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }

    public Address getAddress() { return address; }
    public void setAddress(Address address) { this.address = address; }

    public List<String> getProjects() { return projects; }
}

// 深克隆演示
public class DeepCloneDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        System.out.println("=== 深克隆 vs 浅克隆演示 ===");

        // 创建原始员工对象
        Address address = new Address("中国", "北京", "中关村大街1号");
        Employee original = new Employee("王五", 30, address);
        original.addProject("电商系统");
        original.addProject("支付系统");

        System.out.println("\n原始对象:");
        original.display();

        // 浅克隆
        Employee shallowCloned = original.shallowClone();
        shallowCloned.setName("赵六");
        shallowCloned.setAge(25);
        shallowCloned.getAddress().setCity("上海"); // 修改地址
        shallowCloned.addProject("CRM系统"); // 添加项目

        System.out.println("\n浅克隆后:");
        System.out.println("原始对象:");
        original.display();
        System.out.println("\n浅克隆对象:");
        shallowCloned.display();

        System.out.println("\n观察：浅克隆共享引用类型对象，修改会相互影响！");

        // 深克隆
        Employee deepCloned = original.deepClone();
        deepCloned.setName("孙七");
        deepCloned.setAge(28);
        deepCloned.getAddress().setCity("广州"); // 修改地址
        deepCloned.addProject("物流系统"); // 添加项目

        System.out.println("\n深克隆后:");
        System.out.println("原始对象:");
        original.display();
        System.out.println("\n深克隆对象:");
        deepCloned.display();

        System.out.println("\n观察：深克隆完全独立，修改不会相互影响！");
    }
}

  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
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

/**
 * 抽象形状原型
 */
public abstract class Shape implements Cloneable {
    protected String type;
    protected String color;

    public Shape(String type, String color) {
        this.type = type;
        this.color = color;
    }

    public abstract void draw();
    public abstract Shape clone() throws CloneNotSupportedException;

    public String getType() { return type; }
    public String getColor() { return color; }
    public void setColor(String color) { this.color = color; }
}

/**
 * 圆形原型
 */
public class Circle extends Shape {
    private int radius;

    public Circle(String color, int radius) {
        super("Circle", color);
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("绘制 " + color + " 圆形，半径: " + radius);
    }

    @Override
    public Circle clone() throws CloneNotSupportedException {
        return (Circle) super.clone();
    }

    public int getRadius() { return radius; }
    public void setRadius(int radius) { this.radius = radius; }
}

/**
 * 矩形原型
 */
public class Rectangle extends Shape {
    private int width;
    private int height;

    public Rectangle(String color, int width, int height) {
        super("Rectangle", color);
        this.width = width;
        this.height = height;
    }

    @Override
    public void draw() {
        System.out.println("绘制 " + color + " 矩形，宽: " + width + ", 高: " + height);
    }

    @Override
    public Rectangle clone() throws CloneNotSupportedException {
        return (Rectangle) super.clone();
    }

    public int getWidth() { return width; }
    public void setWidth(int width) { this.width = width; }

    public int getHeight() { return height; }
    public void setHeight(int height) { this.height = height; }
}

/**
 * 原型管理器 - 管理所有原型对象
 */
public class ShapePrototypeManager {
    private Map<String, Shape> prototypes = new HashMap<>();
    private static ShapePrototypeManager instance = new ShapePrototypeManager();

    private ShapePrototypeManager() {
        // 初始化预定义的原型
        loadPrototypes();
    }

    public static ShapePrototypeManager getInstance() {
        return instance;
    }

    private void loadPrototypes() {
        // 预设一些常用的原型
        prototypes.put("red-circle", new Circle("红色", 10));
        prototypes.put("blue-circle", new Circle("蓝色", 15));
        prototypes.put("green-rectangle", new Rectangle("绿色", 20, 30));
        prototypes.put("yellow-rectangle", new Rectangle("黄色", 25, 35));

        System.out.println("原型管理器初始化完成，加载了 " + prototypes.size() + " 个原型");
    }

    // 注册新原型
    public void addPrototype(String key, Shape prototype) {
        prototypes.put(key, prototype);
        System.out.println("注册新原型: " + key);
    }

    // 根据key克隆原型
    public Shape createShape(String prototypeKey) throws CloneNotSupportedException {
        Shape prototype = prototypes.get(prototypeKey);
        if (prototype != null) {
            return prototype.clone();
        }
        throw new IllegalArgumentException("找不到原型: " + prototypeKey);
    }

    // 列出所有可用原型
    public void listPrototypes() {
        System.out.println("=== 可用原型列表 ===");
        for (String key : prototypes.keySet()) {
            Shape shape = prototypes.get(key);
            System.out.println(key + " -> " + shape.getType() + " (" + shape.getColor() + ")");
        }
    }
}

// 原型管理器使用示例
public class PrototypeManagerDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        System.out.println("=== 原型管理器模式演示 ===");

        ShapePrototypeManager manager = ShapePrototypeManager.getInstance();

        // 显示所有可用原型
        manager.listPrototypes();

        System.out.println("\n=== 克隆形状 ===");

        // 克隆红色圆形
        Shape redCircle1 = manager.createShape("red-circle");
        Shape redCircle2 = manager.createShape("red-circle");

        redCircle1.draw();
        redCircle2.draw();

        // 验证是不同的对象
        System.out.println("两个红色圆形是不同对象: " + (redCircle1 != redCircle2));

        // 克隆并修改属性
        Circle blueCircle = (Circle) manager.createShape("blue-circle");
        blueCircle.setRadius(25);
        blueCircle.draw();

        // 注册自定义原型
        Circle purpleCircle = new Circle("紫色", 8);
        manager.addPrototype("purple-circle", purpleCircle);

        Shape clonedPurple = manager.createShape("purple-circle");
        clonedPurple.draw();

        System.out.println("\n=== 批量创建形状 ===");
        String[] shapeKeys = {"red-circle", "blue-circle", "green-rectangle", "yellow-rectangle"};

        for (String key : shapeKeys) {
            Shape shape = manager.createShape(key);
            shape.draw();
        }
    }
}

  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
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104

/**
 * 数据库查询结果原型
 */
public class QueryResult implements Cloneable {
    private String sql;
    private List<Map<String, Object>> data;
    private long executeTime;
    private Date queryTime;

    public QueryResult(String sql) {
        this.sql = sql;
        this.data = new ArrayList<>();
        this.queryTime = new Date();

        // 模拟耗时的数据库查询
        executeQuery();
    }

    private void executeQuery() {
        System.out.println("执行数据库查询: " + sql);
        // 模拟查询耗时
        try {
            Thread.sleep(1000); // 模拟1秒查询时间
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        // 模拟查询结果
        for (int i = 1; i <= 5; i++) {
            Map<String, Object> row = new HashMap<>();
            row.put("id", i);
            row.put("name", "用户" + i);
            row.put("email", "user" + i + "@example.com");
            data.add(row);
        }

        executeTime = System.currentTimeMillis();
        System.out.println("查询完成，返回 " + data.size() + " 条记录");
    }

    @Override
    public QueryResult clone() throws CloneNotSupportedException {
        QueryResult cloned = (QueryResult) super.clone();

        // 深克隆数据列表
        cloned.data = new ArrayList<>();
        for (Map<String, Object> row : this.data) {
            cloned.data.add(new HashMap<>(row));
        }

        // 克隆时间对象
        cloned.queryTime = new Date(this.queryTime.getTime());

        System.out.println("克隆查询结果完成，避免了重新执行数据库查询");
        return cloned;
    }

    public void displayResult() {
        System.out.println("=== 查询结果 ===");
        System.out.println("SQL: " + sql);
        System.out.println("查询时间: " + queryTime);
        System.out.println("执行耗时: " + executeTime + "ms");
        System.out.println("结果数据:");
        for (Map<String, Object> row : data) {
            System.out.println("  " + row);
        }
    }

    // 修改数据的方法
    public void updateUserName(int id, String newName) {
        for (Map<String, Object> row : data) {
            if (Objects.equals(row.get("id"), id)) {
                row.put("name", newName);
                break;
            }
        }
    }
}

// 数据库查询结果克隆演示
public class DatabaseQueryDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        System.out.println("=== 数据库查询结果克隆演示 ===");

        // 首次查询（耗时操作）
        System.out.println("\n1. 首次执行查询:");
        QueryResult originalResult = new QueryResult("SELECT * FROM users WHERE active = 1");
        originalResult.displayResult();

        // 克隆查询结果（避免重新查询）
        System.out.println("\n2. 克隆查询结果:");
        QueryResult clonedResult = originalResult.clone();

        // 修改克隆的结果
        clonedResult.updateUserName(1, "管理员");
        System.out.println("\n3. 修改克隆结果后:");

        System.out.println("原始结果:");
        originalResult.displayResult();

        System.out.println("\n克隆结果:");
        clonedResult.displayResult();
    }
}

  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
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215

/**
 * 图形元素抽象原型
 */
public abstract class GraphicElement implements Cloneable {
    protected int x, y; // 位置
    protected String color;
    protected int width, height; // 尺寸

    public GraphicElement(int x, int y, String color, int width, int height) {
        this.x = x;
        this.y = y;
        this.color = color;
        this.width = width;
        this.height = height;
    }

    public abstract void render();
    public abstract GraphicElement clone() throws CloneNotSupportedException;

    // 移动元素
    public void moveTo(int newX, int newY) {
        this.x = newX;
        this.y = newY;
    }

    // getter和setter方法
    public int getX() { return x; }
    public int getY() { return y; }
    public String getColor() { return color; }
    public void setColor(String color) { this.color = color; }
    public int getWidth() { return width; }
    public int getHeight() { return height; }
}

/**
 * 文本框元素
 */
public class TextBox extends GraphicElement {
    private String text;
    private String font;
    private int fontSize;

    public TextBox(int x, int y, String color, int width, int height,
                   String text, String font, int fontSize) {
        super(x, y, color, width, height);
        this.text = text;
        this.font = font;
        this.fontSize = fontSize;
    }

    @Override
    public void render() {
        System.out.println("渲染文本框:");
        System.out.println("  位置: (" + x + ", " + y + ")");
        System.out.println("  尺寸: " + width + "x" + height);
        System.out.println("  颜色: " + color);
        System.out.println("  文本: " + text);
        System.out.println("  字体: " + font + ", 大小: " + fontSize);
    }

    @Override
    public TextBox clone() throws CloneNotSupportedException {
        return (TextBox) super.clone();
    }

    public String getText() { return text; }
    public void setText(String text) { this.text = text; }

    public String getFont() { return font; }
    public void setFont(String font) { this.font = font; }

    public int getFontSize() { return fontSize; }
    public void setFontSize(int fontSize) { this.fontSize = fontSize; }
}

/**
 * 按钮元素
 */
public class Button extends GraphicElement {
    private String label;
    private String style;

    public Button(int x, int y, String color, int width, int height,
                  String label, String style) {
        super(x, y, color, width, height);
        this.label = label;
        this.style = style;
    }

    @Override
    public void render() {
        System.out.println("渲染按钮:");
        System.out.println("  位置: (" + x + ", " + y + ")");
        System.out.println("  尺寸: " + width + "x" + height);
        System.out.println("  颜色: " + color);
        System.out.println("  标签: " + label);
        System.out.println("  样式: " + style);
    }

    @Override
    public Button clone() throws CloneNotSupportedException {
        return (Button) super.clone();
    }

    public String getLabel() { return label; }
    public void setLabel(String label) { this.label = label; }

    public String getStyle() { return style; }
    public void setStyle(String style) { this.style = style; }
}

/**
 * 图形编辑器 - 使用原型模式复制元素
 */
public class GraphicEditor {
    private List<GraphicElement> elements = new ArrayList<>();
    private GraphicElement clipboard; // 剪贴板

    // 添加元素
    public void addElement(GraphicElement element) {
        elements.add(element);
        System.out.println("添加了新元素到画布");
    }

    // 复制元素到剪贴板
    public void copyElement(int index) throws CloneNotSupportedException {
        if (index >= 0 && index < elements.size()) {
            clipboard = elements.get(index).clone();
            System.out.println("元素已复制到剪贴板");
        }
    }

    // 粘贴元素从剪贴板
    public void pasteElement(int offsetX, int offsetY) throws CloneNotSupportedException {
        if (clipboard != null) {
            GraphicElement newElement = clipboard.clone();
            newElement.moveTo(newElement.getX() + offsetX, newElement.getY() + offsetY);
            elements.add(newElement);
            System.out.println("从剪贴板粘贴了新元素");
        }
    }

    // 渲染所有元素
    public void renderAll() {
        System.out.println("\n=== 画布渲染 ===");
        for (int i = 0; i < elements.size(); i++) {
            System.out.println("元素 " + i + ":");
            elements.get(i).render();
            System.out.println();
        }
    }

    // 批量复制元素（创建网格布局）
    public void createGrid(int sourceIndex, int rows, int cols, int spacingX, int spacingY)
            throws CloneNotSupportedException {
        if (sourceIndex >= 0 && sourceIndex < elements.size()) {
            GraphicElement template = elements.get(sourceIndex);

            for (int row = 0; row < rows; row++) {
                for (int col = 0; col < cols; col++) {
                    if (row == 0 && col == 0) continue; // 跳过原始元素

                    GraphicElement cloned = template.clone();
                    cloned.moveTo(
                        template.getX() + col * spacingX,
                        template.getY() + row * spacingY
                    );
                    elements.add(cloned);
                }
            }
            System.out.println("创建了 " + (rows * cols - 1) + " 个网格布局元素");
        }
    }
}

// 图形编辑器演示
public class GraphicEditorDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        System.out.println("=== 图形编辑器原型模式演示 ===");

        GraphicEditor editor = new GraphicEditor();

        // 创建原始元素
        TextBox titleText = new TextBox(10, 10, "黑色", 200, 30,
                                       "标题文本", "Arial", 16);
        Button submitButton = new Button(50, 100, "蓝色", 100, 40,
                                       "提交", "圆角");

        editor.addElement(titleText);
        editor.addElement(submitButton);

        System.out.println("\n=== 初始画布 ===");
        editor.renderAll();

        // 复制粘贴操作
        System.out.println("=== 复制粘贴操作 ===");
        editor.copyElement(0); // 复制标题文本
        editor.pasteElement(0, 50); // 粘贴到下方

        // 修改粘贴的文本内容
        TextBox copiedText = (TextBox) editor.elements.get(2);
        copiedText.setText("副标题文本");
        copiedText.setColor("灰色");

        System.out.println("\n=== 复制粘贴后画布 ===");
        editor.renderAll();

        // 创建按钮网格
        System.out.println("=== 创建按钮网格 ===");
        editor.createGrid(1, 2, 3, 120, 60); // 基于索引1的按钮创建2行3列网格

        System.out.println("\n=== 最终画布 ===");
        editor.renderAll();
    }
}