什么是原型模式

原型模式(Prototype Pattern)是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，调用者不需要知道任何创建细节，不调用构造函数，原型模式属于创建型模式。

原型模式示例1

1.标准的原型模式需要先创建一个原型接口

package com.zwx.design.pattern.prototype;

public interface IPrototype {
    IPrototype clone();
}

2.创建一个对象实现原型接口

package com.zwx.design.pattern.prototype.impl;

import com.zwx.design.pattern.prototype.IPrototype;
import java.util.List;

public class PrototypeImplA implements IPrototype{
    private String name;

    private int age;

    private List<String> phoneList;

    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 List<String> getPhoneList() {
        return phoneList;
    }

    public void setPhoneList(List<String> phoneList) {
        this.phoneList = phoneList;
    }

    @Override
    public IPrototype clone() {
        PrototypeImplA prototypeImplA = new PrototypeImplA();
        prototypeImplA.setAge(this.age);
        prototypeImplA.setName(this.name);
        prototypeImplA.setPhoneList(this.phoneList);
        return prototypeImplA;
    }
}

PrototypeImplA实现了接口IPrototype，并且实现了clone方法，返回了一个新的对象

3.编写测试类

package com.zwx.design.pattern.prototype;

import com.zwx.design.pattern.prototype.impl.PrototypeImplA;
import java.util.ArrayList;
import java.util.List;

public class ProtoTypeTest {
    public static void main(String[] args) throws Exception {
        PrototypeImplA prototypeImplA = new PrototypeImplA();
        prototypeImplA.setAge(18);
        prototypeImplA.setName("张三");
        List<String> phoneList = new ArrayList<>();
        phoneList.add("88888888");
        phoneList.add("77777777");
        prototypeImplA.setPhoneList(phoneList);

        PrototypeImplA cloneProtoType = (PrototypeImplA) prototypeImplA.clone();
        System.out.println(prototypeImplA.getPhoneList() == cloneProtoType.getPhoneList());//true
    }
}

最后一个会输出true,这是因为这种克隆方式是浅克隆，对象中如果有引用对象那么被克隆后的对象依然会指向原对象，如果需要复制两个独立的对象，则需要使用深克隆，后面示例2中我们会对比一下两种克隆方式

原型模式示例2

1.创建一个原型对象,实现Cloneable接口

package com.zwx.design.pattern.prototype.impl;

import java.io.*;
import java.util.List;

public class PrototypeB implements Cloneable {
    private String name;

    private int age;

    private List<String> phoneList;

    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 List<String> getPhoneList() {
        return phoneList;
    }

    public void setPhoneList(List<String> phoneList) {
        this.phoneList = phoneList;
    }
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

Object类默认有clone()方法，protected级别，且是浅克隆，如果我们需要使用默认的clone()方法，则必须实现一个Cloneable接口(Cloneable是一个标记接口，类似的还有Serializable等接口)，否则会抛出异常CloneNotSupportedException

2.编写测试类

package com.zwx.design.pattern.prototype;

import com.zwx.design.pattern.prototype.impl.PrototypeB;
import java.util.ArrayList;
import java.util.List;

public class ProtoTypeTest2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        PrototypeB prototypeImplB = new PrototypeB();
        prototypeImplB.setAge(18);
        prototypeImplB.setName("张三");
        List<String> phoneList = new ArrayList<>();
        phoneList.add("88888888");
        phoneList.add("77777777");
        prototypeImplB.setPhoneList(phoneList);

        PrototypeB cloneProtoTypeB = (PrototypeB)prototypeImplB.clone();
        System.out.println(prototypeImplB.getPhoneList() == cloneProtoTypeB.getPhoneList());//true
    }
}

这时候输出的结果还是true，因为上面我们用的是Object自带的clone()方法，默认是浅克隆，那么如何实现深克隆呢？接下来我们对PrototypeB类进行改写。

3.改写PrototypeB 类，实现深克隆

package com.zwx.design.pattern.prototype.impl;

import java.io.*;
import java.util.List;

public class PrototypeB implements Cloneable, Serializable {
    private String name;

    private int age;

    private List<String> phoneList;

    public String getName() {
        return name;
    }

    public void setName(String name) throws CloneNotSupportedException{
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public List<String> getPhoneList() {
        return phoneList;
    }

    public void setPhoneList(List<String> phoneList) {
        this.phoneList = phoneList;
    }
    public Object clone() throws CloneNotSupportedException {
//        return super.clone();
        return this.deepClone();
    }

    public PrototypeB 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);

            PrototypeB clone = (PrototypeB)ois.readObject();
            return clone;
        }catch (Exception e){
            return null;
        }
    }
}

多实现了一个Serializable接口，然后clone()方法中返回了自定义的深克隆方法deepClone()，这时候再运行测试类，返回的就是false！

4.深克隆带来的问题

深克隆会破坏单例对象，所以如果是单例对象我们可以通过两个办法防止破坏：
1、不实现Cloneable接口，使得该类不支持克隆
2、重写clone()方法，并且返回单例对象

原型模式适用场景

1、类初始化消耗资源较多时
2、初始化一个对象时需要非常繁琐的过程时
3、构造函数比较复杂时
4、循环体中生产大量对象时，可读性下降时

原型模式优点

1、当创建一个对象比较复杂时，使用原型对象通常效率会更高

原型模式缺点

1、需要为每个对象配备克隆或者可拷贝的方法
2、对克隆复杂对象或者对克隆出来的对象进行复杂改造时，易带来风险，深克隆、浅克隆要运用得当

总结

原型模式就是如何快速构建对象的方法总结，通过简单工厂将getter、setter封装到某个方法中，实现快速复制。
原型模式到底应该采用浅克隆还是深克隆？这个应根据实际业务场景具体分析，但是即使浅克隆能满足需求，也应该实现Cloneable接口，将clone()方法定义为public，并调用super.clone()返回克隆对象

用原型模式解决重复setter方法

java设计模式之原型模式