JAVA设计模式之观察者模式

JAVA设计模式之观察者模式

概念：

观察者模式（observer），

主要用于1:N的通知。当一个对象（目标对象Subject或Objservable，消息发布）的状态变化时，它需要及时通知一系列对象（观察者对象，Observer，消息订阅），令他们做出响应。

通知观察者的两种方式：

推

每次都会把通知以广播方式发送给所有观察者，所有观察者被动接受。

拉

观察者只要知道情况即可。至于什么时候获取内容，都由观察者自主决定。

角色

目标对象Subject

具体目标对象ConcreteSubject

抽象观察者接口Observer

具体观察者ConcreteObserver

类图

应用

聊天室程序，服务器发给客户端

邮件订阅

Servlet中的监听器实现

Android中的广播机制

群发消息

JDK的AWT中事件处理模型，基于观察者模式的委派事件模型

代码

// 目标对象
public class Subject {
protected List observers = new ArrayList<>();

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

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

// 通知观察者更新
public void notifyAllObservers() {
for (Observer observer : observers) {
observer.update(this);
}
}

}

// 具体目标对象
public class ConcreteSubject extends Subject {
private int state;

public int getState() {
return state;
}

public void setState(int state) {
this.state = state;
this.notifyAllObservers();
}
}

// 观察者接口
public interface Observer {

void update(Subject subject);
}

// 具体观察者
public class ObserverA implements Observer {

private int myState;    //与subject保持同步

@Override
public void update(Subject subject) {
myState = ((ConcreteSubject) subject).getState();
System.out.println("update to " + myState);
}

public int getMyState() {
return myState;
}

public void setMyState(int myState) {
this.myState = myState;
}
}

// 客户端
public class Main {
public static void main(String[] args) {
// 创建具体通知者
ConcreteSubject subject = new ConcreteSubject();

// 创建多个观察者
ObserverA observer1 = new ObserverA();
ObserverA observer2 = new ObserverA();
ObserverA observer3 = new ObserverA();

subject.registerObserver(observer1);
subject.registerObserver(observer2);
subject.registerObserver(observer3);

// 改变subject的状态值
subject.setState(1);

System.out.println(observer1.getMyState());
System.out.println(observer2.getMyState());
System.out.println(observer3.getMyState());

}
}

通过javase 的java.util.Observable, java.util.Observer实现

// 通过java.util.Observable实现目标对象
public class ConcreteSubject2 extends Observable {
private int state;

public void setState(int state) {
this.state = state;
setChanged();
notifyObservers(state);
}
}

// 通过java.util.Observer实现观察者
public class Observer2 implements java.util.Observer {
private int myState;

@Override
public void update(Observable o, Object arg) {
myState = (int) arg;
}

public int getMyState() {
return myState;
}

public void setMyState(int myState) {
this.myState = myState;
}
}

// 通过javase 的java.util.Observable, java.util.Observer实现
public class Main2 {
public static void main(String[] args) {
ConcreteSubject2 subject2 = new ConcreteSubject2();

Observer2 observer1 = new Observer2();
Observer2 observer2 = new Observer2();
Observer2 observer3 = new Observer2();

subject2.addObserver(observer1);
subject2.addObserver(observer2);
subject2.addObserver(observer3);

subject2.setState(10);

System.out.println(observer1.getMyState());
System.out.println(observer2.getMyState());
System.out.println(observer3.getMyState());
}
}