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

最新推荐文章于 2021-04-10 19:36:03 发布
最新推荐文章于 2021-04-10 19:36:03 发布
阅读量217 收藏
点赞数
分类专栏： # 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
每天进步一点点，也许某一天你也会变得那么渺小！！！

斗罗昊天锤
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
观察者（Observer）模式
dengjili的专栏
02-09 223
观察者（Observer）模式例子这里引入例子，当前有几个硬件设备，负责收集当前温度，湿度和气压，WeatherData对象从气象站收集数据，然后WeatherData向显示器发送数据，对应显示面板解析数据后显示（计算原始数据，输出日常所见的数据） 由于各种场合的需要，有的人只需要看到气象状况，有的人需要看到天气预报，所有根据需要显示不同信息，显示到不同的面板 初期设计 对应代码实现 D
设计模式2：观察者(Observer)模式
weixin_34348111的博客
02-09 80
背景问题：假设我们现在接到一个来自气象台的软件开发合约，对方希望我们开发一个天气预报类的软件。假设需要建立三种布告板，分别显示目前的状况，气象统计及简单的预报。当气象台提供的WeatherObject对象获得最新的测量数据时，三种布告板必须实时更新。如气象台所说，他们的WeatherData源文件中有getTemperature( ),getHumidity( ),getPr...
Java内置的观察者模式
chen_zeliang的专栏
06-30 106
1.定义一个可观察者WeatherData,继承了java.util.Observable类 [code="java"]package pattern.javaObserver; import java.util.Observable; public class WeatherData extends Observable{ private float temperature...
深入浅出设计模式二——WeatherData设计(观察者模式）实现二
05-27
NULL 博文链接：https://quicker.iteye.com/blog/605988
设计模式之----观察者模式（observer-pattern）的理解
04-10 2607
文章目录1.前言2.概念3.模式的结构和实现3.1 模式的结构3.1 模式的实现 1.前言 在现实世界中，许多对象并不是独立存在的，其中一个对象的行为发生改变可能会导致一个或者多个其他对象的行为也发生改变。例如，股票价格与股民、微信公众号与微信用户、气象局的天气预报与听众、小偷与警察等。在软件世界也是这样，例如MVC 模式中的模型与视图的关系，事件模型中的事件源与事件处理者。所有这些，如果用观察者模式来实现就非常方便。 2.概念 当对象间存在一种一对多的依赖关系，则 可以使用观察者模式（Observer
设计模式C++学习之观察者模式（Observer）
09-07
观察者模式（Observer）是软件设计模式中的一种行为模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。这种模式在C++中广泛应用，特别是在需要...
C++设计模式之观察者模式（Observer）
08-27
C++设计模式之观察者模式（Observer） 观察者模式（Observer）是一种常用的设计模式，它主要用于解决对象之间的一对多关系问题。在这种模式中，一个对象（被观察者）维护一个观察者对象的集合，当被观察者对象变化...
Java设计模式之观察者模式（Observer模式）介绍
09-03
观察者模式（Observer模式）是软件设计模式中的一种行为模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。在Java中，这个模式是通过`java.util....
php设计模式 Observer(观察者模式)
10-28
观察者模式（Observer Pattern）是其中一种常见模式，它遵循“发布-订阅”原则，用于建立对象之间的一对多依赖关系。当一个对象的状态发生变化时，所有依赖该对象的其他对象都会得到通知，并自动更新它们的状态。 ...
设计模式-观察者模式-作业-observer.zip
08-27
观察者模式（Observer Pattern）是软件设计模式中的行为模式之一，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动或发布-...
设计模式笔记2：观察者模式（Observer Pattern）
java开发指南博客 【转载】
06-07 136
一、观察者模式内容 观察者模式在对象之间定义了一对多的依赖，这样一来，依赖它的对象都会受到通知并自动更新。 观察者模式又叫做发布-订阅（Publish/Subscribe）模式、模型-视图（Model/View）模式、源-监听器（Source/Listener）模式或从属者（Dependents）模式。 一个软件系统常常要求在某一个对象的状态发生变化的时候，某些其它的对象做出相应的改变。做到...
设计模式2-观察者模式(Observer)全面解析+案例实践+总结
chen
08-28 675
本文是对面向对象设计模式--观察者模式的全面解析，主要分为对设计模式的一些思考整理、定义解析、以气象布告板案例讲解观察者模式、多案例练习加深对观察者模式的理解、最后总结知识要点与观察者模式的一些优缺点与适用场景。 第一篇：设计模式二三事 1）设计模式实际是告诉我们如何组织类和对象，以解决某种问题。它们不是被发明的，而是被前人发现的，是历经验证的能够解决某种问题的一些软件设计经验的总结，并得到了...
【设计模式】HeadFirst设计模式（二）：观察者(Observer)模式
u010800530的专栏
04-26 1362
一、观察者模式定义 在观察者模式中，一个被观察者管理所有依赖于它的观察者对象，它定义了一个一对多的依赖关系，这样一来，当一个对象改变状态时，它的所有依赖者都会受到通知并自动更新。 主题（被观察者）通过一个共同的接口来更新观察者，观察者依赖于此主题。 二、观察者模式例子——气象监测系统 描述： 气象监测系统分为三个部分：气象站（获取实际气象数据的物理装置）、WeatherData对象（追踪
设计模式第二集——观察者模式（Observer）
weixin_30332705的博客
07-29 97
　　观察者模式，就像订报纸杂志。出版社（主题Subject）有新的报纸出版就会通知读者（观察者 Observer），当读者不想看报纸的时候，取消订阅就不会再受到新送来的报纸。这就是一种典型的观察者模式。 　　观察者模式：在对象之间定义一对多的依赖，这样当一个对象改变状态，依赖它的对象都会受到通知并自动更新。 　　观察者类图： 　　Subject是主题接口，对象使用这个接口注册为观察者...
Java 设计模式之观察者模式（Observer）
大魔王的博客
02-16 234
一、观察者模式（Observer Pattern） 观察者模式定义了对象之间的一对多依赖，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新 主题和观察者松耦合 主题唯一依赖的是一个实现Observer接口的对象列表 二、模式详解 ...
设计模式（二）：观察者模式
手写我对你的温柔
03-02 760
设计模式（二）：观察者模式 本文将会通过一个小Demo来记述使用观察者模式的好处以及Java中内置的观察者模式。 Demo描述： 气象站提供数据：温度、气压、和湿度。这时候有第三方公司需要接入今天的数据，来展示在公司的公告板上。气象站测量数据更新时需要实时更新通知给第三方。 通常的设计解决方案：采用OO原则：公报板CurrentCoditions的update()方法调用datachage()...
设计模式（二）观察者（Observer）模式
暴躁兔子的记录
10-12 444
参考： 《headfirst设计模式》 https://blog.csdn.net/hguisu/article/details/7556625 概念解析 观察者模式是jdk中使用最多的模式之一，非常有用。观测模式定义对象间的一种一对多的依赖关系。当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 话不多说看例子解析 通过报纸和杂志的订阅，这种关系来解释一下观察者模式。 ...
观察者模式(Observer)——接口与委托实现
萌萌的It人 www.itmmd.com
04-24 858
在程序中，有时候需要实现一种，当某一个对象（目标对象）的状态发生改变，所有依赖对象（观察者对象）都将得到通知。这个时候，就可以使用观察者模式（Observer）。 在GOF的设计模式中，这样说：定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。 虽然我读的是《Head Frist 设计模式》，但是，通过其中的例子，可以简单初级的了解这个思
06行为型模式1
最新发布
08-03
观察者模式是一种行为型设计模式，它建立了一种对象与对象之间的依赖关系。当一个对象的状态发生改变时，所有依赖于它的对象都会收到通知并且自动更新。这种模式的动机在于创建一个松散耦合的系统，其中对象之间的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值