Java设计模式之-观察者模式（Observer）
Java设计模式之-观察者模式（Observer）
如果你发现一件心仪的商品，但是由于双十一已经剁手了，只能等到打折再去买。为了及时获得该商品的打折信息，你有两种方式：
- “拉”：每过一会儿就到店里看一下，有没有相关的打折信息，把信息从店家“拉”到自己眼前；
- “推”：店家通过短信、邮件等方式将打折信息直接推送到自己眼前，当然你需要先告诉商家我要订阅这些信息（垃圾短信另当别论）
上面两种方式相比，我当然希望“推”模式，不用自己跑腿，只要和对方建立起信息变更的订阅关系，就可以被动的收到通知，这就是我们今天要说的观察者模式。（P.S. 传统意义上，观察者可以做成“推”或“拉”，但实际都是“推”，只是推的信息的多少）
观察者模式
PropertyChangeSupport.PNG
观察者模式
观察者模式有5个模块构成：
- 抽象被观察者：定义了被观察者的抽象方法，比如添加观察者，移除观察者，通知观察者等；
- 具体被观察者：实现了抽象被观察者的方法，不一定是extends或implements，也可能是包含了一个专门用于管理观察者的实例（如PropertyChangeSupport)；
- 抽象观察者：定义了观察者需要实现的方法，该方法是与被观察者约定好的，统一接口的，表示在接收到被观察者推来的信息后应该怎样反馈；
- 具体观察者：实现了抽象观察者的方法，定义了具体针对通知的响应行为，一般来说会影响客户端的表现；
- 客户端：直接操作的是抽象被观察者接口，使被观察者改变，并获得反馈。
整个观察者模式如上所说，现在我们来看一下具体如何实现。
抽象被观察者
在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
