观察者模式

1、概念
对象之间多对一依赖的一种设计方案，被依赖对象（被观察者）为subject，依赖对象（观察者）为observers。subject通知observers变化。

2、UML类图

3、优缺点
优点：

1. 以集合的方式管理观察者，包括注册、移除、通知等；
2. 遵守了ocp原则。

4、应用场景
zookeeper、netty的事件驱动（register相应的channel的相应处理）

5、观察者模式与发布订阅模式的区别
注：发布者与订阅者完全解藕。

6、demo
subject被依赖对象（被观察者）接口

package com.model.observer.inprove;

/**
 * 被观察者接口 - 被依赖对象
 */
public interface Subject {
    boolean registerObserver(Observer observer);

    boolean removeObserver(Observer observer);

    void notifyAllObservers();
}

subject被依赖对象（被观察者）实现类

package com.model.observer.inprove;
import java.util.ArrayList;
import java.util.List;
/**
 * 被观察者实现类 - 被依赖对象
 * 核心类 - 包含天气最新数据
 * 含有观察者并管理观察者
 *
 * 类似于jdk自带的Observable类。
 *
 */
public class WeatherData implements Subject {
    private float temperature;
    private float pressure;
    private float humidity;

    private List<Observer> observers = new ArrayList<>();


    public float getTemperature() {
        return temperature;
    }

    public void setTemperature(float temperature) {
        this.temperature = temperature;
    }

    public float getPressure() {
        return pressure;
    }

    public void setPressure(float pressure) {
        this.pressure = pressure;
    }

    public float getHumidity() {
        return humidity;
    }

    public void setHumidity(float humidity) {
        this.humidity = humidity;
    }

    private void dataChange() {
        notifyAllObservers();
    }

    public void setData(float temperature, float pressure, float humidity) {
        this.temperature = temperature;
        this.pressure = pressure;
        this.humidity = humidity;
        dataChange();
    }

    @Override
    public boolean registerObserver(Observer observer) {
        return observers.add(observer);
    }

    @Override
    public boolean removeObserver(Observer observer) {
        return observers.remove(observer);
    }

    @Override
    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update(getTemperature(), getPressure(), getHumidity());
        }
    }
}

observe依赖对象（观察者）接口

package com.model.observer.inprove;

/**
 * 观察者接口，由观察者实现
 */
public interface Observer {
    void update(float temperature, float pressure, float humidity);
}

observe依赖对象（观察者）实现类

package com.model.observer.inprove;

/**
 * 观察者实现类
 */
public class CurrentConditions implements Observer {
    private float temperature;
    private float pressure;
    private float 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("********CurrentConditions*******");
        System.out.println("today temperature = " + temperature);
        System.out.println("today pressure = " + pressure);
        System.out.println("today humidity = " + humidity);
    }

}

测试类

package com.model.observer.inprove;

/**
 * 观察者模式测试类
 * 内容：天气数据变更，通知各观察者
 * 对象之间多对一依赖的一种设计方案，被依赖对象（被观察者）为subject，依赖对象（观察者）为observers。subject通知observers变化。
 * 应用场景：zookeeper、netty的事件驱动（register相应的channel的相应处理）
 */
public class Main {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();

        CurrentConditions currentConditions = new CurrentConditions();

        weatherData.registerObserver(currentConditions);

        System.out.println("***通知各个观察者***");
        weatherData.setData(11, 222, 33);
    }
}

结果输出

***通知各个观察者***
********CurrentConditions*******
today temperature = 11.0
today pressure = 222.0
today humidity = 33.0