【设计模式——学习笔记】23种设计模式——观察者模式Observer（原理讲解+应用场景介绍+案例介绍+Java代码实现）-Toy模板网

这篇具有很好参考价值的文章主要介绍了【设计模式——学习笔记】23种设计模式——观察者模式Observer（原理讲解+应用场景介绍+案例介绍+Java代码实现）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

案例引入

有一个天气预报项目，需求如下：

气象站可以将每天测量到的温度、湿度、气压等等以公告的形式发布出去(比如发布到自己的网站或第三方)
需要设计开放型API，便于其他第三方也能接入气象站获取数据
提供温度、气压、湿度的接口
测量数据更新时，要能实时的通知给第三方

原始方案实现

设计一个WeatherData类，类里面的方法如下：

getTemperature0：获取温度
getHumidity0：获取湿度
getPressure0：获取气压
dataChange0：可以定时（如每十分钟调用一次）调用该方法去气象站更新温度、湿度、气压数据，并主动推送给应用者

实现

【当前天气状况】

package com.atguigu.observer;

/**
 * 显示当前天气情况（可以理解成是气象站的网站）
 * @author Administrator
 *
 */
public class CurrentConditions {
   /**
    * 温度
    */
   private float temperature;
   /**
    * 气压
    */
   private float pressure;
   /**
    * 湿度
    */
   private float humidity;

   /**
    * 更新 天气情况，是由WeatherData来调用将最新的数据推送过来
    * @param temperature
    * @param pressure
    * @param humidity
    */
   public void update(float temperature, float pressure, float humidity) {
      this.temperature = temperature;
      this.pressure = pressure;
      this.humidity = humidity;
      display();
   }

   /**
    * 显示天气情况
    */
   public void display() {
      System.out.println("***Today mTemperature: " + temperature + "***");
      System.out.println("***Today mPressure: " + pressure + "***");
      System.out.println("***Today mHumidity: " + humidity + "***");
   }
}

【气象台的天气数据】

package com.atguigu.observer;

/**
 * 类是核心
 * 1. 包含最新的天气情况信息
 * 2. 含有 CurrentConditions 对象
 * 3. 当数据有更新时，就主动的调用CurrentConditions对象的update方法(含 display), 这样他们（接入方）就看到最新的信息
 * @author Administrator
 *
 */
public class WeatherData {
   private float temperatrue;
   private float pressure;
   private float humidity;
   private CurrentConditions currentConditions;

   /**
    * 加入新的第三方
    * @param currentConditions
    */
   public WeatherData(CurrentConditions currentConditions) {
      this.currentConditions = currentConditions;
   }

   public float getTemperature() {
      return temperatrue;
   }

   public float getPressure() {
      return pressure;
   }

   public float getHumidity() {
      return humidity;
   }

   public void dataChange() {
      //调用 接入方的 update
      currentConditions.update(getTemperature(), getPressure(), getHumidity());
   }

   /**
    * 当数据有更新时，就调用 setData
    * @param temperature
    * @param pressure
    * @param humidity
    */
   public void setData(float temperature, float pressure, float humidity) {
      this.temperatrue = temperature;
      this.pressure = pressure;
      this.humidity = humidity;
      //调用dataChange， 将最新的信息 推送给 接入方 currentConditions
      dataChange();
   }
}

【主类】

package com.atguigu.observer;

public class Client {
   public static void main(String[] args) {
      //创建接入方 currentConditions
      CurrentConditions currentConditions = new CurrentConditions();
      //创建 WeatherData 并将 接入方 currentConditions 传递到 WeatherData中
      WeatherData weatherData = new WeatherData(currentConditions);

      //更新天气情况
      weatherData.setData(30, 150, 40);

      //天气情况变化
      System.out.println("============天气情况变化=============");
      weatherData.setData(40, 160, 20);
   }
}

【运行】

***Today mTemperature: 30.0***
***Today mPressure: 150.0***
***Today mHumidity: 40.0***
============天气情况变化=============
***Today mTemperature: 40.0***
***Today mPressure: 160.0***
***Today mHumidity: 20.0***

Process finished with exit code 0

问题分析

当添加其他第三方网站时，需要修改WeatherData类，不符合开闭原则，不利于维护

【设计模式——学习笔记】23种设计模式——观察者模式Observer（原理讲解+应用场景介绍+案例介绍+Java代码实现）,设计模式,设计模式,学习,笔记,观察者模式

改进：推荐使用观察者模式

介绍

基础介绍

观察者模式的工作原理：观察者到观察对象中进行注册，当观察对象的状态发生改变时，就通知已经注册的观察者，观察者可以被从观察对象中移除

登场角色

Subject(观察对象)：Subject角色定义了注册、删除观察者的方法，还可以声明“获取现在的状态”的方法
ConcreteSubject(具体的观察对象)：当自身状态发生变化后，它会通知所有已经注册的Observer角色
Observer(观察者)：负责接收来自Subject角色状态变化的通知，声明了update方法来接收通知
ConcreteObserver(具体的观察者)：当它的update方法被调用后，会去获取要观察的对象的最新状态

案例实现

案例一

类图

实现

【Subject：观察对象接口】

package com.atguigu.observer.improve;

/**
 * 接口, 让WeatherData 来实现
 */
public interface Subject {

   /**
    * 观察者注册
    * @param o
    */
   public void registerObserver(Observer o);

   /**
    * 移除观察者
    * @param o
    */
   public void removeObserver(Observer o);

   /**
    * 通知所有观察者
    */
   public void notifyObservers();
}

【Observer：观察者接口】

package com.atguigu.observer.improve;

/**
 * 观察者接口
 */
public interface Observer {

    /**
     * 更新数据
     *
     * @param temperature
     * @param pressure
     * @param humidity
     */
    public void update(float temperature, float pressure, float humidity);
}

【WeatherData：具体观察对象】

package com.atguigu.observer.improve;

import java.util.ArrayList;

/**
 * 类是核心
 * 1. 包含最新的天气情况信息
 * 2. 含有 观察者集合，使用ArrayList管理
 * 3. 当数据有更新时，就主动的调用ArrayList, 通知所有的（接入方）就看到最新的信息
 *
 * @author Administrator
 */
public class WeatherData implements Subject {
    private float temperature;
    private float pressure;
    private float humidity;
    /**
     * 观察者集合
     */
    private ArrayList<Observer> observers;

    /**
     * 构造方法
     */
    public WeatherData() {
        // 创建新的集合
        observers = new ArrayList<Observer>();
    }

    public float getTemperature() {
        return temperature;
    }

    public float getPressure() {
        return pressure;
    }

    public float getHumidity() {
        return humidity;
    }

    public void dataChange() {
        //调用 接入方的 update
        notifyObservers();
    }

    //当数据有更新时，就调用 setData
    public void setData(float temperature, float pressure, float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        //调用dataChange， 将最新的信息 推送给 接入方 currentConditions
        dataChange();
    }

    /**
     * 注册一个观察者
     * @param o
     */
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    /**
     * 移除一个观察者
     * @param o
     */
    @Override
    public void removeObserver(Observer o) {
        if (observers.contains(o)) {
            observers.remove(o);
        }
    }

    /**
     * 遍历所有的观察者，并通知
     */
    @Override
    public void notifyObservers() {
        for (int i = 0; i < observers.size(); i++) {
            observers.get(i).update(this.temperature, this.pressure, this.humidity);
        }
    }
}

【CurrentConditions：具体观察者】

package com.atguigu.observer.improve;

public class CurrentConditions implements Observer {
    /**
     * 温度
     */
    private float temperature;
    /**
     * 气压
     */
    private float pressure;
    /**
     * 湿度
     */
    private float humidity;

    /**
     * 更新 天气情况，是由 WeatherData 来调用，我使用推送模式
     *
     * @param temperature
     * @param pressure
     * @param humidity
     */
    public void update(float temperature, float pressure, float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }

    /**
     * 显示
     */
    public void display() {
        System.out.println("***Today mTemperature: " + temperature + "***");
        System.out.println("***Today mPressure: " + pressure + "***");
        System.out.println("***Today mHumidity: " + humidity + "***");
    }
}

【BaiduSite：具体观察者】

package com.atguigu.observer.improve;

/**
 * 百度网站
 */
public class BaiduSite implements Observer {
    private float temperature;
    private float pressure;
    private float humidity;

    /**
     * 更新天气情况，是由 WeatherData 来调用，我使用推送模式
     *
     * @param temperature
     * @param pressure
     * @param humidity
     */
    public void update(float temperature, float pressure, float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        display();
    }

    /**
     * 显示
     */
    public void display() {
        System.out.println("===百度网站====");
        System.out.println("***百度网站 气温 : " + temperature + "***");
        System.out.println("***百度网站 气压: " + pressure + "***");
        System.out.println("***百度网站 湿度: " + humidity + "***");
    }

}

【主类】

package com.atguigu.observer.improve;

public class Client {

   public static void main(String[] args) {
      //创建一个WeatherData
      WeatherData weatherData = new WeatherData();

      //创建观察者
      CurrentConditions currentConditions = new CurrentConditions();
      BaiduSite baiduSite = new BaiduSite();

      //注册到weatherData
      weatherData.registerObserver(currentConditions);
      weatherData.registerObserver(baiduSite);

      //测试
      System.out.println("通知各个注册的观察者, 看看信息");
      weatherData.setData(10f, 100f, 30.3f);

      System.out.println();
      System.out.println("----- 移除一个观察者 -----");
      weatherData.removeObserver(currentConditions);
      //测试
      System.out.println();
      System.out.println("通知各个注册的观察者, 看看信息");
      weatherData.setData(10f, 100f, 30.3f);
   }

}

【运行】

通知各个注册的观察者, 看看信息
***Today mTemperature: 10.0***
***Today mPressure: 100.0***
***Today mHumidity: 30.3***
===百度网站====
***百度网站 气温 : 10.0***
***百度网站 气压: 100.0***
***百度网站 湿度: 30.3***

----- 移除一个观察者 -----

通知各个注册的观察者, 看看信息
===百度网站====
***百度网站 气温 : 10.0***
***百度网站 气压: 100.0***
***百度网站 湿度: 30.3***

Process finished with exit code 0

分析

使用该模式，拓展方便，比如需要新增一个观察者，只需要实现一个具体的观察者类，然后在观察对象中注册即可

案例二

类图

实现

【观察者接口】

package com.atguigu.observer.Sample;

public interface Observer {
    public abstract void update(NumberGenerator generator);
}

【被观察对象抽象类】

package com.atguigu.observer.Sample;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 用来生成数值的抽象类
 */
public abstract class NumberGenerator {
    /**
     * 保存Observer们
     */
    private ArrayList observers = new ArrayList();

    /**
     * 注册Observer
     *
     * @param observer
     */
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    /**
     * 删除Observer
     *
     * @param observer
     */
    public void deleteObserver(Observer observer) {
        observers.remove(observer);
    }

    /**
     * 向Observer发送通知
     */
    public void notifyObservers() {
        Iterator it = observers.iterator();
        while (it.hasNext()) {
            Observer o = (Observer) it.next();
            o.update(this);
        }
    }

    /**
     * 获取数值
     *
     * @return
     */
    public abstract int getNumber();

    /**
     * 生成数值
     */
    public abstract void execute();
}

【具体的被观察对象】

package com.atguigu.observer.Sample;

import java.util.Random;

/**
 * 具体的被观察对象
 */
public class RandomNumberGenerator extends NumberGenerator {
    /**
     * 随机数生成器
     */
    private Random random = new Random();
    /**
     * 当前数值
     */
    private int number;

    /**
     * 获取当前数值
     * @return
     */
    public int getNumber() {                
        return number;
    }

    public void execute() {
        for (int i = 0; i < 20; i++) {
            // 生成随机数
            number = random.nextInt(50);
            // 通知观察者
            notifyObservers();
        }
    }
}

【数值显示观察者】

package com.atguigu.observer.Sample;

/**
 * 使用数字形式显示观察到的数值
 */
public class DigitObserver implements Observer {
    public void update(NumberGenerator generator) {
        System.out.println("DigitObserver:" + generator.getNumber());
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
        }
    }
}

【图像显示观察者】

package com.atguigu.observer.Sample;

/**
 * 使用图像显示观察到的数值
 */
public class GraphObserver implements Observer {
    public void update(NumberGenerator generator) {
        System.out.print("GraphObserver:");
        int count = generator.getNumber();
        for (int i = 0; i < count; i++) {
            System.out.print("*");
        }
        System.out.println("");
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
        }
    }
}

【主类】

package com.atguigu.observer.Sample;

public class Main {
    public static void main(String[] args) {
        NumberGenerator generator = new RandomNumberGenerator();
        Observer observer1 = new DigitObserver();
        Observer observer2 = new GraphObserver();
        generator.addObserver(observer1);
        generator.addObserver(observer2);
        generator.execute();
    }
}

【运行】

DigitObserver:2
GraphObserver:**
DigitObserver:7
GraphObserver:*******
DigitObserver:6
GraphObserver:******
DigitObserver:26
GraphObserver:**************************
DigitObserver:16
GraphObserver:****************
DigitObserver:6
GraphObserver:******
DigitObserver:28
GraphObserver:****************************
DigitObserver:10
GraphObserver:**********
DigitObserver:6
GraphObserver:******
DigitObserver:10
GraphObserver:**********
DigitObserver:20
GraphObserver:********************
DigitObserver:14
GraphObserver:**************
DigitObserver:21
GraphObserver:*********************
DigitObserver:38
GraphObserver:**************************************
DigitObserver:31
GraphObserver:*******************************
DigitObserver:34
GraphObserver:**********************************
DigitObserver:19
GraphObserver:*******************
DigitObserver:30
GraphObserver:******************************
DigitObserver:0
GraphObserver:
DigitObserver:1
GraphObserver:*

Process finished with exit code 0

观察者模式在JDK源码的应用

Observable直接就是类，没有实现Subject接口，直接在类中实现管理Observer的核心方法，当然，可以写更多的子类来集成Observable以便实现更多的操作

【设计模式——学习笔记】23种设计模式——观察者模式Observer（原理讲解+应用场景介绍+案例介绍+Java代码实现）,设计模式,设计模式,学习,笔记,观察者模式文章来源地址https://www.toymoban.com/news/detail-625127.html

总结

可替换性强：被观察对象中的观察者集合的观察者类型是Observer角色，可以接收各种各样的具体Observer角色，而且可以统一调用他们的update方法；Observer的update方法接收的数据类型也是Subject，在update方法里面也可以统一调用方法来获取具体被观察对象的属性
update方法所需要的参数非常灵活，可以自己按照需求来定义
观察者模式并非主动去观察，而是被观测对象主动去通知，称为发布——订阅模式可能更加贴切

文章说明

本文章为本人学习尚硅谷的学习笔记，文章中大部分内容来源于尚硅谷视频（点击学习尚硅谷相关课程），也有部分内容来自于自己的思考，发布文章是想帮助其他学习的人更方便地整理自己的笔记或者直接通过文章学习相关知识，如有侵权请联系删除，最后对尚硅谷的优质课程表示感谢。
本人还同步阅读《图解设计模式》书籍（图解设计模式/(日)结城浩著;杨文轩译–北京:人民邮电出版社，2017.1），进而综合两者的内容，让知识点更加全面

到了这里，关于【设计模式——学习笔记】23种设计模式——观察者模式Observer（原理讲解+应用场景介绍+案例介绍+Java代码实现）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！