设计模式之原型模式

设计模式之原型模式

---

什么是原型模式

原型模式：通过new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式
就是java中的克隆技术，以某个对象为原型，复制出新的对象，显新的对象具有原型对象的特点
克隆，类似于new，但是不同于new new创建的对象属性采取默认值，克隆出的对象属性和原型对象相同，并且克隆出的新的对象改变不会影响原型对象。
原型模式的实现，Cloneable接口和clone方法

---

原型模式怎么使用

我们以克隆羊多利为例实现浅复制

import java.util.Date;

public class Sheep implements Cloneable {
    private String name;
    private Date brithday;

    public Sheep(String name, Date brithday) {
        super();
        this.name = name;
        this.brithday = brithday;
    }

    public Sheep() {
        super();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object object = super.clone(); // 调用object的clone 实现克隆
        return object;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name
     *            the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the brithday
     */
    public Date getBrithday() {
        return brithday;
    }

    /**
     * @param brithday
     *            the brithday to set
     */
    public void setBrithday(Date brithday) {
        this.brithday = brithday;
    }
}

package Prototype;

import java.util.Date;

/**
 * 原型模式，克隆模式（浅克隆）
 */
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date date = new Date();
        Sheep sheep = new Sheep("多利的原型", date);
        Sheep sheep2 = (Sheep) sheep.clone();

        System.out.println(sheep);
        System.out.println(sheep.getName());
        System.out.println(sheep.getBrithday());

        date.setTime(43243151543252L);
        System.out.println(sheep.getBrithday());

        sheep2.setName("多利");
        System.out.println();
        System.out.println("---------克隆后--------------");
        System.out.println(sheep2);
        System.out.println(sheep2.getName());
        System.out.println(sheep2.getBrithday());

    }
}
//Prototype.Sheep@2a139a55
//多利的原型
//Fri Apr 21 10:04:39 GMT+08:00 2017
//Wed Apr 27 18:32:23 GMT+08:00 3340
//
//---------克隆后--------------
//Prototype.Sheep@70dea4e
//多利
//Wed Apr 27 18:32:23 GMT+08:00 3340


//浅复制共用一个date对象，当date对象修改时克隆对象也被修改

---

深复制（将属性也进行克隆）

package Prototype;

import java.util.Date;

public class Sheep2 implements Cloneable{
    private String name;
    private Date brithday;

    public Sheep2(String name, Date brithday) {
        super();
        this.name = name;
        this.brithday = brithday;
    }

    public Sheep2() {
        super();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object object = super.clone(); // 调用object的clone 实现克隆
        Sheep2 sheep2 = (Sheep2) object;
        sheep2.brithday = (Date) this.brithday.clone();//将date进行可克隆
        return object;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name
     *            the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the brithday
     */
    public Date getBrithday() {
        return brithday;
    }

    /**
     * @param brithday
     *            the brithday to set
     */
    public void setBrithday(Date brithday) {
        this.brithday = brithday;
    }
}

package Prototype;

import java.util.Date;

/**
 *  原型模式，（深复制）
 */
public class Client2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date date = new Date();
        Sheep2 sheep = new Sheep2("多利的原型", date);
        Sheep2 sheep2 = (Sheep2) sheep.clone();

        System.out.println(sheep);
        System.out.println(sheep.getName());
        System.out.println(sheep.getBrithday());

        date.setTime(43243151543252L);
        System.out.println(sheep.getBrithday());

        sheep2.setName("多利");
        System.out.println();
        System.out.println("---------克隆后--------------");
        System.out.println(sheep2);
        System.out.println(sheep2.getName());
        System.out.println(sheep2.getBrithday());
    }

}
//Prototype.Sheep2@2a139a55
//多利的原型
//Fri Apr 21 10:13:18 GMT+08:00 2017
//Wed Apr 27 18:32:23 GMT+08:00 3340
//
//---------克隆后--------------
//Prototype.Sheep2@70dea4e
//多利
//Fri Apr 21 10:13:18 GMT+08:00 2017

//深复制，将date属性进行复制，改变date之后克隆对象的date不变，克隆之后为两个date对象

用序列化反序列化实现深克隆

package Prototype;

import java.io.Serializable;
import java.util.Date;

public class Sheep implements Cloneable,Serializable{
    private String name;
    private Date brithday;

    public Sheep(String name, Date brithday) {
        super();
        this.name = name;
        this.brithday = brithday;
    }

    public Sheep() {
        super();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object object = super.clone(); // 调用object的clone 实现克隆
        return object;
    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name
     *            the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the brithday
     */
    public Date getBrithday() {
        return brithday;
    }

    /**
     * @param brithday
     *            the brithday to set
     */
    public void setBrithday(Date brithday) {
        this.brithday = brithday;
    }
}

package Prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

public class Client3 {
    public static void main(String[] args) throws Exception {
        Date date = new Date();
        Sheep sheep = new Sheep("多利的原型", date);


        System.out.println(sheep);
        System.out.println(sheep.getName());
        System.out.println(sheep.getBrithday());
        //用序列化和反序列化实现深复制
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(sheep);
        byte[] bytes = bos.toByteArray();


        ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
        ObjectInputStream ois = new ObjectInputStream(bis);

        Sheep sheep2 = (Sheep) ois.readObject();


        date.setTime(43243151543252L);
        System.out.println(sheep.getBrithday());
        sheep2.setName("多利");
        System.out.println();
        System.out.println("---------克隆后--------------");
        System.out.println(sheep2);
        System.out.println(sheep2.getName());
        System.out.println(sheep2.getBrithday());

    }
}
//Prototype.Sheep@2a139a55
//多利的原型
//Fri Apr 21 10:30:14 GMT+08:00 2017
//Wed Apr 27 18:32:23 GMT+08:00 3340
//
//---------克隆后--------------
//Prototype.Sheep@677327b6
//多利
//Fri Apr 21 10:30:14 GMT+08:00 2017

/**
 *   测试new方式和clone方式创建对象耗时
 *   
 *   如果需要创建多个对象，并且创建的对象比较耗时，可以用原型模式。
 */
public class Client4 {
    public static void main(String[] args) throws CloneNotSupportedException {
        newtest(1000);
        clonetest(1000);
    }

    public static void newtest(int size) {
        long start = System.currentTimeMillis();

        for (int i = 0; i < size; i++) {
            computer c = new computer();
        }

        long end = System.currentTimeMillis();
        System.out.println("new 的方式耗时" + (end - start));
    }

    public static void clonetest(int size) throws CloneNotSupportedException {
        long start = System.currentTimeMillis();

        computer c = new computer();
        for (int i = 0; i < size; i++) {
            computer c2 = (computer) c.clone();
        }

        long end = System.currentTimeMillis();
        System.out.println("clone" + " 的方式耗时" + (end - start));
    }
}

class computer implements Cloneable {
    public computer() {
        try {
            Thread.sleep(10);
            // 模拟创建对象耗时
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

}
//new 的方式耗时10188
//clone 的方式耗时10

什么时候用原型模式

开发中常见的场景：
一般和工厂方法模式一起出现，通过克隆的方式创建对象，然后由工厂提供给调用者
Spring的bean的创建就是单例模式和克隆模式。

创建型模式：都是用来创建对象的

单利模式：保证类只有一个对象，并且提供一个访问该实例的全局访问点。

工厂模式：
简单工厂模式：用来生产同一等级结构的任意产品（对于新的产品，秀要修改已有的代码）
工厂方法模式：用于生产同一等级结构中的固定产品。（支持增加新产品）
抽象工厂模式：用来生产不同产品族的全部产品。（对于增加新的产品无能为力）
建造者模式：
分离对象的子组建的单独构造（由builder负责）和装配（有Director负责）。从而可以构造出复杂的对象。
原型模式 ：
通过new产生一个需要非常繁琐的数据准备或者访问权限，可以使用原型模式。