观察者模式

分享视频链接：https://www.bilibili.com/video/BV1PC4y1x7ig/

 

以下是文字稿和幻灯片：

大家好，我今天给大家分享的是观察者模式：

在生活中我们有一个很常见的场景，也就是在等红绿灯的时候

这里面呢，观察者就是我们的汽车，而观察目标就是我们的交通信号灯。

他们之间是一个一对多的关系，建立一种对象与对象之间的依赖关系，一个对象发生改变时将自动通知其他对象，其他对象将相应做出反应

那我们来看看是什么是观察者模式：

观察者模式（Observer Design Pattern）也被称为发布订阅模式（Publish-Subscribe Design Pattern）

在对象之间定义一个一对多的依赖，当一个对象状态改变的时候，所有依赖的对象都会自动收到通知。

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

观察者模式 UML类图：

模式包含4个角色：

Subject: 目标

ConcreteSubject:具体目标

Observer: 观察者

ConcreteObserver: 具体观察者

我们下面来看一下代码实践：

一个天气预报系统，凡是订阅了改天气预报的，当天气发生改变的时候就把通知发送给所有订阅该天气预报的人。如兽人族（Orcs）和霍比特人（Hobitts）订阅了该天气预报系统，当天气从晴变成雨天的时候，兽人族和霍比特人就收到了天气变成雨天的通知。 如果还有其他订阅了该天气预报的如人族（Terran），只需要在WeatherObserver中加入该人族（Terran）订阅者，这样当天气发生改变的时候，人族也会收到天气通知。

 

//先定义天气类型（WeatherType.java），定义为枚举类型（sunny，rainny，windy，clod）
public enum WeatherType {
    SUNNY,WINDY,CLOD,RAINY;

    @Override
    public String toString(){
        return this.name().toLowerCase();
    }
}

//再将订阅者抽象成一个接口（WeatherObserver.java），所有订阅天气预报系统的必须实现这个接口
public interface WeatherObserver {
      public void Upadate(WeatherType currentWeather);
}

//天气类（Weather）负责定义数据结构来接收订阅者和通知更新订阅者天气变化。使用List<WeatherObserver>来接收订阅者，定义方法addObserver来接收新的订阅者和notifyAllObsever方法来更新订阅者天气状态。
import java.util.ArrayList;
import java.util.List;

public class Weather {
     private WeatherType currentWeather;
     private List<WeatherObserver> observers;
     
     public Weather(){
         observers=new ArrayList<>();
         currentWeather=WeatherType.SUNNY;
     }
     
     public void addObservers(WeatherObserver observer){
         observers.add(observer);
     }
     
     public void removeObservers(WeatherObserver observer){
         observers.remove(observer);
     }
     
     
     public  void timePasses(){
         WeatherType[] enumValues=WeatherType.values();
        /* for(WeatherType type:enumValues){
             System.out.println(type);
         }*/
         //改变天气，让天气的enum类型往后推一个
         currentWeather=enumValues[(currentWeather.ordinal() + 1) % enumValues.length];
         System.out.println("The weather change to  "+currentWeather);
         notifyAllObserver();
     }
     
     public void notifyAllObserver(){
         for(WeatherObserver obs: observers){
             obs.Upadate(currentWeather);
         }
     }
}

//添加两个订阅天气预报的“人”，一个兽族（Orcs.java)一个霍比特人(Hobitts.java)。 如上面所说，要订阅该天气预报必须实现WeatherOberver接口。
public class Orcs implements WeatherObserver{

    @Override
    public void Upadate(WeatherType currentWeather) {
        switch(currentWeather){
        case CLOD:
            System.out.println("The orcs are freezing cold");
            break;
        case SUNNY:
            System.out.println("The sun hurts the orcs' eyes.");
            break;
        case RAINY:
            System.out.println("The orcs are dripping wet.");
            break;
        case WINDY:
            System.out.println("The orc smell almost vanishes in the wind.");
        default:
            break;
        }        
    }


public class Hobbits implements WeatherObserver{

    @Override
    public void Upadate(WeatherType currentWeather) {
        switch(currentWeather){
        case CLOD:
            System.out.println("The Hobbits are freezing cold");
            break;
        case SUNNY:
            System.out.println("The sun hurts the Hobbits' eyes.");
            break;
        case RAINY:
            System.out.println("The Hobbits are dripping wet.");
            break;
        case WINDY:
            System.out.println("The Hobbits smell almost vanishes in the wind.");
        default:
            break;
        }       
    }
}

//测试
public class APP {
    public static void main(String[] args){
        Weather weather=new Weather();
        weather.addObservers(new Orcs());
        weather.addObservers(new Hobbits());
        
        //weather.addObservers(new Terran());
        
        weather.timePasses();
        
        //weather.timePasses();
        
    }
}

观察者模式可以实现表示层和数据逻辑层的分离。

观察者模式在观察目标和观察者之间建立一个抽象的耦合。

观察者模式支持广播通信。

将所有的观察者都通知到会花费很多时间可能存在循环依赖

谢谢大家