观察者模式——心有灵犀

100000860378

发布于 2018-09-13 15:26:11

3250

发布于 2018-09-13 15:26:11

文章被收录于专栏：spring源码深度学习

一、定义

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

二、第一个小栗子

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

//抽象被观察者
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

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2018.06.07 ，如有侵权请联系 cloudcommunity@tencent.com 删除

其他

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

其他

登录后参与评论

0 条评论

热度