原型模式和享元模式，前者是在创建多个实例时，对创建过程的性能进行调优 ；后者是用减
少创建实例的方式，来调优系统性能。这么看，你会不会觉得两个模式有点相互矛盾呢？

在有些场景下，我们需要重复创建多个实例，例如在循环体中赋值一个对象 ，此时我们就可以采用原型模式来优化对象的创建过程；而在有些场景下，我们则可以避免重复创建多个实例，在内存中共享对象就好了

原型模型

原型模型的实现

原型模式是通过给出一个原型对象来指明所创建的对象的类型，然后使用自身实现的克隆接口来复制这个原型对象，该模式就是用这种方式来创建出更多同类型的对象。

**使用这种方式创建新的对象的话，就无需再通过 new 实例化来创建对象了。**这是因为Object 类的 clone 方法是一个本地方法，它可以直接操作内存中的二进制流，所以性能相对 new 实例化来说，更佳

new一个对象和clone一个对象，性能差在哪里呢？上边提到直接从内存复制二进制怎末理解？

答: 一个对象通过new创建的过程为：

1、在内存中开辟一块空间；

2、在开辟的内存空间中创建对象；

3、调用对象的构造函数进行初始化对象。

而一个对象通过clone创建的过程为：

1、根据原对象内存大小开辟一块内存空间；

2、复制已有对象，克隆对象中所有属性值。

相对new来说，clone少了调用构造函数。如果构造函数中存在大量属性初始化或大对象，则使用clone的复制对象的方式性能会好一些。

首先先看一段原型模式的代码

要实现一个原型类，需要具备三个条件：

实现 Cloneable 接口 ：Cloneable 接口与序列化接口的作用类似，它只是告诉虚拟机可

以安全地在实现了这个接口的类上使用 clone 方法。在 JVM 中，只有实现了 Cloneable

接口的类才可以被拷贝，否则会抛出 CloneNotSupportedException 异常。
重写 Object 类中的 clone 方法 ：在 Java 中，所有类的父类都是 Object 类，而 Object

类中有一个 clone 方法，作用是返回对象的一个拷贝。
在重写的 clone 方法中调用 super.clone() ：默认情况下，类不具备复制对象的能力，需

要调用 super.clone() 来实现

从上面我们可以看出，原型模式的主要特征就是使用 clone 方法复制一个对象。通常，有

些人会误以为 Object a=new Object();Object b=a; 这种形式就是一种对象复制的过程，

然而这种复制只是对象引用的复制，也就是 a 和 b 对象指向了同一个内存地址，如果 b 修

改了，a 的值也就跟着被修改了。我们可以通过一个简单的例子来看看普通的对象复制问题：

如果是复制对象，此时打印的日志应该为：

然而，实际上是：

学生 1： test2

学生 2 ：test2

通过 clone 方法复制的对象才是真正的对象复制，clone 方法赋值的对象完全是一个独立
的对象。Object 类的 clone 方法是一个本地方法，它直接操作内存中的二进

制流，特别是复制大对象时，性能的差别非常明显。我们可以用 clone 方法再实现一遍以

上例子

java 复制代码

// 学生类实现 Cloneable 接口
class Student implements Cloneable{
private String name; // 姓名
public String getName() {
return name;
}
public void setName(String name) {
this.name= name;
}
// 重写 clone 方法
public Student clone() {
Student student = null;
try {
student = (Student) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return student;
}
}
public class Test {
public static void main(String args[]) {
Student stu1 = new Student(); // 创建学生 1
stu1.setName("test1");
Student stu2 = stu1.clone(); // 通过克隆创建学生 2
stu2.setName("test2");
System.out.println(" 学生 1:" + stu1.getName());
System.out.println(" 学生 2:" + stu2.getName());
}
}

运行结果：

学生 1：test1

学生 2：test2

深拷贝和浅拷贝

在调用 super.clone() 方法之后，首先会检查当前对象所属的类是否支持 clone，也就是看

该类是否实现了 Cloneable 接口

如果支持，则创建当前对象所属类的一个新对象，并对该对象进行初始化，使得新对象的成

员变量的值与当前对象的成员变量的值一模一样，但对于其它对象的引用以及 List 等类型

的成员属性，则只能复制这些对象的引用了。所以简单调用 super.clone() 这种克隆对象方

式，就是一种浅拷贝。

所以，当我们在使用 clone() 方法实现对象的克隆时，就需要注意浅拷贝带来的问题。我们

再通过一个例子来看看浅拷贝。

java 复制代码

// 定义学生类
class Student implements Cloneable{
private String name; // 学生姓名
private Teacher teacher; // 定义老师类
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Teacher getTeacher() {
return teacher;
}
public void setName(Teacher teacher) {
this.teacher = teacher;
}
//重写克隆方法
public Student clone() {
Student student = null;
try {
student = (Student) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return student;
}
}
// 定义老师类
class Teacher implements Cloneable{
private String name; // 老师姓名
public String getName() {
return name;
}
public void setName(String name) {
this.name= name;
}
// 重写克隆方法，堆老师类进行克隆
public Teacher clone() {
Teacher teacher= null;
try {
teacher= (Teacher) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return student;
}
}
public class Test {
public static void main(String args[]) {
Teacher teacher = new Teacher (); // 定义老师 1
teacher.setName(" 刘老师 ");
Student stu1 = new Student(); // 定义学生 1
stu1.setName("test1");
stu1.setTeacher(teacher);
Student stu2 = stu1.clone(); // 定义学生 2
stu2.setName("test2");
stu2.getTeacher().setName(" 王老师 ");// 修改老师
System.out.println(" 学生 " + stu1.getName + " 的老师是:" + stu1.getTeacher().get
System.out.println(" 学生 " + stu1.getName + " 的老师是:" + stu2.getTeacher().get
}
}

运行结果：

观察以上运行结果，我们可以发现：在我们给学生 2 修改老师的时候，学生 1 的老师也跟

着被修改了。这就是浅拷贝带来的问题。

我们可以通过深拷贝来解决这种问题，其实深拷贝就是基于浅拷贝来递归实现具体的每个对
象，代码如下：

适用场景

在一些重复创建对象的场景下，我们就可以使用原型模式来提高对象的创建性能。例如，在开头提到的，循环体内创建对象时，我们就可以考虑用 clone 的方式来实现。

例如：

可以优化为：

除此之外，原型模式在开源框架中的应用也非常广泛。例如 Spring 中，@Service 默认都

是单例的。用了私有全局变量，若不想影响下次注入或每次上下文获取 bean，就需要用到

原型模式，我们可以通过以下注解来实现，@Scope("prototype")。

以上可能会有这个哥们们不理解比如这个问题

文中说的，@service默认是单例模式，若不想影响下次请求，就要使用原型模式？

**回复：**纠正下，不是每次请求，而是每次bean注入或通过上下文获取bean时。

如果我们使用的是单例，假设有一个全局变量private int a=1，我们通过上下文获取到实例，调用A方法修改了变量a=2，此时下一个通过上下文获取到实例调用B方法获取变量，则a=2。

如果我们使用的是原型模式，假设有一个全局变量private int a=1，我们通过上下文获取到实

例，调用A方法修改了变量a=2，此时下一个通过上下文获取到实例调用B方法获取变量，则还是a=1。