第 17 章 设计模式（4 >>> 观察者模式(Observer)）

最新推荐文章于 2021-04-10 19:36:03 发布
最新推荐文章于 2021-04-10 19:36:03 发布
阅读量247 收藏
点赞数
分类专栏： # Scala进阶
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuanalex/article/details/105160149
版权

一、提出需求

1、气象站项目，具体要求如下：
1. 气象站可以将每天测量到的温度，湿度，气压等等以公告的形式发布出去(比如发布到自己的网站)；
2. 需要设计开放型API，便于其他第三方公司也能接入气象站获取数据；
3. 提供温度、气压和湿度的接口；
4. 测量数据更新时，要能实时的通知给第三方。
2、WeatherData类
通过对气象站项目的分析，我们可以初步设计出一个WeatherData类。

设计图：
在这里插入图片描述
设计图说明:

1. 通过getXxx方法，可以让第三方公司接入，并得到相关信息；
2. 当数据有更新时，气象站通过调用dataChange() 去更新数据，当第三方再次获取时，就能得到最新数据，
当然也可以推送。

二、气象局方案设计

1、 方案一：普通方案

说明：CurrentConditions(当前的天气情况)，可以理解成是气象局的网站 //推送。
在这里插入图片描述

2、方案一代码实现
===============================class CurrentConditions===============================
package com.lj.akka.observermode
/**
  * @author Administrator
  * @create 2020-03-28
  */
class CurrentConditions {
    private var mTemperature: Float = _
    private var mPressure: Float = _
    private var mHumidity: Float = _

    def disPlay(): Unit = {
        println("Today mTemperature：" + mTemperature)
        println("Today mPressure：" + mPressure)
        println("Today mHumidity：" + mHumidity)
    }

    def update(mTemperature: Float, mPressure: Float, mHumidity: Float): Unit = {
        this.mTemperature = mTemperature
        this.mPressure = mPressure
        this.mHumidity = mHumidity
        // 显示更新的信息
        disPlay()
    }
}
===============================class WeatherData===============================
package com.lj.akka.observermode
/**
  * @author Administrator
  * @create 2020-03-28
  */
class WeatherData {
    // 温度
    private[this] var _mTemperature: Float = _
    // 压力
    private[this] var _mPressure: Float = _
    // 湿度
    private[this] var _mHumidity: Float = _
    private[this] var _mCurrentConditions: CurrentConditions = _

    def this(mCurrentConditions: CurrentConditions) {
        this
        this._mCurrentConditions = mCurrentConditions
    }

    def mTemperature: Float = _mTemperature
    def mTemperature_=(value: Float): Unit = {
      _mTemperature = value
    }

    def mPressure: Float = _mPressure
    def mPressure_=(value: Float): Unit = {
      _mPressure = value
    }

    def mHumidity: Float = _mHumidity
    def mHumidity_=(value: Float): Unit = {
      _mHumidity = value
    }

    def dataChange(mCurrentConditions: CurrentConditions) = {
        mCurrentConditions.update(_mTemperature, _mPressure, _mHumidity)
    }

    def mCurrentConditions_=(mTemperature: Float, mPressure: Float, mHumidity: Float): Unit= {
        this._mTemperature = mTemperature
        this._mPressure = mPressure
        this._mHumidity = mHumidity
        dataChange(_mCurrentConditions)
    }
}
===============================使用：object InternetWeather===============================
package com.lj.akka.observermode
/**
  * @author Administrator
  * @create 2020-03-28
  */
object InternetWeather {
    def main(args: Array[String]): Unit = {
        val mCurrentConditions = new CurrentConditions
        val mWeatherData = new WeatherData(mCurrentConditions)
        mWeatherData.mCurrentConditions_=(23, 180, 35)
    }
}
3、方案一问题分析
1. 其他第三方公司接入气象站获取数据的问题；
2. 无法在运行时动态的添加第三方。
3. 在WeatherData中，当增加一个第三方，都需要创建一个对应的第三方的公告板对象，并加入到dataChange, 
不利于维护，也不是动态加入
		def  dataChange() = {
			mCurrentConditions.update(getTemperature(), getPressure(), getHumidity())
		}

三、观察者模式原理

1、设计图

在这里插入图片描述在这里插入图片描述

2、设计图分析

** > 观察者模式类似订牛奶业务**

1. 奶站/气象局：Subject
2. 用户/第三方网站：Observer

> Subject：登记注册、移除和通知

1. registerObserver 注册；
2. removeObserver 移除；
3. notifyObservers() 通知所有的注册的用户，根据不同需求，可以是更新数据，让用户来取，也可能是实施推送，
看具体需求定。

> Observer：接收输入

观察者模式：对象之间多对一依赖的一种设计方案，被依赖的对象为Subject，依赖的对象为Observer，Subject通知Observer变化,比如这里的奶站是Subject，是1的一方。用户是Observer，是多的一方。

四、气象站设计方案二（观察者模式）

1、设计类图

在这里插入图片描述

2、观察者模式的好处
1. 观察者模式设计后，会以集合的方式来管理用户(Observer)，包括注册，移除和通知。
2. 这样，我们增加观察者(这里可以理解成一个新的公告板)，就不需要去修改核心类WeatherDataSt，即不会修
改代码。它可以作为一个独立的进程保持运行，无需重新加载。

五、观察者模式实现功能需求

1、代码结构图

在这里插入图片描述

2、代码实现
==============================trait Subject==============================
package com.lj.akka.observermode.myobserver
/**
  * @author Administrator
  * @create 2020-03-28
  */
trait Subject {
    // 注册
    def registerObserver(observer: Observer)
    // 移除
    def removeObserver(observer: Observer)
    // 通知
    def notifyObserver()
}
==============================trait Observer==============================
package com.lj.akka.observermode.myobserver
/**
  * @author Administrator
  * @create 2020-03-28
  */
trait Observer {
    // 更新
    def update(mTemperature: Float, mPressure: Float, mHumidity: Float)
    def getName(): String
}
==========================class CurrentConditions extends Observer==========================
package com.lj.akka.observermode.internetweather.mode
import com.lj.akka.observermode.myobserver.Observer
/**
  * @author Administrator
  * @create 2020-03-28
  */
// 第三方板块
class CurrentConditions extends Observer {
    private var mTemperature: Float = _
    private var mPressure: Float = _
    private var mHumidity: Float = _
    var name: String = "Current"

    def display(): Unit = {
        println(s"---------------${name}播报天气预报：--------------------")
        println("Update Current Today Temperature:" + mTemperature)
        println("Update Current Today Pressure:" + mPressure)
        println("Update Current Today Humidity:" + mHumidity)
    }

    override def update(mTemperature: Float, mPressure: Float, mHumidity: Float): Unit = {
        this.mTemperature = mTemperature
        this.mPressure = mPressure
        this.mHumidity = mHumidity
        display()
    }
    override def getName(): String = {
        this.name
    }
}
==============================trait Subject==============================
package com.lj.akka.observermode.internetweather.mode
import com.lj.akka.observermode.myobserver.Observer
/**
  * @author Administrator
  * @create 2020-03-28
  */
// 第三方板块
class TMConditions extends Observer {
    private var mTemperature: Float = _
    private var mPressure: Float = _
    private var mHumidity: Float = _
    val name: String = "TM"

    def display(): Unit = {
        println(s"---------------${name}播报天气预报：--------------------")
        println("Update TM Today Temperature:" + mTemperature)
        println("Update TM Today Pressure:" + mPressure)
        println("Update TM Today Humidity:" + mHumidity)
    }

    override def update(mTemperature: Float, mPressure: Float, mHumidity: Float): Unit = {
        this.mTemperature = mTemperature
        this.mPressure = mPressure
        this.mHumidity = mHumidity
        display()
    }
    override def getName(): String = {
        this.name
    }
}
==============================class WeatherData extends Subject==============================
package com.lj.akka.observermode.internetweather.mode
import com.lj.akka.observermode.myobserver.{Observer, Subject}
import scala.collection.mutable.ListBuffer
/**
  * @author Administrator
  * @create 2020-03-28
  */
class WeatherData extends Subject{

    private var _mTemperature: Float = _
    private var _mPressure: Float = _
    private var _mHumidity: Float = _
    private val mObservers: ListBuffer[Observer] = ListBuffer()

    def mTemperature: Float = _mTemperature
    def mTemperature_=(value: Float) = {
        _mTemperature = value
    }

    def mPressure: Float = _mPressure
    def mPressure_=(value: Float): Unit = {
        _mPressure = value
    }

    def mHumidity: Float = _mHumidity
    def mHumidity_=(value: Float) = {
        _mHumidity = value
    }

    def dataChange(): Unit = {
        println("气象局检测到天气变化，通知第三方......")
        notifyObserver()
    }
    def setData(mTemperature: Float, mPressure: Float, mHumidity: Float): Unit = {
        mTemperature_=(mTemperature)
        mPressure_=(mPressure)
        mHumidity_=(mHumidity)
        dataChange()
    }

    override def registerObserver(observer: Observer): Unit = {
        if (!mObservers.contains(observer)) {
            mObservers.append(observer)
            println(s"气象局收到第三方 ${observer.getName()} 的订购指令，并订购成功。")
        }
    }
    override def removeObserver(observer: Observer): Unit = {
        println("气象局收到")
        if (mObservers.contains(observer)) {
            mObservers -= observer
            println(s"气象局收到第三方 ${observer.getName()} 的退订指令，并退订成功。")
        }
    }
    override def notifyObserver(): Unit = {
        for (observer <- mObservers) {
            println("通知：" + observer.getName() + " 天气发生了变化......")
            observer.update(mTemperature, mPressure, mHumidity)
        }
    }
}
==============================object InternetWheather==============================
package com.lj.akka.observermode
import com.lj.akka.observermode.internetweather.mode.{CurrentConditions, TMConditions, WeatherData}
/**
  * @author Administrator
  * @create 2020-03-28
  */
object InternetWheather {
    def main(args: Array[String]): Unit = {
        val mWeatherData = new WeatherData
        val mCurrentConditions = new CurrentConditions
        val mTMConditions = new TMConditions

        // 注册
        mWeatherData.registerObserver(mCurrentConditions)
        mWeatherData.registerObserver(mTMConditions)
        // 更新天气
        mWeatherData.setData(15, 30, 43)
        // 移除
        mWeatherData.removeObserver(mTMConditions)
    }
}
=================================运行结果=======================================
气象局收到第三方 Current 的订购指令，并订购成功。
气象局收到第三方 TM 的订购指令，并订购成功。
气象局检测到天气变化，通知第三方......
通知：Current 天气发生了变化......
---------------Current播报天气预报：--------------------
Update Current Today Temperature:15.0
Update Current Today Pressure:30.0
Update Current Today Humidity:43.0
通知：TM 天气发生了变化......
---------------TM播报天气预报：--------------------
Update TM Today Temperature:15.0
Update TM Today Pressure:30.0
Update TM Today Humidity:43.0
气象局收到
气象局收到第三方 TM 的退订指令，并退订成功。
=================================运行结果=======================================
3、Java内置观察者模式

1. java.util.Observable

1. Observable 的作用和地位等价于，我们讲的Subject；
2. Observable 是类，不是接口，已经实现了核心的方法 注册，移除和通知，如下图。

在这里插入图片描述
2. java.util.Observer

1. Observer 的作用和地位等价于我们讲的Observer；
2. java.util.Observer的源码如下:
		package java.util;
		public interface Observer {
		    void update(Observable var1, Object var2);
		}
3. Observable和Observer的使用方法和前面讲的案例基本一样，只是Observable是类，通过继承来实现观察者模式。

对以前的知识回顾，加深基础知识！
学习来自：北京尚硅谷韩顺平老师—尚硅谷大数据技术之Scala
每天进步一点点，也许某一天你也会变得那么渺小！！！

斗罗昊天锤
关注
专栏目录
【设计模式之 Observer Mode】什么是观察者模式？看过NBA直播你就知道了！
路遥知码力的博客
10-04 1398
【设计模式】观察者模式 1 场景 一场湖人的NBA的主场球赛将会有多种方式在各个平台直播，有视频直播与文字比分直播。而各个平台需要获取NBA比赛分数的数据，将NBA球馆内的分数显示在各个官方直播平台的比分数据栏上。并且各个官方直播平台会依据基本的数据情况进行各自的展示。 数据中心会依据比赛情况不断更新比赛数据对象。 从数据中心获取数据并不是我们这次所关注的，我们关注的是如何将每次更新比赛数据对象的情况，同步给各个官方直播平台的方式。如何做到松耦合并且并且具备扩展性。 2 场景实现 很直观我们需要做的任务就
观察者（Observer）模式
dengjili的专栏
02-09 254
观察者（Observer）模式例子这里引入例子，当前有几个硬件设备，负责收集当前温度，湿度和气压，WeatherData对象从气象站收集数据，然后WeatherData向显示器发送数据，对应显示面板解析数据后显示（计算原始数据，输出日常所见的数据） 由于各种场合的需要，有的人只需要看到气象状况，有的人需要看到天气预报，所有根据需要显示不同信息，显示到不同的面板 初期设计 对应代码实现 D
设计模式2：观察者(Observer)模式
weixin_34348111的博客
02-09 93
背景问题：假设我们现在接到一个来自气象台的软件开发合约，对方希望我们开发一个天气预报类的软件。假设需要建立三种布告板，分别显示目前的状况，气象统计及简单的预报。当气象台提供的WeatherObject对象获得最新的测量数据时，三种布告板必须实时更新。如气象台所说，他们的WeatherData源文件中有getTemperature( ),getHumidity( ),getPr...
设计模式之----观察者模式（observer-pattern）的理解
04-10 2642
文章目录1.前言2.概念3.模式的结构和实现3.1 模式的结构3.1 模式的实现 1.前言 在现实世界中，许多对象并不是独立存在的，其中一个对象的行为发生改变可能会导致一个或者多个其他对象的行为也发生改变。例如，股票价格与股民、微信公众号与微信用户、气象局的天气预报与听众、小偷与警察等。在软件世界也是这样，例如MVC 模式中的模型与视图的关系，事件模型中的事件源与事件处理者。所有这些，如果用观察者模式来实现就非常方便。 2.概念 当对象间存在一种一对多的依赖关系，则 可以使用观察者模式（Observer
设计模式笔记2：观察者模式（Observer Pattern）
java开发指南博客 【转载】
06-07 163
一、观察者模式内容 观察者模式在对象之间定义了一对多的依赖，这样一来，依赖它的对象都会受到通知并自动更新。 观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。 一个软件系统常常要求在某一个对象的状态发生变化的时候，某些其它的对象做出相应的改变。做到...
设计模式C++学习之观察者模式（Observer）
09-07
观察者模式（Observer）是软件设计模式中的一种行为模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。这种模式在C++中广泛应用，特别是在需要...
PHP设计模式之观察者模式(Observer)详细介绍和代码实例
10-26
观察者模式是一种行为设计模式，它定义了对象间的一种一对多的依赖关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式经常用于实现软件的分布式事件通知系统，例如，图形...
C++设计模式之观察者模式（Observer）
08-27
C++设计模式之观察者模式（Observer） 观察者模式（Observer）是一种常用的设计模式，它主要用于解决对象之间的一对多关系问题。在这种模式中，一个对象（被观察者）维护一个观察者对象的集合，当被观察者对象变化...
Java设计模式之观察者模式（Observer模式）介绍
09-03
观察者模式（Observer模式）是软件设计模式中的一种行为模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。在Java中，这个模式是通过`java.util....
C#设计模式之Observer观察者模式解决牛顿童鞋成绩问题示例
08-29
观察者模式（Observer Pattern）是软件设计模式中的一种行为模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。在C#中，我们可以利用事件和委托来...
深入浅出设计模式二——WeatherData设计(观察者模式）实现二
05-27
NULL 博文链接：https://quicker.iteye.com/blog/605988
【设计模式】HeadFirst设计模式（二）：观察者(Observer)模式
u010800530的专栏
04-26 1390
一、观察者模式定义 在观察者模式中，一个被观察者管理所有依赖于它的观察者对象，它定义了一个一对多的依赖关系，这样一来，当一个对象改变状态时，它的所有依赖者都会受到通知并自动更新。 主题（被观察者）通过一个共同的接口来更新观察者，观察者依赖于此主题。 二、观察者模式例子——气象监测系统 描述： 气象监测系统分为三个部分：气象站（获取实际气象数据的物理装置）、WeatherData对象（追踪
设计模式之观察者模式(ObserverPattern)
Worthy_Wang的博客
04-01 504
设计模式之观察者模式(ObserverPattern) 文章目录设计模式之观察者模式(ObserverPattern)一.观察者模式(ObserverPattern)二.编程实例1.进制转换器2.客人敲门案例 一.观察者模式(ObserverPattern) 在生活中会遇到很多使用观察者模式的案例，比如股票跌涨后，股民作为观察者会对股票进行交易；客人来敲门，门铃响了之后管家就会去开门等等。其中观...
解析.NET观察者模式（Observer Pattern ）
08-15 147
概要 观察者模式是一种设计模式。设计模式是面向对象思想的集大成，GOF在其经典著作中总结了23种设计模式，又可分为：创建型、结构型和行为型3个大类,其中观察者模式属于行为型模式。 目录 观察者模式定义 实现观察者模式的过程 观察者模式结构　 观察者模式实例　 观察者模式总结 一、观察者模式定义 1．观察者模式定义了对象间的一对多依赖关系。当一方的对象改变状态时，所...
Akka工具（二）—Event Bus
二月初二
12-01 1778
某一天 小明：你好，你是报刊工作人员吗？ 报刊：是的，请问，你有什么需要吗？ 小明：我想订阅报刊，关于娱乐、经济、社会类的，其它的我不想要，可以吗？ 报刊：可以的，并且你可以随时取消订阅。 小明：好的，谢谢你。祝你工作愉快！ 通常该过程我们都是在软件上实现的，但是这并不影响我们要说明的内容。实际项目中，业务是复杂多样的，一个业务可能需要依赖另外一个业务，同时也可能取消和该业务的关联，如...
设计模式学习之二观察者模式（Observer）——参与气象观测站的设计
越国岩的专栏
05-05 1712
      业务需求：希望建立下一代Internet气象观测站！该气象站必须建立在我们专利申请中的WeatherData对象上，由WeatherData对象负责追踪目前的天气状况(温度、湿度、气压)。要求：建立一个应用，有三种布告板，分别显示目前的状况，气象统计及简单的预报。当WeatherObject对象获得最新的测量数据时，三种布告板必须实时更新。而且，这是一个可以扩展的气象站，Weather-O-Rama气象站希望能有一组API，好让其他开发人员可以写出自己的气象布告板，并插入此应用中。 接下来看We
RxJS Observable——理解观察者模式
小仙女的博客
07-31 2700
Observable——理解观察者模式 观察者模式（Observer mode）指的是函数自动观察数据对象，一旦对象有变化，函数就会自动执行。——《ECMAScript 6 入门》 一 理解三个概念 js对象是属性和函数的集合 observable（可观察对象）：由Rx.Observable.create 或创建操作符创建的的对象 observer（观察者对象）：一个回调函数的集合 ...
PHP设计模式：深入理解观察者模式(Observer)
本文详细介绍了PHP中的观察者模式（Observer），一种用于建立对象间一对多关系的设计模式。当一个对象的状态发生变化时，所有依赖它的对象都会收到通知并自动更新。 观察者模式的主要意图是定义一个一对多的依赖...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值