【3W2H设计模式】- 原型模式

亦凉 2023-09-27 16:51 125阅读 0赞

## 【3W2H设计模式】- 原型模式 ##

#### 一、WHAT 什么是原型模式 ####

原型模式是创建者模式的一种，用于创建重复对象，且能保证性能。它提供了一种创建对象的最佳方式。

原型模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。

#### 二、WHY 为什么用原型模式 ####

原型模式实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。原型模式主要解决在运行期建立和删除原型。

#### 三、WHEN 什么时候用原型模式 ####

1.  资源优化场景。
2.  类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
3.  性能和安全要求的场景。
4.  通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
5.  一个对象多个修改者的场景。
6.  一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
7.  在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。

#### 四、HOW 如何实现原型模式 ####

##### 4.1 类图 #####

![在这里插入图片描述][215dedc1b4d74e5bb6df60abad044eeb.png_pic_center]

##### 4.2、原型模式组成与作用 #####

<table> 
 <thead> 
  <tr> 
   <th>编号</th> 
   <th>组成（角色）</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>抽象原型（Prototype）</td> 
   <td>规定拷贝接口。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>具体原型（Concrete Prototype）</td> 
   <td>被拷贝的对象。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>客户（Client）</td> 
   <td>客户类提出创建对象的请求。</td> 
  </tr> 
 </tbody> 
</table>

##### 4.3、创建者模式代码示例 #####

*  创建一个抽象原型
    
        public interface Prototype{
              
            int id = 0;
            String name = null;
            Prototype clone();
        }
 *  实现原型创建具体的原型
    
        public class ConcretePrototypeA implements Prototype {
              
        
            public int getId() {
              
                return id;
            }
        
            public void setId(int id) {
              
                this.id = id;
            }
        
            public String getName() {
              
                return name;
            }
        
            public void setName(String name) {
              
                this.name = name;
            }
        
            private int id;
            private String name;
        
            @Override
            public ConcretePrototypeA clone() {
              
                ConcretePrototypeA concretePrototype = new ConcretePrototypeA();
                concretePrototype.setId(this.id);
                concretePrototype.setName(this.name);
                return concretePrototype;
            }
        }
    
        /*
         * 继承Prototype并创建类ConcretePrototypeB
         */
        public class ConcretePrototypeB implements Prototype {
              
        
            public int getIdb() {
              
                return idb;
            }
        
            public void setIdb(int idb) {
              
                this.idb = idb;
            }
        
            public String getNameb() {
              
                return nameb;
            }
        
            public void setNameb(String nameb) {
              
                this.nameb = nameb;
            }
        
            public String getValueb() {
              
                return valueb;
            }
        
            public void setValueb(String valueb) {
              
                this.valueb = valueb;
            }
        
            private int idb;
            private String nameb;
            private String valueb;
            @Override
            public ConcretePrototypeB clone() {
              
                ConcretePrototypeB concretePrototype = new ConcretePrototypeB();
                concretePrototype.setIdb(this.idb);
                concretePrototype.setNameb(this.nameb);
                concretePrototype.setValueb(this.valueb);
                return concretePrototype;
            }
 *  使用 *Prototype* 类实现*clone* 对象。
    
        public class Client {
              
            public static void main(String[] args) {
              
                ConcretePrototypeA concreteProductA=new ConcretePrototypeA();
                concreteProductA.setId(100);
                concreteProductA.setName("Clone ConcreteProtoTypeA");
                System.out.println(concreteProductA.getName());
        
                ConcretePrototypeA prototypeA=concreteProductA.clone();
                prototypeA.setId(100);
                prototypeA.setName("Clone PrototypeA");
                System.out.println(prototypeA.getName());
            }
        }

##### 4.4、通过浅拷贝创建新对象 #####

在浅克隆中，如果源对象的成员变量是值类型，将复制一份给克隆对象；如果源对象的成员变量是引用类型，则将引用对象的地址复制一份给目标对象，也就是说源对象和目标对象的成员变量指向相同的内存地址。简言之，浅克隆，当对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员对象并没有复制。

*  ###### 继承Cloneable创建一个类ShallowClone ######
    
        import java.util.List;
        public class ShallowClone implements Cloneable{
              
            private int id;
            private String name;
        
            public int getId() {
              
                return id;
            }
        
            public void setId(int id) {
              
                this.id = id;
            }
        
            public String getName() {
              
                return name;
            }
        
            public void setName(String name) {
              
                this.name = name;
            }
        
            public List<String> getAddr() {
              
                return addr;
            }
        
            public void setAddr(List<String> addr) {
              
                this.addr = addr;
            }
        
            private List<String> addr;
        
            @Override
            public ShallowClone clone() {
              
                try {
              
                    return (ShallowClone) super.clone();
                } catch (CloneNotSupportedException e) {
              
                    throw new AssertionError();
                }
            }
        }
 *  ###### Client实现一个浅拷贝 ######
    
        import java.util.ArrayList;
        import java.util.List;
        public class ShallowCloneClinet {
              
         public static void main(String[] args) {
              
             ShallowClone superClone=new ShallowClone();
             superClone.setId(100);
             superClone.setName("赤木");
             List<String> attrList=new ArrayList<>();
             attrList.add("东京");
             attrList.add("京都");
             superClone.setAddr(attrList);
             System.out.println("superClone Id="+superClone.getId());
             System.out.println("superClone Id="+superClone.getName());
        
             ShallowClone superClone2=superClone.clone();
             superClone2.setId(10000);
             superClone2.setName("赤木");
             System.out.println("superClone2 Id="+superClone2.getId());
             System.out.println("superClone2 Id="+superClone2.getName());
             }
         }
 *  ###### 浅拷贝执行结果![在这里插入图片描述][c1fed54cd1184f6a9c2a01910c9c692d.png_pic_center] ######

##### 4.5、通过序列化深拷贝创建对象 #####

*  ###### 继承Serializable创建SerializableClone ######
    
        import java.io.*;
        
        public class SerializableClone implements Serializable {
              
            private int id;
            private String name;
            public int getId() {
              
                return id;
            }
        
            public void setId(int id) {
              
                this.id = id;
            }
        
            public String getName() {
              
                return name;
            }
        
            public void setName(String name) {
              
                this.name = name;
            }
            public SerializableClone deepClone() throws Exception {
              
                ByteArrayOutputStream buf = new ByteArrayOutputStream();
                // 把流放在 tyr资源块中，程序结束java会自动关闭流资源
                try (ObjectOutputStream outputStream = new ObjectOutputStream(buf)) {
              
                    outputStream.writeObject(this);
                }
                try (ObjectInputStream inputStream = new ObjectInputStream(new ByteArrayInputStream(buf.toByteArray()))) {
              
                    return (SerializableClone) inputStream.readObject();
                }
            }
        }
 *  ###### Client实现一个深拷贝 ######
    
        public class SerializableClient {
              
            public static void main(String[] args) {
              
                SerializableClone clone=new SerializableClone();
                clone.setId(100);
                clone.setName("樱木花道");
                System.out.println("clone->Id:"+clone.getId());
                System.out.println("clone->Name:"+clone.getName());
                try {
              
                    SerializableClone clone2 = clone.deepClone();
                    clone2.setId(1000);
                    clone2.setName("流川枫天");
                    System.out.println("clone2->Id:"+clone2.getId());
                    System.out.println("clone2->Name:"+clone2.getName());
                }catch (Exception e){
              
                    System.out.println(e.getMessage());
                }
            }
        }
 *  ###### 深拷贝执行结果 ######
    
    ![在这里插入图片描述][2b1bf9a1417144f2a4d06c0aa721a18d.png_pic_center]

#### 五、HOW TO CHANGE（原型模式在代码中如何使用） ####

*  ###### OA流程管理中复制功能 ######
 *  ###### 项目管理中复制创建一个新项目 ######
 *  ###### MES系统中BOM复制功能，通过复制功能创建一个类似的BOM ######

[215dedc1b4d74e5bb6df60abad044eeb.png_pic_center]: https://img-blog.csdnimg.cn/215dedc1b4d74e5bb6df60abad044eeb.png#pic_center
[c1fed54cd1184f6a9c2a01910c9c692d.png_pic_center]: https://img-blog.csdnimg.cn/c1fed54cd1184f6a9c2a01910c9c692d.png#pic_center
[2b1bf9a1417144f2a4d06c0aa721a18d.png_pic_center]: https://img-blog.csdnimg.cn/2b1bf9a1417144f2a4d06c0aa721a18d.png#pic_center