观察者模式——心有灵犀

一、定义

定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。

二、第一个小栗子

举个小栗子帮助理解。
天气预报，一个气象台检测温度、气压、湿度，气象公司获得这些数据。气象台是被观察者，气象公司是观察者。

//抽象被观察者
public interface Subject {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObservers();
}

//气象台
public class WeatherDataSt implements Subject {
    private float temperatrue;
    private float pressure;
    private float humidity;

    private List<Observer> observers;
    public WeatherDataSt()
    {
        observers=new ArrayList<Observer>();
    }

//注册观察者
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);

    }
//删除观察者
    @Override
    public void removeObserver(Observer o) {
        if (observers.contains(o)){
            observers.remove(o);
        }
    }
//更新信息通知观察者
    @Override
    public void notifyObservers() {
        observers.forEach(observer -> observer.update(temperatrue,pressure,humidity));
    }

    public void setData(float temperatrue,float pressure,float humidity){
        this.temperatrue = temperatrue;
        this.pressure = pressure;
        this.humidity = humidity;
    }
}

//抽象观察者
public interface Observer {
    public void update(float mTemperatrue,float mPressure,float mHumidity);
}

//今日天气预报公司
public class CurrentConditions implements Observer {
    private float teperatrue,pressure,humidity;
    @Override
    public void update(float teperatrue, float pressure, float humidity) {
        this.humidity = humidity;
        this.pressure = pressure;
        this.teperatrue = teperatrue;
        display();
    }

    public void display() {
        System.out.println("***Today teperatrue:" + teperatrue + "***");
        System.out.println("***Today pressure:" + pressure + "***");
        System.out.println("***Today humidity:" + humidity + "***");

    }
}

//明日天气公司
public class ForcastConditions implements Observer{
    private float temperatrue;
    private float pressure;
    private float humidity;
    @Override
    public void update(float temperatrue, float pressure, float humidity) {
        // TODO Auto-generated method stub
        this.temperatrue=temperatrue;
        this.pressure=pressure;
        this.humidity=humidity;

        display();
    }
    public void display()
    {
        System.out.println("**明天温度:"+(temperatrue+Math.random())+"**");
        System.out.println("**明天气压:"+(pressure+10*Math.random())+"**");
        System.out.println("**明天湿度:"+(humidity+Math.random())+"**");
    }
}

//测试
public class WeatherTest {
    public static void main(String[] args) {
        Observer o1 = new CurrentConditions();
        Observer o2 = new ForcastConditions();

        WeatherDataSt subject = new WeatherDataSt();
        subject.registerObserver(o1);
        subject.registerObserver(o2);

        subject.setData(20,30,40);
        subject.notifyObservers();
    }
}

//打印：
***Today teperatrue:20.0***
***Today pressure:30.0***
***Today humidity:40.0***
**明天温度:20.748446673124064**
**明天气压:39.210757687486826**
**明天湿度:40.14864883880736**

Subject被观察者

定义被观察者必须实现的职责，它必须能够动态增加、取消观察者。它一般是抽象类或者是实现类，仅仅完成作为被观察者必须实现的职责：管理观察者并通知观察者。

Observer观察者

观察者接收到消息后，即进行update（更新方法）操作，接收到的信息进行处理。

三、第二个栗子

这个栗子原版出自《设计模式之禅（第二版）》，李斯和韩非子是师兄弟，韩非子在韩国，李斯在秦国，各奉君主，李斯经常观察韩非子的日常。这样韩非子就是被观察者，李斯是观察者。

//抽象被观察者
public abstract class  Observable {
    private List<Observer> observers = Collections.synchronizedList(new ArrayList<>());
    public void addObserver(Observer observer){
        this.observers.add(observer);
    }
    public void deleteObserver(Observer observer){
        this.observers.remove(observer);
    }
    public void notifyObservers(String context){
        observers.forEach(observer -> observer.update(context));
    }
}

//韩非子
public class HanFeiZi extends Observable {
    //韩非子要吃饭了
    public void haveBreakfast(){
        super.notifyObservers("韩非子在吃饭");
    }

    //韩非子在娱乐
    public void haveFun(){
        super.notifyObservers("韩非子在娱乐");
    }

}

//抽象观察者
public interface Observer {
    void update(String context);
}

//李斯
public class Lisi implements Observer {
    @Override
    public void update(String context) {
        System.out.println("李斯：观察到韩国活动，开始汇报秦始皇。。。。");
        this.reportToQinShiHuang(context);
        System.out.println("李斯报告完毕");
    }

    //汇报给秦始皇
    public void reportToQinShiHuang(String context){
        System.out.println("李斯报告----"+context);
    }
}

//测试
public class DaDian {
    public static void main(String[] args) {
        Observer lisi = new Lisi();
        Observer zhaogao = new ZhaoGao();

        System.out.println("--------------监视韩非子---------------");
        HanFeiZi hanFeiZi = new HanFeiZi();

        hanFeiZi.addObserver(lisi);
        hanFeiZi.addObserver(zhaogao);

        hanFeiZi.haveBreakfast();
        hanFeiZi.haveFun();
    }
    
}

打印：
--------------监视韩非子---------------
李斯：观察到韩国活动，开始汇报秦始皇。。。。
李斯报告----韩非子在吃饭
李斯报告完毕
赵高：观察到韩国活动，开始汇报秦始皇。。。。
赵高报告----韩非子在吃饭
赵高报告完毕
李斯：观察到韩国活动，开始汇报秦始皇。。。。
李斯报告----韩非子在娱乐
李斯报告完毕
赵高：观察到韩国活动，开始汇报秦始皇。。。。
赵高报告----韩非子在娱乐
赵高报告完毕

看了两个栗子，应该了解观察者模式是什么了吧。

观察者模式的优点

观察者和被观察者之间是抽象耦合，如此设计，则不管增加观察者还是被观察者都非常容易扩展。
建立一套触发机制。

如果秦始皇不太相信李斯，就让赵高也去观察，并且同时观察韩国君的行动。

增加被观察者：韩国君

public class HanGuoJun extends Observable {

    public void  sleep(){
        super.notifyObservers("韩国君睡觉了");
    }
}

增加观察者：赵高

public class ZhaoGao implements Observer {
    @Override
    public void update(String context) {
        System.out.println("赵高：观察到韩国活动，开始汇报秦始皇。。。。");
        this.reportToQinShiHuang(context);
        System.out.println("赵高报告完毕");
    }

    //汇报给秦始皇
    public void reportToQinShiHuang(String context){
        System.out.println("赵高报告----"+context);
    }
}

测试：

public class DaDian {
    public static void main(String[] args) {
        Observer lisi = new Lisi();
        Observer zhaogao = new ZhaoGao();

        System.out.println("--------------监视韩非子---------------");
        HanFeiZi hanFeiZi = new HanFeiZi();

        hanFeiZi.addObserver(lisi);
        hanFeiZi.addObserver(zhaogao);

        hanFeiZi.haveBreakfast();
        hanFeiZi.haveFun();

        System.out.println("--------------监视韩国君---------------");

        HanGuoJun hanGuoJun = new HanGuoJun();
        hanGuoJun.addObserver(zhaogao);
        hanGuoJun.sleep();
    }
}

观察者模式的缺点

观察者模式需要考虑一下开发效率和运行效率问题，一个被观察者，多个观察者，开发和调试就会比较负责，而且在java中消息的通知默认是顺序执行，一个观察者卡壳，会影响整体的执行效率。这种情况下，一般考虑采用异步的方式。

多级触发的效率更是令人担忧

使用场景

关联行为场景。需要注意的是，关联行为是可拆分的，而不是“组合”关系。
事件多级触发场景。
跨系统的消息交换场景，如消息队列的处理机制。

注意事项

广播链的问题

一个观察者可以有双重身份，既是观察者，也是被观察者，这样广播链就比较复杂了，可维护性非常差，
根据经验建议，在一个观察者模式中最多出现一个对象既是观察者也是被观察者，也就是说消息最多转发一次。
注意它和责任链模式的最大区别就是观察者广播链在传播的过程中消息是随时改变的，它是由相邻的两个节点协商的消息结构；
而责任链模式在消息传递过程中基本上保持消息不可变，如果改变也只是在原有的消息上进行修正。

异步处理问题

被观察者发生动作了，观察者要做出回应，如果观察者比较多，而且处理时间比较长怎么办？那就应异步呗，异步处理就要考虑线程安全和队列的问题。

四、java内置观察者和被观察者

java内部为我们提供了两个类，观察者（java.util.Observable）是个类,被观察者（java.util.Observer）是个接口。

看下源码：

java.util.Observable

package java.util;
public class Observable {
    private boolean changed = false;
    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();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }


    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }


    protected synchronized void setChanged() {
        changed = true;
    }


    protected synchronized void clearChanged() {
        changed = false;
    }

   
    public synchronized boolean hasChanged() {
        return changed;
    }

    public synchronized int countObservers() {
        return obs.size();
    }
}

java.util.Observer

package java.util;

public interface Observer {
    void update(Observable o, Object arg);
}

从源码看出java.util.Observable里的方法基本都是同步方法，线程安全的。

通过java内置的设计模式实现第二个栗子

public class Hanfeizi extends Observable {
    public void haveBreakfast(){
        super.setChanged();
        super.notifyObservers("韩非子在吃饭");
    }
}

public class Hanguojun extends Observable {
    public void sleep(){
        super.setChanged();
        super.notifyObservers("韩国君在睡觉");
    }
}


public class Lisi implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println(o);
        this.reportToQinShiHuang(o,arg);
    }

    //汇报给秦始皇
    public void reportToQinShiHuang(Observable o,Object arg){
        System.out.println("李斯报告----"+arg.toString());
    }
}

public class test {
    public static void main(String[] args) {
        Lisi lisi = new Lisi();
        Hanfeizi hanfeizi = new Hanfeizi();
        hanfeizi.addObserver(lisi);
        hanfeizi.haveBreakfast();

        Hanguojun hanguojun = new Hanguojun();
        hanguojun.addObserver(lisi);
        hanguojun.sleep();
    }
}

打印：

javaInDemo.Hanfeizi@4554617c
李斯报告----韩非子在吃饭
javaInDemo.Hanguojun@74a14482
李斯报告----韩国君在睡觉

项目中真实的观察者模式

为什么说“真实”呢？因为我们刚刚讲的那些事太标准的模式了，在系统设计中会对观察者模式进行改造或者改装，主要在以下2个方面：

1、观察者和被观察者之间的消息沟通：

观察者和被观察者之间的消息沟通，被观察者状态改变会触发观察者的一个行为，同时会传递一个消息给观察者，这是正确的，在实际中一般的做法是：观察者中的update方法接受两个参数，一个是被观察者，一个是DTO（Data Transfer Object，据传输对象），DTO一般是一个纯洁的JavaBean，由被观察者生成，由观察者消费。

当然，如果考虑到远程传输，一般消息是以XML格式传递。

2、观察者响应方式：

观察者一个比较复杂的逻辑，它要接受被观察者传递过来的信息，同时还要对他们进行逻辑处理，在一个观察者多个被观察者的情况下，性能就需要提到日程上来考虑了，为什么呢？如果观察者来不及响应，被观察者的执行时间是不是也会被拉长？那现在的问题就是：观察者如何快速响应？有两个办法：

一是采用多线程技术，甭管是被观察者启动线程还是观察者启动线程，都可以明显地提高系统性能，这也就是大家通常所说的异步架构。

二是缓存技术，甭管你谁来，我已经准备了足够的资源给你了，我保证快速响应，这当然也是一种比较好方案，代价就是开发难度很大，而且压力测试要做的足够充分，这种方案也就是大家说的同步架构。

虽然java给我提供了观察者模式的实现，但是实际开发中不一定能满足，就比如Observable，这个类是具体类，只要是实现观察者就必须继承他，倘若这个实现观察者类还要继承一个类，那就没办法了，java只能是单继承，这就增加了耦合。

项目的架构讲究的是高内聚，低耦合。

本文讲解的观察者过于浅显，举的栗子也不太符合实际运用。真正的理解还是要实际开发中去融汇贯通。

源码地址：
https://gitee.com/stefanpy/DesignPattern

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 202,802评论 5赞 476
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,109评论 2赞 379
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 149,683评论 0赞 335
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,458评论 1赞 273
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,452评论 5赞 364
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,505评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,901评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,550评论 0赞 256
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,763评论 1赞 296
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,556评论 2赞 319
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,629评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,330评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,898评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,897评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,140评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,807评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,339评论 2赞 342