本文详细介绍了观察者模式，包括其思想、角色和应用场景。通过代码示例展示了如何在JAVA中实现观察者模式，以及JDK自带的观察者模式API。此外，还讨论了事件驱动模型作为观察者模式的一种应用，并提供了一个游戏升级、降级事件监听的例子。文章最后总结了观察者模式的优点，如低耦合，但也指出可能存在的问题，如通知效率和循环依赖的风险。
观察者模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式，是一种行为型设计模式。
观察者模式的思想是：定义一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。
观察者模式涉及4个角色：
- 抽象主题（Subject）：被观察者的抽象。持有一个保存观察者的集合，拥有添加观察者、删除观察者和通知观察者的方法。
- 具体主题（Concrete Subject）：具体的被观察者，继承自抽象主题，当发生某个行为或属性发生改变时通知观察者。
- 抽象观察者（Observer）：观察者的抽象。
- 具体观察者（Concrete Observer）：具体的观察者，持有一个回调方法，当被观察的主题发生变化时，就是通过这个回调方法来触发观察者的行为。
结构图：
具体代码实现：
观察者：
public interface Observer {
void update(String newState); // 改变自身状态的方法
}
public class ConcreteObserverA implements Observer {
@Override
public void update(String newState) {
System.out.printf("state of Observer A now is: %s\n", newState);
}
}
public class ConcreteObserverB implements Observer {
@Override
public void update(String newState) {
System.out.printf("state of Observer B now is: %s\n", newState);
}
}主题（被观察者）：
public class Subject {
// 持有一个保存观察者的集合
private List<Observer> list = new ArrayList<>();
// 添加观察者
public void attach(Observer observer) {
list.add(observer);
}
// 删除观察者
public void detach(Observer observer) {
list.remove(observer);
}
// 通知列表中的所有观察者
protected void notifyObservers(String newState) {
for (Observer observer : list) {
observer.update(newState);
}
}
}
public class ConcreteSubject extends Subject {
// 一个改变被观察者状态的方法
public void change(String newState) {
System.out.printf("state of Subject now is: %s\n", newState);
notifyObservers(newState); // 改变的同时通知列表中的所有观察者
}
}测试：
public class ObserverTest {
public static void main(String[] args) {
Observer o1 = new ConcreteObserverA();
Observer o2 = new ConcreteObserverB();
ConcreteSubject subject = new ConcreteSubject();
// 注册2个观察者，改变主题的状态，看看效果
subject.attach(o1);
subject.attach(o2);
subject.change("STATE 1");
// 从主题中删除其中一个观察者，再看看效果
System.out.println("==========");
subject.detach(o1);
subject.change("STATE 2");
}
}运行结果：
state of Subject now is: STATE 1
state of Observer A now is: STATE 1
state of Observer B now is: STATE 1
==========
state of Subject now is: STATE 2
state of Observer B now is: STATE 2
JDK自带的实现观察者模式的API
java.util包里面，提供了一个Observable类以及一个Observer接口，实现了JAVA对观察者模式的支持。
java.util.Observer：
void update(Observable o, Object arg) // 只要改变了 observable 对象就调用此方法。java.util.Observable：
void addObserver(Observer o); // 如果观察者与集合中已有的观察者不同，则向对象的观察者集中添加此观察者。
protected void clearChanged(); // 指示对象不再改变，或者它已对其所有的观察者通知了最近的改变，所以 hasChanged 方法将返回 false。
int countObservers(); // 返回 Observable 对象的观察者数目。
void deleteObserver(Observer o); // 从对象的观察者集合中删除某个观察者。
void deleteObservers(); // 清除观察者列表，使此对象不再有任何观察者。
boolean hasChanged(); // 测试对象是否改变。
void notifyObservers(); // 如果 hasChanged 方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来指示此对象不再改变。
void notifyObservers(Object arg); // 如果 hasChanged 方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来指示此对象不再改变。
protected void setChanged(); // 标记此 Observable 对象为已改变的对象；现在 hasChanged 方法将返回 true。具体代码实现：
// 观察者，实现了java.util.Observer接口
public class MyObserver implements Observer {
@Override
public void update(Observable o, Object arg) {
System.out.printf("state of Observer now is: %s\n", arg);
}
}
// 主题（被观察者），继承自java.util.Observable类
public class Subject extends Observable {
public void change(String newState) {
System.out.printf("state of Subject now is: %s\n", newState);
setChanged(); // 这步很重要，如果没有这个动作，下一步的notifyObservers()方法将不会执行
notifyObservers(newState); // 通知列表中的所有观察者
}
}
// 测试
class ObserverTest {
public static void main(String[] args) {
Observer observer = new MyObserver();
Subject subject = new Subject();
// 注册一个观察者，看看效果
subject.addObserver(observer);
subject.change("STATE 1");
// 把观察者从主题的列表中删除，再看看效果
System.out.println("==========");
subject.deleteObserver(observer);
subject.change("STATE 2");
}
}运行结果：
state of Subject now is: STATE 1
state of Observer now is: STATE 1
==========
state of Subject now is: STATE 2
阅读JDK源码我们可以发现，Observable类的notifyObservers(Object arg)方法，只有当hasChanged()返回true时才会通知观察者数据有变化，并且在通知完成之后调用clearChanged()方法，使得hasChanged()返回false，所以当主题数据改变时，需要先手动调用setChanged()方法令hasChanged()返回true才会通知观察者。
事件驱动模型
事件驱动模型是观察者模式的一种典型应用。
事件驱动模型主要涉及3个角色：
- 事件源（Event Source）：相当于主题（被观察者）。
- 事件对象（Event Object）：事件的抽象，例如属性的改变，行为的发生等等。JDK中提供了一个事件类
java.util.EventObject，我们自定义的事件可以继承自这个类，当然也可以自行实现。 - 事件监听器（Event Listener）：相当于观察者。JDK中提供了一个
java.util.EventListener接口，这是一个标识接口，所有监听器都应该实现这个接口。
下面我们将上面的例子改造成事件驱动模型：
监听器：
public interface MyListener extends EventListener {
void update(EventObject e); // 定义一个回调方法，传入一个事件作为参数（这并不是必须的，例如本例中其实没有使用到这个事件对象）
}
public class ConcreteMyListener implements MyListener {
@Override
public void update(EventObject e) {
System.out.println("Listener detected an Event occurred!");
}
}事件源：
public class MyEventSource {
// 持有一个存放监听器的列表
private List<MyListener> list = new ArrayList<>();
// 添加一个监听器到列表
public void addListener(MyListener listener) {
list.add(listener);
}
// 从列表中删除一个监听器
public void removeListener(MyListener listener) {
list.remove(listener);
}
// 通知列表中所有监听器
protected void notifyListeners() {
for (MyListener listener : list) {
listener.update(new EventObject(this)); // 回调
}
}
}
public class ConcreteMyEventSource extends MyEventSource {
public void change() {
System.out.println("Event Source raises an event!!");
notifyListeners(); // 事件发生的同时通知列表中的监听器
}
}测试：
public class MyListenerTest {
public static void main(String[] args) {
MyListener listener = new ConcreteMyListener();
ConcreteMyEventSource source = new ConcreteMyEventSource();
// 注册一个监听器，看看效果
source.addListener(listener);
source.change();
// 把监听器注销，再看看效果
System.out.println("==========");
source.removeListener(listener);
source.change();
}
}运行结果：
Event Source raises an event!!
Listener detected an Event occurred!
==========
Event Source raises an event!!
结构图：
下面再提供一个监听游戏升级、降级事件的例子：
// 定义一个事件类型的枚举
public enum GameEventType {
LEVEL_UP, LEVEL_DOWN;
}
// 游戏事件，本例子里就是升级或降级
public class GameEvent {
private final String username;
private final GameEventType gameEventType;
public GameEvent(String username, GameEventType gameEventType) {
this.username = username;
this.gameEventType = gameEventType;
}
public String getUsername() {
return username;
}
public GameEventType getGameEventType() {
return gameEventType;
}
}
// 抽象监听器，扩展了JDK提供的标识接口
public interface GameEventListener extends EventListener {
void callback(GameEvent e); // 提供一个事件回调方法
}
// 属性监听器
public class AttrEventListener implements GameEventListener {
@Override
public void callback(GameEvent e) {
switch (e.getGameEventType()) {
case LEVEL_UP:
System.out.printf("%s is level up!! hp: +100, att: +10, def: +8\n", e.getUsername());
break;
case LEVEL_DOWN:
System.out.printf("%s is level down!! hp: -100, att: -10, def: -8\n", e.getUsername());
break;
default:
break;
}
}
}
// 技能监听器
public class SkillEventListener implements GameEventListener {
@Override
public void callback(GameEvent e) {
switch (e.getGameEventType()) {
case LEVEL_UP:
System.out.printf("%s is level up!! now can use sword\n", e.getUsername());
break;
case LEVEL_DOWN:
System.out.printf("%s is level down!! now CANNOT use sword\n", e.getUsername());
break;
default:
break;
}
}
}
// 抽象事件分发器，相当于事件源
public interface Dispatcher {
void addListener(GameEventListener listener); // 注册监听器的方法
void trigger(GameEvent event); // 分发事件，将事件通知各个紧监听器
}
// 具体的事件分发器，这里用枚举实现单例
public enum GameEventDispatcher implements Dispatcher {
INSTANCE;
// 存放监听器的列表
private final List<GameEventListener> list = new ArrayList<>();
@Override
public void addListener(GameEventListener listener) {
list.add(listener);
}
@Override
public void trigger(GameEvent event) {
for (GameEventListener listener : list) {
try {
listener.callback(event);
} catch (Exception e) {
// 在循环内捕获异常是为了让后面的监听器不会因为前面的异常而收不到通知，但注意这会降低性能
// ...
}
}
}
}测试：
public class Test {
public static void main(String[] args) {
GameEventListener l1 = new AttrEventListener();
GameEventListener l2 = new SkillEventListener();
GameEvent e1 = new GameEvent("Tommy", GameEventType.LEVEL_UP);
GameEvent e2 = new GameEvent("Tommy", GameEventType.LEVEL_DOWN);
Dispatcher dispatcher = GameEventDispatcher.INSTANCE;
dispatcher.addListener(l1); // 注册属性监听器
dispatcher.addListener(l2); // 注册技能监听器
dispatcher.trigger(e1); // 触发升级事件
System.out.println("==========");
dispatcher.trigger(e2); // 触发降级事件
}
}运行结果：
Tommy is level up!! hp: +100, att: +10, def: +8
Tommy is level up!! now can use sword
==========
Tommy is level down!! hp: -100, att: -10, def: -8
Tommy is level down!! now CANNOT use sword
总结
观察者模式实现了观察者和主题（被观察者）的低耦合。
但是，如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
另外，如果在观察者和被观察者之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
最后，观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。
扫一扫
641
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
