观察者模式详解

前言

  定义：观察者模式（有时又被称为发布-订阅模式、模型-视图模式、源-收听者模式或从属者模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。
  简单点概括成通俗的话来说，就是一个类管理着所有依赖于它的观察者类，并且它状态变化时会主动给这些依赖它的类发出通知。
  那么我们针对上面的描述给出观察者模式的类图：

  可以看到，我们的被观察者类Observable只关联了一个Observer的列表，然后在自己状态变化时，使用notifyObservers方法通知这些Observer，具体这些Observer都是什么，被观察者是不关心也不需要知道的。
  上面就将观察者和被观察者二者的耦合度降到很低了，而我们具体的观察者是必须要知道自己观察的是谁，所以它依赖于被观察者。
  下面博主给写出一个很简单的观察者模式，来使用Java代码简单诠释一下上面的类图。

首先是观察者类

//这个接口是为了提供一个统一的观察者做出相应行为的方法
public interface Observer {

    void update(Observable o);

}

再者是具体的观察者

public class ConcreteObserver1 implements Observer{

    public void update(Observable o) {
        System.out.println("观察者1观察到" + o.getClass().getSimpleName() + "发生变化");
        System.out.println("观察者1做出响应");
    }

}

public class ConcreteObserver2 implements Observer{

    public void update(Observable o) {
        System.out.println("观察者2观察到" + o.getClass().getSimpleName() + "发生变化");
        System.out.println("观察者2做出响应");
    }

}

下面是被观察者，它有一个观察者的列表，并且有一个通知所有观察者的方法，通知的方式就是调用观察者通用的接口行为update方法。下面我们看它的代码。

public class Observable {

    List<Observer> observers = new ArrayList<Observer>();

    public void addObserver(Observer o){
        observers.add(o);
    }

    public void changed(){
        System.out.println("我是被观察者，我已经发生变化了");
        notifyObservers();//通知观察自己的所有观察者
    }

    public void notifyObservers(){
        for (Observer observer : observers) {
            observer.update(this);
        }
    }
}

  这里面很简单，新增两个方法，一个是为了改变自己的同时通知观察者们，一个是为了给客户端一个添加观察者的公共接口。
  上面就将观察者和被观察者二者的耦合度降到很低了，而我们具体的观察者是必须要知道自己观察的是谁，所以它依赖于被观察者。
  下面我们使用客户端调用一下，看一下客户端如何操作。

public class Client {

    public static void main(String[] args) throws Exception {
        Observable observable = new Observable();
        observable.addObserver(new ConcreteObserver1());
        observable.addObserver(new ConcreteObserver2());

        observable.changed();
    }
}

输出结果

我是被观察者，我已经发生变化了
观察者1观察到Observable发生变化
观察者1做出响应
观察者2观察到Observable发生变化
观察者2做出响应

  可以看到我们在操作被观察者时，只要调用changed方法，观察者们就会做出相应的动作，而添加观察者这个行为算是准备阶段，将具体的观察者关联到被观察者上面去。

栗子

  下面博主给出一个有实际意义的例子，比如我们经常看的小说网站，都有这样的功能，就是读者可以订阅作者，这当中就有明显的观察者模式案例，就是作者和读者。他们的关系是一旦读者关注了一个作者，那么这个作者一旦有什么新书，就都要通知读者们，这明显是一个观察者模式的案例，所以我们可以使用观察者模式解决。
  由于JDK中为了方便开发人员，已经写好了现成的观察者接口和被观察者类，下面博主先给出JDK中现成的观察者和被观察者代码，外加自己的一点解释，来帮助一些读者对JDK中对观察者模式的支持熟悉一下。

先来观察者接口

//观察者接口，每一个观察者都必须实现这个接口
public interface Observer {
    //这个方法是观察者在观察对象产生变化时所做的响应动作，从中传入了观察的对象和一个预留参数
    void update(Observable o, Object arg);

}

下面是被观察者类

//被观察者类
public class Observable {
    //这是一个改变标识，来标记该被观察者有没有改变
    private boolean changed = false;
    //持有一个观察者列表
    private Vector 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);
    }
    //notifyObservers(Object arg)的重载方法
    public void notifyObservers() {
        notifyObservers(null);
    }
    //通知所有观察者，被观察者改变了，你可以执行你的update方法了。
    public void notifyObservers(Object arg) {
        //一个临时的数组，用于并发访问被观察者时，留住观察者列表的当前状态，这种处理方式其实也算是一种设计模式，即备忘录模式。
        Object[] arrLocal;
        //注意这个同步块，它表示在获取观察者列表时，该对象是被锁定的
        //也就是说，在我获取到观察者列表之前，不允许其他线程改变观察者列表
        synchronized (this) {
            //如果没变化直接返回
            if (!changed)
                return;
            //这里将当前的观察者列表放入临时数组
            arrLocal = obs.toArray();
            //将改变标识重新置回未改变
            clearChanged();
        }
        //注意这个for循环没有在同步块，此时已经释放了被观察者的锁，其他线程可以改变观察者列表
        //但是这并不影响我们当前进行的操作，因为我们已经将观察者列表复制到临时数组
        //在通知时我们只通知数组中的观察者，当前删除和添加观察者，都不会影响我们通知的对象
        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();
    }
}

  被观察者除了一点同步的地方需要特殊解释一下，其余的相信各位都能看明白各个方法的用途。其实上述JDK的类是有漏洞的，或者说，在我们使用观察者模式时要注意一个问题，就是notifyObservers这个方法中的这一段代码。

for (int i = arrLocal.length-1; i>=0; i--)
    ((Observer)arrLocal[i]).update(this, arg);

  在循环遍历观察者让观察者做出响应时，JDK没有去抓取update方法中的异常，所以假设在这过程中有一个update方法抛出了异常，那么剩下还未通知的观察者就全都通知不到了，所以博主个人比较疑惑这样的用意（博主无法想象JAVA类库的制造者没考虑到这个问题），是sun当时真的忘了考虑这一点，还是另有它意？当然各位读者如果有自己的见解可以告知博主，不过博主认为，不管是sun如此做是别有用意，还是真的欠考虑，我们都要注意在update方法里一定要处理好异常，个人觉得JDK中比较保险的做法还是如下这样。

for (int i = arrLocal.length-1; i>=0; i--){
    try {
        ((Observer)arrLocal[i]).update(this, arg);
    } catch (Throwable e) {
        e.printStackTrace();
    }
}

  这样无论其中任何一个update是否成功都不会影响其余的观察者进行更新状态，我们自己比较保险的做法就是给update方法整个加上try块，或者确认不会发生运行时异常。
  上面博主和各位一起分析了JDK中观察者模式的源码，下面我们就拿上述小说网的例子，做一个DEMO。
  首先要搞清楚在读者和作者之间是谁观察谁，很明显，应该是读者观察作者。所以作者是被观察者，读者是观察者，除了这两个类之外，我们还需要额外添加一个管理器帮我们管理下作者的列表便于读者关注，于是一个观察者模式的DEMO就出现了。如下，首先是读者类，博主在各个类都加了点注释。

读者类

// 读者类，要实现观察者接口
public class Reader implements Observer {

    private String name;

    public Reader(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    // 读者可以关注某一位作者，关注则代表把自己加到作者的观察者列表里
    public void subscribe(String writerName) {
        WriterManager.getInstance().getWriter(writerName).addObserver(this);
    }

    // 读者可以取消关注某一位作者，取消关注则代表把自己从作者的观察者列表里删除
    public void unsubscribe(String writerName) {
        WriterManager.getInstance().getWriter(writerName).deleteObserver(this);
    }

    // 当关注的作者发表新小说时，会通知读者去看
    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof Writer) {
            Writer writer = (Writer) o;
            System.out.println(name + "知道" + writer.getName() + "发布了新书《" + writer.getLastNovel() + "》，非要去看！");
        }
    }

}

作者类

//作者类，要继承自被观察者类
public class Writer extends Observable {
    private String name;// 作者的名称

    private String lastNovel;// 记录作者最新发布的小说

    public Writer(String name) {
        super();
        this.name = name;
        // 将作者添加到管理列表中
        WriterManager.getInstance().add(this);
    }

    // 作者发布新小说了，要通知所有关注自己的读者
    public void addNovel(String novel) {
        System.out.println(name + "发布了新书《" + novel + "》！");
        lastNovel = novel;
        // 状态改变
        setChanged();
        // 通知关注该作者的读者，我发布了新书
        notifyObservers();
    }

    public String getLastNovel() {
        return lastNovel;
    }

    public String getName() {
        return name;
    }
}

然后我们还需要一个管理器帮我们管理这些作者

//管理器，保持一份独有的作者列表
public class WriterManager {

    private Map<String, Writer> writerMap = new HashMap<String, Writer>();

    // 添加作者
    public void add(Writer writer) {
        writerMap.put(writer.getName(), writer);
    }

    // 根据作者姓名获取作者
    public Writer getWriter(String name) {
        return writerMap.get(name);
    }

    // 单例
    private WriterManager() {

    }

    public static WriterManager getInstance() {
        return WriterManagerInstance.instance;
    }

    private static class WriterManagerInstance {

        private static WriterManager instance = new WriterManager();

    }
}

测试

public class Test {
    public static void main(String[] args) {
        // 假设四个读者，两个作者
        Reader r1 = new Reader("张三");
        Reader r2 = new Reader("李四");
        Reader r3 = new Reader("王五");
        Reader r4 = new Reader("赵六");
        Writer w1 = new Writer("王思聪");
        Writer w2 = new Writer("韩寒");
        // 四人关注了王思聪
        r1.subscribe("王思聪");
        r2.subscribe("王思聪");
        r3.subscribe("王思聪");
        r4.subscribe("王思聪");
        // 王五和赵六还关注了韩寒
        r3.subscribe("韩寒");
        r4.subscribe("韩寒");

        // 作者发布新书就会通知关注的读者
        // 王思聪写了设计模式
        w1.addNovel("设计模式");
        System.out.println("");

        // 韩寒写了JAVA编程思想
        w2.addNovel("JAVA编程思想");
        System.out.println("");

        // 赵六取消关注韩寒
        r1.unsubscribe("王思聪");
        // 韩寒再写书将不会通知谢广坤
        w1.addNovel("观察者模式");
    }
}

输出结果

王思聪发布了新书《设计模式》！
赵六知道王思聪发布了新书《设计模式》，非要去看！
王五知道王思聪发布了新书《设计模式》，非要去看！
李四知道王思聪发布了新书《设计模式》，非要去看！
张三知道王思聪发布了新书《设计模式》，非要去看！

韩寒发布了新书《JAVA编程思想》！
赵六知道韩寒发布了新书《JAVA编程思想》，非要去看！
王五知道韩寒发布了新书《JAVA编程思想》，非要去看！

王思聪发布了新书《观察者模式》！
赵六知道王思聪发布了新书《观察者模式》，非要去看！
王五知道王思聪发布了新书《观察者模式》，非要去看！
李四知道王思聪发布了新书《观察者模式》，非要去看！

  我们使用观察者模式的用意是为了作者不再需要关心他发布新书时都要去通知谁，更重要的是他不需要关心他通知的是读者还是其它什么人，他只知道这个人是实现了观察者接口的，即我们的被观察者依赖的只是一个抽象的接口观察者接口，而不关心具体的观察者都有谁都是什么，比如以后要是游客也可以关注作者了，那么只要游客类实现观察者接口，那么一样可以将游客列入到作者的观察者列表中。
  另外，我们让读者自己来选择自己关注的对象，这相当于被观察者将维护通知对象的职能转化给了观察者，这样做的好处是由于一个被观察者可能有N多观察者，所以让被观察者自己维护这个列表会很艰难，这就像一个老师被许多学生认识，那么是所有的学生都记住老师的名字简单，还是让老师记住N多学生的名字简单？答案显而易见，让学生们都记住一个老师的名字是最简单的。
  另外，观察者模式分离了观察者和被观察者二者的责任，这样让类之间各自维护自己的功能，专注于自己的功能，会提高系统的可维护性和可重用性。
  观察者模式其实还有另外一种形态，就是事件驱动模型。
  业务场景概述：

• 观察者模式：发布（release）– 订阅（subscibe），变化（change）– 更新（update）
• 事件驱动模型：请求（request）– 响应（response），事件发生（occur）– 事件处理（handle）

ps:因作者能力有限，有错误的地方请见谅

• 喜欢这篇文章的话可以用快捷键 Ctrl + D 来收藏本页

最后更新： 2018年11月26日 17:48

原始链接： https://blog.hdqyf.club/2018/11/26/20181126-观察者模式详解/

Garen

赏

× 请我吃糖~