Java设计模式之观察者模式

定义

定义对象间的一种一个对多的依赖关系，当一个对象的状态发送改变时，所以依赖于它的对象都得到通知并被自动更新。

角色

• Observable（抽象被观察者）：把所有对观察者对象的引用保存在一个集合中，每个被观察者角色都可以有任意数量的观察者。
• ConcreteObservable（具体被观察者）：在被观察者内部状态改变时，给所有登记过的观察者发出通知。
• Observer（抽象观察者）：为所有具体的观察者定义一个接口，在得到变化通知时更新自己。
• ConcreteObserver （具体观察者）：实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。

适用场景

1. 当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
2. 当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。
3. 当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。

代码实现

抽象的观察者

public interface Observer  {  
     public void update(int state);  
}  

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

public interface Observable  {  
     public void addObserver(Observer watcher);  
     public void removeObserver(Observer watcher);  
     public void notify(int state);  
}  

具体的观察者

public class ConcreteObserver1 implements Observer  {  
     @Override  
     public void update(int state){  
          System.out.println("1的状态变化为："+ state);  
     }  
}  

public class ConcreteObserver2 implements Observer  {  
     @Override  
     public void update(int state){  
          System.out.println("2的状态变化为："+ state);  
     }  
}  

具体的被观察者

public class ConcreteObservable implements Observable{  
     private List<Observer> list = new ArrayList<Observer>();  
     @Override  
     public void addObserver(Observer Observer)  {  
          list.add(Observer);  
     }  
     @Override  
     public void removeObserver(Observer Observer)  {  
          list.remove(Observer);  
     }  
     @Override  
     public void notify(int state){  
          for (Observer watcher : list)  {  
               watcher.update();  
          }  
     }  
}  

测试类

public class Test  {  
     public static void main(String[] args)  {  
          Observable observable = new ConcreteObservable();  
          observable.addObserver(new ConcreteObserver1());  
          observable.addObserver(new ConcreteObserver2());    
          observable.notify(0);
          observable.notify(1);  
     }  
}  

Android中的源码分析

RxJava 源码，标准的观察者模式。