咸鱼翻身记

原型模式

1991/6/26 创建型

# 概述

原型模式是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

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

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

# 实现原型模式

我们现在通过一个简单的例子来实现一个原型模式：

//实现Cloneable 接口的原型抽象类Prototype
   class Prototype implements Cloneable {
        //重写clone方法
        public Prototype clone(){
            Prototype prototype = null;
            try{
                prototype = (Prototype)super.clone();
            }catch(CloneNotSupportedException e){
                e.printStackTrace();
            }
            return prototype;
        }
    }
    //实现原型类
    class ConcretePrototype extends Prototype{
        public void show(){
            System.out.println("原型模式实现类");
        }
    }

    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();
            }
        }
    }
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

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

  • 实现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的值也就跟着被修改了。

我们可以通过一个简单的例子来看看普通的对象复制问题：

class Student {
    private String name;

    public String getName() {
        return name;
    }

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

}
public class Test {

    public static void main(String args[]) {
        Student stu1 = new Student();
        stu1.setName("test1");

        Student stu2 = stu1;
        stu2.setName("test2");

        System.out.println("学生1:" + stu1.getName());
        System.out.println("学生2:" + stu2.getName());
    }
}
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

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

学生1:test1
学生2:test2
1
2

然而，实际上是：

学生1:test2
学生2:test2
1
2

通过clone方法复制的对象才是真正的对象复制，clone方法赋值的对象完全是一个独立的对象。刚刚讲过了，Object类的clone方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。我们可以用 clone 方法再实现一遍以上例子。

//学生类实现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
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

运行结果：

学生1:test1
学生2:test2
1
2

# 深拷贝和浅拷贝

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

如果支持，则创建当前对象所属类的一个新对象，并对该对象进行初始化，使得新对象的成员变量的值与当前对象的成员变量的值一模一样，但对于其它对象的引用以及List等类型的成员属性，则只能复制这些对象的引用了。所以简单调用super.clone()这种克隆对象方式，就是一种浅拷贝。

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

//定义学生类
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 setTeacher(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().getName);
        System.out.println("学生" + stu1.getName + "的老师是:" + stu2.getTeacher().getName);
    }
}
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

运行结果：

学生test1的老师是：王老师
学生test2的老师是：王老师
1
2

观察以上运行结果，我们可以发现：在我们给学生2修改老师的时候，学生1的老师也跟着被修改了。这就是浅拷贝带来的问题。

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

public Student clone() {
        Student student = null;
        try {
            student = (Student) super.clone();
            Teacher teacher = this.teacher.clone();//克隆teacher对象
            student.setTeacher(teacher);
            } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            }
            return student;
}
1
2
3
4
5
6
7
8
9
10
11

# 适用场景

前面我详述了原型模式的实现原理，那到底什么时候我们要用它呢？

在不得已需要重复创建大量同一对象时，我们可以使用原型模式，通过clone方法复制对象，这种方式比用new和序列化创建对象的效率要高；

例如，我在开头提到的，循环体内创建对象时，我们就可以考虑用clone的方式来实现。

for(int i=0; i<list.size(); i++){
  Student stu = new Student();
  ...
}
1
2
3
4

我们可以优化为：

Student stu = new Student();
for(int i=0; i<list.size(); i++){
 Student stu1 = (Student)stu.clone();
  ...
}
1
2
3
4
5

除此之外，原型模式在开源框架中的应用也非常广泛。例如Spring中，@Service默认都是单例的。用了私有全局变量，若不想影响下次注入或每次上下文获取bean，就需要用到原型模式，我们可以通过以下注解来实现，@Scope(“prototype”)。

享元模式