原型模式

原型模式

应用场景：

  原型模式就是从一个对象再创建另外一个可定制的对象， 而且不需要知道任何创建的细节。
  所谓原型模式， 就是 Java 中的克隆技术， 以某个对象为原型。 复制出新的对象。 显然新的对象具备原型对象的特点， 效率高（避免了重新执行构造过程步骤） 。
  在MVC架构中的DTO、VO、POJO、Entity之间的相互赋值，就是用到了原型模式；Spring中BeanDefination类也是用到了原型模式，这个我会在之后Spring源码专题中再说。

实现：

  谈到拷贝，自然要提及浅拷贝与深拷贝。
  浅拷贝与深拷贝区别：
  对于数据类型是引用类型的成员变量，浅拷贝只是将内存地址复制一份给新对象。
这种情况下，修改一个对象的成员变量会影响另一个对象的成员变量。

浅拷贝

public class CloneTest {
    public static void main(String[] args) {
        CloneTarget p = new CloneTarget();
        p.name = "Tom";
        p.target = new CloneTarget();
        System.out.println(p.target);

        try {
            CloneTarget obj =  (CloneTarget) p.clone();
            System.out.println(obj.target);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出结果：

  上述代码中target属性是一个对象（引用类型），浅拷贝拷贝的是对象的内存地址，并没有新创建对象。所以输出的成员变量对象值相同。
  这就存在一个问题：修改一个对象的成员变量会影响另一个对象的成员变量。

  接下来看

深拷贝

  机智的小伙伴肯定会猜到深拷贝的第一种方法：就是逐层进行浅拷贝=深拷贝。
  问题又来了：假如对象的属性很多，属性的层级又很多，那岂不要累死个屁的。。。
  所以我们来介绍另一种方法：没错，就是序列化！

//猴子
public class Monkey {
    public int height;
    public int weight;
    public Date birthday;
}

//金箍棒
public class JinGuBang implements Serializable {
    public float h = 100;
    public float d = 10;

    public void big(){
        this.d *= 2;
        this.h *= 2;
    }

    public void small(){
        this.d /= 2;
        this.h /= 2;
    }
}

//使用clone(),须实现Cloneable接口
public class QiTianDaSheng extends Monkey implements Cloneable,Serializable {

    public JinGuBang jinGuBang;

    public  QiTianDaSheng(){
        //只是初始化
        this.birthday = new Date();
        this.jinGuBang = new JinGuBang();
    }
    
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return this.deepClone();
    }

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

            QiTianDaSheng copy = (QiTianDaSheng)ois.readObject();
            copy.birthday = new Date();
            return copy;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }
}

//测试类
public class Main {
    public static void main(String[] args) {
        QiTianDaSheng qiTianDaSheng = new QiTianDaSheng();

        try {
            QiTianDaSheng clone = (QiTianDaSheng)qiTianDaSheng.clone();
			//比较内存地址
            System.out.println( qiTianDaSheng.jinGuBang == clone.jinGuBang);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出结果：

  由此可知，深拷贝是将数据类型为引用类型的成员变量重新创建，拷贝后互不影响。

反射

  反射的原理与序列化相似，在Spring的BeanDefination中拷贝对象用的就是反射。

一图流