随笔- 71 文章- 2 评论- 1 阅读- 47953

05.（创建型模式）java设计模式之原型模式

一、什么是原型模式

是⼀种对象创建型模式，使⽤原型实例指定创建对象的种类，并且通过拷⻉这些原型创建新的对象，主要⽤于创建重复的对象，同时⼜能保证性能
⼯作原理是将⼀个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷⻉⾃⼰来实现创建过程
应该是最简单的设计模式了，实现⼀个接⼝，重写⼀个⽅法即完成了原型模式

应⽤场景

创建新对象成本较⼤，新的对象可以通过原型模式对已有对象进⾏复制来获得。
如果系统要保存对象的状态，做备份使⽤

二、原型模式的实现方式

模式结构分析：

Prototype: 声明克隆⽅法的接⼝,是所有具体原型类的公共⽗类，Cloneable接⼝。

ConcretePrototype : 具体原型类。

Client: 让⼀个原型对象克隆⾃身从⽽创建⼀个新的对象。

代码实现：

查看代码


@Data
public class Person implements Cloneable, Serializable {
    private String name;
    private int age;
    private List<String> listPhone = new ArrayList<>();
    /*
     * 进行简单的浅复制
     * */
    public Person clone() throws CloneNotSupportedException {
        try {
            return (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            throw e;
        }
    }
    /**
     * 深拷⻉
     *
     * @return
     */
    public Person deepClone() {
        try {
            //输出 序列化
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(this);
            //输⼊ 反序列化
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            Person copyObj = (Person) ois.readObject();
            return copyObj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

测试用例

浅copy：只复制对应的值类型，对于引用类型来说只复制地址。

@Test
public void prototype() throws CloneNotSupportedException {
   //浅复制
    Person person=new Person();
    person.setAge(18);
    person.setName("测试A");
    person.getListPhone().add("phoneA");
    Person personClone= person.clone();
    personClone.getListPhone().add("phoneB");
    System.out.println(person.toString());
    System.out.println(personClone.toString());
    System.out.println(person==personClone);
    System.out.println(person.equals(personClone));
}

测试结果：

Person(name=测试A, age=18, listPhone=[phoneA, phoneB])
Person(name=测试A, age=18, listPhone=[phoneA, phoneB])
false
true

深copy：值与引用类型中的内容一块复制，两个对象之后成为两个完全独立的对象。

@Test
public void prototypeDeep() throws CloneNotSupportedException {
    //深复制
    Person person=new Person();
    person.setAge(18);
    person.setName("测试A");
    person.getListPhone().add("phoneA");
    Person personClone= person.deepClone();
    personClone.getListPhone().add("phoneB");
    System.out.println(person.toString());
    System.out.println(personClone.toString());
    System.out.println(person==personClone);
    System.out.println(person.equals(personClone));
}

Person(name=测试A, age=18, listPhone=[phoneA])
Person(name=测试A, age=18, listPhone=[phoneA, phoneB])
false
false

方法评估：

优点：

当创建新的对象实例较为复杂时，使⽤原型模式可以简化对象的创建过程，可以提⾼新实例的创建效率。
可辅助实现撤销操作，使⽤深克隆的⽅式保存对象的状态，使⽤原型模式将对象复制⼀份并将其状态保存起来，以便在需要的时候使⽤恢复到历史状态。

缺点：

需要为每⼀个类配备⼀个克隆⽅法，对已有的类进⾏改造时，需要修改源代码，违背了“开闭原则”
在实现深克隆时需要编写较为复杂的代码，且当对象之间存在多重的嵌套引⽤时，需要对每⼀层对象对应的类都必须⽀持深克隆

三、JAVA知识点

Java中的克隆方法：

　Java的所有类都是从java.lang.Object类继承而来的，而Object类提供protected Object clone()方法对对象进行复制，子类当然也可以把这个方法置换掉，提供满足自己需要的复制方法。对象的复制有一个基本问题，就是对象通常都有对其他的对象的引用。当使用Object类的clone()方法来复制一个对象时，此对象对其他对象的引用也同时会被复制一份。

　　Java语言提供的Cloneable接口只起一个作用，就是在运行时期通知Java虚拟机可以安全地在这个类上使用clone()方法。通过调用这个clone()方法可以得到一个对象的复制。由于Object类本身并不实现Cloneable接口，因此如果所考虑的类没有实现Cloneable接口时，调用clone()方法会抛出CloneNotSupportedException异常。

浅克隆和深克隆

　　无论你是自己实现克隆方法，还是采用Java提供的克隆方法，都存在一个浅度克隆和深度克隆的问题。

　　浅度克隆

　　只负责克隆按值传递的数据（比如基本数据类型、String类型），而不复制它所引用的对象，换言之，所有的对其他对象的引用都仍然指向原来的对象。

　　深度克隆

　　除了浅度克隆要克隆的值外，还负责克隆引用类型的数据。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深度克隆把要复制的对象所引用的对象都复制了一遍，而这种对被引用到的对象的复制叫做间接复制。

利用序列化实现深度克隆

　　把对象写到流里的过程是序列化(Serialization)过程；而把对象从流中读出来的过程则叫反序列化(Deserialization)过程。应当指出的是，写到流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。

　　在Java语言里深度克隆一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的拷贝）写到一个流里（序列化），再从流里读回来（反序列化），便可以重建对象。

查看代码

     public  Object deepClone() throws IOException, ClassNotFoundException{
        //将对象写到流里
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        //从流里读回来
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }