016.观察者模式

李斯和韩非子都是荀子的学生，李斯是师兄，韩非子是师弟，若干年后，李斯成为秦国的上尉，致力于统一全国，于是安插了间谍到各个国家的重要人物的身边进行监视，韩非子身边也有很多间谍，韩非子早饭吃的什么，晚上在做什么娱乐，李斯都了如指掌，我们先通过程序把这个过程展现一下，看看李斯是怎么监控韩非子的，先看类图：

程序实现：

public interface IHanFeiZi {

    // 吃早饭
    void haveBreakfast();

    // 娱乐
    void haveFun();

}

/**
 * 被观察者
 */
public class HanFeiZi implements IHanFeiZi {

    // 韩非子是否在吃饭
    private boolean isHaveBreakfast = false;
    // 韩非子是否在娱乐
    private boolean isHaveFun = false;

    @Override
    public void haveBreakfast() {
        System.out.println("韩非子: 开始吃饭...");
        isHaveBreakfast = true;
    }

    @Override
    public void haveFun() {
        System.out.println("韩非子: 开始娱乐...");
        isHaveFun = true;
    }

    public boolean isHaveBreakfast() {
        return this.isHaveBreakfast;
    }

    public boolean isHaveFun() {
        return this.isHaveFun;
    }

    public void setHaveBreakfast(boolean haveBreakfast) {
        isHaveBreakfast = haveBreakfast;
    }

    public void setHaveFun(boolean haveFun) {
        isHaveFun = haveFun;
    }
}

package p16_observer_pattern.version1;

public interface ILiSi {

    // 发现别人有动静，自己也要行动起来
    void update(String context);

}

/**
 * 观察者
 */
public class LiSi implements ILiSi {

    // 首先李斯是个观察者，一旦韩非子有活动，他就要向老板汇报
    @Override
    public void update(String context) {
        System.out.println("李斯: 观察到韩非子活动，向秦始皇汇报...");
        report(context);
    }

    public void report(String reportContext) {
        System.out.println("李斯: 报告，韩非子有活动了: " + reportContext);
    }
}

package p16_observer_pattern.version1;

/**
 * 监控程序
 */
public class Watch extends Thread {

    private HanFeiZi hanFeiZi;
    private LiSi liSi;
    private String type;

    public Watch(HanFeiZi hanFeiZi, LiSi liSi, String type) {
        this.hanFeiZi = hanFeiZi;
        this.liSi = liSi;
        this.type = type;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 监控是否在吃早饭
            if ("breakfast".equals(type)) {
                // 发现韩非子在吃饭，就通知李斯
                if (hanFeiZi.isHaveBreakfast()) {
                    liSi.update("韩非子在吃早饭");
                    // 重置状态，继续监控
                    hanFeiZi.setHaveBreakfast(false);
                }
            // 监控是否在娱乐
            } else {
                // 发现韩非子在娱乐，就通知李斯
                if (hanFeiZi.isHaveFun()) {
                    liSi.update("韩非子在娱乐");
                    // 重置状态，继续监控
                    hanFeiZi.setHaveFun(false);
                }
            }
        }
    }

}

public class Client {

    public static void main(String[] args) throws InterruptedException {

        LiSi liSi = new LiSi();
        HanFeiZi hanFeiZi = new HanFeiZi();

        // 观察早餐
        Watch watchBreakfast = new Watch(hanFeiZi, liSi, "breakfast");
        watchBreakfast.start();
        // 观察娱乐
        Watch watchFun = new Watch(hanFeiZi, liSi, "fun");
        watchFun.start();

        // 韩非子吃饭
        Thread.sleep(1000);
        hanFeiZi.haveBreakfast();

        // 韩非子娱乐
        Thread.sleep(1000);
        hanFeiZi.haveFun();

    }

}

运行Client程序后，控制台打印出如下信息：

韩非子: 开始吃饭...
李斯: 观察到韩非子活动，向秦始皇汇报...
李斯: 报告，韩非子有活动了: 韩非子在吃早饭
韩非子: 开始娱乐...
李斯: 观察到韩非子活动，向秦始皇汇报...
李斯: 报告，韩非子有活动了: 韩非子在娱乐

以上程序的问题：

使用死循环while(true)来做监听，占用大量CPU资源
不是面向对象的程序

改进，首先修改类图：

类图非常简单，就是在HanFeiZi类中引用了ILiSi这个接口，看代码变化：

public class HanFeiZi implements IHanFeiZi {

    // 引用李斯接口
    private ILiSi liSi = new LiSi();

    @Override
    public void haveBreakfast() {
        System.out.println("韩非子: 开始吃饭...");
        // 通知李斯
        liSi.update("韩非子在吃饭");
    }

    @Override
    public void haveFun() {
        System.out.println("韩非子: 开始娱乐...");
        // 通知李斯
        liSi.update("韩非子在娱乐");
    }

}

public class Client {

    public static void main(String[] args) throws InterruptedException {

        HanFeiZi hanFeiZi = new HanFeiZi();

        // 韩非子吃饭
        hanFeiZi.haveBreakfast();

        // 韩非子娱乐
        hanFeiZi.haveFun();

    }

}

运行结果正确，效率也提升了。

代码还是可以继续改善，首先，韩非子并不是只有李斯在监控，再者，韩非子并非只有吃饭和娱乐两个活动需要监视，为了很好的拓展程序，我们修改类图如下：

我们把接口名称修改了一下，这样显得更抽象化，Observable是被观察者，就是类似韩非子这样的人，Observer接口是观察者，类似李斯这样的，同时还有其他国家的比如王斯、刘斯等，在Observable接口中有三个比较重要的方法，分别是addObserver()增加观察者，deleteObserver()删除观察者，notifyObservers()通知所有的观察者，这是什么意思呢？我这里有一个信息，一个对象，我可以允许有多个对象来察看，你观察也成，我观察也成，只要是观察者就成，也就是说我的改变或动作执行，会通知其他的对象，看程序会更明白一点：

/**
 * 所有被观察者的通用接口
 */
public interface Observable {

    // 增加观察者
    void addObserver(Observer observer);

    // 删除观察者
    void deleteObserver(Observer observer);

    // 通知所有观察者
    void notifyObservers(String context);

}

public class HanFeiZi implements Observable {

    // 所有的观察者
    private List<Observer> observerList = new ArrayList<>();

    @Override
    public void addObserver(Observer observer) {
        observerList.add(observer);
    }

    @Override
    public void deleteObserver(Observer observer) {
        observerList.remove(observer);
    }

    @Override
    public void notifyObservers(String context) {
        for (Observer observer : observerList) {
            observer.update(context);
        }
    }

    public void haveBreakfast() {
        System.out.println("韩非子: 开始吃饭...");
        notifyObservers("韩非子在吃饭");
    }

    public void haveFun() {
        System.out.println("韩非子: 开始娱乐...");
        notifyObservers("韩非子在娱乐");
    }

}

/**
 * 所有观察者的通用接口
 */
public interface Observer {

    void update(String context);

}

/**
 * 李斯是秦国的观察者
 */
public class LiSi implements Observer {

    @Override
    public void update(String context) {
        System.out.println("李斯: 观察到韩非子活动，向秦王汇报...");
        report(context);
    }

    public void report(String reportContext) {
        System.out.println("李斯: 报告秦王，韩非子有活动了: " + reportContext);
    }

}

/**
 * 刘斯是齐国的观察者
 */
public class LiuSi implements Observer {

    @Override
    public void update(String context) {
        System.out.println("刘斯: 观察到韩非子活动，向齐王汇报...");
        report(context);
    }

    public void report(String reportContext) {
        System.out.println("刘斯: 报告齐王，韩非子有活动了: " + reportContext);
    }

}

/**
 * 王斯是楚国的观察者
 */
public class WangSi implements Observer {

    @Override
    public void update(String context) {
        System.out.println("王斯: 观察到韩非子活动，向楚王汇报...");
        report(context);
    }

    public void report(String reportContext) {
        System.out.println("王斯: 报告楚王，韩非子有活动了: " + reportContext);
    }

}

public class Client {

    public static void main(String[] args) {

        Observer liSi =  new LiSi();
        Observer wangSi =  new WangSi();
        Observer liuSi =  new LiuSi();

        HanFeiZi hanFeiZi = new HanFeiZi();
        hanFeiZi.addObserver(liSi);
        hanFeiZi.addObserver(wangSi);
        hanFeiZi.addObserver(liuSi);

        hanFeiZi.haveBreakfast();

    }

}

Client的运行结果如下：

韩非子: 开始吃饭...
李斯: 观察到韩非子活动，向秦王汇报...
李斯: 报告秦王，韩非子有活动了: 韩非子在吃饭
王斯: 观察到韩非子活动，向楚王汇报...
王斯: 报告楚王，韩非子有活动了: 韩非子在吃饭
刘斯: 观察到韩非子活动，向齐王汇报...
刘斯: 报告齐王，韩非子有活动了: 韩非子在吃饭

好了，结果也正确了，也符合开闭原则了，也同时实现类间解耦，想再加观察者，就继续实现Observer接口就成了，但是，我们还有一个优化点：HanFeiZi 这个实现类中应该抽象出一个父类，父类完全实现接口，HanFeiZi这个类只实现两个方法haveBreakfast() 和 haveFun() 就可以了。另外，JDK中提供了java.util.Observable类和 java.util.Observer接口，也就是说我们上面写的那个例子中的Observable接口可以改换成java.util.Observale类，Observer接口可以换成java.util.Observer接口，看如下类图：

代码实现如下：

import java.util.Observable;

public class HanFeiZi extends Observable {

    public void haveBreakfast() {
        System.out.println("韩非子: 开始吃饭...");
        // 通知所有观察者
        super.setChanged();
        super.notifyObservers("韩非子在吃饭");
    }

    public void haveFun() {
        System.out.println("韩非子: 开始娱乐...");
        super.setChanged();
        super.notifyObservers("韩非子在娱乐");
    }

}

/* ---------------------------------------------------------------------------------------------------------*/

import java.util.Observable;
import java.util.Observer;

public class LiSi implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("李斯: 观察到韩非子活动，向秦王汇报...");
        report(arg.toString());
    }

    public void report(String reportContext) {
        System.out.println("李斯: 报告秦王，韩非子有活动了: " + reportContext);
    }

}

/* ---------------------------------------------------------------------------------------------------------*/

import java.util.Observable;
import java.util.Observer;

public class LiuSi implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("刘斯: 观察到韩非子活动，向齐王汇报...");
        report(arg.toString());
    }

    public void report(String reportContext) {
        System.out.println("刘斯: 报告齐王，韩非子有活动了: " + reportContext);
    }

}

/* ---------------------------------------------------------------------------------------------------------*/

import java.util.Observable;
import java.util.Observer;

public class WangSi implements Observer {

    @Override
    public void update(Observable o, Object arg) {
        System.out.println("王斯: 观察到韩非子活动，向楚王汇报...");
        report(arg.toString());
    }

    public void report(String reportContext) {
        System.out.println("王斯: 报告楚王，韩非子有活动了: " + reportContext);
    }

}

/* ---------------------------------------------------------------------------------------------------------*/

import java.util.Observer;

public class Client {

    public static void main(String[] args) {

        Observer liSi =  new LiSi();
        Observer wangSi =  new WangSi();
        Observer liuSi =  new LiuSi();

        HanFeiZi hanFeiZi = new HanFeiZi();
        hanFeiZi.addObserver(liSi);
        hanFeiZi.addObserver(wangSi);
        hanFeiZi.addObserver(liuSi);

        hanFeiZi.haveBreakfast();

    }

}

程序运行结果上面的运行是结果是一模一样的，程序已经简约到极致了。这就是观察者模式，通用类图如下：

观察者模式在什么情况下使用呢？观察者可以实现消息的广播，一个消息可以触发多个事件，这是观察者模式非常重要的功能。使用观察者模式也有两个重点问题要解决：

广播链的问题。

如果你做过数据库的触发器，你就应该知道有一个触发器链的问题，比如表 A 上写了一个触发器，内容是一个字段更新后更新表 B 的一条数据，而表 B 上也有个触发器，要更新表 C，表 C 也有触发器…

我们的观察者模式也是一样的问题，一个观察者可以有双重身份，既是观察者，也是被观察者，这没什么问题，但是链一旦建立，这个逻辑就比较复杂，可维护性非常差，根据经验建议，在一个观察者模式中最多出现一个对象既是观察者也是被观察者，也就是说消
息最多转发一次（传递两次），这还是比较好控制的；
异步处理问题。

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

本文原书：

《您的设计模式》作者：CBF4LIFE

最后编辑于：2021.01.03 18:57:18

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

016.观察者模式

推荐阅读更多精彩内容