《设计模式》设计模式的基本原则
《设计模式》单例模式
《设计模式》工厂模式
《设计模式》原型模式
《设计模式》建造者模式
《设计模式》适配器模式
《设计模式》桥接模式
《设计模式》装饰者模式
《设计模式》组合模式
《设计模式》外观模式
《设计模式》享元模式
《设计模式》代理模式
《设计模式》模板方法模式
《设计模式》命令模式
《设计模式》原型模式
定义：
- 原型模式就是指用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。
- 它是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道创建的细节。
- 它的工作原理就是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即
对象.clone().
原型模式的 UML 类图如下所示：
其中：
- Prototype 表示原型类，声明一个克隆自己的接口
- ConcretePrototype 表示具体的原型类，实现一个克隆自己的操作
- Client 让一个原型对象克隆自己，从而创建一个新的对象(属性一样)
原型模式的注意事项：
- 创建新的对象比较复杂时，可以使用原型模式简化对象的创建过程，提高效率。
- 不用重新初始化对象，而是动态地获得对象运行时的状态。
- 如果原始对象属性发生变化，其他克隆对象也会发生变化，而无需修改代码。
- 原型模式默认使用浅拷贝克隆对象，如果想实现深拷贝，推荐使用对象序列化方式。
现在有一只羊，姓名为 tom，年龄为1，颜色为白色，需要编写程序创建 10 只和 tom 羊属性完全相同的羊。
使用传统方式对问题进行分析，其 UML 图如下所示：
Sheep 类
public class Sheep {
private String name;
private int age;
private String 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;
}
public Sheep(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
}
Client 类
public class Client {
public static void main(String[] args) {
Sheep sheep = new Sheep("tom", 1, "白色");
Sheep sheep1 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
//...
}
}
传统实现方式的优点是简单易操作，也很容易理解。但是，在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较为低下。此外，总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活。
使用原型模式解决这个问题，需要让 Sheep 类实现 Cloneable 接口中的 clone 方法，这样就可以让 Sheep 类具有复制的能力，让程序具有更高的效率和扩展性。
扫描二维码关注公众号，回复：
14813364 查看本文章
Sheep 类
public class Sheep implements Cloneable{
private String name;
private int age;
private String color;
public Sheep friend; //默认是浅拷贝,直接拷贝地址
private String address = "山羊";
@Override
public Object clone() {
Sheep sheep = null;
try {
sheep = (Sheep) super.clone(); //默认是浅拷贝,直接拷贝地址
} catch (Exception e) {
e.printStackTrace();
}
return sheep;
}
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age=" + age +
", color='" + color + '\'' +
", address='" + address + '\'' +
'}';
}
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;
}
public Sheep(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
}
Client 类
public class Client {
public static void main(String[] args) {
Sheep sheep = new Sheep("tom", 1, "白色");
sheep.friend = new Sheep("jack", 2, "黑色");
Sheep sheep1 = (Sheep) sheep.clone(); //sheep1 != sheep,但是 sheep.friend==sheep1.friend
Sheep sheep2 = (Sheep) sheep.clone(); //sheep2 != sheep,但是 sheep.friend==sheep2.friend
Sheep sheep3 = (Sheep) sheep.clone();
}
}
以上就是使用原型模式解决克隆羊问题的具体实现。
原型模式在 Spring 框架中也有应用， AbstractBeanFactory 类中的 doGetBean 方法部分代码如下：
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
if (mbd.isSingleton()) {
sharedInstance = this.getSingleton(beanName, () -> {
try {
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
var11 = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
//...
}
//...
}