观察者模式学习

观察者模式

1.基本介绍

• 对象之间多对一依赖的一种设计模式，依赖的对象为Subject，被依赖的对象为Observer，Subject通知Observer变化

2.原理类图

• Subject为消息发送站，他的三个方法分别：
  • registerObServer（）：订阅，注册第三方，需要接受消息的对象
  • removeObServe （）：移除第三方
  • notifyObServer（）：发送通知，监听到动态则传达给订阅的对象
• ObServer为各个第三方的对象
  • update（）：被调用的方法，通过该方法给第三方观察者传递消息

3.案例

1.案例要求

• 使用观察者模式实现一个多对一的案例：天气消息推送系统，向多个第三方网站推送天气预报情况

2.实现类图

• WeatherData：天气预报站，向观察者（第三方网站Observer）发送通知

  • observers：通过注册的第三方网站集合，即接受通知的对象集合

• Observer：第三方接口，需要接受通知的对象实现该接口

3.代码实现

Subject接口

public interface Subject {
    //注册一个观察者
	void register(Observer observer);
    //移除一个观察者
	void remove(Observer observer);
	//发出通知
    void notifyObserver();
}

核心类WeatherData

//包含最新的天气情况消息
//含有 观察者集合，使用ArrayList管理
//当数据有更新时，就主动的调用 ArrayList他们（接入方）就看到最新的信息
public class WeatherData implements Subject{
    //天气信息
	private Integer temperature;
	private Integer humidity;
    //观察者集合
	private ArrayList<Observer> observers;
	//构造器
	public WeatherData() {
		// TODO Auto-generated constructor stub
		observers=new ArrayList<>();
		temperature=0;
		humidity=0;
	}
	//注册一个观察者
	@Override
	public void register(Observer observer) {
		// TODO Auto-generated method stub
		observers.add(observer);
	}
	//移除一个观察者
	@Override
	public void remove(Observer observer) {
		// TODO Auto-generated method stub
		observers.remove(observer);
	}
	//向观察者发出通知
	@Override
	public void notifyObserver() {
		// TODO Auto-generated method stub
		for(Observer observer : observers) {
			observer.update(temperature,humidity);
		}
	}
    //更新数据时发出通知
	public void setData(Integer temperature,Integer humidity) {
		this.temperature=temperature;
		this.humidity = humidity;
		notifyObserver();
	}
}

观察者接口：具体的第三方对象实现该接口的update方法，各自对获取到的天气信息进行处理

public interface Observer {
	void update(Integer temperature, Integer humidity);
}

观察者实现：一个为例

public class Sina implements Observer{
    //实现update获取数据
	@Override
	public void update(Integer temperature, Integer humidity) {
        //各自进行实现
		display(temperature, humidity);
	}
	public void display(Integer temperature, Integer humidity) {
		System.out.println("新浪提醒你，最新温度："+temperature);
		System.out.println("新浪提醒你，最新湿度："+humidity);
	}
}

Client调用

public class Client {
	public static void main(String[] args) {
        //创建一个关键类，消息发送站
		WeatherData weatherData = new WeatherData();
        //创建观察者类
		Observer baidu = new Baidu();
		Observer sina = new Sina();
        //注册观察者
		weatherData.register(baidu);
		weatherData.register(sina);
        //更新数据测试
		weatherData.setData(30,20);
		System.out.println("===========================");
        //移除观察者
		weatherData.remove(baidu);
        //更新数据测试
		weatherData.setData(25, 39);
	}
}

4.小结

• 使用观察者模式能够在符合ocp原则的前提下实现需求，当需要添加新的观察者时，不需要对消息站进行改动，通过直接向消息站中的观察者集合添加新的观察者，以达到动态的控制多对一的依赖

4.JDK中的Observable源码分析

Observable充当了Subject的角色，即是接口也是实现，在这里是个类，实现了所有核心方法

public class Observable {
    private boolean changed = false;
    //观察者集合
    private Vector<Observer> obs;
public Observable() {
    obs = new Vector<>();
}
//注册一个观察者（线程安全）
public synchronized void addObserver(Observer o) {
    if (o == null)
        throw new NullPointerException();
    if (!obs.contains(o)) {
        obs.addElement(o);
    }
}
//删除一个观察者（线程安全）
public synchronized void deleteObserver(Observer o) {
    obs.removeElement(o);
}
//发送通知
public void notifyObservers() {
    notifyObservers(null);
}
    
public void notifyObservers(Object arg) {
    Object[] arrLocal;
    synchronized (this) {
        if (!changed)
            return;
        arrLocal = obs.toArray();
        clearChanged();
    }
    for (int i = arrLocal.length-1; i>=0; i--)
        ((Observer)arrLocal[i]).update(this, arg);
}

而观察者接口，与我们定义的一致，拥有一个update方法

public interface Observer {
    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     * <code>notifyObservers</code> method to have all the object's
     * observers notified of the change.
     *
     * @param   o     the observable object.
     * @param   arg   an argument passed to the <code>notifyObservers</code>
     *                 method.
     */
    void update(Observable o, Object arg);
}