• 原型模式简介

    概念：

    原型模式 (Prototype Pattern)是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而无需依赖于昂贵的实例化过程。该模式基于原型实例生成新的对象，并且可以根据需要进行修改和定制。

    特点：

    1. 通过克隆已有对象来创建新对象，避免了重复的初始化过程。
    2. 可以动态地添加或删除已有的原型。
    3. 提供了一种简单、灵活和高效的方式来创建多个相似对象。

    优点：

    1. 减少了重复代码，提高了代码复用性。
    2. 避免了耗时的实例化操作，提升性能。
    3. 简化了对象创建过程，使得系统更加灵活。

    缺点：

    1. 需要为每个可变属性添加适当的克隆方法，并在每次修改时更新这些方法。
    2. 如果存在循环引用，则需要小心处理克隆过程中可能出现的无限循环问题。

    适用场景：

    1. 当一个系统需要独立于其具体类型创建多个相似但不同配置项或版本时，可以使用原型模式。
    2. 当一个系统需要动态地加载和配置类实例时，可以使用原型模式。

    实现方式：

    浅拷贝：

    直接对目标对象进行浅拷贝，复制基本数据类型的值和引用类型的地址。

    实现原理

    1. 创建一个新对象，并将原始对象中所有的字段值复制给新对象。
    2. 对于基本数据类型，直接进行值复制。
    3. 对于引用类型，只复制其地址而不创建新的实例。

    实现代码:

    1. import java.util.ArrayList;
    2. import java.util.List;
    3.  
    4. class Prototype implements Cloneable {
    5.     private int id;
    6.     private String name;
    7.     private List list;
    8.  
    9.     // 构造函数
    10.  
    11.     public Prototype(int id, String name, List list) {
    12.         this.id = id;
    13.         this.name = name;
    14.         this.list = list;
    15.     }
    16.  
    17.     // Getter 和 Setter
    18.  
    19.  
    20.     public void setList(List list) {
    21.         this.list = list;
    22.     }
    23.  
    24.     public List getList(){
    25.         return this.list;
    26.     }
    27.  
    28.     @Override
    29.     public Prototype clone() throws CloneNotSupportedException {
    30.         return (Prototype) super.clone();
    31.     }
    32. }
    33.  
    34.  
    35. public class Main {
    36.     public static void main(String[] args) {
    37.         List originalList = new ArrayList<>();
    38.         originalList.add("item1");
    39.         originalList.add("item2");
    40.  
    41.         Prototype originalObject = new Prototype(1, "Original", originalList);
    42.  
    43.         try {
    44.             Prototype clonedObject = originalObject.clone();
    45.  
    46.             System.out.println(originalObject == clonedObject); // 输出 false
    47.             System.out.println(originalObject.getList() == clonedObject.getList()); // 输出 true
    48.  
    49.         } catch (CloneNotSupportedException e) {
    50.             e.printStackTrace();
    51.         }
    52.     }
    53. }

    在上述示例中，Prototype 类实现了 Cloneable 接口，并重写了 clone() 方法。通过调用 super.clone() 进行浅拷贝操作，返回一个新的克隆对象。

    接下来我们创建了一个原始对象 originalObject，并进行浅拷贝得到克隆对象 clonedObject。可以观察到两个对象不相等（因为引用地址不同），但是它们共享相同的引用类型字段（即列表），所以对列表的修改会同时影响两个对象。

    存在问题
    由于浅拷贝仅仅是对引用进行了简单地复制操作，并没有创建全新独立的副本，因此可能会导致以下问题：

    1. 如果被复制的引用类型发生改变，那么克隆后得到的副本也会受到影响。
    2. 在多层嵌套结构中，如果某个属性发生改变，则克隆后得到副本中对应属性也会改变。

    深拷贝：

    对目标对象进行深拷贝，复制基本数据类型的值和引用类型的整个对象。

    实现原理

    1. 创建一个新对象，并将原始对象中所有字段值复制给新对象。
    2. 对于基本数据类型，直接进行值复制。
    3. 对于引用类型，在克隆过程中创建该引用类型的全新副本，并将副本赋值给新对象。

    实现代码

    1. import java.util.ArrayList;
    2. import java.util.List;
    3.  
    4. class Prototype implements Cloneable {
    5.     private int id;
    6.     private String name;
    7.     private List list;
    8.  
    9.     // 构造函数
    10.  
    11.     public Prototype(int id, String name, List list) {
    12.         this.id = id;
    13.         this.name = name;
    14.         this.list = list;
    15.     }
    16.  
    17.     // Getter 和 Setter
    18.  
    19.  
    20.     public List getList() {
    21.         return list;
    22.     }
    23.  
    24.     public void setList(List list) {
    25.         this.list = list;
    26.     }
    27.  
    28.     @Override
    29.     public Prototype clone() throws CloneNotSupportedException {
    30.         Prototype clonedObject = (Prototype) super.clone();
    31.         clonedObject.list = new ArrayList<>(this.list); // 创建全新副本
    32.         return clonedObject;
    33.     }
    34. }
    35.  
    36.  
    37. public class Main {
    38.     public static void main(String[] args) {
    39.         List originalList = new ArrayList<>();
    40.         originalList.add("item1");
    41.         originalList.add("item2");
    42.  
    43.         Prototype originalObject = new Prototype(1, "Original", originalList);
    44.  
    45.         try {
    46.             Prototype clonedObject = originalObject.clone();
    47.  
    48.             System.out.println(originalObject == clonedObject); // 输出 false
    49.             System.out.println(originalObject.getList() == clonedObject.getList()); // 输出 false
    50.  
    51.         } catch (CloneNotSupportedException e) {
    52.             e.printStackTrace();
    53.         }
    54.     }
    55. }

    在上述示例中，Prototype 类实现了 Cloneable 接口，并重写了 clone() 方法。通过调用 super.clone() 进行浅拷贝操作，然后对引用类型字段进行深层次克隆。

    接下来我们创建了一个原始对象 originalObject，并进行深拷贝得到克隆对象 clonedObject。可以观察到两个对象完全独立（因为引用地址不同），它们的列表也是独立的副本，所以对列表的修改不会相互影响。

    深拷贝虽然解决了浅拷贝可能带来的问题，但也存在以下问题：

    1. 如果被复制的引用类型内部还包含其他引用类型，则需要递归地进行深层次克隆操作。
    2. 某些类可能无法被序列化或反序列化而导致无法使用标准方法实现深拷贝。

    原型注册表

    使用原型管理器来存储和获取原型实例，可以通过名称或标识符查找并克隆相应的原型。

    实现原理

    1. 创建一个原型注册表类（通常为单例），用于存储和管理多个不同类型的原型对象。
    2. 在注册表中添加方法，用于向注册表中添加、删除或获取指定名称的原型对象。
    3. 当客户端需要创建新对象时，可以通过调用注册表中相应名称的方法来获取对应的克隆副本。

    实现代码

    1. import java.util.ArrayList;
    2. import java.util.List;
    3. import java.util.HashMap;
    4. import java.util.Map;
    5.  
    6. class Prototype implements Cloneable {
    7.     private int id;
    8.     private String name;
    9.     private List list;
    10.  
    11.     // 构造函数
    12.  
    13.     public Prototype(int id, String name, List list) {
    14.         this.id = id;
    15.         this.name = name;
    16.         this.list = list;
    17.     }
    18.  
    19.     // Getter 和 Setter
    20.     public void setName(String name){
    21.         this.name = name;
    22.     }
    23.  
    24.     public String getName() {
    25.         return this.name;
    26.     }
    27.     public List getList() {
    28.         return list;
    29.     }
    30.  
    31.     public void setList(List list) {
    32.         this.list = list;
    33.     }
    34.  
    35.     @Override
    36.     public Prototype clone() throws CloneNotSupportedException {
    37.         Prototype clonedObject = (Prototype) super.clone();
    38.         clonedObject.list = new ArrayList<>(this.list); // 创建全新副本
    39.         return clonedObject;
    40.     }
    41. }
    42.  
    43. class PrototypeRegistry {
    44.     private static PrototypeRegistry instance;
    45.     private Map prototypes;
    46.  
    47.     private PrototypeRegistry() {
    48.         prototypes = new HashMap<>();
    49.     }
    50.  
    51.     public static synchronized PrototypeRegistry getInstance() {
    52.         if (instance == null) {
    53.             instance = new PrototypeRegistry();
    54.         }
    55.         return instance;
    56.     }
    57.  
    58.     public void addPrototype(String name, Prototype prototype) {
    59.         prototypes.put(name, prototype);
    60.     }
    61.  
    62.     public void removePrototype(String name) {
    63.         prototypes.remove(name);
    64.     }
    65.  
    66.     public Prototype getPrototype(String name) throws CloneNotSupportedException {
    67.         Prototype prototype = prototypes.get(name);
    68.         if (prototype != null) {
    69.             return prototype.clone();
    70.         }
    71.         return null;
    72.     }
    73. }
    74.  
    75. public class Main {
    76.     public static void main(String[] args) {
    77. // 创建原始对象并添加到注册表
    78.         List originalList = new ArrayList<>();
    79.         originalList.add("item1");
    80.         originalList.add("item2");
    81.  
    82.         Prototype originalObject = new Prototype(1, "Original", originalList);
    83.  
    84.         PrototypeRegistry registry = PrototypeRegistry.getInstance();
    85.         registry.addPrototype("object1", originalObject);
    86.  
    87. // 从注册表获取副本并进行修改
    88.         try {
    89.             Prototype clonedObject = registry.getPrototype("object1");
    90.  
    91.             if (clonedObject != null) {
    92.                 clonedObject.setName("Cloned");
    93.  
    94.                 System.out.println(originalObject.getName()); // 输出 "Original"
    95.                 System.out.println(clonedObject.getName()); // 输出 "Cloned"
    96.  
    97.                 System.out.println(originalObject.getList() == clonedObject.getList()); // 输出 false
    98.             }
    99.         } catch (CloneNotSupportedException e) {
    100.             e.printStackTrace();
    101.         }
    102.  
    103.     }
    104. }

    在深拷贝实现代码的基础上，我们增加了PrototypeRegistry 类实现了原型注册表的功能。通过使用单例模式保证只有一个注册表实例，并使用 HashMap 存储原型对象。然后创建了一个原始对象 originalObject 并将其添加到注册表中。然后通过调用 getPrototype() 方法从注册表中获取副本，并对副本进行修改。可以观察到两个对象是独立的，对一个对象的修改不会影响到另一个对象。

    序列化与反序列化

    将对象序列化为字节流，然后再反序列化为新对象。

    实现原理

    1. 被克隆的对象必须实现 Serializable 接口。
    2. 序列化：使用 ObjectOutputStream 将对象写入输出流，并将其转换为字节数组。
    3. 反序列化：使用 ObjectInputStream 从输入流中读取字节数组，并将其转换回原始对象。

    实现代码

    1. import java.io.*;
    2. import java.util.ArrayList;
    3. import java.util.List;
    4.  
    5. class Prototype implements Serializable {
    6.     private int id;
    7.     private String name;
    8.     private List list;
    9.  
    10.     // 构造函数
    11.  
    12.     public Prototype(int id, String name, List list) {
    13.         this.id = id;
    14.         this.name = name;
    15.         this.list = list;
    16.     }
    17.  
    18.     // Getter 和 Setter
    19.  
    20.  
    21.     public List getList() {
    22.         return list;
    23.     }
    24.  
    25.     public Prototype deepClone() {
    26.         try {
    27.             ByteArrayOutputStream baos = new ByteArrayOutputStream();
    28.             ObjectOutputStream oos = new ObjectOutputStream(baos);
    29.             oos.writeObject(this);
    30.  
    31.             ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    32.             ObjectInputStream ois = new ObjectInputStream(bais);
    33.             return (Prototype) ois.readObject();
    34.  
    35.         } catch (IOException | ClassNotFoundException e) {
    36.             e.printStackTrace();
    37.         }
    38.  
    39.         return null;
    40.     }
    41. }
    42.  
    43. public class Main {
    44.     public static void main(String[] args) {
    45.         List originalList = new ArrayList<>();
    46.         originalList.add("item1");
    47.         originalList.add("item2");
    48.  
    49.         Prototype originalObject = new Prototype(1, "Original", originalList);
    50.  
    51.         Prototype clonedObject = originalObject.deepClone();
    52.  
    53.         System.out.println(originalObject == clonedObject); // 输出 false
    54.         System.out.println(originalObject.getList() == clonedObject.getList()); // 输出 false
    55.  
    56.     }
    57. }

    在上述示例中，Prototype 类实现了 Serializable 接口，并提供了一个 deepClone() 方法来进行深拷贝。在该方法中，首先将对象写入输出流并转换为字节数组，然后再从输入流中读取字节数组并转换回对象。然后我们创建了一个原始对象 originalObject 并通过调用 deepClone() 方法进行深拷贝得到副本对象 clonedObject。可以观察到两个对象是独立的（因为引用地址不同），它们的列表也是独立的副本，所以对列表的修改不会相互影响。需要注意的是当被克隆的类包含不可被序列化或反序列化的字段（如线程、文件句柄等），则需要采取额外措施来处理这些字段。

  • 相关阅读:
    主机jvisualvm连接到tomcat服务器查看jvm状态
    Java打印输出:8x8x
    网工内推 | 网络工程师，软考证书优先，六险一金，包吃
    掌握Go类型内嵌：设计模式与架构的新视角
    Java设计模式之建造者模式详解（Builder Pattern）
    网站高性能架构设计——高性能数据库集群
    不使用IDE编译和启动main方法
    win操作系统下安装Deepspeed
    视频可回溯系统技术方案vue3+ts+tegg+mysql+redis+oss
    用html编写的简易新闻页面
  • 原文地址：https://blog.csdn.net/aidscooler/article/details/132707425