观察者模式

观察者模式

案例

张三他们最近把项目忙完了，公司也暂时没有其他的事做。所以大家在上班的时候都比较悠闲，但是组长说老板今天回来巡查工作情况，大家在老板来的时候注意一下就可以了。大家一听就默默的开始了自己的上班摸鱼模式。过了一会老板果然过来了，大家看到老板过来后调整一下姿势，开启认真工作模式。下面用代码的形式来模拟这一过程：

1.首先定义两个类：

员工类：

public class Employee {
    private String name;

    public void work() {
        System.out.println(this.name + "说：老板好");
        System.out.println(this.name + "调整姿势，认真工作中~~");
    }

    public Employee(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

老板类：

public class Boss {
    private String name;

    public void inspect() {
        System.out.println("老板" + this.name + "来巡查工作~~");
        System.out.println("老板说：大家好");
    }

    public Boss(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

2.模拟过程：

public class Main {
    public static void main(String[] args) {
        Employee zs = new Employee("张三");
        Employee ls = new Employee("李四");
        Employee ww = new Employee("王五");
        Boss zl = new Boss("赵六");
        System.out.println("大家都在上班摸鱼中~~");
        zl.inspect();
        System.out.println(zs.getName() + "看到老板" + zl.getName() + "来巡查工作");
        zs.work();
        System.out.println(ls.getName() + "看到老板" + zl.getName() + "来巡查工作");
        ls.work();
        System.out.println(ww.getName() + "看到老板" + zl.getName() + "来巡查工作");
        ww.work();
    }
}

3.结果：

大家都在上班摸鱼中~~
老板赵六来巡查工作~~
老板说：大家好
张三看到老板赵六来巡查工作
张三说：老板好
张三调整姿势，认真工作中~~
李四看到老板赵六来巡查工作
李四说：老板好
李四调整姿势，认真工作中~~
王五看到老板赵六来巡查工作
王五说：老板好
王五调整姿势，认真工作中~~

可以看到在老板来巡查的时候，每个人都各自看到了老板来巡查，然后各自开始转换工作状态，以期在老板心里留下个好的印象。但同时每个人都要注意到老板有没有来，如果有人没有注意老板来巡查，从而被老板发现上班在摸鱼的话，估计就离下岗不远了。这让张三想到了可以用观察者模式来改进一下，保证每个人都能观察到老板来巡查从而转换工作状态。

模式介绍

观察者模式（有时又被称为模型（Model）-视图（View）模式、源-收听者(Listener)模式或从属者模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。

角色构成

  • Subject（目标）：目标又称为主题，它是指被观察的对象。在目标中定义了一个观察者集合，一个观察目标可以接受任意数量的观察者来观察，它提供一系列方法来增加和删除观察者对象，同时它定义了通知方法notify()。目标类可以是接口，也可以是抽象类或具体类。
  • ConcreteSubject（具体目标）：具体目标是目标类的子类，通常它包含有经常发生改变的数据，当它的状态发生改变时，向它的各个观察者发出通知；同时它还实现了在目标类中定义的抽象业务逻辑方法（如果有的话）。如果无须扩展目标类，则具体目标类可以省略。
  • Observer（观察者）：观察者将对观察目标的改变做出反应，观察者一般定义为接口，该接口声明了更新数据的方法update()，因此又称为抽象观察者。
  • ConcreteObserver（具体观察者）：在具体观察者中维护一个指向具体目标对象的引用，它存储具体观察者的有关状态，这些状态需要和具体目标的状态保持一致；它实现了在抽象观察者Observer中定义的update()方法。通常在实现时，可以调用具体目标类的attach()方法将自己添加到目标类的集合中或通过detach()方法将自己从目标类的集合中删除。

UML类图

observer

代码改造

下面就根据观察者模式的角色构成对代码进行改造：

1.首先定义目标类极其实现类：

抽象目标类：

public abstract class Subject {
    // 保存观察者
    protected List<Observer> observers = new ArrayList<>();

    // 增加观察者方法
    public void add(Observer observer) {
        observers.add(observer);
    }

    // 删除观察者方法
    public void remove(Observer observer) {
        observers.remove(observer);
    }

    // 通知观察者方法
    public abstract void notifyObserver();
}

具体目标类，这里将 Boos 类当作具体被观察的类：

public class Boss extends Subject {
    private String name;

    public Boss(String name) {
        this.name = name;
    }

    public void inspect() {
        System.out.println("老板" + this.name + "来巡查工作~~");
        notifyObserver();
    }

    @Override
    public void notifyObserver() {
        System.out.println("老板说：大家好~~");
        for (Observer observer : observers) {
            observer.work();
        }
    }

    public String getName() {
        return name;
    }
}

2.然后定义观察者及其具体实现类：

抽象观察者类：

public abstract class Observer {
    public abstract void work();
}

具体观察者类，将 Employee 类当作具体观察者：

public class Employee extends Observer {
    private String name;

    public Employee(String name) {
        this.name = name;
    }

    @Override
    public void work() {
        System.out.println(this.name + "说：老板好");
        System.out.println(this.name + "调整姿势，认真工作中~~");
    }

    public String getName() {
        return name;
    }
}

3.模拟过程：

public class Main {
    public static void main(String[] args) {
        Employee zs = new Employee("张三");
        Employee ls = new Employee("李四");
        Employee ww = new Employee("王五");
        Boss zl = new Boss("赵六");
        zl.add(zs);
        zl.add(ls);
        zl.add(ww);
        System.out.println("大家都在上班摸鱼中~~");
        zl.inspect();
    }
}

4.模拟结果：

大家都在上班摸鱼中~~
老板赵六来巡查工作~~
老板说：大家好~~
张三说：老板好
张三调整姿势，认真工作中~~
李四说：老板好
李四调整姿势，认真工作中~~
王五说：老板好
王五调整姿势，认真工作中~~

可以看到通过引入抽象的目标类，使其提供维护观察者的方法和通知观察者的方法，使得目标类发生变化时可以通过具体的通知方法通知观察者对象。同时引入抽象的观察者类，它定义了观察到目标类变化后将要执行的动作，方便目标类进行使用。在这里的案例中，这一流程可以看成是老板赵六来公司巡查工作情况，与大家打招呼后（相当于通知了大家及观察者），而张三他们就根据老板来公司这一动作变化，切换自己的工作状态，这样老板一来到办公室巡查就可以发现同时改变自己的状态，就不用担心被老板发现上班摸鱼了^o^/。

除了我们自己编写抽象目标类观察者类以外，JDK 中也提供了相关的目标类和观察者接口，可以直接继承目标类(java.util.Observable) 并实现观察者接口(java.util.Observer) 也可以达到上面的效果。

  • java.util.Observable 目标类源码：
public class Observable {
    // 标志是否发生改变
    private boolean changed = false;
    // 保存观察者的容器，使用 Vector 保证线程安全
    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();
            // 将状态重置为 false
            clearChanged();
        }

        // 循环通知观察者
        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

    // 清空观察者容器
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    // 设置是否改变为 true
    protected synchronized void setChanged() {
        changed = true;
    }

    // 重置改变为 false
    protected synchronized void clearChanged() {
        changed = false;
    }

    // 判断是否发生改变
    public synchronized boolean hasChanged() {
        return changed;
    }

    // 获取当前观察者个数
    public synchronized int countObservers() {
        return obs.size();
    }
}
  • java.util.Observer 观察者接口源码：
public interface Observer {
    /**
     * 声明通知方法，当目标类改变时调用
     *
     * @param   o     目标类对象
     * @param   arg   目标类对象调用时传递的额外参数，不传则为 null
     */
    void update(Observable o, Object arg);
}

下面给出使用的示例代码：

1.继承目标类：

public class BossObservable extends Observable {
    private String name;

    public BossObservable(String name) {
        this.name = name;
    }

    public void inspect() {
        System.out.println("老板" + this.name + "来巡查工作~~");
        System.out.println("老板说：大家好~~");
        // 设置状态已改变才会通知到观察者
        super.setChanged();
        // 通知注册的观察者
        super.notifyObservers();
    }

    public String getName() {
        return name;
    }
}

2.实现观察者接口：

public class EmployeeObserver implements Observer {
    private String name;

    public EmployeeObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(Observable o, Object arg) {
        System.out.println(this.name + "说：老板好");
        System.out.println(this.name + "调整姿势，认真工作中~~");
    }

    public String getName() {
        return name;
    }
}

3.测试：

public class Main {
    public static void main(String[] args) {
        EmployeeObserver zs = new EmployeeObserver("张三");
        EmployeeObserver ls = new EmployeeObserver("李四");
        EmployeeObserver ww = new EmployeeObserver("王五");
        BossObservable zl = new BossObservable("赵六");
        zl.addObserver(zs);
        zl.addObserver(ls);
        zl.addObserver(ww);
        System.out.println("大家都在上班摸鱼中~~");
        zl.inspect();
    }
}

4.结果：

大家都在上班摸鱼中~~
老板赵六来巡查工作~~
老板说：大家好~~
王五说：老板好
王五调整姿势，认真工作中~~
李四说：老板好
李四调整姿势，认真工作中~~
张三说：老板好
张三调整姿势，认真工作中~~

可以看到达到了相同的效果。

模式应用

观察者模式的应用非常广泛，下面举一个 Swing 例子说明它实际的应用。

1.首先定义一个事件监听器：

// 这里相当于模式中的观察者
public class ButtonListener implements ActionListener {
    private String name;

    public ButtonListener(String name) {
        this.name = name;
    }

    // 被点击时被调用
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("触发了事件" + this.name);
    }
}

2.使用示例

public class Main {
    public static void main(String[] args) {
        // 创建 JFrame 实例
        JFrame jf = new JFrame();
        // 设置宽高
        jf.setSize(200, 100);
        // 设置在窗口中间打开
        jf.setLocationRelativeTo(null);
        // 设置默认关闭操作
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        // 创建一个按钮
        JButton jb = new JButton("click me");
        // 创建两个监听器
        ButtonListener buttonListenerA = new ButtonListener("监听器A");
        ButtonListener buttonListenerB = new ButtonListener("监听器B");
        // 注册监听器
        jb.addActionListener(buttonListenerA);
        jb.addActionListener(buttonListenerB);
        // 添加到窗体中
        jf.add(jb);
        // 设置界面可见
        jf.setVisible(true);
    }
}

这里在一个窗体中定义了一个按钮，并在按钮上面添加了自定义的监听器，它会在按钮点击时被触发。

2.启动之后会生成一个窗体：

observer-button

3.在点击按钮之后，会打印出相关语句：

触发了事件监听器B
触发了事件监听器A

通过上面的代码可以看出 JButton 是具体目标类，ButtonListener 是具体观察者实现类。经过源码追踪，可以找到抽象目标类 AbstractButton 接口和观察者接口 ActionListener。其中 ActionListener 接口主要声明了通知接口，具体代码如下：

public interface ActionListener extends EventListener {

    // 通知方法
    public void actionPerformed(ActionEvent e);

}

AbstractButton 抽象类中定义保存观察者的容器类，并提供了添加、移除观察者的方法，具体相关代码如下：

// 保存观察者的容器类
protected EventListenerList listenerList = new EventListenerList();

// 添加观察者方法
public void addActionListener(ActionListener l) {
    listenerList.add(ActionListener.class, l);
}

// 删除观察者方法
public void removeActionListener(ActionListener l) {
    if ((l != null) && (getAction() == l)) {
        setAction(null);
    } else {
        listenerList.remove(ActionListener.class, l);
    }
}

// 通知观察者方法
protected void fireActionPerformed(ActionEvent event) {
    // 获取观察者集合
    Object[] listeners = listenerList.getListenerList();
    // 构造事件对象
    ActionEvent e = null;
    // 从列表中倒数第二个开始通知观察者
    for (int i = listeners.length-2; i>=0; i-=2) {
        // 判断是否是 ActionListener 类标识
        if (listeners[i]==ActionListener.class) {
            if (e == null) {
                String actionCommand = event.getActionCommand();
                if(actionCommand == null) {
                    actionCommand = getActionCommand();
                }
                // 构造事件对象
                e = new ActionEvent(AbstractButton.this,
                                    ActionEvent.ACTION_PERFORMED,
                                    actionCommand,
                                    event.getWhen(),
                                    event.getModifiers());
            }
            // 真正调用我们编写的通知代码
            // 这里用 i+1 是因为在添加的时候除了添加实际观察者对象外，会先添加一个ActionListener.class标识
            ((ActionListener)listeners[i+1]).actionPerformed(e);
        }
    }
}

通过源码分析，真正保存观察者对象的类是 EventListenerList 它在内部维护了一个 protected transient Object[] listenerList 数组用于观察者对象的相关操作。上面在调用实际观察者对象时使用 ((ActionListener)listeners[i+1]).actionPerformed(e) 是因为在添加时在 EventListenerList 内部会先保存一个 ActionListener.class 对象，标识判断，具体代码如下：

public synchronized <T extends EventListener> void add(Class<T> t, T l) {
    // null 值检查
    if (l==null) {
        return;
    }
    // 判断 l 是不是 t 的子类
    if (!t.isInstance(l)) {
        throw new IllegalArgumentException("Listener " + l +
                                     " is not of type " + t);
    }
    // 判断 listenerList 为空则直接将 t（这里是 ActionListener 接口）,l（自定义 ButtonListener） 保存进 listenerList，不为空则添加到末尾两个位置
    if (listenerList == NULL_ARRAY) {
        // if this is the first listener added,
        // initialize the lists
        listenerList = new Object[] { t, l };
    } else {
        // 
        int i = listenerList.length;
        Object[] tmp = new Object[i+2];
        System.arraycopy(listenerList, 0, tmp, 0, i);

        tmp[i] = t;
        tmp[i+1] = l;

        listenerList = tmp;
    }
}

总结

1.主要优点

  • 观察者模式可以实现表示层和数据逻辑层的分离，定义了稳定的消息更新传递机制，并抽象了更新接口，使得可以有各种各样不同的表示层充当具体观察者角色。

  • 观察者模式在观察目标和观察者之间建立一个抽象的耦合。观察目标只需要维持一个抽象观察者的集合，无须了解其具体观察者。由于观察目标和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。

  • 观察者模式支持广播通信，观察目标会向所有已注册的观察者对象发送通知，简化了一对多系统设计的难度。

  • (4) 观察者模式满足“开闭原则”的要求，增加新的具体观察者无须修改原有系统代码，在具体观察者与观察目标之间不存在关联关系的情况下，增加新的观察目标也很方便。

2.主要缺点

  • 如果一个观察目标对象有很多直接和间接观察者，将所有的观察者都通知到会花费很多时间。
  • 如果在观察者和观察目标之间存在循环依赖，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
  • 观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

3.适用场景

  • 一个抽象模型有两个方面，其中一个方面依赖于另一个方面，将这两个方面封装在独立的对象中使它们可以各自独立地改变和复用。
  • 一个对象的改变将导致一个或多个其他对象也发生改变，而并不知道具体有多少对象将发生改变，也不知道这些对象是谁。
  • 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

参考资料

  • 大话设计模式
  • 设计模式Java版本-刘伟

本篇文章github代码地址：https://github.com/Phoegel/design-pattern/tree/main/observer
转载请说明出处，本篇博客地址：https://www.jianshu.com/p/cd063fbf45f1

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,378评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,356评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,702评论 0赞 342
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,259评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,263评论 5赞 371
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,036评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,349评论 3赞 400
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,979评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,469评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,938评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,059评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,703评论 4赞 323
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,257评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,262评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,485评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,501评论 2赞 354
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,792评论 2赞 345