常见的设计模式之原型模式

概念

原型模式（Prototype pattern）是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，属于创建者模式
原型模式主要包含三个角色：

• 客户（client）：客户类提供创建对象的请求
• 抽象原型（prototype）：规定拷贝接口
• 具体原型（concrete prototype）：被拷贝的对象

注意：对不通过new关键字，而是通过对象拷贝来实现创建对象的模式就称为原型模式

实现

浅克隆

标准写法

1.创建原型接口

public interface IPrototype<T> {
    T clone();
}

2.创建具体原型

public class ConcretePrototype implements IPrototype {
    int age;
    String name;

    @Override
    public String toString() {
        return "ConcretePrototype{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public ConcretePrototype clone() {
        ConcretePrototype cp=new ConcretePrototype();
        cp.setAge(this.age);
        cp.setName(this.name);
        return cp;
    }
}

3.测试

public class PrototypeTest {
    public static void main(String[] args) {
        //创建原型
        ConcretePrototype cp =new ConcretePrototype();
        cp.setName("tom");
        cp.setAge(21);
        System.out.println(cp);
        //拷贝原型
        ConcretePrototype cloneType=cp.clone();
        System.out.println(cloneType);
    }
}

运行结果：

这时候，有人就问了，这不就是把属性复制放到对象里面么，和原来也没多少差别。确实，上面的赋值过程是我们自己完成的，在实际编码中，我们一般不会浪费做这种浪费体力的劳动。
接下来，我们看原型模式另一种写法

实现JDK中的Cloneable接口

JDK已经帮我们实现了一个线程API，我们只需实现Cloneable接口接口即可

1.创建具体原型

public class ConcretePrototype implements Cloneable {
    int age;
    String name;

    @Override
    public String toString() {
        return "ConcretePrototype{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public ConcretePrototype clone() {
        try {
            return (ConcretePrototype)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

2.测试

public class PrototypeTest {
    public static void main(String[] args) {
        //创建原型
        ConcretePrototype cp =new ConcretePrototype();
        cp.setName("tom");
        cp.setAge(21);
        System.out.println(cp);
        //拷贝原型
        ConcretePrototype cloneType=cp.clone();
        System.out.println(cloneType);
    }
}

运行结果：

接下来，我们在ConcretePrototype 类中添加爱好属性：

public class PrototypeTest {
    public static void main(String[] args) {
        //创建原型
        ConcretePrototype cp =new ConcretePrototype();
        cp.setName("tom");
        cp.setAge(21);
        List<String>hobbies=new ArrayList<String>();
        hobbies.add("书法");
        hobbies.add("绘画");
        cp.setHobbies(hobbies);

        //拷贝原型
        ConcretePrototype cloneType=cp.clone();
        cloneType.getHobbies().add("游泳");
        System.out.println(cp);
        System.out.println(cloneType);
    }
}

运行结果：

我们在给复制对象添加了一项爱好之后发现，原型对象也跟着发生了改变。这显然不符合我们的预期，因为我们希望克隆出来的对象与原型对象之间是两个独立对象，没有任何联系。经过分析发现，原来是hobbies共用了一个地址，也就是说，复制的是引用的地址。这个也就是我们常说的浅克隆

深克隆

通过序列化方式实现：

public class ConcretePrototype implements Serializable {
    int age;
    String name;
    List<String>hobbies;

    @Override
    public String toString() {
        return "ConcretePrototype{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", hobbies=" + hobbies +
                '}';
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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


    public ConcretePrototype 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);
            return (ConcretePrototype)ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

public class PrototypeTest {
    public static void main(String[] args) {
        //创建原型
        ConcretePrototype cp =new ConcretePrototype();
        cp.setName("tom");
        cp.setAge(21);
        List<String>hobbies=new ArrayList<String>();
        hobbies.add("书法");
        hobbies.add("绘画");
        cp.setHobbies(hobbies);

        //拷贝原型
        ConcretePrototype cloneType=cp.deepClone();
        cloneType.getHobbies().add("游泳");
        System.out.println(cp);
        System.out.println(cloneType);
    }
}

运行结果：

深克隆会破坏单例，解决方法也非常简单：禁止深克隆即可。要么我们的单例类不实现Cloneable接口；要么我们从写==clone()方法，在clone()==方法中返回单例对象即可。

在源码中的运用

我们先看Cloneable 接口：

public interface Cloneable {
}

Cloneable 接口很简单，再看一下它的实现类。比如ArrayList类的实现：

public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

总结

优点

1. 提高了性能。比直接new一个对象性能上提升了许多
2. 简化了创建对象的过程

缺点

1. 需要为每一个类配置一个克隆方法
2. 当对已有的类进行改造时，需要修改代码，违背了开闭原则