本文转自：http://www.2cto.com/kf/201206/137875.html
观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。
观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
________________________________________
观察者模式的结构
一个软件系统里面包含了各种对象，就像一片欣欣向荣的森林充满了各种生物一样。在一片森林中，各种生物彼此依赖和约束，形成一个个生物链。一种生物的状态变化会造成其他一些生物的相应行动，每一个生物都处于别的生物的互动之中。
同样，一个软件系统常常要求在某一个对象的状态发生变化的时候，某些其他的对象做出相应的改变。做到这一点的设计方案有很多，但是为了使系统能够易于复用，应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用，但是同时设计师需要使这些低耦合度的对象之间能够维持行动的协调一致，保证高度的协作。观察者模式是满足这一要求的各种设计方案中最重要的一种。
下面以一个简单的示意性实现为例，讨论观察者模式的结构。
观察者模式所涉及的角色有：
● 抽象主题(Subject)角色：抽象主题角色把所有对观察者对象的引用保存在一个聚集（比如ArrayList对象）里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，抽象主题角色又叫做抽象被观察者(Observable)角色。
● 具体主题(ConcreteSubject)角色：将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者(Concrete Observable)角色。
● 抽象观察者(Observer)角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。
● 具体观察者(ConcreteObserver)角色：存储与主题的状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态 像协调。如果需要，具体观察者角色可以保持一个指向具体主题对象的引用。
源代码
抽象主题角色类
[java]
1. package com.bankht.Observer;
2.
3. import java.util.ArrayList;
4. import java.util.List;
5.
6. /**
7. * @author: 特种兵—AK47
8. * @创建时间：2012-6-28 下午09:43:26
9. *
10. * @类说明 ：抽象主题角色类
11. */
12. public abstract class Subject {
13. /**
14. * 用来保存注册的观察者对象
15. */
16. private List<Observer> list = new ArrayList<Observer>();
17.
18. /**
19. * 注册观察者对象
20. *
21. * @param observer
22. * 观察者对象
23. */
24. public void attach(Observer observer) {
25.
26. list.add(observer);
27. System.out.println("Attached an observer");
28. }
29.
30. /**
31. * 删除观察者对象
32. *
33. * @param observer
34. * 观察者对象
35. */
36. public void detach(Observer observer) {
37.
38. list.remove(observer);
39. }
40.
41. /**
42. * 通知所有注册的观察者对象
43. */
44. public void nodifyObservers(String newState) {
45.
46. for (Observer observer : list) {
47. observer.update(newState);
48. }
49. }
50. }
具体主题角色类
[java]
1. package com.bankht.Observer;
2.
3. /**
4. * @author: 特种兵—AK47
5. * @创建时间：2012-6-28 下午09:44:36
6. *
7. * @类说明 ：具体主题角色类
8. */
9. public class ConcreteSubject extends Subject {
10.
11. private String state;
12.
13. public String getState() {
14. return state;
15. }
16.
17. public void change(String newState) {
18. state = newState;
19. System.out.println("主题状态为：" + state);
20. // 状态发生改变，通知各个观察者
21. this.nodifyObservers(state);
22. }
23. }
抽象观察者角色类
[java]
1. package com.bankht.Observer;
2.
3. /**
4. * @author: 特种兵—AK47
5. * @创建时间：2012-6-28 下午09:45:20
6. *
7. * @类说明 ： 抽象观察者角色类
8. */
9. public interface Observer {
10. /**
11. * 更新接口
12. *
13. * @param state
14. * 更新的状态
15. */
16. public void update(String state);
17. }
具体观察者角色类
[java]
1. package com.bankht.Observer;
2.
3. /**
4. * @author: 特种兵—AK47
5. * @创建时间：2012-6-28 下午09:45:58
6. *
7. * @类说明 ：具体观察者角色类
8. */
9. public class ConcreteObserver implements Observer {
10. // 观察者的状态
11. private String observerState;
12.
13. @Override
14. public void update(String state) {
15. /**
16. * 更新观察者的状态，使其与目标的状态保持一致
17. */
18. observerState = state;
19. System.out.println("状态为：" + observerState);
20. }
21.
22. }
客户端类
[java]
1. package com.bankht.Observer;
2.
3. /**
4. * @author: 特种兵—AK47
5. * @创建时间：2012-6-28 下午09:56:04
6. *
7. * @类说明 ：客户端类
8. */
9. public class Client {
10.
11. public static void main(String[] args) {
12. // 创建主题对象
13. ConcreteSubject subject = new ConcreteSubject();
14. // 创建观察者对象
15. Observer observer = new ConcreteObserver();
16. // 将观察者对象登记到主题对象上
17. subject.attach(observer);
18. // subject.detach(observer);
19. // 改变主题对象的状态
20. subject.change("new state");
21. }
22.
23. }
运行结果如下：
[html]
1. Attached an observer
2. 主题状态为：new state
3. 状态为：new state
在运行时，这个客户端首先创建了具体主题类的实例，以及一个观察者对象。然后，它调用主题对象的attach()方法，将这个观察者对象向主题对象登记，也就是将它加入到主题对象的聚集中去。
这时，客户端调用主题的change()方法，改变了主题对象的内部状态。主题对象在状态发生变化时，调用超类的notifyObservers()方法，通知所有登记过的观察者对象。
推模型和拉模型
在观察者模式中，又分为推模型和拉模型两种方式。
● 推模型
主题对象向观察者推送主题的详细信息，不管观察者是否需要，推送的信息通常是主题对象的全部或部分数据。
● 拉模型
主题对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到主题对象中获取，相当于是观察者从主题对象中拉数据。一般这种模型的实现中，会把主题对象自身通过update()方法传递给观察者，这样在观察者需要获取数据的时候，就可以通过这个引用来获取了。
根据上面的描述，发现前面的例子就是典型的推模型，下面给出一个拉模型的实例。
拉模型的抽象观察者类
拉模型通常都是把主题对象当做参数传递。
[java]
1. package com.bankht.Observer.pull;
2.
3. /**
4. * @author: 特种兵—AK47
5. * @创建时间：2012-6-28 下午10:03:02
6. *
7. * @类说明 ：拉模型通常都是把主题对象当做参数传递。
8. */
9. public interface Observer {
10. /**
11. * 更新接口
12. *
13. * @param subject
14. * 传入主题对象，方面获取相应的主题对象的状态
15. */
16. public void update(Subject subject);
17. }
拉模型的具体观察者类
[java]
1. package com.bankht.Observer.pull;
2.
3. /**
4. * @author: 特种兵—AK47
5. * @创建时间：2012-6-28 下午10:03:25
6. *
7. * @类说明 ： 拉模型的具体观察者类
8. */
9. public class ConcreteObserver implements Observer {
10. // 观察者的状态
11. private String observerState;
12.
13. @Override
14. public void update(Subject subject) {
15. /**
16. * 更新观察者的状态，使其与目标的状态保持一致
17. */
18. observerState = ((ConcreteSubject) subject).getState();
19. System.out.println("观察者状态为：" + observerState);
20. }
21.
22. }
拉模型的抽象主题类
拉模型的抽象主题类主要的改变是nodifyObservers()方法。在循环通知观察者的时候，也就是循环调用观察者的update()方法的时候，传入的参数不同了。
[java]
1. package com.bankht.Observer.pull;
2.
3. import java.util.ArrayList;
4. import java.util.List;
5.
6. /**
7. * @author: 特种兵—AK47
8. * @创建时间：2012-6-28 下午10:03:48
9. *
10. * @类说明
11. * ：拉模型的抽象主题类主要的改变是nodifyObservers()方法。在循环通知观察者的时候，也就是循环调用观察者的update()方法的时候，
12. * 传入的参数不同了。
13. */
14. public abstract class Subject {
15. /**
16. * 用来保存注册的观察者对象
17. */
18. private List<Observer> list = new ArrayList<Observer>();
19.
20. /**
21. * 注册观察者对象
22. *
23. * @param observer
24. * 观察者对象
25. */
26. public void attach(Observer observer) {
27.
28. list.add(observer);
29. System.out.println("Attached an observer");
30. }
31.
32. /**
33. * 删除观察者对象
34. *
35. * @param observer
36. * 观察者对象
37. */
38. public void detach(Observer observer) {
39.
40. list.remove(observer);
41. }
42.
43. /**
44. * 通知所有注册的观察者对象
45. */
46. public void nodifyObservers() {
47.
48. for (Observer observer : list) {
49. observer.update(this);
50. }
51. }
52. }
拉模型的具体主题类
跟推模型相比，有一点变化，就是调用通知观察者的方法的时候，不需要传入参数了。
[java]
1. package com.bankht.Observer.pull;
2.
3. /**
4. * @author: 特种兵—AK47
5. * @创建时间：2012-6-28 下午10:04:24
6. *
7. * @类说明 ：跟推模型相比，有一点变化，就是调用通知观察者的方法的时候，不需要传入参数了。
8. */
9. public class ConcreteSubject extends Subject {
10.
11. private String state;
12.
13. public String getState() {
14. return state;
15. }
16.
17. public void change(String newState) {
18. state = newState;
19. System.out.println("主题状态为：" + state);
20. // 状态发生改变，通知各个观察者
21. this.nodifyObservers();
22. }
23. }
还是用刚才的Client.java 测试一下：
[html]
1. Attached an observer
2. 主题状态为：new state
3. 观察者状态为：new state
两种模式的比较
■ 推模型是假定主题对象知道观察者需要的数据；而拉模型是主题对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需要取值。
■ 推模型可能会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者；而拉模型就不会造成这样的情况，因为拉模型下，update()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要。
JAVA提供的对观察者模式的支持
在JAVA语言的java.util库里面，提供了一个Observable类以及一个Observer接口，构成JAVA语言对观察者模式的支持。
Observer接口
这个接口只定义了一个方法，即update()方法，当被观察者对象的状态发生变化时，被观察者对象的notifyObservers()方法就会调用这一方法。
[java]
1. public interface Observer {
2.
3. void update(Observable o, Object arg);
4. }
Observable类
被观察者类都是java.util.Observable类的子类。java.util.Observable提供公开的方法支持观察者对象，这些方法中有两个对Observable的子类非常重要：一个是setChanged()，另一个是notifyObservers()。第一方法setChanged()被调用之后会设置一个内部标记变量，代表被观察者对象的状态发生了变化。第二个是notifyObservers()，这个方法被调用时，会调用所有登记过的观察者对象的update()方法，使这些观察者对象可以更新自己。
[java]
1. public class Observable {
2. private boolean changed = false;
3. private Vector obs;
4.
5. /** Construct an Observable with zero Observers. */
6.
7. public Observable() {
8. obs = new Vector();
9. }
10.
11. /**
12. * 将一个观察者添加到观察者聚集上面
13. */
14. public synchronized void addObserver(Observer o) {
15. if (o == null)
16. throw new NullPointerException();
17. if (!obs.contains(o)) {
18. obs.addElement(o);
19. }
20. }
21.
22. /**
23. * 将一个观察者从观察者聚集上删除
24. */
25. public synchronized void deleteObserver(Observer o) {
26. obs.removeElement(o);
27. }
28.
29. public void notifyObservers() {
30. notifyObservers(null);
31. }
32.
33. /**
34. * 如果本对象有变化（那时hasChanged 方法会返回true）
35. * 调用本方法通知所有登记的观察者，即调用它们的update()方法
36. * 传入this和arg作为参数
37. */
38. public void notifyObservers(Object arg) {
39.
40. Object[] arrLocal;
41.
42. synchronized (this) {
43.
44. if (!changed)
45. return;
46. arrLocal = obs.toArray();
47. clearChanged();
48. }
49.
50. for (int i = arrLocal.length-1; i>=0; i--)
51. ((Observer)arrLocal[i]).update(this, arg);
52. }
53.
54. /**
55. * 将观察者聚集清空
56. */
57. public synchronized void deleteObservers() {
58. obs.removeAllElements();
59. }
60.
61. /**
62. * 将“已变化”设置为true
63. */
64. protected synchronized void setChanged() {
65. changed = true;
66. }
67.
68. /**
69. * 将“已变化”重置为false
70. */
71. protected synchronized void clearChanged() {
72. changed = false;
73. }
74.
75. /**
76. * 检测本对象是否已变化
77. */
78. public synchronized boolean hasChanged() {
79. return changed;
80. }
81.
82. /**
83. * Returns the number of observers of this <tt>Observable</tt> object.
84. *
85. * @return the number of observers of this object.
86. */
87. public synchronized int countObservers() {
88. return obs.size();
89. }
90. }
这个类代表一个被观察者对象，有时称之为主题对象。一个被观察者对象可以有数个观察者对象，每个观察者对象都是实现Observer接口的对象。在被观察者发生变化时，会调用Observable的notifyObservers()方法，此方法调用所有的具体观察者的update()方法，从而使所有的观察者都被通知更新自己。
怎样使用JAVA对观察者模式的支持
这里给出一个非常简单的例子，说明怎样使用JAVA所提供的对观察者模式的支持。在这个例子中，被观察对象叫做Watched；而观察者对象叫做Watcher。Watched对象继承自java.util.Observable类；而Watcher对象实现了java.util.Observer接口。另外有一个Test类扮演客户端角色。
源代码
被观察者Watched类源代码
[java]
1. package com.bankht.Observer.java;
2.
3. import java.util.Observable;
4.
5. /**
6. * @author: 特种兵—AK47
7. * @创建时间：2012-6-28 下午10:23:14
8. *
9. * @类说明 ：被观察者Watched类源代码
10. */
11. public class Watched extends Observable {
12.
13. private String data = "";
14.
15. public String getData() {
16. return data;
17. }
18.
19. public void setData(String data) {
20.
21. if (!this.data.equals(data)) {
22. this.data = data;
23. setChanged();
24. }
25. notifyObservers();
26. }
27.
28. }
观察者类源代码
[java]
1. package com.bankht.Observer.java;
2.
3. import java.util.Observable;
4. import java.util.Observer;
5.
6.
7. /**
8. * @author: 特种兵—AK47
9. * @创建时间：2012-6-28 下午10:23:44
10. *
11. * @类说明 ： 观察者类源代码
12. */
13. public class Watcher implements Observer {
14.
15. public Watcher(Observable o) {
16. o.addObserver(this);
17. }
18.
19. @Override
20. public void update(Observable o, Object arg) {
21.
22. System.out.println("状态发生改变：" + ((Watched) o).getData());
23. }
24.
25. }
测试类源代码
[java]
1. package com.bankht.Observer.java;
2.
3.
4. /**
5. * @author: 特种兵—AK47
6. * @创建时间：2012-6-28 下午10:25:43
7. *
8. * @类说明 ：测试类源代码
9. */
10. public class Test {
11.
12. public static void main(String[] args) {
13.
14. // 创建被观察者对象
15. Watched watched = new Watched();
16. // 创建观察者对象，并将被观察者对象登记
17. new Watcher(watched);
18. // 给被观察者状态赋值
19. watched.setData("start");
20. watched.setData("run");
21. watched.setData("stop");
22.
23. }
24.
25. }
Test对象首先创建了Watched和Watcher对象。在创建Watcher对象时，将Watched对象作为参数传入；然后Test对象调用Watched对象的setData()方法，触发Watched对象的内部状态变化；Watched对象进而通知实现登记过的Watcher对象，也就是调用它的update()方法。
作者：m13666368773