一天一个设计模式(四) - 原型模式(Prototype)

时间  2019-11-29
标签 一天 1天 一个 设计 模式 原型 prototype 栏目 微服务 繁體版
原文   原文链接

前言

原型模式属于对象的建立模式。经过给出一个原型对象来指明全部建立的对象的类型，而后用这个原型对象提供的复制办法建立出更多同类型的对象。java

原型模式的结构

原型模式要求对象实现一个能够克隆自身的接口(类型)。这样一来，经过原型实例建立新的对象，就不须要关心这个实例自己的类型，只须要实现克隆自身的方法，也而无需再去经过new来建立。编程

原型类型的表现形式

  1. 简单形式
  2. 登记形式

正文

简单形式

相关角色

  1. 客户(Client)角色：客户类提出建立对象的请求；
  2. 抽象原型(Prototype)角色：这是一个抽象角色，一般由一个Java接口或者Java抽象类实现。此角色定义了的具体原型类所需的实现的方法。
  3. 具体原型(Concrete Prototype)角色：此角色须要实现抽象原型角色要求的克隆相关的接口。

示例代码

Prototype.java后端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
/**
 * 抽象原型角色
 */
public abstract class Prototype {
 private String id;

 public Prototype(String id) {
 this.id = id;
 }

 public String getId() {
 return id;
 }

 public void setId(String id) {
 this.id = id;
 }

 /**
 * 克隆自身的方法
 * @return 一个从自身克隆出来的对象。
 */
 public abstract Prototype clone();
}

ConcretePrototype1.java缓存

1
2
3
4
5
6
7
8
9
10
 
public class ConcretePrototype1 extends Prototype {
 public ConcretePrototype1(String id) {
 super(id);
 }

 public Prototype clone() {
 Prototype prototype = new ConcretePrototype1(this.getId());
 return prototype;
 }
}

ConcretePrototype2.java多线程

1
2
3
4
5
6
7
8
9
10
 
public class ConcretePrototype2 extends Prototype {
 public ConcretePrototype2(String id) {
 super(id);
 }

 public Prototype clone() {
 Prototype prototype = new ConcretePrototype2(this.getId());
 return prototype;
 }
}

运行结果

登记形式

相关角色

  1. 客户(Client)角色：客户类提出建立对象的请求；
  2. 抽象原型(Prototype)角色：这是一个抽象角色，一般由一个Java接口或者Java抽象类实现。此角色定义了的具体原型类所需的实现的方法。
  3. 具体原型(Concrete Prototype)角色：此角色须要实现抽象原型角色要求的克隆相关的接口。
  4. 原型管理器(Prototype Manager)角色：提供各类原型对象的建立和管理。

示例代码

除了原型管理器Prototype Manager之外，登记模式和简单模式并没有其余差别。架构

Prototype.java
W框架

1
2
3
4
5
 
public interface Prototype {
 public Prototype clone();
 public String getName();
 public void setName(String name);
}

 

ConcretePrototype1.java异步

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
 
public class ConcretePrototype1 implements Prototype {
 private String name;

 @Override
 public String getName() {
 return this.name;
 }

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

 @Override
 public Prototype clone() {
 Prototype prototype = new ConcretePrototype1();
 prototype.setName(this.name);
 return prototype;
 }

 @Override
 public String toString() {
 return "ConcretePrototype1 [name=" + name + "]";
 }

}

 

ConcretePrototype2.java分布式

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
 
public class ConcretePrototype2 implements Prototype {
 private String name;

 @Override
 public String getName() {
 return this.name;
 }

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

 @Override
 public Prototype clone() {
 Prototype prototype = new ConcretePrototype2();
 prototype.setName(this.name);
 return prototype;
 }

 @Override
 public String toString() {
 return "ConcretePrototype2 [name=" + name + "]";
 }
}

 

PrototypeManager.javaide

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
 
public class PrototypeManager {
 /**
 * 用来记录原型的编号同原型实例的对象关系
 */
 private static Map<String, Prototype> map = new HashMap<>();

 /**
 * 私有化构造方法，避免从外部建立实例
 */
 private PrototypeManager() {
 }

 /**
 * 向原型管理器里面添加或者修改原型实例
 *
 * @param prototypeId 原型编号
 * @param prototype 原型实例
 */
 public static void setProtoType(String prototypeId, Prototype prototype) {
 map.put(prototypeId, prototype);
 }

 /**
 * 根据原型编号从原型管理器里面移除原型实例
 *
 * @param prototypeId 原型编号
 */
 public static void removePrototype(String prototypeId) {
 map.remove(prototypeId);
 }

 /**
 * 根据原型编号获取原型实例
 *
 * @param prototypeId 原型编号
 * @return 原型实例对象
 * @throws Exception 若是根据原型编号没法获取对应实例，则提示异常“您但愿获取的原型尚未注册或已被销毁”
 */
 public static Prototype getPrototype(String prototypeId) throws Exception {
 Prototype prototype = map.get(prototypeId);

 if (prototype == null) {
 throw new Exception("您但愿获取的原型尚未注册或已被销毁");
 }

 return prototype;
 }

}

 

Client.java

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
 
public class Client {
 public static void main(String[] args) {
 try {
 // 建立第一个实例
 Prototype p1 = new ConcretePrototype1();
 // 注册第一个实例
 PrototypeManager.setProtoType("p1", p1);

 // 克隆第一个实例的原型
 Prototype p3 = PrototypeManager.getPrototype("p1").clone();
 p3.setName("张三");
 System.out.println("第一个实例的副本：" + p3);

 // 建立第二个实例
 Prototype p2 = new ConcretePrototype2();
 // 注册第二个实例
 PrototypeManager.setProtoType("p2", p2);

 // 克隆第二个实例的原型
 Prototype p4 = PrototypeManager.getPrototype("p2").clone();
 p4.setName("李四");
 System.out.println("第二个实例的副本：" + p4);

 // 注销第一个实例
 PrototypeManager.removePrototype("p1");
 // 再次克隆第一个实例的原型
 Prototype p5 = PrototypeManager.getPrototype("p1").clone();
 p5.setName("王五");
 System.out.println("第一个实例的副本：" + p5);
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
}

 

运行结果

二者之间的比较

简单形式和登记形式的原型模式各有其长处和短处。

  1. 若是要建立的原型对象数据较少并且比较固定的话，能够采用第一种形式。在这种状况下，原型对象的引用能够由客户端本身保存。
  2. 若是要建立的原型对象数据不固定的话，能够采用第二种形式。在这种状况下，客户端不保存对原型对象的引用，这个任务被交给原型管理器角色。在克隆一个对象以前，客户端能够查看管理员对象是否已经有一个知足要求的原型对象。若是有，能够从原型管理器角色中取得这个对象引用；若是没有，客户端就须要自行复制此原型对象。

总结

原型模式的优势

原型模式容许在运行时动态改变具体的实现类型。原型模式能够在运行期间，有客户来注册符合原型接口的实现类型，也能够动态的改变具体的实现类型，看起来接口没有任何变化，可是其实运行的已是另一个类实体了。由于克隆一个原型对象就相似于实例化一个类。

原型模式的缺点

原型模式最主要的缺点是每个类都必需要配备一个克隆方法。配备克隆方法须要对类的功能进行通盘考虑，这对于全新的类来讲并非很难，可是对于已有的类来讲并不容易。

欢迎关注技术公众号： 零壹技术栈

零壹技术栈零壹技术栈

本账号将持续分享后端技术干货，包括虚拟机基础，多线程编程，高性能框架，异步、缓存和消息中间件，分布式和微服务，架构学习和进阶等学习资料和文章。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程