观察者模式概述
对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
- Observable：抽象被观察者，把所有观察者对象的引用保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除以及通知观察者对象。
- Observer：抽象观察者，该角色是观察者的抽象类，它定义了一个更新接口，使得在得到主题的更改通知时更新自己。
sadfasd.jpg
/**
* 抽象观察者
*/
public interface Observer {
public void update(String state);
}
------------------------------------------------------------------------------------------------------
/**
* 抽象被观察者
*/
public abstract class Observable{
/**
* 观察者对象列表
*/
private List<Observer> list = new ArrayList<Observer>();
/**
* 新增观察者，将观察者对象放入观察者对象列表中
* @param observer 观察者对象
*/
public void attach (Observer observer) {
list.add(observer);
}
/**
* 删除观察者，从观察者对象列表中删除观察者
* @param observer 观察者对象
*/
public void detach (Observer observer) {
list.remove(observer);
}
/**
* 通知观察者状态变更，逐个遍历观察者对象列表，调用观察者状态变更方法
* @param newState 新的状态
*/
public void nodifyObservers(String newState) {
for (Observer observer : list) {
observer.update(newState);
}
}
}
------------------------------------------------------------------------------------------------------
/**
* 具体被观察者
*/
public class ConcreateSubject extends Observable{
/**
* 对象状态
*/
private String state;
/**
* 获取状态
* @return 返回状态值
*/
public String getState() {
return state;
}
/**
* 状态变更方法，修改状态，并将状态通知观察者对象
* @param newState 新的状态
*/
public void change(String newState) {
this.state = newState;
this.nodifyObservers(this.state);
}
}
------------------------------------------------------------------------------------------------------
/**
* 具体观察者
*/
public class ConcreateObserver implements Observer {
//观察者状态
private String observerState;
/**
* 更新观察者状态方法
* @param state 新的状态
*/
public void update(String state) {
this.observerState = state;
System.out.println("Observer state is " + this.observerState);
}
}
------------------------------------------------------------------------------------------------------
/**
* 客户端
*/
public class Client {
public static void main(String[] args) {
//创建具体主题角色类的实例
ConcreateSubject subject = new ConcreateSubject();
//创建观察者角色实例
Observer observer = new ConcreateObserver();
//将观察者对象登记到主题角色对象上
subject.attach(observer);
//修改主题角色状态
subject.change("State1");
}
}
java中提供对观察者支持
在JAVA语言的java.util库里面，提供了一个Observable类以及一个Observer接口，构成JAVA语言对观察者模式的支持。
Observer接口
这个接口只定义了一个方法，即update()方法，当被观察者对象的状态发生变化时，被观察者对象的notifyObservers()方法就会调用这一方法。
public interface Observer {
void update(Observable o, Object arg);
}
Observable类
被观察者类都是java.util.Observable类的子类。java.util.Observable提供公开的方法支持观察者对象，这些方法中有两个对Observable的子类非常重要：一个是setChanged()，另一个是notifyObservers()。
第一方法setChanged()被调用之后会设置一个内部标记变量，代表被观察者对象的状态发生了变化。第二个是notifyObservers()，这个方法被调用时，会调用所有登记过的观察者对象的update()方法，使这些观察者对象可以更新自己。
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);
}
/**
* 如果调用方法`hasChanged()`表明对象已改变，则通知所有注册观察者对象
* 通过调用观察者对象的`update()`方法。
* 然后调用方法`clearChanged()`复位对象修改状态，重新开始判断
*/
public void notifyObservers(Object arg) {
/*
* 一个数组，保存当前正在进行监控的观察者对象
*/
Object[] arrLocal;
synchronized (this) {
/* 我们不希望观察者对象在保持监控的时候回调任何代码
* 这个方法将会提取每个观察者对象的状态，因此需要使用同步事务锁
* 但是通知观察者对象方法不需要
* 最糟糕的情况是下面两种
* 1) 新增的观察者对象将会错过正在进行中的通知
* 2) 一个最近未注册的观察者将在其不需要的时候收到通知
*/
if (!changed)
return;
arrLocal = obs.toArray();
clearChanged();
}
for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}
/**
* 清空观察者对象列表
*/
public synchronized void deleteObservers() {
obs.removeAllElements();
}
/**
* 当被观察的对象，也就是主题对象发生变更时，调用此方法
* 然后调用`hasChanged()`方法就会返回true
*/
protected synchronized void setChanged() {
changed = true;
}
/**
* 重置变化状态为未变化
*/
protected synchronized void clearChanged() {
changed = false;
}
/**
* 判断主题对象是否发生改变
*/
public synchronized boolean hasChanged() {
return changed;
}
/**
* 得到观察者对象列表中观察者对象数量
*/
public synchronized int countObservers() {
return obs.size();
}
}
这个类代表一个被观察者对象，有时称之为主题对象。一个被观察者对象可以有数个观察者对象，每个观察者对象都是实现Observer接口的对象。在被观察者发生变化时，会调用Observable的notifyObservers()方法，此方法调用所有的具体观察者的update()方法，从而使所有的观察者都被通知更新自己。
示例
/**
* 被观察者对象类，继承Observable
*/
public class Watched extends Observable {
private String data;
public String getData() {
return data;
}
public void setData(String data) {
if (this.data != data) {
this.data = data;
//对象值发生变更，设置对象已发生改变
setChanged();
System.out.println("Data changed to : " + data);
}
//通知观察者对象们
notifyObservers();
}
}
------------------------------------------------------------------------------------------------------
/**
* 创建具体观察者对象类，实现Observer接口
*/
public class Watcher implements java.util.Observer {
public Watcher(Observable observable) {
observable.addObserver(this);
}
public void update(Observable o, Object arg) {
System.out.println("Data hasChanged to : " + ((Watched)o).getData());
}
}
------------------------------------------------------------------------------------------------------
public class TestObserver {
public static void main(String[] args) {
//创建被观察对象，也就是具体主题对象
Watched watched = new Watched();
//创建具体观察者对象，并且将观察者对象添加到被观察者对象的观察者兑现列表中
java.util.Observer watcher = new Watcher(watched);
//修改被观察者对象内容
watched.setData("START");
watched.setData("END");
watched.setData("STOP");
}
}
------------------------------------------------------------------------------------------------------
Data changed to : START
Data hasChanged to : START
Data changed to : END
Data hasChanged to : END
Data changed to : STOP
Data hasChanged to : STOP
- 首先创建被观察对象Watched，然后创建观察者对象watcher，并且调用构造方法，添加到被观察者对象的观察者对象列表中。
- 在被观察对象修改内容时，在内容变化的情况下，修改被观察对象的变更状态为已改变。然后调用通知观察者对象方法notifyObservers，传递自身对象。
- 观察者对象接受到update方法的调用后，处理被观察者对象，并获取其中内容。
