前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >[设计模式] 观察者模式

[设计模式] 观察者模式

作者头像
架构探险之道
发布2019-08-13 16:53:11
5060
发布2019-08-13 16:53:11
举报
文章被收录于专栏:架构探险之道

[设计模式] 观察者模式

手机用户请 横屏获取最佳阅读体验, REFERENCES中是本文参考的链接,如需要链接和更多资源,可以关注其他博客发布地址。

平台

地址

CSDN

https://blog.csdn.net/sinat_28690417

简书

https://www.jianshu.com/u/3032cc862300

个人博客

https://yiyuery.github.io/NoteBooks/

观察者模式定义了对象之间的一对多依赖,这样依赖,当一个对象改变状态时,它的所有依赖者都会收到通知并更新。

对于观察模式的实现方式有很多种,一般是以包含Subject和Observer接口的类设计做法最为常见。

根据多个观察者对于同一主题信息的获取方式,可以分为:

  1. 被观察者(主题)主动推送,一变化,就将被观察对象推送给所有观察者。
  2. 观察者通过接口主动拉取主题中的部分信息,避免无关信息的干扰。

观察者模式的好处:

  • 提供了一种对象设计,让主题和观察者之间松耦合
  • 解决一对多的依赖问题

场景分析

加入我们现在有个手机工厂,每次生产出一批手机后,就需要通知对应的代理商过来拿货。

我们就可以利用观察者模式来实现这个场景需求。

  • 手机工厂就是被观察对象,也就是主题。
  • 多个代理商分别充当不同的观察者对象。需要监听手机工厂的 生产情况。
  • 一旦手机工厂生产出手机,就会通知我们的代理商过来取货。

实战

类图

  • 首先,我们需要定义观察者和被观察者接口,并定义通知能力接口。
代码语言:javascript
复制
public interface Observer<T> {

    /**
     * 观察者接收通知
     */
    void handle(T message);
}

public interface Subject<T> extends INotify{

    /**
     * 注册观察者
     * @param observer
     */
    void register(Observer<T> observer);

    /**
     * 注销观察者
     * @param observer
     */
    void cancel(Observer<T> observer);

}

public interface INotify {

    /**
     * 通知
     */
    void sendMessage();
}
  • 然后,定义对应实例实现观察者和被观察者

手机工厂

代码语言:javascript
复制
public class PhoneFactory implements Subject<Message> {

    private List<Observer<Message>> observers;

    /**
     * 消息体
     */
    private Message message;

    public PhoneFactory() {
        this.observers = new ArrayList<>();
    }

    /**
     * 注册观察者
     *
     * @param observer
     */
    @Override
    public void register(Observer<Message> observer) {
        observers.add(observer);
    }

    /**
     * 注销观察者
     *
     * @param observer
     */
    @Override
    public void cancel(Observer<Message> observer) {
        observers.remove(observer);
    }

    /**
     * 发送通知
     */
    @Override
    public void sendMessage() {
        observers.forEach(p->{
            p.handle(message);
        });
    }

    /**
     * 外部设置消息变更
     * @param message
     */
    public void setMessage(Message message) {
        this.message = message;
        sendMessage();
    }
}

消息体

代码语言:javascript
复制
@Data
@Builder
@AllArgsConstructor
public class Message {

    /**
     * 消息体
     */
    private String data;
}

代理商

代码语言:javascript
复制
//淘宝
public class TaobaoAgent implements Observer<Message> {
    /**
     * 观察者接收通知
     *
     * @param message
     */
    @Override
    public void handle(Message message) {
        System.out.println("Taobao receive message: " + message.getData());
    }
}
//天猫
public class TianmaoAgent implements Observer<Message> {
    /**
     * 观察者接收通知
     *
     * @param message
     */
    @Override
    public void handle(Message message) {
        System.out.println("Tianmao receive message: " + message.getData());
    }
}
  • 最后,定义测试类,我们来看下效果
代码语言:javascript
复制
/**
 * 自定义观察者模式
 */
@Test
public void testX1() {
    //被观察者
    PhoneFactory phoneFactory = new PhoneFactory();
    //观察者
    TianmaoAgent tianmaoAgent = new TianmaoAgent();
    TaobaoAgent taobaoAgent = new TaobaoAgent();
    //注册
    phoneFactory.register(tianmaoAgent);
    phoneFactory.register(taobaoAgent);
    //发送通知
    phoneFactory.setMessage(Message.builder()
            .data("刚生产了100台Xiaomi手机")
            .build());
    //移除观察者
    phoneFactory.cancel(tianmaoAgent);
    //再次发送通知
    System.out.println("-------------------");
    phoneFactory.setMessage(Message.builder()
            .data("刚又生产了100台iPhone")
            .build());

}

打印

代码语言:javascript
复制
Tianmao receive message: 刚生产了100台Xiaomi手机
Taobao receive message: 刚生产了100台Xiaomi手机
-------------------
Taobao receive message: 刚又生产了100台iPhone

从输出可以看出,观察者和被观察者有以下几个特点:

  • 观察者可以随时进行注册和注销行为
  • 被观察者只会给注册过的观察者发送通知
  • 不同代理商接收通知的顺序和自己注册的先后有关系

那么思考下这个模式有没有什么不好的地方?

  • 每次被观察者发送消息,观察者都需要全部接收并处理。如果信息比较复杂或是观察者只关注其中一部分数据怎么处理?
  • 这种属于被动等待被观察者推的行为,如果不是通知,而是其他一些实时数据的监控呢?如果观察者不想等待,想直接获取当前实时数据信息呢?
  • JDK内置了观察者模式的实现,为什么还要自己定义呢?与自定义的有什么区别呢?

带着问题,我们来看下JDK内置的观察者模式怎么实现的?并看下如何实现主动拉取被观察者信息。

JDK内置观察者模式实现

代码语言:javascript
复制
public class PhoneFactory2 extends Observable {

    /**
     * 消息体
     */
    private Message message;


    public void setMessage(Message message) {
        this.message = message;
        setChanged();
        notifyObservers(message);
    }

    /**
     * 观察者按需主动拉取自己所需要信息
     * @return
     */
    public Message getMessage() {
        return message;
    }
}

public class TaobaoAgent2 implements Observer {

    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     * <code>notifyObservers</code> method to have all the object's
     * observers notified of the change.
     *
     * @param o   the observable object.
     * @param arg an argument passed to the <code>notifyObservers</code>
     */
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Taobao2 receive message: " + arg.toString());
    }
}

public class TianmaoAgent2 implements Observer {

    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     * <code>notifyObservers</code> method to have all the object's
     * observers notified of the change.
     *
     * @param o   the observable object.
     * @param arg an argument passed to the <code>notifyObservers</code>
     */
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("Tianmao2 receive message: " + arg.toString());
    }

}

比较下变化:

  • 首先代码量上减少了,不需要定义接口
  • notifyObservers方法不用实现,直接使用父层方法
  • 使用的是继承的方式实现观察者和被观察者
  • 定义了getMessage方法,可以主动拉取信息
  • 发送通知前,需要调用父层方法setChanged

定义下测试类:

代码语言:javascript
复制
/**
 * 使用JDK原生观察者模式
 */
@Test
public void testX2() {
    //被观察者
    PhoneFactory2 phoneFactory = new PhoneFactory2();
    //观察者
    TianmaoAgent2 tianmaoAgent = new TianmaoAgent2();
    TaobaoAgent2 taobaoAgent = new TaobaoAgent2();
    //注册
    phoneFactory.addObserver(tianmaoAgent);
    phoneFactory.addObserver(taobaoAgent);
    //发送通知
    phoneFactory.setMessage(Message.builder()
            .data("刚生产了100台Xiaomi手机")
            .build());
    //移除观察者
    phoneFactory.deleteObserver(tianmaoAgent);
    //再次发送通知
    System.out.println("-------------------");
    phoneFactory.setMessage(Message.builder()
            .data("刚又生产了100台iPhone")
            .build());
    //主动拉取消息
    System.out.println("pull message:" + phoneFactory.getMessage());
}

看下测试类的输出:

代码语言:javascript
复制
Taobao2 receive message: Message(data=刚生产了100台Xiaomi手机)
Tianmao2 receive message: Message(data=刚生产了100台Xiaomi手机)
-------------------
Taobao2 receive message: Message(data=刚又生产了100台iPhone)
pull message:Message(data=刚又生产了100台iPhone)

分析下两次输出的区别:

  • 接收消息的顺序反了
  • 被观察者开放了自身被监控属性的Getter方法

其实乍看之下,两种方式实现结果貌似没什么区别,但是仔细观察JDK内置的Observable,不是一个接口,是个类。其内部的setChanged方法也是被 protected修饰的

代码语言:javascript
复制
protected synchronized void setChanged() {
        changed = true;
}

这意味着:你除非继承自Observable,否则无法创建Observable实例,并组合到你自己的对象中来,这个设计违反了 多用组合,少用继承的设计原则。

相较于我们自己实现的观察者模式,可以结合泛型定义被通知的消息体,还可以结合我们的通知接口 INotify等方式来扩展,开发自由度更加高。但是无论是哪种方式,关键是熟悉观察者模式后,善用即可,

REFERENCES

《Head First》读书笔记

本文参与 腾讯云自媒体同步曝光计划,分享自微信公众号。
原始发表:2019-08-12,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 架构探险之道 微信公众号,前往查看

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

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

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • [设计模式] 观察者模式
    • 场景分析
      • 实战
        • REFERENCES
        领券
        问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档