原型模式(五)

原型模式

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

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

介绍

意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

主要解决：在运行期建立和删除原型。

何时使用： 1、当一个系统应该独立于它的产品创建，构成和表示时。 2、当要实例化的类是在运行时刻指定时，例如，通过动态装载。 3、为了避免创建一个与产品类层次平行的工厂类层次时。 4、当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

如何解决：利用已有的一个原型对象，快速地生成和原型对象一样的实例。

关键代码： 1、实现克隆操作，在 JAVA 继承 Cloneable，重写 clone()，在 .NET 中可以使用 Object 类的 MemberwiseClone() 方法来实现对象的浅拷贝或通过序列化的方式来实现深拷贝。 2、原型模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些"易变类"拥有稳定的接口。

应用实例： 1、细胞分裂。 2、JAVA 中的 Object clone() 方法。

优点： 1、性能提高。 2、逃避构造函数的约束。

缺点： 1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 2、必须实现 Cloneable 接口。

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

注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。

 

简单案例

package com.tzy.Prototype;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Heaton
 * @date 2018/5/6 23:42
 * @describe 人
 */
public class Person implements Cloneable {
    private String name;
    private int age;
    private String sex;
    private List<String> friends;

    public List<String> getFriends() {
        return friends;
    }

    public void setFriends(List<String> friends) {
        this.friends = friends;
    }

    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Person clone() {
        try {
            Person person = (Person) super.clone();
            if (person.getFriends() == null) {
                return person;
            }
            List<String> newfriends = new ArrayList<String>();
            for (String friend : this.getFriends()) {
                newfriends.add(friend);
            }
            person.setFriends(newfriends);
            return person;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }

}

package com.tzy.Prototype;

import java.util.ArrayList;
import java.util.List;

/**
* @author Heaton
* @date 2018/5/6 23:45
* @describe 测试
*/
public class MainClass {
    public static void main(String[] args) {
//        Person person1 = new Person();
//        person1.setName("lifengxing");
//        person1.setAge(30);
//        person1.setSex("男");
//
//        Person person2 = person1;
////        Person person2 = person1.clone();
//        System.out.println(person1==person2);
//
//        System.out.println(person1.getName());
//        System.out.println(person1.getAge());
//        System.out.println(person1.getSex());
//
//        System.out.println(person2.getName());
//        System.out.println(person2.getAge());
//        System.out.println(person2.getSex());
        
        Person person1 = new Person();
        List<String> friends = new ArrayList<String>();
        friends.add("James");
        friends.add("Yao");

        person1.setFriends(friends);

        Person person2 = person1.clone();

        System.out.println(person1.getFriends());
        System.out.println(person2.getFriends());

        friends.add("Mike");
        person1.setFriends(friends);
        System.out.println(person1.getFriends());
        System.out.println(person2.getFriends());
    }
}

 

 

 继续把一把

应用场景： 原型模式就是从一个对象再创建另外一个可定制的对象， 而且不需要知道任何创建的细节。
所谓原型模式， 就是 Java 中的克隆技术， 以某个对象为原型。 复制出新的对象。 显然新的对象具备原
型对象的特点， 效率高（避免了重新执行构造过程步骤） 。

归类	特点	穷举
创建型模式	首先有一个原型。 数据内容相同， 但对象实例不同（完全两个个体） 。	孙悟空吹毫毛

package com.tzy.Prototype.two;

/**
* @author Heaton
* @date 2018/3/30 0030 14:40
* @describe 克隆实现
*/
public class CloneTarget extends Prototype {

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

}

package com.tzy.Prototype.two;


import java.util.ArrayList;

/**
* @author Heaton
* @date 2018/3/30 0030 14:40
* @describe 克隆模式实现Cloneable接口
*/
public class Prototype implements Cloneable {

    public String name;

    CloneTarget target = null;

    public ArrayList<CloneTarget> list;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

package com.tzy.Prototype.two;


import java.util.ArrayList;

/**
* @author Heaton
* @date 2018/3/30 0030 14:40
* @describe 克隆测试
*/
public class CloneTest {

    public static void main(String[] args) {

        CloneTarget p = new CloneTarget();
        p.name = "Tom";
        p.list = new ArrayList<CloneTarget>();
        p.list.add(new CloneTarget());
        p.target = new CloneTarget();
        System.out.println(p.target);

        try {
            CloneTarget obj =  (CloneTarget) p.clone();
            System.out.println(obj.target);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

成功的浅赋值了。（地址引用的赋值）

那么要产生一个全新的对象呢，我要对象不一样。

package com.tzy.Prototype.two;

import java.util.Date;

/**
* @author Heaton
* @date 2018/3/30 0030 14:51
* @describe 猴子**
*/
public class Monkey {
    public int height;
    public int weight;
    public Date birthday;

}

package com.tzy.Prototype.two;

import java.io.Serializable;

/**
* @author Heaton
* @date 2018/3/30 0030 14:52
* @describe 猴子武器金箍棒
*/
public class JinGuBang implements Serializable {
    public float h = 100;
    public float d = 10;

    public void big(){
        this.d *= 2;
        this.h *= 2;
    }

    public void small(){
        this.d /= 2;
        this.h /= 2;
    }

    @Override
    public String toString() {
        return "JinGuBang{" +
                "h=" + h +
                ", d=" + d +
                '}';
    }
}

package com.tzy.Prototype.two;


import java.io.*;
import java.util.Date;

/**
* @author Heaton
* @date 2018/3/30 0030 14:52
* @describe 猴子变身齐天大圣
*/
public class QiTianDaSheng extends Monkey implements Cloneable,Serializable {

    public JinGuBang jinGuBang;

    public  QiTianDaSheng(){
        //只是初始化
        this.birthday = new Date();
        this.jinGuBang = new JinGuBang();
    }
    //注意深拷贝方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return this.deepClone();
    }


    public Object deepClone(){
        try{

            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);

            QiTianDaSheng copy = (QiTianDaSheng)ois.readObject();
            copy.birthday = new Date();
            return copy;

        }catch (Exception e){
            e.printStackTrace();
            return null;
        }

    }


    public QiTianDaSheng copy(QiTianDaSheng target){

        QiTianDaSheng qiTianDaSheng = new QiTianDaSheng();
        qiTianDaSheng.height = target.height;
        qiTianDaSheng.weight = target.weight;

        qiTianDaSheng.jinGuBang = new JinGuBang();
        qiTianDaSheng.jinGuBang.h = target.jinGuBang.h;
        qiTianDaSheng.jinGuBang.d = target.jinGuBang.d;

        qiTianDaSheng.birthday = new Date();
        return  qiTianDaSheng;
    }

    @Override
    public String toString() {
        return "QiTianDaSheng{" +
                "jinGuBang=" + jinGuBang +
                '}';
    }
}

package com.tzy.Prototype.two;


public class Main {

    public static void main(String[] args) {
        //实现深克隆的方式有很多种，方法一
        QiTianDaSheng q = new QiTianDaSheng();
        try {
            QiTianDaSheng n = (QiTianDaSheng)q.clone();
            System.out.println(q.jinGuBang == n.jinGuBang);
            System.out.println(q == n);
            System.out.println(q);
            System.out.println(n);
        } catch (Exception e) {
            e.printStackTrace();
        }

        //实现深克隆的方式有很多种，方法二
        QiTianDaSheng q1 = new QiTianDaSheng();
        QiTianDaSheng n1 = q1.copy(q1);
        System.out.println(q1.jinGuBang == n1.jinGuBang);
        System.out.println(q1 == n1);
        System.out.println(q1);
        System.out.println(n1);


    }
}

这样就完成了深度复制，对象不同，值一样。两个不同的东西。

还有通过反射等方法实现的，自行扩展了。

 

总结一下，原型模式，可以理解为对象的复制，浅赋值和深复制，代码已经很好的解释了。