【设计模式】原型模式

介绍

原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

代码演示

简单工厂将getter，setter封装到某个方法中，JDK提供的实现Cloneable 接口，实现快速复制。

浅克隆

案例：孙悟空有他的终极武器，金箍棒，可长可短。有72变，拔一根毫毛就是一只猴子猴孙。

只是利用getter，setter的场景

定义Monkey类，只有名字的属性

@Getter
@Setter
public class Monkey {
    public String name;
}

定义金箍棒的类，金箍棒有高度和重量两个属性

@Getter
@Setter
@AllArgsConstructor
public class JinGuBang {
    //高度
    private int height;
    // 重量
    private int weight;
}

定义孙悟空的类，孙悟空的武器就是金箍棒。

@Getter
@Setter
public class SunWuKong extends Monkey {
    private JinGuBang jinGuBang;

}

孙悟空拔一根毫毛，生出跟自己长得一模一样的猴子猴孙

public class Client {

    public static void main(String[] args) {
        SunWuKong sunwukong = new SunWuKong();
        sunwukong.setName("齐天大圣");
        sunwukong.setJinGuBang(new JinGuBang(1000, 30000));
        // 造一个跟孙悟空一模一样的猴子猴孙
        SunWuKong copy = new SunWuKong();
        copy.setName(sunwukong.getName());
        copy.setJinGuBang(sunwukong.getJinGuBang());

    }
}

我造一只猴子猴孙，我直接通过set，get就可以完成，但是如果我想要造几千只几万只呢？
不着急，请看下面的分解

使用Cloneable的代码

Monkey类，JinGuBang 类与不使用设计模式代码一致。所以下面代码就不贴这两个类了。
孙悟空类

@Getter
@Setter
public class SunWuKong extends Monkey implements Cloneable {
    private JinGuBang jinGuBang;

    @Override
    public Object clone() {
        SunWuKong sunWuKong = new SunWuKong();
        sunWuKong.setName(this.getName());
        sunWuKong.setJinGuBang(this.getJinGuBang());
        return sunWuKong;
    }
}

测试类

public class Client {
    public static void main(String[] args) {
        SunWuKong sunWuKong=new SunWuKong();
        JinGuBang jinGuBang=new JinGuBang(100,3000);
        sunWuKong.setJinGuBang(jinGuBang);
        sunWuKong.setName("齐天大圣");
        SunWuKong copy=(SunWuKong) sunWuKong.clone();

        System.out.println("孙悟空和拷贝的孙悟空指向同一个引用地址嘛？ "+(sunWuKong==copy));
        System.out.println("孙悟空和拷贝的孙悟空有同一根金箍棒嘛？"+(sunWuKong.getJinGuBang()==copy.getJinGuBang()));
        System.out.println("孙悟空的名字和拷贝的孙悟空名字是同一个嘛？" +(sunWuKong.getName()==sunWuKong.getName()));
    }
}

打印结果

孙悟空和拷贝的孙悟空指向同一个引用地址嘛？ false
孙悟空和拷贝的孙悟空有同一根金箍棒嘛？true
孙悟空的名字和拷贝的孙悟空名字是同一个嘛？true

根据打印结果，可以知道，孙悟空和拷贝，两个对象并不是同一个对象，但是他们拥有同一根金箍棒。但是呢，金箍棒只有一根，两个人争着用肯定是会有问题的。

我们再写一个类来验证下，拷贝的金箍棒变了，孙悟空的金箍棒是不是也会变

public class ShadowPrototypeTest {
    public static void main(String[] args) {
        SunWuKong sunWuKong = new SunWuKong();
        sunWuKong.setJinGuBang( new JinGuBang(100, 3000));
        sunWuKong.setName("齐天大圣");

        SunWuKong copy = (SunWuKong) sunWuKong.clone();
        copy.getJinGuBang().setHeight(1);

        System.out.println(JSON.toJSONString(sunWuKong.getJinGuBang()));
    }
}

打印结果

{"height":1,"weight":3000}

浅克隆类图

通过验证，说明，拷贝的孙悟空 金箍棒变大变小了，也会影响到本体的孙悟空。这个时候肯定是会有问题了，先不说金箍棒就只有龙宫有那么一根绝版，就说我们的齐天大圣跟妖怪作战的时候，突然金箍棒受到了其他人的控制，变大变小了，那孙悟空岂不是都要抓狂了。
于是这个时候深克隆来了，深克隆解决了什么问题呢，没错，就是copy的对象，可以跟本体一样拥有一根"金箍棒"，但是他的金箍棒跟本体孙悟空的真的金箍棒可不是同一根。金箍棒全世界就那么一根呐。copy的"金箍棒"可以是一根棍子，可以是其他的。

深克隆

对浅克隆中对金箍棒类进行修改,使用序列化

@Getter
@Setter
@AllArgsConstructor
public class JinGuBang implements  Serializable {
    private static final long serialVersionUID = 1L;

    //高度
    private int height;
    // 重量
    private int weight;

}

对浅克隆中的孙悟空类进行修改,使用序列化，将对象写入到流中

@Getter
@Setter
public class SunWuKong extends Monkey implements Cloneable,Serializable {
    private static final long serialVersionUID = 1L;

    private JinGuBang jinGuBang;

    @Override
    public Object clone() {
        return this.deepClone();
    }

    // 克隆会破坏单例
    private Object deepClone() {
        SunWuKong copy = null;
        ObjectOutputStream out=null;
        ObjectInputStream in=null;

        try {
            //内存中完成操作，对象读写，是通过字节码直接操作
            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
             out = new ObjectOutputStream(byteOut);
            out.writeObject(this);
            ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
             in = new ObjectInputStream(byteIn);

            // 完整的新的对象，new 一个对象
            copy = (SunWuKong) in.readObject();

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally {
            if (out!=null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        return copy;
    }

}

深克隆测试类

public class DeepPrototypeTest {
    public static void main(String[] args) {
        SunWuKong sunWuKong = new SunWuKong();
        sunWuKong.setJinGuBang(new JinGuBang(100, 3000));
        sunWuKong.setName("齐天大圣");

        SunWuKong copy = (SunWuKong) sunWuKong.clone();

        System.out.println("本体的金箍棒引用地址：" + sunWuKong.getJinGuBang());
        if (copy != null) {
            System.out.println("copy的金箍棒引用地址：" + copy.getJinGuBang());
        }

    }
}

打印结果展示

本体的金箍棒引用地址：com.example.teach.designpatterns.prototype.simple.simple1.JinGuBang@5b480cf9
copy的金箍棒引用地址：com.example.teach.designpatterns.prototype.simple.simple1.JinGuBang@4b9af9a9

通过打印结果我们可以看到，本体和拷贝对金箍棒并不是同一根。

深克隆类图

个人的理解是Java中定义的clone()没有深浅克隆之分，都是统一的调用Object的clone方法。

通过深克隆和浅克隆两个模型，可以知道
浅克隆不会克隆原对象中的引用类型，仅仅拷贝了引用类型的指向。
深克隆则拷贝了所有。拷贝的这个对象完全是不一样的对象。深克隆能够做到原对象和新对象之间完全没有影响。

使用场景

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

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

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

应用实例

应用实例：
1:JAVA 中的 Object clone() 方法
2：BeanUtils.copy()
3:JSON.parseObject()
4:Guava
5：spring中的配置scope=“prototype”;
6: ArrayList扩容的时候，调用的grow()方法，里面有一个逻辑是调用到

        elementData = Arrays.copyOf(elementData, newCapacity);

ArrayList 克隆的时候，是对它内部元素一个一个的迭代，再进行赋值

 public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

主要的逻辑在System.arraycopy();

System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));