016.观察者模式

作者: CoderJed | 来源:发表于2020-12-31 13:58 被阅读0次

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

程序实现：

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

016.观察者模式

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读