观察者模式学习
观察者模式
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);
}
