观察者模式

应用场景

建立一个对象与多个对象之间的一对多的依赖关系，一个对象状态发生改变时将会通知其他对象，发生状态改变的对象为subject，变化主体，被通知的对象为observer，一个subject可以有多个observer，且observer之间相互独立，可以随机增减observer。常见的例子有微信的公众号与关注的人，公众号为subject，关注的人为observer，当有新推送时，所有的observer都能收到消息。

定义

观察者模式定义了对象之间的一对多依赖关系，被观察的是有状态并可以修改状态的subject（主体），观察者为observer，当subject状态改变时，它的所有observer都会受到通知并自动更新。

例子

我们用微信公众号与微信用户做为例子，一个微信公众号可以有多个微信用户关注，当公众号更新消息时所有关注用户都能收到信息，一个微信用户能够关注多个公众号，当其中任意公众号更新时都能收到消息。意思是要实现多对多的依赖关系，但不要忘记，多对多其实包含了一对多，多个一对多的关系就组成了多对多，所以适合使用观察者模式，公众号为subject，用户为observer，下面是uml类图

WechatSubscription是微信公众号类，实现subject接口，数组observers存储它的观察者（微信用户），有增删观察者的方法，同时在发布文章后可以通知观察者。
Wechatuser是微信用户类，实现observer接口，subjects存储用户所关注的公众号，通过update方法获取公众号的消息。

下面是代码
Observer.java

package priv.mxz.observer_pattern;import sun.rmi.runtime.Log;import java.util.ArrayList;interface Observer {void update(Subject subject, Object obj);
}class WechatUser implements Observer{private ArrayList<Subject> subjects;private String name;public WechatUser(String name){subjects=new ArrayList<Subject>();this.name=name;}@Overridepublic void update(Subject subject, Object obj) {if (obj!=null && obj instanceof String) {System.out.println("wechat user "+ name+" got article from "+ subject);System.out.println("article detail: "+obj);}}public void follow(Subject subject){if (subject!=null){subjects.add(subject);subject.registerObserver(this);}}public void unfollow(Subject subject){if (subject!=null){int index=subjects.indexOf(subject);if (index>=0){subjects.remove(index);subject.removeObserver(this);}}}}

Subject.java

package priv.mxz.observer_pattern;import jdk.nashorn.api.scripting.ScriptObjectMirror;
import jdk.nashorn.internal.scripts.JD;import java.util.ArrayList;interface Subject {void registerObserver(Observer observer);void removeObserver(Observer observer);void notifyObservers();
}class WechatSubscription implements Subject{private ArrayList<Observer> observers;private String article;private String name;public WechatSubscription(String name){observers=new ArrayList<Observer>();article="no article now";this.name=name;}@Overridepublic void registerObserver(Observer observer) {if (observer!=null)observers.add(observer);}@Overridepublic void removeObserver(Observer observer) {int index=observers.indexOf(observer);if (index>=0)observers.remove(index);}@Overridepublic void notifyObservers() {for (Observer observer:observers) {observer.update(this,article);}}public void pushArticle(String article) {this.article = article;notifyObservers();}}

ObserverPattern.java

package priv.mxz.observer_pattern;public class ObserverPattern {public static void main(String[] args) {WechatUser mike=new WechatUser("Mike");WechatUser jason=new WechatUser("Jason");WechatSubscription taobao=new WechatSubscription("Taobao");WechatSubscription alipay=new WechatSubscription("Alipay");System.out.println("wechat user mike follow taobao");System.out.println("wechat user mike follow alipay");mike.follow(taobao);mike.follow(alipay);System.out.println("wechat user jason follow alipay");jason.follow(alipay);System.out.println("taobao push first article");taobao.pushArticle("taobao first article");System.out.println("alipay push first article");alipay.pushArticle("alipay first article");System.out.println("wechat user jason unfollow alipay");mike.unfollow(alipay);System.out.println("alipay push second article");alipay.pushArticle("alipay second article");}
}

先把输出结果展示出来

wechat user mike follow taobao
wechat user mike follow alipay
wechat user jason follow alipay
taobao push first article
wechat user Mike got article from priv.mxz.observer_pattern.WechatSubscription@1540e19d
article detail: taobao first article
alipay push first article
wechat user Mike got article from priv.mxz.observer_pattern.WechatSubscription@677327b6
article detail: alipay first article
wechat user Jason got article from priv.mxz.observer_pattern.WechatSubscription@677327b6
article detail: alipay first article
wechat user jason unfollow alipay
alipay push second article
wechat user Jason got article from priv.mxz.observer_pattern.WechatSubscription@677327b6
article detail: alipay second article

ObserverPattern中有函数入口，首先定义两个微信用户mike和jason，然后定义两个公众号taobao和alipay，然后让mike关注taobao和alipay，jason只关注alipay。随后taobao发送文章，查看输出发现只有mike收到了推送，jason没有，因为jason没有关注mike，然后让alipay也发送文章，此时mike和jason都收到了文章，最后让mike取消关注alipay，alipay再发送文章只有jason收到了推送。由此可见观察者模式可以很方便地增删观察者，在subject状态更新时，能及时地把消息发送给所有注册的观察者。

java内置的观察者模式

在JDK的java.util包中，有Observable类和Observer接口，两者共同实现了java内置的观察者模式

Observable类

Observable提供了如下方法

1. addObserver()
2. deleteObserver()
3. notifyObservers()
4. serChanged()

继承Observable类的类充当观察者模式中subject的角色,子类不需要自己维护所有观察者的列表，用户可以决定采用push或者pull的方式更新消息，差别在于调用notifyObservers()还是notifyObservers(Object arg) 前者对应pull方式，后者对应push方法，arg就是subject主动push给观察者的数据。如果没有arg，那么就需要观察者从subject实例中pull数据

setChanged()方法用于标志状态发生变化，在调用notifyObservers()或者notifyObservers(Object arg)前必须调用setChanged()，否则实际上不会通知观察者。

因为java不支持多重继承，所以一个类继承了Observable类后无法再继承其他类，有必要的话可以自己实现subject接口来取代Observable类

Observer接口

Observer接口只定义了一个方法
update(Observable o,Object arg)
第一个参数是发送通知的Observable实例，第二个是notifyObservers(Object arg)中的arg，如果arg不为空，则对应push方式，如果arg为空，则对应pull方式，观察者从o中拉取数据。

优缺点

优点

1. 定义了对象间的一对多依赖关系，且观察者可以随时增删。
2. 实现了表示层与数据逻辑层的分离，当数据逻辑层发生变化时能及时通知所有相关表示层

缺点

1. 如果一个观察目标对象有很多直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间，而且如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
2. java自带的观察者模式有较大限制，Observable设计成一个类限制了自带的观察者模式的使用。