从Java类库看设计模式

　　很多时候，对于一个设计来说(软件上的，建筑上的，或者它他工业上的)，经验是至关重要的。好的经验给我们以指导，并节约我们的时间;坏的经验则给我们以借鉴，可以减少失败的风险。然而，从知识层面上来讲，经验只是作为一种工作的积累而存在于个人的大脑中的，很难被传授或者记录。为了解决这样的问题，人们提出了所谓的模式的概念。所谓模式，是指在一个特定背景下，反复出现的问题解决方案。模式是经验的文档化。

　　软件模式的概念现在比较的广泛，涉及到分析，设计，体系结构，编码，测试，重构等软件构造生命期中的各个部分。这儿主要讨论的是设计模式，指的是在软件设计过程中反复出现的一些问题的解决方法了。不过我们一般在提到设计模式的时候，一般都是指GOF的经典书《Design Pattern--Elements of Reusable Object-Oriented Software》出现的23个模式，因而，它是具体的针对于面向对象软件设计过程的。

　　从全局上看来，模式代表了一种语言，一种被文档化的经验，甚至是一种文化。往往很多不方便描叙，或者描叙起来很复杂的问题，用模式语言来叙说，会让听者产生心领神会的感觉。当然，这需要交流双方都能够很好地把握模式语言的含义。然而，这并不是一件容易的事情。模式在各个人的理解上往往存在差异，这篇文章旨在从一个具体的应用角度：Java类库，来阐叙设计模式。并结合具体的例子，希望能够加深大家对设计模式的理解。

　　这儿说的Java类库，其实并没有局限于JDK本身，还包括了一些其他的类库中的例子，比如JAXP等(当然，下一个版本的JDK中也会包含JAXP了)。其实设计模式的思想现在应用的如此广泛，无论在什么样的设计中，只要稍微大一点的设计，都可以找到很多很多设计模式的踪迹，或者说都不可避免的用到设计模式。下面所讲的设计模式，大部分都是GOF的那部经典中出现过的23个模式，然而，还有一些，比如MVC，并不属于那里。一般的来讲，我们认为GOF的23个模式是一些中级的模式，在它下面还可以抽象出一些更为一般的低层的模式，在其上也可以通过组合来得到一些高级的模式。当然，这儿的低中高的区别，如同区别不同的语言一样，并没有优劣之分，仅仅是在应用层面上的区别。

　　Observer模式

　　Observer模式的功用，是希望两个(或多个)对象，我们称之为Subject和Observer，当一方的状态发生改变的时候，另一方能够得到通知。也就是说，作为Observer的一方，能够监视到Subject的某个特定的状态变化，并为之做出反应。一个简单的例子就是：当一个用户视图中的数据被用户改变后，后端的数据库能够得到更新，而当数据库被其他方式更新后，用户视图中的数据显示也会随之改变。

　　图一：Obverser模式的类图

　　在JDK中实际上有一个对Observer模式的简单的实现：就是类java.util.Observerable和接口java.util.Observer。java.util.Observerable类对应于Subject，而java.util.Observer就是观察者了。JDK中并没有把这两个部分都设计为接口，而是让类java.util.Observerable提供了部分的实现，简化了许多编程的工作。当然，这也减少了一定的灵活性。

　　下面列出了Observer和Observeral的函数列表，及其简单的功能说明

　　java.util.Observer：

　　public void update(Observable obs, Object obj)

　　java.util.Observer 接口很简单，只定义了这一个方法，狭义的按照Observer模式的说法，Observer应该在这个方法中调用Subject的getXXX()方法来取得最新的状态，而实际上，你可以只是在其中对Subject的某些事件进行响应。这便是Java中的代理事件模型的一个雏形--对事件进行响应。只不过，在Observer模式中将事件特定化为某个状态/数据的改变了。

　　java.util.Observable

　　public void addObserver(Observer obs)

　　向Subject注册一个Observer。也就是把这个Observer对象添加到了一个java.util.Observable内部的列表中。在JDK中对于这个列表是简单的通过一个java.util.Vector类来实现的，而实际上，在一些复杂的Observer模式的应用中，需要把这个部分单另出来形成一个Manager类，来管理Subject和Observer之间的映射。这样，Subject和Observer进一步的被解藕，程序也会具有更大的灵活性。

　　public void deleteObserver(Observer obs)

　　从Subject中删除一个已注册了Observer的引用。

　　public void deleteObservers()

　　从Subjec中删除所有注册的Observer的引用。

　　public int countObservers()

　　返回注册在Subject中的Observer个数。

　　protected void setChanged()

　　设置一个内部的标志以指明这个Ovserver的状态已经发生改变。注意这是一个protected方法，也就是说只能在Observer类和其子类中被调用，而在其它的类中是看不到这个方法的。

　　protected void clearChanged()

　　清除上叙的内部标志。它在notifyObservers()方法内部被自动的调用，以指明Subject的状态的改变已经传递到Ovserver中了。

　　public boolean hasChanged()

　　确定Subject的状态是否发生了改变。

　　public void notifyObservers(Object obj)

　　它首先检查那个内部的标志，以判断状态是否改变，如果是的话，它会调用注册在Subject中的每个Observer的update()方法。在JDK中这个方法内部是作为synchronized来实现的，也就是如果发生多个线程同时争用一个java.util.Observerable的notifyObservers()方法的话，他们必须按调度的等待着顺序执行。在某些特殊的情况下，这会有一些潜在的问题：可能在等待的过程中，一个刚刚被加入的Observer会被遗漏没有被通知到，而一个刚刚被删除了的Observer会仍然收到它已经不想要了的通知。

　　public void notifyObservers()

　　等价于调用了notifyObservers(null)。

　　因而在Java中应用Observer就很简单了，需要做的是：让需要被观察的Subject对象继承java.util.Observerable，让需要观察的对象实现java.util.Observer接口，然后用java.util.Observerable的addObserver(Observer obj)方法把Observer注册到Subject对象中。这已经完成了大部分的工作了。然后调用java.util.Observerable的notifyObservers(Object arg)等方法，就可以实现Observer模式的机理。我们来看一个简单使用了这个模式的例子。这个例子有三个类：FrameSubject，DateSubject，FrameObject和EntryClass，FrameSubject中用户可以设置被观察的值，然后自动的会在FrameObject中显示出来，DateSubject封装被观察的值，并且充当Observer模式中的Subject。

  1 public class FrameSubject extends JFrame {
  2
  3 　　…………..
  4
  5 　　 // 因为无法使用多重继承，这儿就只能使用对象组合的方式来引入一个
  6
  7 　　 // java.util.Observerable对象了。
  8
  9 　　DateSubject subject = new DateSubject();
10
11 　　 // 这个方法转发添加Observer消息到DateSubject。
12
13 　　 public void registerObserver(java.util.Observer o){
14
15 　　subject.addObserver(o);
16
17 　　}
18
19 　　 // 数据改变，事件被触发后调用notifyObservers()来通知Observer。
20
21 　　 void jButton1_actionPerformed(ActionEvent e) {
22
23 　　subject.setWidthInfo(Integer.parseInt(jTextField1.getText()));
24
25 　　subject.setHeightInfo(Integer.parseInt(jTextField2.getText()));
26
27 　　subject.notifyObservers();
28
29 　　}
30
31 　　……………
32
33 　　}
34
35 　　 public class DateSubject extends Observable {
36
37 　　 // 封装被观察的数据
38
39 　　 private int widthInfo;
40
41 　　 private int heightInfo;
42
43 　　 public int getWidthInfo() {
44
45 　　 return widthInfo;
46
47 　　}
48
49 　　 public void setWidthInfo( int widthInfo) {
50
51 　　 this .widthInfo = widthInfo;
52
53 　　 // 数据改变后，setChanged()必须被调用，否则notifyObservers()方法会不起作用
54
55 　　 this .setChanged();
56
57 　　}
58
59 　　 public void setHeightInfo( int heightInfo) {
60
61 　　 this .heightInfo = heightInfo;
62
63 　　 this .setChanged();
64
65 　　}
66
67 　　 public int getHeightInfo() {
68
69 　　 return heightInfo;
70
71 　　}
72
73 　　}
74
75 　　 public class FrameObserver extends JFrame implements java.util.Observer {
76
77 　　…………..
78
79 　　 // 观察的数据
80
81 　　 int widthInfo = 0 ;
82
83 　　 int heightInfo = 0 ;
84
85 　　 // 在update()方法中实现对数据的更新和其它必要的反应。
86
87 　　 public void update(Observable o, Object arg) {
88
89 　　DateSubject subject = (DateSubject) o;
90
91 　　widthInfo = subject.getWidthInfo();
92
93 　　heightInfo = subject.getHeightInfo();
94
95 　　jLabel1.setText( " The heightInfo from subject is: " );
96
97 　　jLabel3.setText(String.valueOf(heightInfo));
98
99 　　jLabel2.setText( " The widthInfo from subject is: " );
100
101 　　jLabel4.setText(String.valueOf(widthInfo));
102
103 　　}
104
105 　　…………….
106
107 　　}
108
109 　　 public class EntryClass {
110
111 　　 public static void main(String[] args) {
112
113 　　……………..
114
115 　　FrameSubject frame = new FrameSubject();
116
117 　　FrameObserver frame2 = new FrameObserver();
118
119 　　 // 在Subject中注册Observer，将两者联系在一起
120
121 　　frame.registerObserver(frame2);
122
123 　　…………..
124
125 　　frame.setVisible( true );
126
127 　　frame2.setVisible( true );
128
129 　　……………..
130
131 　　}
132
133 　　}
134
135

　　我认为在JDK中这个Observer模式的实现，对于一般的Observer模式的应用，已经是非常的足够了的。但是一方面它用一个类来实现了Subject，另一方面它使用Vector来保存Subject对于Observer的引用，这虽然简化了编程的过程，但会限制它在一些需要更为灵活，复杂的设计中的应用，有时候(虽然这种情况不多)，我们还不得不重新编写新的Subject对象和额外的Manager对象来实现更为复杂的Observer模式的应用。

　　随着现代软件工业的不断进步，软件系统的规模的日益扩大，越来越需要对某些个不断出现的问题进行模式化思维，以成功的经验或者失败的教训来减少软件开发失败的风险。模式代表了一种文档化的经验，它为某一类的问题提供了最好(或者说很好)的解决方案，使得即使不是经验丰富的软件工程师，也能够根据模式来构建相对成功的系统。本节给出的一个Obverser模式的示例，比较好的说明了这一点。Obverser模式主要解决在对象间的状态映射或者镜像的问题。