观察者模式

1.基本介绍

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

2.原理类图

• Subject为消息发送站，他的三个方法分别： registerObServer（）：订阅，注册第三方，需要接受消息的对象
• removeObServe （）：移除第三方
• notifyObServer（）：发送通知，监听到动态则传达给订阅的对象

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);
}