观察者模式详解

最新推荐文章于 2024-02-09 07:30:00 发布
最新推荐文章于 2024-02-09 07:30:00 发布
阅读量175 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 观察者 订阅 分布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/balsamspear/article/details/84972517
版权

观察者模式（Observer Pattern）

定义

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

通俗的定义：发布订阅模式（报社-读者）

模式总结过程

公司经营电商系统，有自己的工厂，当工厂有新产品产出时，通知仓库更新库存、通知商店拿货、通知客户购买

  1. 初步的实现如下
// 自家工厂
public class Factory {
    public void produce(String goods) {
        System.out.println("工厂生产了新产品: " + goods);
        // 通知库存更新
        new Repertory().updateData(goods);
        // 通知商店拿货
        new Store().sale(goods);
        // 通知客户购买
        new Customer().buy(goods);
    }
}
// 仓库
public class Repertory {

    public void updateData(String goods) {
        System.out.println("仓库更新库存: " + goods);
    }
}
// 商店
public class Store {

    public void sale(String goods) {
        System.out.println("商店拿货销售: " + goods);
    }
}
// 客户
public class Customer {

    public void buy(String goods) {
        System.out.println("客户购买: " + goods);
    }
}
// 客户端
public class Client {

    public static void main(String[] args) {
        Factory factory = new Factory();
        factory.produce("智能机器人");
    }
}
/*
工厂生产了新产品: 智能机器人
仓库更新库存: 智能机器人
商店拿货销售: 智能机器人
客户购买: 智能机器人
*/

这样的设计，有几个问题

  1. 针对实现编程，而非针对接口编程
  2. 如果工厂有新产品后的通知目标增加或减少，需要对原代码进行修改
  3. 无法在运行时动态地增加或删除通知目标，如我们不想通知客户了
  4. 耦合程度很高
  1. 针对上述问题，我们进行优化，工厂类抽象一个接口出来，所有目标也抽象一个接口出来，然后工厂类持有观察者接口的引用
// 主题接口（消息发布者）
public interface Subject {

    // 注册观察者，也就是加入需要通知的目标
    void registerObserver(Observer observer);

    // 移除观察者，也就是删除不需要通知的目标
    void removeObserver(Observer observer);

    // 通知所有观察者，也就是通知所有的目标
    void notifyObservers();
    
    // 生产
    void produce(String goods);
}
// 自家工厂
public class Factory implements Subject {

    // 观察者集合
    private List<Observer> list;

    // 产品
    private String goods;

    public Factory() {
        list = new ArrayList<>();
    }

    // 生产产品
    @Override
    public void produce(String goods) {
        System.out.println("工厂生产了新产品: " + goods);
        this.goods = goods;
        notifyObservers();
    }

    @Override
    public void registerObserver(Observer observer) {
        list.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        list.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : list) {
            observer.update(goods);
        }
    }
}
// 抽象观察者（这里自己定义，而非使用jdk源码中的Observer）
public interface Observer {
    // 统一一个方法让工厂类调用
    void update(String goods);
}
// 仓库
public class Repertory implements Observer {

    public void updateData(String goods) {
        System.out.println("仓库更新库存: " + goods);
    }

    @Override
    public void update(String goods) {
        updateData(goods);
    }
}
// 商店
public class Store implements Observer {

    public void sale(String goods) {
        System.out.println("商店拿货销售: " + goods);
    }

    @Override
    public void update(String goods) {
        sale(goods);
    }
}
// 客户
public class Customer implements Observer {

    public void buy(String goods) {
        System.out.println("客户购买: " + goods);
    }

    @Override
    public void update(String goods) {
        buy(goods);
    }
}
// 客户端
public class Client {

    public static void main(String[] args) {
        Subject subject = new Factory();//工厂

        Repertory repertory = new Repertory();//仓库
        Store store = new Store();//商店
        Customer customer = new Customer();//客户

        subject.registerObserver(repertory);//添加仓库为通知目标
        subject.registerObserver(store);//添加商店为通知目标
        subject.registerObserver(customer);//添加客户为通知目标

        subject.produce("智能机器人");

        // 客户不想收到通知
        subject.removeObserver(customer);

        System.out.println("--------");

        subject.produce("智能家具");
    }
}
/*
工厂生产了新产品: 智能机器人
仓库更新库存: 智能机器人
商店拿货销售: 智能机器人
客户购买: 智能机器人
--------
工厂生产了新产品: 智能家具
仓库更新库存: 智能家具
商店拿货销售: 智能家具
*/

再发一次初步实现的问题

  1. 针对实现编程，而非针对接口编程
  2. 如果工厂有新产品后的通知目标增加或减少，需要对原代码进行修改
  3. 无法在运行时动态地增加或删除通知目标，如我们不想通知客户了
  4. 耦合程度很高

现在，我们的实现就很不错了，针对初步现实的问题，我们再来对比一下

  1. 我们针对接口编程，并非针对实现编程
  2. 通知目标增加时，只需要再实现Observer接口，再把这个实现registerObserver到工厂即可；减少时，工厂类调用removeObserver()即可
  3. 运行时，也可以动态地增加或删除通知目标（registerObserver/removeObserver）
  4. 耦合程度很低（工厂类只依赖观察者接口的集合，不需要知道具体观察者的实现）
优点
  1. 解耦，符合开闭原则
  2. 符合好莱坞原则：别来找我，我找你们。也就是被观察者通知所有观察者
缺点
  1. 运行效率较低，一个被观察者，多个观察者时，开发代码和调试会比较复杂
  2. 消息的通知是默认顺序执行的，若其中一个观察者卡壳，会影响到此观察者后面的观察者执行，影响整体的执行， 多级触发时的效率更让人担忧
应用
  1. 对一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可变
  2. 分布订阅型场景
jdk中的观察者模式
  1. 抽象观察者接口
package java.util;

/**
 * A class can implement the <code>Observer</code> interface when it
 * wants to be informed of changes in observable objects.
 *
 * @author  Chris Warth
 * @see     java.util.Observable
 * @since   JDK1.0
 */
public interface 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>
     *                 method.
     */
    void update(Observable o, Object arg);
}
  1. 主题类（对比工厂类）
package java.util;

public class Observable {
    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);
    }
    // ...
    // 只列一小部分方法
}

注意：这里是一个类，虽然实现了大部分功能，但并不是接口

使用jdk API实现上述例子
// 自家工厂
// 继承jdk中的Observable类
public class Factory extends Observable {

    public void produce(String goods) {
        System.out.println("工厂生产了新产品: " + goods);
        setChanged();//只有状态改变才会通知观察者
        notifyObservers(goods);
    }
}
// 仓库
// 实现jdk中的Obserer接口
public class Repertory implements Observer {

    private void updateData(String goods) {
        System.out.println("仓库更新库存: " + goods);
    }

    @Override
    public void update(Observable o, Object arg) {
        updateData((String) arg);
    }
}
// 商店
// 实现jdk中的Obserer接口
public class Store implements Observer {

    private void sale(String goods) {
        System.out.println("商店拿货销售: " + goods);
    }

    @Override
    public void update(Observable o, Object arg) {
        sale((String) arg);
    }
}
// 客户
// 实现jdk中的Obserer接口
public class Customer implements Observer {

    private void buy(String goods) {
        System.out.println("客户购买: " + goods);
    }

    @Override
    public void update(Observable o, Object arg) {
        buy((String) arg);
    }
}
// 客户端
public class Client {

    public static void main(String[] args) {
        Factory factory = new Factory();//工厂

        Repertory repertory = new Repertory();//仓库
        Store store = new Store();//商店
        Customer customer = new Customer();//客户

        factory.addObserver(repertory);//添加仓库为通知目标
        factory.addObserver(store);//添加商店为通知目标
        factory.addObserver(customer);//添加客户为通知目标

        factory.produce("智能机器人");

        // 客户不想收到通知
        factory.deleteObserver(customer);
        System.out.println("--------");

        factory.produce("智能家具");
    }
}
/*
工厂生产了新产品: 智能机器人
客户购买: 智能机器人
商店拿货销售: 智能机器人
仓库更新库存: 智能机器人
--------
工厂生产了新产品: 智能家具
商店拿货销售: 智能家具
仓库更新库存: 智能家具
*/

优点：省事，被观察者的许多功能已经实现，直接使用即可，也提供了观察者接口

缺点：

  1. 被观察者通知观察者时，是倒序通知，这个要注意
  2. 被观察者是一个类，提供方便的同时，也限制了工厂类的扩展
balsamspear
关注
专栏目录
观察者模式
ThinkWon的博客
09-25 5373
当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。 介绍 意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。 何时使用：一个对象（目标对象）...
设计模式——观察者模式详解
weixin_30537451的博客
10-30 689
0.前言写在最前面，本人的设计模式类博文，建议先看博文前半部分的理论介绍，再看后半部分的实例分析，最后再返回来复习一遍理论介绍，这时候你就会发现我在重点处标红的用心，对于帮助你理解设计模式有奇效哦~此篇总结整理设计模式中的观察者模式。本文原创，转载请注明出处为SEU_Calvin的博客。1．观察者模式介绍观察者模式定义：观察者模式定义了一个一对多的依赖关系，使得当被观察者状态发生改变时...
设计模式 - 观察者模式(Observer Pattern) 详解
Mystra
05-22 4603
观察者模式(Observer Pattern) 详解 本文地址:http://blog.csdn.net/caroline_wendy/article/details/26583157 版权所有, 禁止转载, 如有转载, 请站内联系. 观察者模式(Observer Pattern): 定义了对象之间的一对多的依赖, 这样一来, 当一个对象改变状态时, 它的所有依赖者都会收到通知并自动更新. 使用方法:
Java设计模式—观察者模式详解
08-26
Java设计模式—观察者模式详解 观察者模式是 Java 设计模式中的一种重要模式，用于定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 观察者模式的定义...
jQuery的观察者模式详解
12-11
在jQuery中，on方法可以为元素绑定事件，trigger方法可以手动触发事件，围绕这2个方法，我们来体验jQuery中的观察者模式(Observer Pattern)。 ■ on方法绑定内置事件，自然触发 比如，我们给页面的body元素绑定一个...
vue双向绑定及观察者模式详解
10-17
在本篇介绍中，我们将深入探讨Vue.js框架中的双向绑定机制以及观察者模式的具体实现原理。双向绑定是指将视图层（View）与数据模型（Model）之间建立一种同步机制，当数据模型发生变更时，视图层会自动更新；反之，...
观察者模式 详解
GeorgeWang
06-18 1367
定义 一个或多个观察者对目标的状态感兴趣，它们通过将自己依附在目标对象上以便注册所感兴趣的内容。 目标状态发生改变并且观察者可能对这些改变感兴趣，就会发送一个通知消息，调用每个观察者的更新方法。 当观察者不再对目标感兴趣的时候，它们可以简单的将自己从中分离。 组成角色 抽象目标角色（AbstractSubject） 抽象观察者角色（AbstractObserver） 具体目标角色（ConcreteS
观察者模式详解 (附java语言源码)
数据知道的博客
05-28 8367
观察者模式（Observer Pattern）： 定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动刷新。（Define a one-to-many dependency between objects so that when one object changes state all its dependents are notified an...
观察者模式详解Demo
yaoyaoyao_123的博客
07-12 258
观察者模式细分的话可以分为以下几个具体对象： 观察者，具体观察者，被观察者，具体被观察者，以下通过一个小的应用场景具体详解： 假如：微信公众号是被观察者，那么微信公众号中的《Android前沿技术》这个订阅号就是一个具体的被观察者，微信用户就是观察者，个人就是具体观察者。 首先定义微信公众号类： import com.example.myproject.observer.IWXUser...
观察者模式详解：原理、步骤、结构图、代码实现、场景及优缺点
十年以上编程经验的干货分享
12-06 2757
观察者模式是一种行为设计模式，它允许对象定义一对多的依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都会得到通知并自动更新。这种模式也被称为发布-订阅模式。
设计模式--观察者模式（详解）
浮晓悠羡
03-21 566
java设计模式--观察者模式 一个贴切又通俗的例子让你明白什么是观察者模式，同时还告诉你java内置的观察者。 1. 概述 　　观察者模式定义了对象之间的一对多的依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。有时被称作发布/订阅模式， 可借助下图理解下定义 2. 解决的问题 　　将一个系统分割成一个一些类相互协作的类有一个不好的副作用，那
JAVA设计模式之观察者模式详解
最新发布
励志成为一名优秀的全能型软件开发工程师。
02-09 1574
观察者模式的应用场景非常广泛，小到代码层面的解耦，大到架构层面的系统解耦，再或者 一些产品的设计思路，都有这种模式的影子.现在我们常说的基于事件驱动的架构，其实也是观察者模式的一种最佳实践。当我们观察某一个对象时，对象传递出的每一个行为都被看成是一个事件，观察者通过处理每一个事件来完成自身的操作处理。生活中也有许多观察者模式的应用,比如 汽车与红绿灯的关系,‘红灯停,绿灯行’,在这个过程中交通信号灯是汽车的观察目标,而汽车是观察者.​。
详解设计模式：观察者模式
栗筝i的博客
12-02 4100
观察者模式（Observer Pattern）也被称为发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式，是在 GoF 23 种设计模式中定义了的行为型模式。 观察者模式 定义了一对多的关系，让多个观察者对象同时监听某一个主体对象，这个主体对象发生变化时就会通知所有的观察者对象，使得他们能够自己更新自己。 本片文章内容包括：关于观察者模式、观察者模式 Demo（伪代码）
设计模式之观察者模式详解
weixin_45538589的博客
09-17 5320
观察者模式 (Observer Pattern) 又叫发布-订阅模式 (Publish/Subscribe)，定义一种一对多的依赖关系，一个主题对象 (被观察对象) 可被多个观察者对象同时监听，使得每当主题对象状态变化时，所有依赖于它的对象都会得到通知并被更新，属于行为型模式。 ​ 观察者模式的核心是将观察者与主题对象解耦，以类似于消息、广播发送的机制联动两者，使被观察者的变动能通知到感兴趣的观察者们，从而做出相应的响应
观察者模式详解与应用
"观察者模式" 观察者模式是一种行为设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动编程或者实时数据更新的场景...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值