Prototype(原型模式)

原型模式

原型模式主要用于对象的创建，使用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

UML类图

原型模式的核心是就是原型类 Prototype，Prototype 类需要具备以下两个条件：

1. 实现 Cloneable 接口：在 Java 中 Cloneable 接口的作用就是在运行时通知虚拟机可以安全地在实现了
   Cloneable 接口的类上使用 clone() 方法，只有在实现了 Cloneable 的类才可以被拷贝，否则在运行时会抛出
   CloneNotSupportedException 异常。
2. 重写 Object 类中的 clone() 方法：Java 中所有类的父类都是 Object，Object 中有一个clone()
   方法用于返回对象的拷贝，但是其作用域 protected，一般的类无法调用，因此，Prototype 类需要将 clone()
   方法的作用域修改为 public。

原型模式的优点与适用场景：

1. 原型模式比 new 方式创建对象的性能要好的多，因为 Object 类的 clone()
   方法是一个本地方法，直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显；

2. 简化对象的创建；
   所以原型模式适合在重复地创建相似对象的场景使用，比如在一个循环体内创建对象，假如对象创建过程比较复杂或者循环次数很多的话，使用原型模式不但可以简化创建过程，而且也可以提供系统的整体性能。

代码实现

浅克隆

	public class Test {
	    public static void main(String[] args) throws Exception {
	        Person p1 = new Person();
	        Person p2 = (Person)p1.clone();
	        System.out.println(p2.age + " " + p2.score);
	        System.out.println(p2.loc);
	
	        System.out.println(p1.loc == p2.loc);
	        p1.loc.street = "sh";
	        System.out.println(p2.loc);
	    }
	}
	
	class Person implements Cloneable {
	    int age = 8;
	    int score = 100;
	
	    Location loc = new Location("bj", 22);
	    @Override
	    public Object clone() throws CloneNotSupportedException {
	        return super.clone();
	    }
	}
	
	class Location {
	    String street;
	    int roomNo;
	
	    @Override
	    public String toString() {
	        return "Location{" +
	                "street='" + street + '\'' +
	                ", roomNo=" + roomNo +
	                '}';
	    }
	
	    public Location(String street, int roomNo) {
	        this.street = street;
	        this.roomNo = roomNo;
	    }
	}
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

结果

	8 100
	Location{street='bj', roomNo=22}
	true
	Location{street='sh', roomNo=22}
1
2
3
4

深克隆

	public class Test {
	    public static void main(String[] args) throws Exception {
	        Person p1 = new Person();
	        Person p2 = (Person)p1.clone();
	        System.out.println(p2.age + " " + p2.score);
	        System.out.println(p2.loc);
	
	        System.out.println(p1.loc == p2.loc);
	        p1.loc.street = "sh";
	        System.out.println(p2.loc);
	    }
	}
	
	class Person implements Cloneable {
	    int age = 8;
	    int score = 100;
	
	    Location loc = new Location("bj", 22);
	    @Override
	    public Object clone() throws CloneNotSupportedException {
	        Person p = (Person)super.clone();
	        p.loc = (Location)loc.clone();
	        return p;
	    }
	}
	
	class Location implements Cloneable {
	    String street;
	    int roomNo;
	
	    @Override
	    public String toString() {
	        return "Location{" +
	                "street='" + street + '\'' +
	                ", roomNo=" + roomNo +
	                '}';
	    }
	
	    public Location(String street, int roomNo) {
	        this.street = street;
	        this.roomNo = roomNo;
	    }
	
	    @Override
	    public Object clone() throws CloneNotSupportedException {
	        return super.clone();
	    }
	}
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

运行结果

	8 100
	Location{street='bj', roomNo=22}
	false
	Location{street='bj', roomNo=22}
1
2
3
4

开发中的应用场景

原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone的方法创建一个对象，然后由工厂方法提供给调用者。
spring中bean的创建实际就是两种：单例模式和原型模式。（原型模式需要和工厂模式搭配起来）