了解观察者模式--通过详细代码与例子

观察者模式

应用场景

建立一个对象与多个对象之间的一对多的依赖关系，一个对象状态发生改变时将会通知其他对象，发生状态改变的对象为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;
    }

    @Override
    public 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;
    }

    @Override
    public void registerObserver(Observer observer) {
        if (observer!=null)
            observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        int index=observers.indexOf(observer);
        if (index>=0)
            observers.remove(index);
    }

    @Override
    public 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设计成一个类限制了自带的观察者模式的使用。