观察者模式(Observer)

[b]意图：[/b]定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态发生改变时，会通知所有观察者对象，是他们能够自动更新自己。
[b]别名：[/b]Publish/Subscribe模式
[b]结构图：[/b]
[img]http://dl.iteye.com/upload/attachment/0065/4792/986c437b-7937-3bd7-9408-944658f09e8d.png[/img]
Subject：主题
Observer：观察者
观察者可以定义他感兴趣的主题，一个主题可以呗多个观察者所订阅，当主题(Subject)的状态发生改变时会通知它所有订阅它的观察者。
Subject类中的Notify方法，是在其状态改变时调用，Notify方法会调用所有Observer中的update方法。Observer类中的update方法在其子类中实现，所以各个不同的ConcreteObserver可以根据具体情况对Subject的改变做出相应的操作。

Linux netfilter可以说是观察者模式的一个实现
实现示例：

public abstract class Subject {
	private List<Observer> observers = new ArrayList<Observer>();

	public void attach(Observer observer) {
		observers.add(observer);
	}

	public void detach(Observer observer) {
		observers.remove(observer);
	}

	public void Notify() {
		for (Observer o: observers) {
			o.update();
		}
	}
}

public abstract class Observer {
	protected String name;
	public Observer(String name) {
		this.name = name;
	}
	public abstract void update();
}

public class ConcreteSubject extends Subject {
	private String subjectState;
	public void setState(String state) {
		this.subjectState = state;
	}

	public String getState() {
		return this.subjectState;
	}
}

public class ConcreteObserver extends Observer {

	private ConcreteSubject subject;
	private String observerState;
	public ConcreteObserver(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}


	public ConcreteObserver(ConcreteSubject subject, String name) {
		super(name);
		this.subject = subject;
	}

	@Override
	public void update() {
		observerState = subject.getState();
		System.out.println("Observer " + this.name + " State is: " + observerState);
	}
}

客户端使用：

public class Client {
	public static void main(String argv[]) {
		ConcreteSubject s = new ConcreteSubject();
		ConcreteObserver oA = new ConcreteObserver(s, "A");
		ConcreteObserver oB= new ConcreteObserver(s, "B");
		ConcreteObserver oC = new ConcreteObserver(s, "C");
		s.attach(oA);
		s.attach(oB);
		s.attach(oC);

		s.setState("1234567890");
		s.Notify();

		System.out.println("############################");
		s.detach(oB);
		ConcreteObserver oD = new ConcreteObserver(s, "D");
		s.attach(oD);
		s.setState("abcdefghijklmnopqrstuvwxyz");
		s.Notify();
	}
}

运行结果：

Observer A State is: 1234567890
Observer B State is: 1234567890
Observer C State is: 1234567890
############################
Observer A State is: abcdefghijklmnopqrstuvwxyz
Observer C State is: abcdefghijklmnopqrstuvwxyz
Observer D State is: abcdefghijklmnopqrstuvwxyz

观察者模式定义了两个接口Subject与Observer，使得抽象不依赖于具体的实现。