认真学习设计模式之观察者模式(Observer Pattern)

【1】观察者模式

① 观察者模式定义

观察者模式也叫(发布-订阅模式)定义了对象之间的一对多的依赖，当一个对象(主题)改变状态时，它的所有依赖者都会收到通知并自动更新。

在观察者模式中，会改变的是主题的状态，以及观察者的数目和类型。主题与观察者都是用接口，观察者使用主题的接口向主题注册，而主题利用观察者的接口通知观察者。这样可以让两者之间运作正常，又同时具有松耦合的优点–可观察者不知道观察者的细节，只知道观察者实现了观察者接口。

当你使用观察者模式时，你可以从被观察者处推(push)或拉(pull)数据(然而，推的方式被认为更“正确”)。

有多个观察者时，不可以依赖特定的通知次序。Java有多种观察者模式的实现，包括通用的java.util.Observer(观察者)与java.util.Observalbe(可观察者-被观察者-主题)。

关于观察者的一切，主题只知道观察者实现了某个接口(也就是Observer接口)。主题不需要知道观察者的具体类是谁、做了写什么或其他任何细节。任何时候我们都可以增加新的观察者。因为主题唯一依赖的东西是一个实现Observer接口的对象列表，所以我们可以随时增加观察者。事实上，在运行时我们可以用新的观察者取代现有的观察者，主题不会受到任何影响。同样的，也可以在任何时候删除某些观察者。

我们可以独立地复用主题或观察者。如果我们再其他地方需要使用主题或观察者，可以轻易地复用，因为二者并非紧耦合。改变主题或观察者其中一方，并不会影响另一方。因为两者是松耦合的，所以只要他们之间的接口仍被遵守，我们就可以自由地改变他们。

---

② 观察者模式设计

实现观察者模式的方法不只一种，但是以包含Subject与Observer接口的类设计的做法最为常见。

Subject（抽象主题<被观察者>）：抽象主题中把所有观察者对象的引用都保存在一个集合里(设计原则里面的多用组合，少用继承)，每个主题都可以有任何数量的观察者，这个主题提供一个接口,来增加或者删除具体的观察者对象。

ConcreteSubject（具体主题<被观察者>）：具体主题中就操作了具体的观察者对象，将有关状态存入具体的观察者对象中，假如具体主题内部状态发生了改变,则给所有注册过的观察者发出更新的通知。然后具体的观察者则更新自己的状态。

Observer（抽象观察者）：为所有观察者定义一个接口，在得到主题的通知时则更新自己。

ConcreteObserver（具体观察者）：实现抽象观察者定义的接口，自身的状态随着主题的更新而更新。

---

【2】自定义观察者模式代码实现

① 定义一个抽象观察者接口

类似于公众号用户角色，也可以使用抽象类。抽象观察者中只提供一个更新状态的方法，所有实现该抽象观察者的具体观察者，需要随着更新。

public interface Observer {
   //传入主题对象,得到主题对象的通知时更新自己
   void update(Subject subject);
}

② 定义一个具体的观察者

相当于具体的公众号用户。

public class ConcreteObserver implements Observer {

   private int state; //state属性需要和Subject中的state保持一致
   
   @Override
   public void update(Subject subject) {
       //当目标对象（主题对象）状态发生改变时，观察者也发生改变。
       // 将主题对象强转为具体的主题对象(被观察者)
       ConcreteSubject subject1 = (ConcreteSubject) subject;
       this.state = subject1.getState();
   }
   public void setState(int state) {
       this.state = state;
   }
   public int getState() {
       return state;
   }
}

---

③ 定义主题对象(被观察者)

主题对象中存储了所有该主题下的所有观察者，并提供增加、删除及通知观察者的方法。

/*
* 被观察者
* 抽象主题对象：把所有观察者对象都保存到一个集合里，每个主题都可有任何数量的观察者
* 抽象主题对象提供了通通知、增加和删除观察者对象的方法
*/
public interface Subject {
   //注册添加观察者
   public void registerObserver(Observer observer){ }；
   //删除观察者
   public void removerObserver(Observer observer){ }；
   //通知所有观察者
   public void notifyAllObserver(){ }；
}

④ 定义具体的主题对象(具体被观察者)

用于观察者来监视观察的具体主题对象。

public class ConcreteSubject implements Subject{
	 //保存该主题下所有的观察者
   private List<Observer> observers;
   //默认状态为0
   private int state;
   
   public ConcreteSubject (){
		observers= new ArrayList<Observer>();
	}
    //注册添加观察者
   public void registerObserver(Observer observer){
       observers.add(observer);
   }
   
   //删除观察者
   public void removerObserver(Observer observer){
       observers.remove(observer);
   }
   
   //通知所有观察者-push模式
   public void notifyAllObserver(){
       for (Observer obs : observers) {
           obs.update(this);//更新当前主题（subject）对象的信息到所有观察者中
       }
   }
   //提供给pull模式
   public int getState() {
       return state;
   }
   public void setState(int state) {
       this.state = state;
       //当修改了主题对象状态时，通知所有观察者
       this.notifyAllObserver();//通知所有观察者
   }
}

---

【3】JDK中Observable 和Observer

以上是我们自己定义的Observer(观察者)和Subject(被观察者)。其实java的JDK中已经帮我们写好了这两个主题对象接口和观察者接口。

JDK中内置好的对象接口:

• java.util.Observable //这个类就相当于我们自己定义的subject；
• java.util.Observer //这个就相当于我们自定义的Observer接口；

下面，使用JDK提供的两个接口类来实现一个观察者模式。

① 定义一个具体的目标对象（被观察者,上面代码中的ConcreteSubject）：继承java.util.Observable类。

public class ConcreteSubject extends Observable{
   private int state;
   
   public void updateState(int s) {
       state = s; //目标对象发生了改变
       setChanged(); //Observable类中的setChanged()方法，表示目标对象发生了更改
       notifyObservers(state); //通知所有的观察者对象
   }
   
   public int getState() {
       return state;
   }
   public void setState(int state) {
       this.state = state;
   }
}

---

② 定义具体的观察者：实现java.util.Observer接口。

public class ConcreteObserver implements Observer {

   private int state; //具体观察者中的状态和目标对象的状态保持一致
   
   @Override
   public void update(Observable o, Object arg) {
       ConcreteSubject subject = (ConcreteSubject)o;
       state = subject.getState();
   }
   public int getState() {
       return state;
   }
   public void setState(int state) {
       this.state = state;
   }
}

这个模式观察者与被观察者之间是属于轻度的关联关系。并且是抽象松耦合的，这样，对于两者来说都比较容易进行扩展。改变主题或观察者中的一方，另一方不会受到影像。

JDK中也自带的观察者模式。但是被观察者是一个类而不是接口，限制了它的复用能力。我们可以在jdk的api文档具体查看这两个类的使用方法。在JavaBean和Swing中也可以看到观察者模式的影子。