设计模式之观察者模式

观察者模式

定义

       观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。

观察者模式UML图如下：

观察者模式中的角色

• Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
• ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
• Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
• ConcrereObserver：具体观察者，是实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

观察者模式的实现

抽线观察者

1. public interface Watcher  
2. {  
3.      public void update();  
4. }  

抽象的被观察者，在其中声明方法（添加、移除观察者，通知观察者）：

1. public interface Watched  
2. {  
3.      public void addWatcher(Watcher watcher);  
4.   
5.      public void removeWatcher(Watcher watcher);  
6.   
7.      public void notifyWatchers();  
8. }  

具体的观察者

1. public class Security implements Watcher  
2. {  
3.      @Override  
4.      public void update()  
5.      {  
6.           System.out.println(“运输车有行动，保安贴身保护");  
7.      }  
8. }  

1. public class Police implements Watcher  
2. {  
3.      @Override  
4.      public void update()  
5.      {  
6.           System.out.println(“运输车有行动，警察护航");  
7.      }  
8. }  

具体的被观察者

1. public class Transporter implements Watched  
2. {  
3.      private List<Watcher> list = new ArrayList<Watcher>();  
4.   
5.      @Override  
6.      public void addWatcher(Watcher watcher)  
7.      {  
8.           list.add(watcher);  
9.      }  
10.   
11.      @Override  
12.      public void removeWatcher(Watcher watcher)  
13.      {  
14.           list.remove(watcher);  
15.      }  
16.   
17.      @Override  
18.      public void notifyWatchers(String str)  
19.      {  
20.           for (Watcher watcher : list)  
21.           {  
22.                watcher.update();  
23.           }  
24.      }  
25.   
26. }  

测试类

1. public class Test  
2. {  
3.      public static void main(String[] args)  
4.      {  
5.           Transporter transporter = new Transporter();  
6.   
7.           Police police = new Police();  
8.           Security security = new Security();  
9.           Thief thief = new Thief();  
10.   
11.           transporter.addWatcher(police);  
12.           transporter.addWatcher(security);  
13.           transporter.addWatcher(security);  
14.   
15.           transporter.notifyWatchers();  
16.      }  
17. }  

java中观察者模式的实现

1. public class SimpleObservable extends Observable    
2. {    
3.    private int data = 0;    
4.       
5.    public int getData(){     
6.        return data;    
7.    }    
8.       
9.    public void setData(int i){    
10.        if(this.data != i) {   
11.           this.data = i;   
12.           setChanged();    
13.   
14.           //只有在setChange()被调用后，notifyObservers()才会去调用update()，否则什么都不干。  
15.           notifyObservers();      
16.        }    
17.    }    
18. }    

1. public class SimpleObserver implements Observer    
2. {    
3.    public SimpleObserver(SimpleObservable simpleObservable){    
4.       simpleObservable.addObserver(this );    
5.    }    
6.       
7.    public void update(Observable observable ,Object data){  // data为任意对象，用于传递参数  
8.       System.out.println(“Data has changed to” + (SimpleObservable)observable.getData());    
9.    }    
10. }