[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可以说是观察者模式的一个实现
实现示例:
客户端使用:
运行结果:
观察者模式定义了两个接口Subject与Observer,使得抽象不依赖于具体的实现。
[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,使得抽象不依赖于具体的实现。