设计模式：创建型-原型模式

女爷i 2022-11-05 11:00 132阅读 0赞

### 目录 ###

*  第一章 原型模式介绍
 *  第二章 原型模式实现（浅克隆）
 *  第三章 原型模式实现（深克隆：第一种）
 *  第四章 原型模式实现（深克隆：第二种）
 *  第五章 原型模式应用

--------------------

> 项目地址：https://gitee.com/caochenlei/design-pattern

# 第一章 原型模式介绍 #

原型模式的介绍：

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

在原型模式中的克隆可以细分为“浅克隆”和“深克隆”两种，具体介绍如下：

*  **浅克隆：** 对于数据类型是基本数据类型的成员变量，浅克隆会直接进行值传递，也就是将该属性值复制一份给新的对象。对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅克隆会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
 *  **深克隆：** 复制对象的所有基本数据类型的成员变量值，为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，也就是说，对象进行深克隆要对整个对象（包括对象的引用类型）进行克隆。

原型模式的优点：

*  Java 自带的原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。
 *  可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作。

原型模式的缺点：

*  需要为每一个类都配置一个 clone 方法，clone 方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违背了开闭原则。
 *  配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。
 *  当实现深克隆时，需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦。因此，深克隆、浅克隆需要运用得当。
 *  深克隆会破坏单例，其实防御方式很简单，单例类不要实现 `Cloneable` 接口即可。

原型模式的场景：

*  对象之间相同或相似，即只是个别的几个属性不同的时候。
 *  创建对象成本较大，例如初始化时间长，占用CPU太多，或者占用网络资源太多等，需要优化资源。
 *  创建一个对象需要繁琐的数据准备或访问权限等，需要提高性能或者提高安全性。
 *  系统中大量使用该类对象，且各个调用者都需要给它的属性重新赋值。

# 第二章 原型模式实现（浅克隆） #

**IdCard**

//身份证对象
    class IdCard { 
        private String id;
    
        public IdCard(String id) { 
            this.id = id;
        }
    
        @Override
        public String toString() { 
            return id;
        }
    }

**Person**

**PersonTest**

public class PersonTest { 
        public static void main(String[] args) throws CloneNotSupportedException { 
            //创建一个对象
            Person person = new Person("张三", 20, new IdCard("10086"));
    
            //克隆两个对象
            Person person1 = (Person) person.clone();
            Person person2 = (Person) person.clone();
    
            //打印三人信息
            System.out.println(person);
            System.out.println(person1);
            System.out.println(person2);
        }
    }

**运行效果：**

Person{ personHashCode=460141958, name='张三', age=20, idCard=10086, idCardHashCode=1163157884}
    Person{ personHashCode=1956725890, name='张三', age=20, idCard=10086, idCardHashCode=1163157884}
    Person{ personHashCode=356573597, name='张三', age=20, idCard=10086, idCardHashCode=1163157884}

**解释说明：**

我们发现可以通过实现`implements Cloneable`来完成浅拷贝，基本变量是值传递克隆，而引用对象`IdCard`则是引用传递，这不符合我们面向对象思想，每一个`Person`应该都有一个独立的`IdCard`，而不是共用一个，而要解决这种问题，我们需要使用深克隆。

# 第三章 原型模式实现（深克隆：第一种） #

**IdCard**

//身份证对象
    class IdCard implements Cloneable { 
        private String id;
    
        public IdCard(String id) { 
            this.id = id;
        }
    
        @Override
        public String toString() { 
            return id;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException { 
            return super.clone();
        }
    }

**Person**

//代表人对象
    public class Person implements Cloneable { 
        private String name;
        private int age;
        private IdCard idCard;
    
        public Person(String name, int age, IdCard idCard) { 
            this.name = name;
            this.age = age;
            this.idCard = idCard;
        }
    
        public IdCard getIdCard() { 
            return idCard;
        }
    
        public void setIdCard(IdCard idCard) { 
            this.idCard = idCard;
        }
    
        @Override
        public String toString() { 
            return "Person{" +
                    "personHashCode=" + this.hashCode() +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    ", idCard=" + idCard +
                    ", idCardHashCode=" + idCard.hashCode() +
                    '}';
        }
    
        //深克隆我们需要自己手动实现，在引用对象中也需要实现clone方法
        @Override
        protected Object clone() throws CloneNotSupportedException { 
            //完成对当前基本数据类型
            //注：String类型通过常量赋值时相当于基本数据类型，通过new关键字创建对象时便是引用数据类型
            Object person = super.clone();
    
            //对引用类型进行单独处理
            Person p = (Person) person;
            IdCard idCard = (IdCard) p.getIdCard().clone();//实现自己的克隆
            p.setIdCard(idCard);
    
            return p;
        }
    }

**PersonTest**

**运行效果：**

Person{ personHashCode=460141958, name='张三', age=20, idCard=10086, idCardHashCode=1163157884}
    Person{ personHashCode=1956725890, name='张三', age=20, idCard=10086, idCardHashCode=356573597}
    Person{ personHashCode=1735600054, name='张三', age=20, idCard=10086, idCardHashCode=21685669}

**解释说明：**

使用这种深克隆的方式，完美的解决了当数据类型为引用类型时，只是拷贝原引用对象地址而不是一个全新的引用对象的引用，但是这种实现有一个很大的弊端，需要在每一个对象中都实现`clone`方法，如果类全是你自己写的，那自然没问题，实现一下就行了，不过有点麻烦。但是，如果你引用的是第三方的一个类，无法修改源代码，这种方式，显然就无法实现深克隆了。

# 第四章 原型模式实现（深克隆：第二种） #

**IdCard**

//身份证对象
    class IdCard implements Serializable { 
        private String id;
    
        public IdCard(String id) { 
            this.id = id;
        }
    
        @Override
        public String toString() { 
            return id;
        }
    }

**Person**

//代表人对象
    public class Person implements Serializable { 
        private String name;
        private int age;
        private IdCard idCard;
    
        public Person(String name, int age, IdCard idCard) { 
            this.name = name;
            this.age = age;
            this.idCard = idCard;
        }
    
        public IdCard getIdCard() { 
            return idCard;
        }
    
        public void setIdCard(IdCard idCard) { 
            this.idCard = idCard;
        }
    
        @Override
        public String toString() { 
            return "Person{" +
                    "personHashCode=" + this.hashCode() +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    ", idCard=" + idCard +
                    ", idCardHashCode=" + idCard.hashCode() +
                    '}';
        }
    
        //手动实现深克隆方法
        public Person deepClone() { 
            //创建流对象
            ByteArrayOutputStream bos = null;
            ObjectOutputStream oos = null;
            ByteArrayInputStream bis = null;
            ObjectInputStream ois = null;
    
            try { 
                //序列化
                bos = new ByteArrayOutputStream();
                oos = new ObjectOutputStream(bos);
                oos.writeObject(this);
    
                //反序列化
                bis = new ByteArrayInputStream(bos.toByteArray());
                ois = new ObjectInputStream(bis);
                return (Person) ois.readObject();
            } catch (Exception e) { 
                e.printStackTrace();
                return null;
            } finally { 
                //关闭流
                try { 
                    ois.close();
                    bis.close();
                    oos.close();
                    bos.close();
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            }
        }
    }

**PersonTest**

public class PersonTest { 
        public static void main(String[] args) { 
            //创建一个对象
            Person person = new Person("张三", 20, new IdCard("10086"));
    
            //克隆两个对象
            Person person1 = person.deepClone();
            Person person2 = person.deepClone();
    
            //打印三人信息
            System.out.println(person);
            System.out.println(person1);
            System.out.println(person2);
        }
    }

**运行效果：**

Person{ personHashCode=1300109446, name='张三', age=20, idCard=10086, idCardHashCode=1020371697}
    Person{ personHashCode=20132171, name='张三', age=20, idCard=10086, idCardHashCode=186370029}
    Person{ personHashCode=2094548358, name='张三', age=20, idCard=10086, idCardHashCode=51228289}

**解释说明：**

这种方式我们需要手动编写`deepClone`方法，使用Java流中的序列化与反序列化来实现深克隆，但是这种实现，需要在每一个类中都继承序列化`Serializable`接口，这种方式，如果你调用的是第三方类，也有可能第三方类上没有实现`Serializable`序列化接口，但是一般来说，大多都会实现，总的来说，这种比较推荐使用，而且效率也高，要是真的第三方类没有实现`Serializable`序列化接口，这里可以再提供一种思路，但是不具体实现了，可以借助第三方工具包`fastjson`先将对象转换为`json字符串`，然后再把`json字符串`转为对象，这样也是可以的。

# 第五章 原型模式应用 #

最佳实践：`java.util.ArrayList`

![9c3304a22583e4432778f054520ddd71.png][]

[9c3304a22583e4432778f054520ddd71.png]: /images/20221023/1441b9952ece4291b9054e894bea45f3.png