By

文章目录
  1. 原型模式

原型模式

  • 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象
    Prototype
  • 原型的接口与自定义的原型
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
/**
 * 手机原型接口
 */
interface PhonePrototype {
    PhonePrototype clone();
    String getName();
    void setName(String name);
    String getCpu();
    void setCpu(String cpu);
    String getGpu();
    void setGpu(String gpu);
    String getColor();
    void setColor(String color);
    String getFlashMemory();
    void setFlashMemory(String flashMemory);
    String getCamera();
    void setCamera(String camera);
}
/**
 * 自定义的原型IPhone原型
 */
public class IphonePrototype implements PhonePrototype,Serializable {
    private String cpu;
    private String gpu;
    private String color;
    private String flashMemory;
    private String camera;
    private String name;
    public IphonePrototype() {
    }
    public String getCpu() {
        return cpu;
    }
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }
    public String getGpu() {
        return gpu;
    }
    public void setGpu(String gpu) {
        this.gpu = gpu;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getFlashMemory() {
        return flashMemory;
    }
    public void setFlashMemory(String flashMemory) {
        this.flashMemory = flashMemory;
    }
    public String getCamera() {
        return camera;
    }
    public void setCamera(String camera) {
        this.camera = camera;
    }
    @Override
    public PhonePrototype clone() {
        return (PhonePrototype)ClassUtil.deepCopy(this);
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public void setName(String name) {
        this.name=name;
    }
}
  • 创建一个原型管理器用于统一管理所有的原型
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
/**
 * Created with IntelliJ IDEA. User: pingansheng Date: 2016/11/12 Time: 11:19
 */
public class PrototypeManager {
    /**
     * 用来记录原型的编号和原型实例的对应关系
     */
    private static Map<String,PhonePrototype> map = new HashMap<>();
    /**
     * 私有化构造方法，避免外部创建实例
     */
    private PrototypeManager(){}
    /**
     * 向原型管理器里面添加或是修改某个原型注册
     * @param prototypeId 原型编号
     * @param prototype    原型实例
     */
    public synchronized static void setPrototype(String prototypeId , PhonePrototype prototype){
        map.put(prototypeId, prototype);
    }
    /**
     * 从原型管理器里面删除某个原型注册
     * @param prototypeId 原型编号
     */
    public synchronized static void removePrototype(String prototypeId){
        map.remove(prototypeId);
    }
    /**
     * 获取某个原型编号对应的原型实例
     * @param prototypeId    原型编号
     * @return    原型编号对应的原型实例
     * @throws Exception    如果原型编号对应的实例不存在，则抛出异常
     */
    public synchronized static PhonePrototype getPrototype(String prototypeId) throws Exception{
        PhonePrototype prototype = map.get(prototypeId);
        if(prototype == null){
            throw new Exception("您希望获取的原型还没有注册或已被销毁");
        }
        return prototype;
    }
}
  • 客户端对原型的使用
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
public class App {
    /**
     * 原型模式，根据一个给定的对象创建新的对象，即克隆，一般使用深度复制
     * @param args
     */
    public static void main(String[] args) throws Exception{
        //创建模型，一般使用此模式，表示此对象难以构造或后续使用需要修改的属性等信息较少
        PhonePrototype iphonePrototype=new IphonePrototype();
        iphonePrototype.setCpu("A8");
        iphonePrototype.setGpu("A8");
        iphonePrototype.setCamera("Single 1200M");
        //放入模型管理器统一管理
        PrototypeManager.setPrototype("iphoneModel",iphonePrototype);
        //客户端使用原型构造各自的对象
        PhonePrototype model=PrototypeManager.getPrototype("iphoneModel");
        PhonePrototype iphone64G=model.clone();
        iphone64G.setColor("black");
        iphone64G.setFlashMemory("64G");
        PhonePrototype iphone128G=model.clone();
        iphone128G.setColor("golden");
        iphone128G.setFlashMemory("128G");
        System.out.println(JSON.toJSONString(iphone64G));
        System.out.println(JSON.toJSONString(iphone128G));
    }
}
  • 一个深度复制的方案
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
/**
 * 深度复制 需要对象及相关对象实现串行化接口
 *
 * @param obj
 * @return
 * @throws Exception
 */
public static Serializable deepCopy(Serializable obj) {
    ByteArrayOutputStream bos = null;
    ObjectOutputStream oos = null;
    ByteArrayInputStream bis = null;
    ObjectInputStream ois = null;
    Serializable target = null;
    try {
        bos = new ByteArrayOutputStream();
        oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);
        byte[] bytes = bos.toByteArray();
        bis = new ByteArrayInputStream(bytes);
        ois = new ObjectInputStream(bis);
        target = (Serializable) ois.readObject();
        oos.close();
        bos.close();
        ois.close();
        bis.close();
        return target;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
文章目录
  1. 原型模式