設(shè)計(jì)模式中，單例模式應(yīng)該是大家最為熟悉的了，那如果我們需要對一個對象進(jìn)行多次復(fù)制的話，大家會用什么呢？這就要用到今天要講的原型模式了。
簡介
其定義為：
使用原型實(shí)例指定將要創(chuàng)建的對象類型，通過復(fù)制這個實(shí)例創(chuàng)建新的對象。
具體來說就是，通過給出一個原型對象來指明所創(chuàng)建的對象的類型，然后使用自身實(shí)現(xiàn)的克隆接口來復(fù)制這個原型對象，該模式就是用這種方式來創(chuàng)建出更多同類型的對象。
這樣的好處是：
Object 類的 clone() 方法是一個本地方法，它可以直接操作內(nèi)存中的二進(jìn)制流，所以性能相對 new 實(shí)例化來說，更加優(yōu)秀。
一個對象通過 new 實(shí)例化創(chuàng)建過程為：
- 在內(nèi)存中開辟一塊空間。
- 在開辟的內(nèi)存空間中創(chuàng)建對象。
- 調(diào)用對象的構(gòu)造函數(shù)進(jìn)行初始化對象。
而一個對象通過 clone() 創(chuàng)建過程為：
- 根據(jù)原對象內(nèi)存大小開辟一塊內(nèi)存空間。
- 復(fù)制已有對象，克隆對象中所有屬性值。
相對 new 來說，clone() 少了調(diào)用構(gòu)造函數(shù)。如果構(gòu)造函數(shù)中存在大量屬性初始化或大對象，則使用 clone() 的復(fù)制對象的方式性能會好一些。
簡單例子
讓我們通過一個例子來具體了解一下：
/**
* 實(shí)現(xiàn)Cloneable 接口的原型抽象類Prototype
*/
public class Prototype implements Cloneable {
/**
* 重寫 clone() 方法
*/
@Override
public Prototype clone() {
Prototype prototype = null;
try {
prototype = (Prototype) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return prototype;
}
}
/**
* 實(shí)現(xiàn)原型類
*/
public class ConcretePrototype extends Prototype {
public void show() {
System.out.println("原型模式實(shí)現(xiàn)類");
}
}
/**
* 測試類
*/
public class Client {
public static void main(String[] args) {
ConcretePrototype cp = new ConcretePrototype();
for (int i = 0; i < 10; i++) {
ConcretePrototype cloneCp = (ConcretePrototype) cp.clone();
cloneCp.show();
}
}
}
當(dāng)我們實(shí)現(xiàn)原型抽象類時，需要注意三點(diǎn)：
- 實(shí)現(xiàn) Cloneable 接口：Cloneable 接口與序列化接口的作用類似，它只是告訴虛擬機(jī)可以安全地在實(shí)現(xiàn)了這個接口的類上使用 clone() 方法。在 JVM 中，只有實(shí)現(xiàn)了 Cloneable 接口的類才可以被拷貝，否則會拋出 CloneNotSupportedException 異常。
- 重寫 Object 類中的 clone() 方法：在 Java 中，所有類的父類都是 Object 類，而 Object 類中有一個 clone() 方法，作用是返回對象的一個拷貝。
- 在重寫的 clone() 方法中調(diào)用 super.clone()：默認(rèn)情況下，類不具備復(fù)制對象的能力，需要調(diào)用 super.clone() 來實(shí)現(xiàn)。
深拷貝與淺拷貝
談到了拷貝，就不得不說到一個經(jīng)典的問題：深拷貝與淺拷貝，有的地方也叫深克隆與淺克隆。
在上面的原型模式中，在調(diào)用 super.clone() 方法之后，首先會檢查當(dāng)前對象所屬的類是否支持 clone，也就是看該類是否實(shí)現(xiàn)了 Cloneable 接口。
如果支持，則創(chuàng)建當(dāng)前對象所屬類的一個新對象，并對該對象進(jìn)行初始化，使得新對象的成員變量的值與當(dāng)前對象的成員變量的值一模一樣，但對于其它對象的引用以及 List 等類型的成員屬性，則只能復(fù)制這些對象的引用了。所以簡單調(diào)用 super.clone() 這種克隆對象方式，就是一種淺拷貝。
為了讓大家更加清楚淺拷貝的弊端，舉個具體的例子：
Student 類中有一個 Teacher 對象，我們讓這兩個類都實(shí)現(xiàn) Cloneable 接口：
@Getter
@Setter
public class Student implements Cloneable{
/**
* 學(xué)生姓名
*/
private String name;
/**
* 學(xué)生所屬的老師
*/
private Teacher teacher;
/**
* 重寫克隆方法，對學(xué)生進(jìn)行克隆
*/
public Student clone() {
Student student = null;
try {
student = (Student) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return student;
}
}
@Getter
@Setter
public class Teacher implements Cloneable{
/**
* 老師姓名
*/
private String name;
/**
* 重寫克隆方法，對老師類進(jìn)行克隆
*/
public Teacher clone() {
Teacher teacher= null;
try {
teacher= (Teacher) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return teacher;
}
}
測試的時候，我們先定義一個學(xué)生和一個老師，并讓其關(guān)聯(lián)在一起。然后復(fù)制之前的學(xué)生，生成一個新的學(xué)生，修改新學(xué)生的老師。
public class Test {
public static void main(String args[]) {
// 定義老師1
Teacher teacher = new Teacher();
teacher.setName("劉老師");
// 定義學(xué)生1
Student stu1 = new Student();
stu1.setName("test1");
// 老師1和學(xué)生1進(jìn)行關(guān)聯(lián)
stu1.setTeacher(teacher);
// 復(fù)制學(xué)生1，生成學(xué)生2
Student stu2 = stu1.clone();
stu2.setName("test2");
// 修改學(xué)生2的老師
stu2.getTeacher().setName("王老師");
// 查看修改結(jié)果
System.out.println("學(xué)生" + stu1.getName() + "的老師是:" + stu1.getTeacher().getName());
System.out.println("學(xué)生" + stu1.getName() + "的老師是:" + stu2.getTeacher().getName());
}
}
我們想要的結(jié)果是：
學(xué)生test1的老師是：劉老師
學(xué)生test2的老師是：王老師
但實(shí)際結(jié)果是：
學(xué)生test1的老師是：王老師
學(xué)生test2的老師是：王老師
觀察以上運(yùn)行結(jié)果，我們可以發(fā)現(xiàn)：在我們給學(xué)生2修改老師的時候，學(xué)生1的老師也跟著被修改了。這就是淺拷貝帶來的問題。
我們可以通過深拷貝的方式解決這類問題，修改 Student 類的 clone() 方法：
/**
* 重寫克隆方法，對學(xué)生和老師都進(jìn)行克隆
*/
public Student clone() {
Student student = null;
try {
student = (Student) super.clone();
// 克隆 teacher 對象
Teacher teacher = this.teacher.clone();
student.setTeacher(teacher);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return student;
}
此時，我們再次運(yùn)行 Test 中的 main() 方法，就可以得到我們預(yù)想的結(jié)果了。
適用場景
在一些重復(fù)創(chuàng)建對象的場景下，我們就可以使用原型模式來提高對象的創(chuàng)建性能。例如：循環(huán)體內(nèi)創(chuàng)建對象時，我們就可以考慮用 clone() 的方式來實(shí)現(xiàn)。
除此之外，原型模式在開源框架中的應(yīng)用也非常廣泛。例如 Spring 中，@Service 默認(rèn)都是單例的。用了私有全局變量，若不想影響下次注入或每次上下文獲取 bean，就需要用到原型模式，我們可以通過以下注解來實(shí)現(xiàn)，@Scope("prototype")。有興趣的朋友深入了解一下其中的原理。
總結(jié)
原型模式，就是針對需要大量復(fù)制同一對象的場景，比如用戶獲取商品、循環(huán)體內(nèi)創(chuàng)建對象等，都是不錯的選擇，且效率好。
有興趣的話可以訪問我的博客或者關(guān)注我的公眾號、頭條號，說不定會有意外的驚喜。
