Java23种设计模式（GOF）——原型模式

使用场景：通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
实质：该模式实质是使用java中的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具备原型对象的特点。
优势：效率高（直接克隆，避免了重新执行构造过程步骤）。
与new的区别：克隆类似于new，但是不同于new。new创建新的对象属性采用的是默认值。克隆出的对象的属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后，再修改克隆对象的值。

实现方式

Cloneable接口和clone方法
Prototype模式中实现起来最困难的地方就是内存复制操作，所幸在java中提供了clone()方法替我们做了绝大部分的事情。

案例

浅克隆

package edu.yunyu.factory.prototype;

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

/**
 * @author huangyzh
 * @create 2020-05-15 20:10
 */
public class Sheep implements Cloneable{
    private String name;
    private Date birthday;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();//直接调用Object对象的clone()方法
    }

    public Sheep(){}

    public Sheep(String name, Date birthday) {
        this.name = name;
        this.birthday = birthday;
    }
	// 省略 getter setter toString方法
}

package edu.yunyu.factory.prototype;

import java.util.Date;

/**
 * 原型模式 -- 浅克隆
 * @author huangyzh
 * @create 2020-05-15 20:15
 */
public class Test01 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date date = new Date(1248238325832583L);
        Sheep s1 = new Sheep("Bans",date);
        System.out.println(s1);
        Object s2 = s1.clone();

        if(s2 instanceof Sheep){
            s2 = (Sheep)s2;
            System.out.println(s2);

            ((Sheep) s2).setName("Nans");
            System.out.println(s2);
        }

        //以上为浅克隆，date对象进行修改后，s1与s2对象中的时间都被改变，如下代码所示
        date.setTime(3454657457474574745L);

        System.out.println("=======以下代码说明浅克隆遇到对象时，拷贝的是其地址值==========");
        System.out.println(s1);
        System.out.println(s2);

    }
}

深克隆

1）clone方式实现

改造代码

package edu.yunyu.factory.prototype;

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

/**
 * @author huangyzh
 * @create 2020-05-15 20:10
 */
public class Sheep02 implements Cloneable {
    private String name;
    private Date birthday;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();//直接调用Object对象的clone()方法

        //添加如下代码实现深克隆
        Sheep02 s = (Sheep02)obj;
        s.birthday = (Date)this.birthday.clone();//意味着把属性也进行克隆
        return obj;
    }

    public Sheep02(){}

    public Sheep02(String name, Date birthday) {
        this.name = name;
        this.birthday = birthday;
    }
    // 省略 getter setter toString方法
}

package edu.yunyu.factory.prototype;

import java.util.Date;

/**
 * 原型模式 -- 深克隆
 * @author huangyzh
 * @create 2020-05-15 20:15
 */
public class Test02 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date date = new Date(1248238325832583L);
        Sheep02 s1 = new Sheep02("Bans",date);
        System.out.println(s1);
        Object s2 = s1.clone();

        if(s2 instanceof Sheep02){
            s2 = (Sheep02)s2;
            System.out.println(s2);

            ((Sheep02) s2).setName("Nans");
            System.out.println(s2);
        }

        //以上为浅克隆，date对象进行修改后，s1与s2对象中的时间都被改变，如下代码所示
        date.setTime(3454657457474574745L);

        System.out.println("=======以下代码说明深克隆对其属性创建了一个新的时间对象==========");
        System.out.println(s1);
        System.out.println(s2);

    }
}

此时再执行测试代码，克隆的对象与原型对象互不影响。

2）序列化和反序列化实现

package edu.yunyu.factory.prototype;

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

/**
 * @author huangyzh
 * @create 2020-05-15 20:10
 */
public class Sheep03 implements Cloneable, Serializable {
    private String name;
    private Date birthday;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();//直接调用Object对象的clone()方法
    }

    public Sheep03(){}

    public Sheep03(String name, Date birthday) {
        this.name = name;
        this.birthday = birthday;
    }
	// 省略 getter setter toString方法
}

package edu.yunyu.factory.prototype;

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

/**
 * 原型模式 -- 序列化反序列化实现深克隆
 * @author huangyzh
 * @create 2020-05-15 20:15
 */
public class Test03 {
    public static void main(String[] args) throws Exception {
        Date date = new Date(1248238325832583L);
        Sheep03 s1 = new Sheep03("Bans",date);
        System.out.println("原型对象："+s1);
        
        //使用序列化反序列化实现深克隆
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);

        oos.writeObject(s1);
        byte[] bytes = bos.toByteArray();

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

        Sheep03 s2 = (Sheep03)ois.readObject();

        date.setTime(395798437598435934L);
        System.out.println("原型对象："+s1);
        System.out.println("克隆对象："+s2);

    }
}

效率测试

短时间大量创建对象，原型模式和普通new方式效率对比测试

public class Laptop implements Cloneable{
    public Laptop(){
        try {
            //模拟场景对象耗时的过程
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

/**
 * 普通new方式创建对象 和 clone创建对象的效率差异
 * 如果需要短时间创建大量对象，且new对象比较耗时，可以使用原型模式
 * @author huangyzh
 * @create 2020-05-15 21:32
 */
public class Test04 {
    public static void main(String[] args) {
        int size = 1000;
        testClone(size);
        testNew(size);
    }
    public static void testNew(int size){
        long start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            Laptop l = new Laptop();
        }
        long end = System.currentTimeMillis();
        System.out.println("new方式创建耗时时间："+(end-start));
    }

    public static void testClone(int size){
        long start = System.currentTimeMillis();
        Laptop l = new Laptop();
        for (int i = 0; i < size; i++) {
            try {
                Laptop l1 = (Laptop) l.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("clone方式创建耗时时间："+(end-start));
    }
}

应用场景

原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone的方法创建一个对象， 然后由工厂方法提供给调用者。
spring中bean的创建实际就是两种：单例模式和原型模式。（当然，原型模式需要和工厂模式搭配起来）