观察者模式也叫发布订阅模式，它是一个在项目中经常使用的模式，定义如下：
定义对象间一种一对多的依赖关系，是的每当一个对象改变状态，所有依赖它的对象都会得到通知并被自动更新
观察者模式通用类图：
通过类图看到观察者模式涉及到如下四种角色：
1.Subject 被观察者
定义被观察者必须实现的职责，它必须能够动态增加、取消观察者。它一般是抽象类或是实现类，仅仅作为被观察者必须实现的职责：管理观察者并通知观察者
2.Observer观察者
观察者接收到消息后即进行更新操作，对收到的消息进行处理
3.ConcreteSubject具体的被观察者
定义被观察者自己的业务逻辑，同时定义对那些事件进行通知
4.ConcreteObserver具体的观察者
每个观察者在接收到消息后的处理逻辑是不同的，各个观察者都有自己的处理逻辑
通用类图代码如下：
/**
* 被观察者
*
*/
public abstract class Subject {
private List<Observer> list = new LinkedList<Observer>();
// 添加一个观察者
public void attach(Observer o) {
list.add(o);
}
// 删除一个观察者
public void detach(Observer o) {
list.remove(o);
}
// 通知观察者
public void notifyObserver() {
for (Observer o : list) {
o.update();
}
}
}
/**
* 具体被观察者
*
*/
public class ConcreteSubject extends Subject {
public void doSomething() {
// 通知观察者
super.notifyObserver();
}
}
/**
* 观察者
*
*/
public interface Observer {
public void update();
}
public class ConcreteObserver implements Observer {
/**
*
* @see com.huashao.chapter.chapter22.ch01.Observer#update()
*/
@Override
public void update() {
System.out.println("收到消息.....");
}
}
由于观察者模式是一个经常使用的模式，所以JDK也对其做了抽象级的定义
/**
* A class can implement the <code>Observer</code> interface when it
* wants to be informed of changes in observable objects.
*
* @author Chris Warth
* @version 1.20, 11/17/05
* @see java.util.Observable
* @since JDK1.0
*/
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);
}
public class Observable {
private boolean changed = false;
private Vector 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 方法会返回true）
* 调用本方法通知所有登记的观察者，即调用它们的update()方法
* 传入this和arg作为参数
*/
public void notifyObservers(Object arg) {
/*
* a temporary array buffer, used as a snapshot of the state of
* current Observers.
*/
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);
}
/**
* 清空观察者集合.
*/
public synchronized void deleteObservers() {
obs.removeAllElements();
}
/**
*
*
*/
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();
}
}