观察者模式

目录

• 观察者模式
  • 案例
  • 模式介绍
  • 代码改造
  • 模式应用
  • 总结
  • 参考资料

观察者模式

案例

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

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类图

代码改造

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

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.启动之后会生成一个窗体：

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.cnblogs.com/phoegel/p/14203406.html