行为模式---之--观察者模式

观察者模式是对象的行为模式，又叫作发布-订阅（Publish/Subscribe）模式，模型-视图（Model/View）模式，源-监听器（Source/Listener）模式或从属者（Dependents）模式。

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知全部观察者对象，使它们可以自动更新本身。

 

观察者模式的角色：

1.抽象主题（Subject）角色：主题角色把全部对观察者的引用保存在一个聚焦里，每一个主题均可以有任何数量的观察者。抽象主题角色提供一个接口，能够增长和删除观察者对象，主题角色又叫作抽象被观察者角色，通常用一个抽象类或接口实现

2.抽象观察者（Observer）角色：为全部的具体观察者定义一个接口，在获得主题的通知时更新本身。这个接口叫作更新接口。抽象观察者角色通常用一个抽象类或一个接口实现

3.具体主题（ConcreteSubject）角色：将有关状态存入具体观察者对象，在具体主题的内部状态改变时，给全部登记过的观察者发出通知。它又叫作具体被观察者角色。

4.具体观察者（ConcreteObserver）角色：存储与主题的状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使自己的状态与主题的状态相协调。若是须要，具体观察者角色能够保存一个指向具体主题对象的引用。

 

示例代码：

 1 public class ObservationTest {
 2     public static void main(String[] args) {
 3         Subject1 subject = new ConcreteSubject();
 4         Observer observer = new ConcreteObserver();
 5         subject.attach(observer);
 6         subject.notifyObserver();
 7     }
 8 
 9 }
10 
11 //抽象主题角色
12 interface Subject1{
13     //调用 这个方法登记一个新 的观察者对象
14     public void attach(Observer observer);
15     //调用这个方法删除一个已经登记过的观察者对象
16     public void delete(Observer observer);
17     //调用这个方法通知全部登记过的观察者对象
18     public void notifyObserver();
19 }
20 //具体主题角色  也能够把对聚焦的维护方法上移到抽象主角角色中
21 class ConcreteSubject implements Subject1{
22     private Vector observers = new Vector();
23 
24     @Override
25     public void attach(Observer observer) {
26         observers.add(observer);
27     }
28 
29     @Override
30     public void delete(Observer observer) {
31         observers.remove(observer);
32     }
33 
34     @Override
35     public void notifyObserver() {
36         for(int i=0;i<observers.size();i++){
37             Observer o = (Observer)observers.get(i);
38             o.update();
39         }
40     }
41     
42 }
43 
44 //抽象观察者
45 interface Observer{
46     //调用这个方法会更新本身
47     public void update();
48 }
49 //具体观察者
50 class ConcreteObserver implements Observer{
51     //调用这个方法更新本身
52     @Override
53     public void update() {
54         System.out.println("I am notified");
55     }
56     
57 }

 

Java语言对观察者模式的支持：

在Java语言的java.util库里，提供了一个Observable类及一个Observer接口，构成Java语言对观察者模式的支持。

Observer接口，这个接口只定义了一个方法update()方法。当被观察者对象的状态发生变化时，被观察者对象的notifyObservers()方法就会调用这一方法。

 

Observable类

被观察者类就是java.util.Observable类的子类。java.util.Observable提供公开的方法支持观察者对象，这些方法中有两个对Observable的子类很是重要：一个是setChanged()调用以后会设置一个内部标记变量，表明被观察者对象的状态发生了变化,另外一个是notifyObservers()，这个方法被调用时，会调用全部登记过的观察者对象的update()方法，使这些观察者对象能够更新本身。

一个示例：

 1 public class JavaObservation {
 2 
 3     public static void main(String[] args) {
 4         //建立被观察者对象
 5         Watched watched = new Watched();
 6         //建立观察者对象，并将被观察者对象登记
 7         Watcher watcher = new Watcher(watched);
 8         //给被观察者对象的状态赋值4次
 9         watched.changeData("A");
10         watched.changeData("B");
11         watched.changeData("C");
12         watched.changeData("D");
13     }
14 
15 }
16 
17 //具体主题
18 class Watched extends Observable{
19     private String data = "";
20     //取值方法
21     public String retrieveData(){
22         return data;
23     }
24     //改值方法
25     public void changeData(String data){
26         if(!this.data.equals(data)){
27             this.data = data;
28             //标记值已改变
29             setChanged();
30         }
31         //通知观察者
32         notifyObservers();
33     }
34 }
35 //具体观察者
36 class Watcher implements Observer{
37     //把观察者加入到观察列表
38     public Watcher (Watched w){
39         w.addObserver(this);
40     }
41     //更新方法
42     @Override
43     public void update(Observable o, Object arg) {
44         System.out.println("Data has been changed to:"+((Watched)o).retrieveData());
45     }
46     
47 }

观察者模式的优势：

1.观察者模式在被观察者之间创建一个抽象的耦合。被观察者所知道的只是一个具体观察者聚焦，每个具体观察者都符合一个抽象观察者的接口。被观察者并不认识任何一个具体观察者，它只知道它们都有一个共同的接口。因为被观察者和观察者没有紧密地耦合在一块儿，所以它们能够属于不一样的抽象化层次。若是被观察者和观察者都被扔到一块儿，那么这个对象必然跨越抽象化和具体化层次。

2.观察者模式支持广播通讯。被观察者会向全部的登记过的观察者发出通知。

观察者模式的缺点：

1.若是一个被观察者对象有不少直接和间接的观察者的话，将全部的观察者都通知会花费不少时间

2.若是在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，致使系统崩溃。在使用观察者模式时要特别注意这一点

3.若是对观察者的通知是经过另外的线程进行异步投递的话，系统必须保证投递是以自恰的方式进行的

4.虽然观察者模式能够随时使用观察者知道所观察的对象发生了变化，可是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。