原型模式

一、克隆羊问题

现在有一只羊tom，姓名为tom，年龄为1，颜色为白色，编写程序创建和tom羊属性完全相同的10只羊。

二、传统方式

1.代码实现

public class Client {

    public static void main(String[] args) {
        //传统的方法
        Sheep sheep = new Sheep("tom", 1, "白色");
        Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        System.out.println(sheep);
        System.out.println(sheep2);
        System.out.println(sheep3);
        System.out.println(sheep4);
        System.out.println(sheep5);
    }
}

2.传统方式的优缺点

1）优点是比较好理解，简单易操作。
2）在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低。
3）总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活

三、原型模式（Prototype）

思路：Java中Object类是所有类的根类，Object类提供了一个clone（）方法，该方法可以将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable，该接口表示该类能够复制且具有复制的能力

代码实现

public class Sheep implements Cloneable {
  private String name;
  private int age;
  private String color;
  private String address = "蒙古羊";
  public Sheep friend; //是对象, 克隆是会如何处理
  public Sheep(String name, int age, String color) {
      super();
      this.name = name;
      this.age = age;
      this.color = color;
  }
  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 String getColor() {
      return color;
  }
  public void setColor(String color) {
      this.color = color;
  }

  @Override
  public String toString() {
      return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", address=" + address + "]";
  }
  //克隆该实例，使用默认的clone方法来完成
  @Override
  protected Object clone()  {
      Sheep sheep = null;
      try {
          sheep = (Sheep)super.clone();
      } catch (Exception e) {
          System.out.println(e.getMessage());
      }
      return sheep;
  }
}

四、原型模式在Spring框架中的源码分析

1）Spring中原型bean的创建，就是原型模式的应用

五、浅拷贝和深拷贝

1.浅拷贝的介绍

1）基本数据类型，浅拷贝会直接进行值传递

2）引用数据类型，如数组、对象等，浅拷贝会进行引用传递。这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

3）浅拷贝是使用默认的clone()方法来实现

2.深拷贝的基本介绍

1）基本数据类型，值传递

2）为引用数据类型的成员变量申请存储空间，复制一份相同的出来，修改复制出来的对象不会影响其他的对象

3）深拷贝实现方式1：重写clone方法实现

4）深拷贝实现方式2：通过对象序列化实现深拷贝（推荐）

3.深拷贝应用实例

1）重写clone方法实现深拷贝（多层引用对象时比较麻烦）

2）对象序列化实现（推荐）

/**
 * 深拷贝
 */
public class DeepProtoType implements Serializable, Cloneable{
    
    public String name; //String 属性
    public DeepCloneableTarget deepCloneableTarget;// 引用类型
    public DeepProtoType() {
        super();
    }

    //深拷贝 - 方式 1 使用clone 方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        //这里完成对基本数据类型(属性)和String的克隆
        deep = super.clone(); 
        //对引用类型的属性，进行单独处理
        DeepProtoType deepProtoType = (DeepProtoType)deep;
        deepProtoType.deepCloneableTarget  = (DeepCloneableTarget)deepCloneableTarget.clone();
        
        return deepProtoType;
    }
    
    //深拷贝 - 方式2 通过对象的序列化实现 (推荐)
    
    public Object deepClone() {
        //创建流对象
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        
        try {
            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this); //当前这个对象以对象流的方式输出
            
            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            DeepProtoType copyObj = (DeepProtoType)ois.readObject();
            
            return copyObj;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            //关闭流
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (Exception e2) {
                System.out.println(e2.getMessage());
            }
        }
    }
}

六、原型模式的注意事项和细节

1）创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，提高效率

2）不用重新初始化对象，而是动态的获得对象运行时的状态

3）如果原始对象发生变化（增加或者减少属性），其他克隆对象也会发生相应的变化，无需修改代码。

3.原型模式