Java设计模式之原型模式

概论

什么是原型模式呢？用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。这个模式就叫作原型模式。原型模式属于对象创建者模式。

原型模式示例

 首先我们需要有一个原型。这个原型实现了Cloneable空接口。这是一个标记接口，并无任何的方法。

package com.example.pattern.prototype;

import lombok.*;

import java.io.Serializable;
import java.util.Arrays;
import java.util.List;

@Setter
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class PrototypeClass implements Cloneable {

    private int id;
    private char code;
    private String name;

    private BaseDomain baseDomain;
    private String[] array;

    private List<String> list;


    @Override
    protected PrototypeClass clone() {
        PrototypeClass prototypeClass = null;

        try {
            prototypeClass = (PrototypeClass) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();

        }

        return prototypeClass;
    }


}

第9行-12行：采用lambok注解，简化了简单对象中的繁琐的get，set，带所有参数的构造函数，无参构造函数。

第15-22行：定义了类型为原子类型，复杂对象，已经数组和集合的成员属性。

最后，我们需要增加一个场景类Client：

public class Client {

    public static void main(String[] args) {
        PrototypeClass prototypeClass = new PrototypeClass();
        prototypeClass.setId(123);
        prototypeClass.setCode('A');
        prototypeClass.setName("Tom");
        prototypeClass.setBaseDomain(new BaseDomain());

        String[] array = new String[]{"22222"};
        prototypeClass.setArray(array);

        List<String> list = new ArrayList<String>();
        list.add("CCC");
        prototypeClass.setList(list);

        PrototypeClass cloneClass = prototypeClass.clone();

        cloneClass.setId(456);
        cloneClass.setCode('B');
        cloneClass.setName("Jack");

        System.out.println("prototypeClass.getId() :"+prototypeClass.getId());
        System.out.println("cloneClass.getId():"+cloneClass.getId());

        System.out.println("prototypeClass.getCode() :"+prototypeClass.getCode());
        System.out.println("cloneClass.getCode():"+cloneClass.getCode());

        System.out.println("prototypeClass.getName() :"+prototypeClass.getName());
        System.out.println("cloneClass.getName():"+cloneClass.getName());

        String[] array2 = new String[]{"33333"};
        cloneClass.setArray(array);

        List<String> list2 = new ArrayList<String>();
        list.add("DDDD");
        cloneClass.setList(list);


        System.out.println("prototypeClass.getList().get(0) :"+prototypeClass.getList().get(0));
        System.out.println("cloneClass.getList().get(0) :"+cloneClass.getList().get(0));

        System.out.println("prototypeClass.getArray()[0] :"+prototypeClass.getArray()[0]);
        System.out.println("cloneClass.getArray()[0] :"+cloneClass.getArray()[0]);



    }
}

第17行：调用了对象的clone方法，直接产生一个对象。这就是对象的复制，而不是使用new 指令。使用对象复制的方式，不会调用构造函数。

我们先执行一下打印出来的结果：

prototypeClass.getId() :123
cloneClass.getId():456
prototypeClass.getCode() :A
cloneClass.getCode():B
prototypeClass.getName() :Tom
cloneClass.getName():Jack
prototypeClass.getList().get(0) :CCC
cloneClass.getList().get(0) :CCC
prototypeClass.getArray()[0] :22222
cloneClass.getArray()[0] :22222

 从以上执行结果来看

①：如果成员属性为int char String类型，复制后的对象的属性的改变不会对原始对象的属性产生任何的影响。

②：如果成员属为是List集合，数组，复制后的对象的属性的改变也会和原始对象的属性产生了影响。

这是为什么呢？因为我们在原型中的拷贝方式是浅拷贝。什么是浅拷贝呢？super.clone是谁的方法呢，当然是Object方法的，因为Object是任何类的超类。而Object类提供的clone方法只是拷贝本对象，这个对象的内部成员属性包括数组，集合，引用对象都不拷贝，还是执行原生对象的内部元素地址。因此数组，集合，引用对象都是在原生对象还是拷贝对象中都是共享而存在的。这就是浅拷贝。

浅拷贝的对象中的成员属性还有对象的情况下， 像以上例子中的 BaseDomain。改变了同一个BaseDomian实例的属性name的情况下， 因为是同一个实例，因此也是共享的，一边都变。如果是重新new一个BaseDomain实例，重新对拷贝之后的对象复制，那是互相不干扰的。　

原型模式在源码中的应用

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);
        }
    }

以上是ArrayList的clone方法，我们可以产生了一个list之后，来clone一下，来简化操作，这里用到的是深拷贝。为什么是深拷贝而不是浅拷贝呢？第4-行-5行数组，修改次数再复制，拷贝之后的对象与原来的对象不再持有同一份引用，因此是深拷贝。而且Arrays.copyOf方法中是重新创建的一个新数组。