观察者模式（Observer）

观察者模式是 JDK 中使用最多的模式之一，非常有用。观察者模式提供了一种对象设计，让主题和观察者之间松耦合。

定义

观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

一对多：一个主题可以对应多个观察者。

依赖：观察者是主题的依赖者，在数据变化更新时，这样比起让许多对象控制同一份数据来，可以得到更干净的 OO 设计。

举例

报社的运营模式：

• 报社的业务就是出版报纸。
• 向某家报社订阅报纸，只要他们有新报纸出版，就会给你送来。只要你是他们的订户，你就会一直收到新报纸。
• 当你不想再看报纸的时候，取消订阅，他们就不会再送新报纸。
• 只要报社还在运营，就会一直有人（或单位）向他们订阅报纸或者取消订阅报纸。

出版者 + 订阅者 = 观察者模式

房产中介公司运行模式：

• 中介公司会通过自己的各种渠道获取到很多房源信息。
• 需要买房的人会到中介公司或者网上注册自己的购房需求。
• 当中介公司有了符合的房源，就会通知购房者。
• 购房者从而获取到最新的房源信息。

中介公司 + 购房者 = 观察者模式

类图

代码实现

 package com.study.design.Observer.custom;
 /**
  * 观察者实现类
  */
 public class ConcreteObserver implements Observer{
     // 本地存储 subject 对象是为了之后取消订阅，如果不需要可以不存
     private Subject subject;
 
     public ConcreteObserver(Subject subject){
         this.subject = subject;
         // 订阅主题
         subject.registerObserver(this);
     }
 
     @Override
     public void update(int stat){
         System.out.println("state update:" + stat);
     }
 }

 package com.study.design.Observer.custom;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class ConcreteSubject implements Subject{
 
     List<Observer> observers;
 
     int stat;
 
     public ConcreteSubject(){
         observers = new ArrayList<Observer>();
     }
 
     @Override
     public void registerObserver(Observer o){
         observers.add(o);
     }
 
     @Override
     public void removeObserver(Observer o){
         int i = observers.indexOf(o);
         if(i > 0){
             observers.remove(i);
         }
     }
 
     @Override
     public void notifyObservers(int stat){
         for(Observer observer : observers){
             observer.update(stat);
         }
     }
 
     @Override
     public void updateStat(int stat){
         this.stat = stat;
         notifyObservers(stat);
     }
 }
 

 package com.study.design.Observer.custom;
 
 /**
  * 观察者接口
  */
 public interface Observer {
 
     void update(int stat);
 }

 package com.study.design.Observer.custom;
 
 /**
  * 主题接口
  */
 public interface Subject {
     void registerObserver(Observer o);
     void removeObserver(Observer o);
     void notifyObservers(int stat);
     void updateStat(int stat);
 }

 package com.study.design.Observer.custom;
 
 public class CustomTest {
 
     public static void main(String[] args) {
         // 创建主题
         Subject subject = new ConcreteSubject();
         // 创建观察者对象
         Observer observer = new ConcreteObserver(subject);
         // 主题状态更新
         subject.updateStat(1);
     }
 }

以上代码展示的是“推”模式，也就是说，在主题数据更新后，由主题对象将最新数据推送给观察者。还可以由观察者主动向主题拉取数据，称为“拉”模式。

在实际开发过程中，如果某个主题负责了多份数据，每个观察者只订阅其中一部分，那么就适合拉模式。由观察者主动向主题拉取所需要的数据，主题只需要为每份数据提供 get 方法，而且在后续如果主题扩展了功能，新增了更多的数据，那么主题也不需要更新对每个观察者的调用，需要改变自己来提供更多的 getter 方法即可。

Java 内置的 Observer 模式两种模式都支持。

Java 内置的观察者模式

Java API 中内置了观察者模式。在 java.util 包内包含最基本的 Observer 接口与 Observable 类，这和我们的 Subject 接口与 Observer 接口很相似。Observer 接口与 Observable 类使用上更方便，因为许多功能都已经事先准备好了。你甚至可以使用推(push)或拉(pull)的方式传送数据。

 package java.util;
 /**
  * 主题类
  * 虽然定义为 class 而非之前的 interface 类型，
  * 但是对状态的更新 setChanged 和 setChanged 方法被定义为了 protected 类型
  * 所以，在实际开发中还是需要实现一个子类继承自 Observable 
  */
 public class Observable {
     /**主题状态**/
     private boolean changed = false;
     /**存放观察者对象**/
     private Vector<Observer> obs;
     /**构造器**/
     public Observable() {
         obs = new Vector<>();
     }
     /**注册观察者对象**/
     public synchronized void addObserver(Observer o) {
         if (o == null)
             throw new NullPointerException();
         if (!obs.contains(o)) {
             obs.addElement(o);
         }
     }
     /**移除指定的观察者对象**/
     public synchronized void deleteObserver(Observer o) {
         obs.removeElement(o);
     }
     /**通知所有观察者对象，状态已经更新，并未传送数据**/
     public void notifyObservers() {
         notifyObservers(null);
     }
     /**通知所有观察者对象，状态已经更新，可传送任意类型的数据**/
     public void notifyObservers(Object arg) {
         Object[] arrLocal;
         synchronized (this) {
             if (!changed)
                 return;
             arrLocal = obs.toArray();
             clearChanged();
         }
         for (int i = arrLocal.length-1; i>=0; i--)
             ((Observer)arrLocal[i]).update(this, arg);
     }
     /**移除所有观察者对象**/
     public synchronized void deleteObservers() {
         obs.removeAllElements();
     }
     /**
      * 更新状态
      * 发送通知前，需要先调用该方法，标记状态已经改变，否则通知发布出去
      */
     protected synchronized void setChanged() {
         changed = true;
     }
     /**
      * 恢复状态
      * 通知发送完成后，需要恢复状态标记
      */
     protected synchronized void clearChanged() {
         changed = false;
     }
     /**获取状态是否更新**/
     public synchronized boolean hasChanged() {
         return changed;
     }
     /**已注册观察者个数**/
     public synchronized int countObservers() {
         return obs.size();
     }
 }
 
 
 package java.util;
 /**
  * 观察者接口，通过该接口实现业务处理
  */
 public interface Observer {
     /**
      * 接收主题数据更新的通知
      * @param o: 主题对象
      @ @param arg: 数据对象，根据业务场景，有可能为 null
      */
     void update(Observable o, Object arg);
 }
 

推模式实现代码：

 package com.study.design.Observer.jdk.push;
 
 import java.util.Observable;
 public class PushObservable extends Observable {
 
     @Override
     protected synchronized void setChanged() {
         super.setChanged();
     }
 }
 

 package com.study.design.Observer.jdk.push;
 
 import java.util.Observable;
 import java.util.Observer;
 
 public class PushObserver implements Observer {
     @Override
     public void update(Observable o, Object arg) {
         System.out.println("update:" + arg.toString());
     }
 }

 package com.study.design.Observer.jdk.push;
 
 public class PushTest {
 
     public static void main(String[] args) {
         // 创建观察者对象
         PushObserver concreteObserver = new PushObserver();
         // 创建主题对象
         PushObservable observable = new PushObservable();
         // 订阅
         observable.addObserver(concreteObserver);
         // 更新主题状态
         observable.setChanged();
         // 发送通知给观察者
         observable.notifyObservers("PushTest change");
     }
 }

拉模式实现步骤：

 package com.study.design.Observer.jdk.pull;
 
 import java.util.Observable;
 
 public class PullObservable extends Observable {
 
     private String data;
 
     @Override
     protected synchronized void setChanged() {
         super.setChanged();
     }
 
     public String getData() {
         return data;
     }
 
     public void setData(String data) {
         this.data = data;
     }
 }
 

 package com.study.design.Observer.jdk.pull;
 
 import java.util.Observable;
 import java.util.Observer;
 
 public class PullObserver implements Observer {
     @Override
     public void update(Observable o, Object arg) {
        if (o instanceof PullObservable){
            PullObservable pullObservable = (PullObservable)o;
            System.out.println("update:" + pullObservable.getData());
        }
     }
 }

 package com.study.design.Observer.jdk.pull;
 
 public class PullTest {
 
     public static void main(String[] args) {
         // 创建观察者对象
         PullObserver concreteObserver = new PullObserver();
         // 创建主题对象
         PullObservable observable = new PullObservable();
         // 订阅
         observable.addObserver(concreteObserver);
         // 更新数据
         observable.setData("PullTest change");
         // 更新主题状态
         observable.setChanged();
         // 发送通知给观察者
         observable.notifyObservers();
     }
 }

注意：当有多个观察者时，多次执行，观察者被调用的执行顺序是不一致的。

要点

• 观察者模式定义了对象之间一对多的关系
• 主题（也就是可观察者）用一个共同的接口来更新观察者
• 观察者和可观察者之间用松耦合方式结合，可观察者不知道观察者的细节，只知道观察者实现了观察者接口
• 使用此模式时，你可以从被观察者推或拉数据
• 有多个观察者时，不可以依赖特定的通知顺序
• 要注意 java.util.Observable 实现上所带来的的一些问题