Design Patterns(三) Prototype

Prototype pattern refers to creating duplicate object while keeping performance in mind. This type of design pattern comes under creational pattern as this pattern provides one of the best ways to create an object.

前言

    原型模式(Prototype Pattern)是用于创建重复的对象,同时又能保证性能。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。例如,一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象,在下一个请求时返回它的克隆,在需要的时候更新数据库,以此来减少数据库调用。

原型模式

介绍:

1) 原型模式(Prototype模式)是指:用原型实例指定创建对象的种类,并且通过拷贝这些原型,创建新的对象;
2) 原型模式是一种创建型设计模式,允许一个对象再创建另外一个可定制的对象,无需知道如何创建的细节;
3) 工作原理是:通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建,即 对象.clone()。

原型式模式-UML图:


代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
import java.io.*;

/**
* @Auther: Arsenal
* @Date: 2020-03-10 20:03
* @Description: 原型模式
* Spring 框架的 scope="prototype" 用到了原型模式
*/
public class Prototype {
public static void main(String[] args) {


Sheep sheep1 = new Sheep("laowang", 18);
Friend friend = new Friend("Friend", 28);
sheep1.setFriend(friend);

//深拷贝法一
//Sheep sheep2 = (Sheep) sheep1.clone();
//深拷贝法二
Sheep sheep2 = (Sheep) sheep1.deepClone();
sheep1.getFriend().setName("Friend Change");
System.out.println("sheep1:" + sheep1);
System.out.println("sheep2:" + sheep2);
System.out.println(sheep1 == sheep2);

}
}

class Sheep implements Serializable, Cloneable {
private String name;
private int age;
public Friend friend;

public Sheep(String name, int age) {
this.name = name;
this.age = age;
}

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 Friend getFriend() {
return friend;
}

public void setFriend(Friend friend) {
this.friend = friend;
}

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

/**
*
* 浅拷贝
* 1) 对于数据类型是基本数据类型的成员变量,浅拷贝会直接进行值传递,也就是将
* 该属性值复制一份给新的对象。
* 2) 对于数据类型是引用数据类型的成员变量,比如说成员变量是某个数组、某个类
* 的对象等,那么浅拷贝会进行引用传递,也就是只是将该成员变量的引用值(内
* 存地址)复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个
* 实例。在这种情况下,在一个对象中修改该成员变量会影响到另一个对象的该成
* 员变量值
* 3) 前面我们克隆羊就是浅拷贝
* 4) 浅拷贝是使用默认的 clone()方法来实现
*
*/
/*@Override
protected Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}*/


/**
* 深拷贝方式一
* 重写clone方法来实现深拷贝
* (不推荐)
*/
@Override
protected Object clone() {
Object deep = null;
try {
deep = super.clone();
Sheep sheep = (Sheep) deep;

//对引用类型的属性,进行单独处理.如果有多个引用类型的话就需要处理多个,所以不推荐
if (friend != null) {
sheep.friend = (Friend) friend.clone();
}
return sheep;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}


/**
* 深拷贝 - 方式2 通过对象的序列化实现 (推荐)
*1) 复制对象的所有基本数据类型的成员变量值
* 2) 为所有引用数据类型的成员变量申请存储空间,并复制每个引用数据类型成员变
* 量所引用的对象,直到该对象可达的所有对象。也就是说,对象进行深拷贝要对
* 整个对象进行拷贝
* 3) 深拷贝实现方式1:重写clone方法来实现深拷贝
* 4) 深拷贝实现方式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);
Sheep copyObj = (Sheep) ois.readObject();
return copyObj;
} catch (Exception e) {
e.printStackTrace();
} finally {
if (ois != null) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}

if (bis != null) {
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}

if (oos != null) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}

if (bos != null) {
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}

}

class Friend implements Serializable, Cloneable {
private String name;
private int id;

public Friend(String name, int id) {
this.name = name;
this.id = id;
}

public String getName() {
return name;
}

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

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

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

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

总结

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

1) 创建新的对象比较复杂时,可以利用原型模式简化对象的创建过程,同时也能够提高效率;
2) 不用重新初始化对象,而是动态地获得对象运行时的状态;
3) 如果原始对象发生变化(增加或者减少属性),其它克隆对象的也会发生相应的变化,无需修改代码;
4) 在实现深克隆的时候可能需要比较复杂的代码;
5) 缺点:需要为每一个类配备一个克隆方法,这对全新的类来说不是很难,但对已有的类进行改造时,需要修改其源代码,违背了ocp原则,这点请同学们注意。

延伸

    原型模式
    Java设计模式(四)之原型模式
    尚硅谷Java设计模式,韩顺平图解java设计模式

Content
  1. 1. 前言
  2. 2. 原型模式
  3. 3. 总结
  4. 4. 延伸