Java设计模式之-观察者模式（Observer）

如果你发现一件心仪的商品，但是由于双十一已经剁手了，只能等到打折再去买。为了及时获得该商品的打折信息，你有两种方式：

• “拉”：每过一会儿就到店里看一下，有没有相关的打折信息，把信息从店家“拉”到自己眼前；
• “推”：店家通过短信、邮件等方式将打折信息直接推送到自己眼前，当然你需要先告诉商家我要订阅这些信息（垃圾短信另当别论）

上面两种方式相比，我当然希望“推”模式，不用自己跑腿，只要和对方建立起信息变更的订阅关系，就可以被动的收到通知，这就是我们今天要说的观察者模式。（P.S. 传统意义上，观察者可以做成“推”或“拉”，但实际都是“推”，只是推的信息的多少）

观察者模式

PropertyChangeSupport.PNG 观察者模式

观察者模式有5个模块构成：

1. 抽象被观察者：定义了被观察者的抽象方法，比如添加观察者，移除观察者，通知观察者等；
2. 具体被观察者：实现了抽象被观察者的方法，不一定是extends或implements，也可能是包含了一个专门用于管理观察者的实例（如PropertyChangeSupport)；
3. 抽象观察者：定义了观察者需要实现的方法，该方法是与被观察者约定好的，统一接口的，表示在接收到被观察者推来的信息后应该怎样反馈；
4. 具体观察者：实现了抽象观察者的方法，定义了具体针对通知的响应行为，一般来说会影响客户端的表现；
5. 客户端：直接操作的是抽象被观察者接口，使被观察者改变，并获得反馈。

整个观察者模式如上所说，现在我们来看一下具体如何实现。

抽象被观察者

在Java中，抽象被观察者可以用一个普通类代替，其中保存一个数组或链表用于存放需要订阅变更的抽象观察者。这种模式比较原始，既然用了Java，最好是不要再重造轮子了，所以我们直接来看一下Java中的一个轮子-PropertyChangeSupport

很多文章中其实提到的是Observable，我学习的时候也是想用这个，但是@Deprecated(since="9") :

 * @deprecated
 * This class and the {@link Observer} interface have been deprecated.
 * The event model supported by {@code Observer} and {@code Observable}
 * is quite limited, the order of notifications delivered by
 * {@code Observable} is unspecified, and state changes are not in
 * one-for-one correspondence with notifications.
 * For a richer event model, consider using the
 * {@link java.beans} package.  For reliable and ordered
 * messaging among threads, consider using one of the concurrent data
 * structures in the {@link java.util.concurrent} package.
 * For reactive streams style programming, see the
 * {@link java.util.concurrent.Flow} API.
 */
@Deprecated(since="9")
public class Observable {

大意就是因为Observable局限性较大，通知的发送顺序不可预知，且状态的改变也不是与通知一一对应的。而它提到的一种替代则是java.beans.PropertyChangeSupport:

PropertyChangeSupport

其中主要的方法是

• 构造函数
• addPropertyChangeListener，增加观察者
• firePropertyChange，通知观察者
• removePropertyChangeListener，移除观察者

具体被观察者

一个PropertyChangeSupport已经能够作为一个抽象被观察者使用了，现在我们再写一个具体被观察者MyEntity:

public class MyEntity {
    private int visitCount;
    private PropertyChangeSupport observer = new PropertyChangeSupport(this);

    public void addObservers(PropertyChangeListener ob) {
        observer.addPropertyChangeListener(ob);
    }

    public void addObservers(String propertyName, PropertyChangeListener ob) {
        observer.addPropertyChangeListener(propertyName, ob);
    }

    public void visit() {
        ++visitCount;
        observer.firePropertyChange("visitCount", visitCount - 1, visitCount);
    }
}

MyEntity有一个visitCount属性，当visit()被调用时，该属性值加1，而后调用firePropertyChange通知所有已经订阅的PropertyChangeListener。可以看到我写了两个addObservers，一个有propertyName参数，另一个没有。

第一个addObservers(PropertyChangeListener ob)会通知所有的ob对象，而第二个addObservers(String propertyName, PropertyChangeListener ob)则是在firePropertyChange()的第一个参数与propertyName一致时才被通知到。

抽象观察者

其实在上面addObservers中的PropertyChangeListener就是一个抽象观察者，它其实是一个定义了变更响应方法propertyChange的接口：

/**
 * A "PropertyChange" event gets fired whenever a bean changes a "bound"
 * property.  You can register a PropertyChangeListener with a source
 * bean so as to be notified of any bound property updates.
 * @since 1.1
 */

public interface PropertyChangeListener extends java.util.EventListener {

    /**
     * This method gets called when a bound property is changed.
     * @param evt A PropertyChangeEvent object describing the event source
     *          and the property that has changed.
     */

    void propertyChange(PropertyChangeEvent evt);

}

而如果我们一直翻看firePropertyChange方法的底层代码，最后可以发现这么一个函数，它循环调用所有listener的propertyChange方法：

    private static void fire(PropertyChangeListener[] listeners, PropertyChangeEvent event) {
        if (listeners != null) {
            for (PropertyChangeListener listener : listeners) {
                listener.propertyChange(event);
            }
        }
    }

具体观察者

具体观察者通过实现PropertyChangeListener接口，来定义propertyChange具体应该做什么。我们可以单独建一个类来做，但更常见的做法是使用匿名内部类：

        MyEntity entity = new MyEntity();
        entity.addObservers(new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                System.out.println("Here we comes a change event!");
                System.out.println(evt.toString());
            }
        });

测试使用

其实就是一个简单的main函数，首先添加两个Observer，分别使用和不使用带有propertyName参数的函数，最后调用visit()使变更发生：

public class ObserverTest {
    public static void main(String[] args) {
        MyEntity entity = new MyEntity();
        entity.addObservers(new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                System.out.println("Here we comes a change event!");
                System.out.println(evt.toString());
            }
        });
        entity.addObservers("visitCount", new PropertyChangeListener() {
            @Override
            public void propertyChange(PropertyChangeEvent evt) {
                System.out.println("Change Event with property Name");
            }
        });
        entity.visit();
    }
}

该main函数执行结果如下：

Here we comes a change event!
java.beans.PropertyChangeEvent[propertyName=visitCount; oldValue=0; newValue=1; propagationId=null; source=com.mock.observers.MyEntity@77f03bb1]
Change Event with property Name