用最简单的一句话来理解观察者模式就是:当一个对象发生改变时，其相关依赖对象皆得到通知并被自动更新。
类图
关于这个图的四个对象有如下解释:
1.抽象主题(Subject)
抽象主题角色把所有对观察者对象的引用保存在一个聚集（比如ArrayList对象）里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，抽象主题角色又叫做抽象被观察者(Observable)角色。
2.具体主题(ConcreteSubject)
将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者(Concrete Observable)角色。也就是观察目标哦。
3.抽象观察者(Observer)
为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。
4.具体观察者(ConcreteObserver)
具体观察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态 像协调。如果需要，具体观察者角色可以保持一个指向具体主题对象的引用。
他们是一种一对多的关系，一个Subject(观察目标)依赖多个Observer（观察者），一个Observer依赖一个Subject。Subject需要做的是注册观察者，注销观察者，以及Subject改变时通知在线其他观察者的方法。Observer定义了当主题改变式，被通知时要调用的update方法。当Observer被实例化的时候，会告诉调用Subject的registerObserver()注册到Subject。当Subject更新的时候会最终调用Observer的update方法通知到观察者。
一、不使用观察者模式的一个错误案例:
public class WeatherData {
//实例变量声明
private float temperaure;
private float humidity;
private float pressure;
public void measuremntsChanged(){
float temp = getTemperaure();
float humidity = getHumidity();
float pressure = getPressure();
// 三种布告的实例对象，将从WeatherData中的数据传入布告中。
currentCOnditionDisplay.update(temp, humidity, pressure);
statiscsDisplay.update(temp, humidity, pressure);
forecastDispaly.update(temp, humidity, pressure);
}
// WeatherData的其他方法
public float getTemperaure() {
return temperaure;//温度
}
public float getHumidity() {
return humidity;//湿度
}
public float getPressure() {
return pressure;//气压
}
}
当一个天气主题发生变化时，将调用measuremntsChanged得到变化后的数据，再一个一个的通知其他需要改变的对象（比如目前的状况、气象统计、天气预测）当然，可能需要改变的对象会更多。当不使用观察者模式时，需要通知的对象每个类都要有一个update方法，但正确的做法应该抽取起来，封装变化的部分。如果之后气象站有变化，我们还有在具体的编程中增加或删减代码，这可能反而会引来其他的问题，是不当的操作。
二、使用观察者:
针对上面的案例，如果我们使用观察者模式，应该怎么实现呢?
1.首先定义接口
观察者接口
public interface Observer {
//观察者中的更新数据，当数据更新时将会传递给观察者
public void update(float temp, float humidity, float pressure);
}
被观察者接口
public interface Subject {
//这两个方法 需要一个观察者作为参数，用于注册和删除
public void registerObserver(Observer o);
public void removeObserver(Observer o);
// 当主题改变时，这个方法会被调用来通知所有的观察者
public void notifyObsevers();
}
2.编写被观察者对象 它需要实现被观察者接口
public class WeatherData implements Subject {
// 用数组来记录观察者
private ArrayList observers;
private float temperature;
private float humdity;
private float pressure;
public WeatherData(){
observers = new ArrayList();
}
//当注册观察者时，我们将观察者添加到数组中
public void registerObserver(Observer o) {
this.observers.add(o);
}
//当观察者想取消注册，我们将观察者从数组中删除
public void removeObserver(Observer o) {
int i = observers.indexOf(0);
if (i >= 0){
observers.remove(o);
}
}
//因为每一个观察者都实现了update方法，所以我们在这里可以通知所有的观察者
public void notifyObsevers() {
for (int i = 0; i < observers.size(); ++i){
Observer observer = (Observer) observers.get(i);
observer.update(temperature, humdity, pressure);
}
}
//当从气象站更新观测值时，我们通知观察者
public void measurementChanged(){
notifyObsevers();
}
//
public void setMeassurements(float temperature,
float humdity, float pressure){
this.temperature = temperature;
this.pressure = pressure;
this.humdity = humdity;
measurementChanged();
}
// WeatherData的其他方法
}
3.编写观察者对象 它需要实现观察者接口
因为观察者对象可能会有很多，每一个观察者对象在目标观察对象更新后，都会作出不同的操作（在update中有自己独特的逻辑），比如天气状况发生改变时，当前状况这个对象需要更新天气，预测天气站需要实时预测，气象统计又会做统计工作等等。
本文只写一个模版为例：
当前条件类CurrentWeatherCondition
public class CurrentWeatherCondition implements Observer{
private float temperature;
private float humifity;
private Subject weatherData;
public CurrentWeatherCondition(Subject weatherData){
/*
这里为什么要保存Subject的引用呢？构造完似乎用不着了呀？
的确如此，但是我们可能以后想要取消注册，如果已经有了对
Subject的引用会比较方便
*/
this.weatherData = weatherData;
// 注册
weatherData.registerObserver(this);
}
public void update(float temperature,
float humidity, float pressure) {
this.temperature = temperature;
this.humifity = humidity;
//获取数据后就在布告板中显示。也就调用display方法
display();
}
public void display() {
//布告板中显示就：直接简单输出
Log.d("weather","Current conditions"
+ temperature + "F degrees " +
"and " + humifity + "% humifity");
}
}
至此我们便完成了第一个观察者模式的例子。
三、观察者模式的优缺点
优点
1.符合松耦合设计原则
对象之间要交互，暴露的东西越少越好。只需要知道对方能干嘛，而不需要知道具体怎么实现的。本例中。Observer不需要知道Subject怎么通知我的，只需要知道，通知我update方法被调用了即可。反过来。Subject不需要知道Observer具体是谁，做了什么。只需要知道它是个Observer即可。做到被观察者和观察者解耦
2.松耦合度的对象之间能够维持行动的协调一致，保证高度的协作。
缺点
1.Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。
2.虽然观察者模式可以随时使观察者知道所观察的对象发生了变化，但是观察者模式没有相应的机制使观察者知道所观察的对象是怎么发生变化的。
3.如果在被观察者之间有循环依赖的话，被观察者会触发它们之间进行循环调用，导致系统崩溃。在使用观察者模式是要特别注意这一点。尽量避免。
四、JDK8内置的观察者模式
上述例子有一个弊端是:当我们去扩展一个新的被观察者Subject时，我们会发现我们写了重复的代码。注册删除和通知Observer这些方法在每一个实现类当中都需要去实现。关于这个，使用jdk8的小伙伴们说很容易解决的啦。jdk8支持接口方法的默认实现嘛，子类可以不实现这些方法。
Java API中有内置的观察者模式。java.util包中含有最基本的Observer接口与Observable类。源码如下：
package java.util;
public interface Observer {
void update(Observable var1, Object var2);
}
package java.util;
public class Observable {
private boolean changed = false;
private Vector<Observer> obs = new Vector();
public Observable() {
}
public synchronized void addObserver(Observer var1) {
if (var1 == null) {
throw new NullPointerException();
} else {
if (!this.obs.contains(var1)) {
this.obs.addElement(var1);
}
}
}
public synchronized void deleteObserver(Observer var1) {
this.obs.removeElement(var1);
}
public void notifyObservers() {
this.notifyObservers((Object)null);
}
public void notifyObservers(Object var1) {
Object[] var2;
synchronized(this) {
if (!this.changed) {
return;
}
var2 = this.obs.toArray();
this.clearChanged();
}
for(int var3 = var2.length - 1; var3 >= 0; --var3) {
((Observer)var2[var3]).update(this, var1);
}
}
public synchronized void deleteObservers() {
this.obs.removeAllElements();
}
protected synchronized void setChanged() {
this.changed = true;
}
protected synchronized void clearChanged() {
this.changed = false;
}
public synchronized boolean hasChanged() {
return this.changed;
}
public synchronized int countObservers() {
return this.obs.size();
}
}
JDK定义Observable类为被观察者 也就是我们上面的ConcreteSubject 具体被观察者类，比起之前我们自己定义的Subject，多了一个状态changed属性，调用setChanged方法设置为true，调用notifyObservers方法的时候设置为false，changed的设计可以让我们更有效的控制变化的通知频率，更加灵活。观察者是接口Observer。update方法接受一个具体被观察者以及Object类型的参数。接受的参数就包含了依赖的被观察者，第二个参数方便我们根据业务传入其他的参数。
此时使用jdk8内置的观察者重新改造上面的代码
1.编写被观察者对象 让它继承Observable类， 相比之前不需要实现被观察者接口了
public class WeatherData extends Observable {
private float temperature;
private float humidity;
private float pressure;
public WeatherData(){}
public void measurementsChanged(){
// 在调用notifyObservers()之前，要要先调用setChanged()来指示
// 状态已经改变。
setChanged();
notifyObservers();
}
public void setMeasurements(float temperature,
float humidity, float pressure){
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
measurementsChanged();
}
public float getHumidity() {
return humidity;
}
public float getPressure() {
return pressure;
}
public float getTemperature() {
return temperature;
}
}
2.编写观察者对象，我们还是以上面的CurrentWeatherCondition为例
public class CurrentWeatherCondition implements Observer{
private float temperature;
private float humidity;
Observable observable;
public CurrentWeatherCondition(Observable observable){
this.observable = observable;
observable.addObserver(this);
}
/*
实现 java.util.Observer接口中的update方法。
*/
public void update(Observable obs, Object arg) {
//判断是否是自己想要观察的观察目标
if (obs instanceof WeatherData){
WeatherData weatherData = (WeatherData) obs;
this.temperature = weatherData.getTemperature();
this.humidity = weatherData.getHumidity();
//获取数据后就在布告板中显示。也就调用display方法
display();
}
}
public void display() {
//布告板中显示就：直接简单输出
Log.d("weather","Current conditions"
+ temperature + "F degrees " +
"and " + humifity + "% humifity");
}
}
如此一来，在使用的java内置的观察者接口之后，我们将上述的四个步骤简化成了两个。只需要编写一个被观察者类和一个观察者类，同时当扩展新的被观察者类也不用写重复的注册、移除、更新的相同代码了。
网友评论