原型模式和深拷贝，浅拷贝

原型模式

案例引入

克隆羊问题

有一只羊，姓名为tom，年龄为1，颜色为白色，编写程序创建和tom羊属性完全相同的羊。
传统方式解决

代码实现

1. public class Sheep {
2.     private String name;
3.     private int age;
4.     private String color;
6.     public Sheep() {
7.     }
9.     public Sheep(String name, int age, String color) {
10.         this.name = name;
11.         this.age = age;
12.         this.color = color;
13.     }
15.     public String getName() {
16.         return name;
17.     }
19.     public void setName(String name) {
20.         this.name = name;
21.     }
23.     public int getAge() {
24.         return age;
25.     }
27.     public void setAge(int age) {
28.         this.age = age;
29.     }
31.     public String getColor() {
32.         return color;
33.     }
35.     public void setColor(String color) {
36.         this.color = color;
37.     }
38. }
39. //测试
40. public class Client {
41.     public static void main(String[] args) {
42.         Sheep sheep = new Sheep("tom", 1, "白色");
43.         Sheep sheep1 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
44.         Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
45.         Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
46.         /**
47.         *  public String toString() {//Object类的toString()方法
48.         *      return getClass().getName() + "@" + Integer.toHexString(hashCode());//会输出全类名@符还有16进制的hashCode值
49.         *  }
50.         */
51.         System.out.println(sheep);//输出的对象的hashcode的值不相同，输出对象时，会默认的调用对象的toString()方法
52.         System.out.println(sheep1);
53.         System.out.println(sheep2);
54.         System.out.println(sheep3);
55.     }
56. }

复制代码

传统实现方式分析

• 1.优点是好理解，简单易操作。
  
• 2.缺点进行新对象创建时，总是需要重新获取原始对象的属性，如果创建的对象复杂时，效率很低。
  
• 3.缺点，总是需要重新初始化对象(new操作)，而不是动态的根据已有对象去创建，不灵活。
  
• 4.改进思路，Java中Object类是所有类的基类，Object类提供了一个clone()方法，该方法可以将一个Java对象赋值一份，但是需要想使用这个方法的类必须要实现一个Cloneable接口，
  该接口才能复制，且具有复制的能力。
  

原型模式

基本介绍

• 1.原型模式(Prototype Pattern)是指，用原型实例创建对象的种类，并且通过拷贝这些原型，创建新的对象。
  
• 2.原型模式是一种设计型模式，允许一个对象再创建另一个可对象，无需知道创建的细节。
  
• 3.工作原理是，通过将一个原型对象通过clone或者其他自己写的克隆方法，拷贝自身。
  

用原型模式实现案例

1. public class Sheep implements Cloneable{
2.     private String name;
3.     private int age;
4.     private String color;
5.     private String address = "蒙古羊";
6.     private Sheep friend;
8.     public Sheep() {
9.     }
11.     public Sheep(String name, int age, String color) {
12.         this.name = name;
13.         this.age = age;
14.         this.color = color;
15.     }
17.     public String getName() {
18.         return name;
19.     }
21.     public void setName(String name) {
22.         this.name = name;
23.     }
25.     public int getAge() {
26.         return age;
27.     }
29.     public void setAge(int age) {
30.         this.age = age;
31.     }
33.     public String getColor() {
34.         return color;
35.     }
37.     public void setColor(String color) {
38.         this.color = color;
39.     }
41.     public String getAddress() {
42.         return address;
43.     }
45.     public void setAddress(String address) {
46.         this.address = address;
47.     }
49.     public Sheep getFriend() {
50.         return friend;
51.     }
53.     public void setFriend(Sheep friend) {
54.         this.friend = friend;
55.     }
57.     @Override
58.     public String toString() {
59.         return "Sheep{" +
60.                 "name='" + name + '\'' +
61.                 ", age=" + age +
62.                 ", color='" + color + '\'' +
63.                 ", address='" + address + '\'' +
64.                 ", friend=" + friend +
65.                 '}';
66.     }
68.     @Override
69.     protected Object clone() {
70.         Sheep sheep = null;
71.         try{
72.             sheep = (Sheep)super.clone();
73.         }catch (Exception e){
74.             System.out.println(e.getMessage());
75.         }
76.         return sheep;
77.     }
78. }
80. public class Client {
81.     public static void main(String[] args) {
82.         Sheep sheep = new Sheep("tom", 1, "白色");
83.         sheep.setFriend(new Sheep("jack",1,"黑色"));
85.         Sheep sheep1 = (Sheep)sheep.clone();
86.         Sheep sheep2 = (Sheep)sheep.clone();
88.         System.out.println("sheep1=" + sheep1 + "sheep1.friend\n" + sheep1.getFriend().hashCode());//输出的hashCode值相同
89.         System.out.println("sheep2=" + sheep2 + "sheep2.friend\n" + sheep2.getFriend().hashCode());
90.     }
91. }

复制代码

原型模式在Spring框架中的使用

1. //AbstractBeanFactory类doGetBean()的部分代码
2. else if (mbd.isPrototype()) {//判断当前bean是否是原型类型
3.    // It's a prototype -> create a new instance.
4.    Object prototypeInstance = null;
5.    try {
6.       beforePrototypeCreation(beanName);
7.       prototypeInstance = createBean(beanName, mbd, args);
8.    }
9.    finally {
10.       afterPrototypeCreation(beanName);
11.    }
12.    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
13. }

复制代码

深拷贝和浅拷贝

浅拷贝介绍

• 1.浅拷贝，对于基本数据类型的属性，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
  
• 2.对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组，某个类的对象等，浅拷贝会进行引用传递，也就是只是将该成员变量的引用值(内存地址)复制给新的对象。实际上两个对象的该成员变量都指向一个实例。在这种情况下，一个对象对于引用类型的属性的改变，就会影响到另一个对象的引用属性。
  
• 3.前面克隆羊就是浅拷贝。
  
• 4.浅拷贝是使用默认的clone方法来实现 sheep = (sheep) super.clone();
  

深拷贝介绍

• 1.复制对象的所有属性，进行拷贝，就是说，基本数据类型拷贝成员变量值，引用数据类型的属性都申请存储空间，并复制每个引用类型属性所引用的对象，进行拷贝。也就是说对象进行深拷贝要对整个对象(包括对象的引用属性)进行拷贝。
  
• 2.深拷贝实现方式，重写clone()和通过对象序列化和反序列化实现深拷贝(推荐)
  序列化，简单的说，就是将对象存储到磁盘。反序列化，将磁盘存储的对象读取到内存。
  代码演示
  

1. public class Money implements Serializable, Cloneable{
2.     private int account;
4.     @Override
5.     protected Object clone() throws CloneNotSupportedException {
6.         return super.clone();
7.     }
8. }
9. public class Person implements Serializable, Cloneable {
10.     private String name;
11.     private int age;
12.     private Money money;
13.     private static final long serialVersionID = 1L;
15.     public Person(String name, int age, Money money) {
16.         this.name = name;
17.         this.age = age;
18.         this.money = money;
19.     }
21.     public String getName() {
22.         return name;
23.     }
25.     public void setName(String name) {
26.         this.name = name;
27.     }
29.     public int getAge() {
30.         return age;
31.     }
33.     public void setAge(int age) {
34.         this.age = age;
35.     }
37.     public Money getMoney() {
38.         return money;
39.     }
41.     public void setMoney(Money money) {
42.         this.money = money;
43.     }
45.     //1.重写clone方法完成深拷贝
46.     //这种方式存在问题，如果一个类中存在引用属性且没有为该属性复制
47.     //就会导致在进行克隆时会出现NullPointException，可以在clone前进行验证解决
48.     @Override
49.     protected Object clone() throws CloneNotSupportedException {
50.         Person person = null;
51.         //1.完成基本数据类型的clone
52.         person = (Person) super.clone();
53.         //2.对引用类型的属性，进行单独处理
54.         person.money = (Money) money.clone();
55.         return person;
56.     }
58.     //方式2 通过对象的序列化和反序列化实现
59.     public Object deepClone() {
60.         ByteArrayOutputStream bos = null;
61.         ObjectOutputStream oos = null;
62.         ByteArrayInputStream bis = null;
63.         ObjectInputStream ois = null;
64.         Object object = null;
65.         try{
66.             bos = new ByteArrayOutputStream();
67.             oos = new ObjectOutputStream(bos);
68.             oos.writeObject(this);//当前对象序列化到对象输出流中
69.             bis = new ByteArrayInputStream(bos.toByteArray());
70.             ois = new ObjectInputStream(bis);//从输出流中反序列化到输入流中
71.             object = ois.readObject();//读取对象
72.         }catch (IOException | ClassNotFoundException e){
73.             e.printStackTrace();
74.         }finally {
75.             try {
76.                 bos.close();
77.                 oos.close();
78.                 bis.close();
79.                 ois.close();
80.             } catch (IOException e) {
81.                 e.printStackTrace();
82.             }
83.         }
84.         return object;
85.     }
86. }
87. //测试
88. public class TestDeepClone {
89.     public static void main(String[] args) throws CloneNotSupportedException {
90.         Money money = new Money();
91.         Person person = new Person("wind", 27, null);
93.         Person clone = (Person) person.clone();
94. //        Person clone = (Person) person.deepClone();
95.         System.out.println(person.getMoney().hashCode() + "-" + clone.getMoney().hashCode());
96.     }
97. }

复制代码

注意事项和细节

• 1.创建新的对象比较复杂，可以利用原型模式简化对象的创建过程，同时也能提高效率。
  
• 2.不用再重新初始化对象，而是动态的根据对象的运行进行创建。
  
• 3.如果原始对象发送变化(增加或减少属性)，克隆对象的也不要发送变化，无需修改克隆的代码。
  
• 4.实现深拷贝，需要比较复杂的代码。
  
• 5.缺点，要为需要克隆的类，配一个克隆方法，这对新创建的类不难，但是对已有的类，需要修改源代码，违反了ocp。
  只是为了记录自己的学习历程，且本人水平有限，不对之处，请指正。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！