观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，让他们能够自动更新自己。今天我们通过模拟按钮的处理事件来深入Java观察者模式的学习。
目录导航
- Java观察者的简要说明
- Java的按钮点击案例
- 使用Java中的Observer来模拟按钮监听事件机制
- Java中的Observer原理的说明
- 使用自定义的Observer来过滤按钮监听事件
- 友情链接
Java观察者的简要说明
观察者模式所涉及的角色有：
● 抽象主题(Subject)角色：抽象主题角色把所有对观察者对象的引用保存在一个聚集（比如ArrayList对象）里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，抽象主题角色又叫做抽象被观察者(Observable)角色。
● 具体主题(ConcreteSubject)角色：将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者(Concrete Observable)角色。
● 抽象观察者(Observer)角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。
● 具体观察者(ConcreteObserver)角色：存储与主题的状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态 像协调。如果需要，具体观察者角色可以保持一个指向具体主题对象的引用。
Java的按钮点击案例
我们建立一个项目去开始今天的测试。项目结构如下：
demo很简单，点击button按钮，修改button上显示的文字
package com.huhx.frame; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame; /** * writer: huhx */ public class Jframe extends JFrame { private JButton button; public Jframe() { button = new JButton("text"); add(button); setVisible(true); button.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { button.setText("world"); } }); } public static void main(String[] args) { new Jframe(); } }
使用Java中的Observer来模拟按钮监听事件机制
java中的内置观察者模式有两个类：一个是observable被观察者类，一个是observer观察者接口。大体上与自定义模式相同，我们编写程序时只需继承obervable类，具体实现observer接口就可以了。值得注意的是：调用notifyObservers()方法之前，必须先调用setChanged()方法。这是因为observable类中把 changed变量初始化为false,notifyObservers()方法会先检查该变量是否为true,如果不为ture，就不会调用 update()方法，这就要我们调用notifyObservers()之前，先用setChanged()方法将changed变量设置为true。
现在我们以上述例子为引子，使用Java中内置的Observer自己来模拟一个按钮监听事件的案例：
一、 创建一个继承obervable类的被观察者，在案例中也就是Button，类记为：MyButton
package com.huhx.observer; import java.util.Observable; import java.util.Observer; /** * @author huhx */ public class MyButton extends Observable { public void addListeners(Observer observer) { addObserver(observer); } public void process(Object args) { setChanged(); notifyObservers(args); } public void process() { process(null); } }
二、 创建几个观察这个按钮的观察者，其实就是按钮的监听事件：
模拟点击事件：
package com.huhx.observer; import java.util.Observable; import java.util.Observer; public class ClickObserver implements Observer { @Override public void update(Observable o, Object arg) { if (arg != null) { System.out.println("click: " + arg.toString()); } else { System.out.println("click no arg"); } } }
模拟按下事件：
package com.huhx.observer; import java.util.Observable; import java.util.Observer; public class PressObserver implements Observer { @Override public void update(Observable o, Object arg) { if (arg != null) { System.out.println("press: " + arg.toString()); } else { System.out.println("press no arg"); } } }
三、 然后我们写一个测试的类，用于模拟按钮的事件：这里的process方法模拟真实按钮的触发事件，通知所有的观察者。比如我们按下按钮。
package com.huhx.observer; import java.util.Observable; import java.util.Observer; public class PersonTest { public static void main(String[] args) { MyButton button = new MyButton(); button.addObserver(new ClickObserver()); button.addListeners(new Observer() { @Override public void update(Observable o, Object arg) { System.out.println("observer"); } }); button.process("huhx"); } }
五、 它的输出结果如下：
observer
click: huhx
Java中的Observer原理的说明
上述我们通过案例，来模拟了按钮的监听事件原理，现在我们通过源码来详细的分析它的运行过程：
一、 Observer是一个观察者可以实现的接口，它的文档说明如下：
A class can implement the Observer interface when it wants to be informed of changes in observable objects.
Observer中有一个update()方法：
void update(Observable o, Object arg); // Observable 是观察者 arg 是notifyObservers方法传入的参数
二、 Observable是一个被观察者继承的类，它的文档说明大致如下：
This class represents an observable object, or "data" in the model-view paradigm. It can be subclassed to represent an object that the application wants to have observed.
Observable有几个重要的方法，我们简单的介绍一下：
void addObserver(Observer o) // 加入观察者到Vetor中 protected void clearChanged() // 设置change为false int countObservers() // 返回Vetor中观察者的数量 void deleteObserver(Observer o) // 从Vetor中删除指定的观察者 void deleteObservers() // 删除所有的观察者 void notifyObservers() // 通知Vetor中的观察者 void notifyObservers(Object arg) // 通知Vetor中的观察者，带参数 boolean hasChanged() // 判断是否发生改变 protected void setChanged() // 设置changed为true
三、 接下来，我们结合上述的例子来分析Observer的原理：
当执行MyButton button = new MyButton()，由于MyButton是继承Observable，所以下述代码会执行。
private boolean changed = false; private Vector obs; public Observable() { obs = new Vector(); }
当执行button.addObserver(new ClickObserver())，把参数中的Observer存放在上述初始化的Vetor中(为了适应多线程，用的是Vetor)
public synchronized void addObserver(Observer o) { if (o == null) throw new NullPointerException(); if (!obs.contains(o)) { obs.addElement(o); } }
当执行button.process("huhx")，如果被观察者发生了改变，就通知Vetor中的观察者去执行update方法。
public void notifyObservers(Object arg) { 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); }
使用自定义的Observer来过滤按钮监听事件
上述案例中，我们还无法做到对观察者的过滤通知，现在我们自己实现一个Observer，来对事件监听的事件过滤，更好的模拟按钮的事件机制。
一、 定义一个常量类，用于各种事件的标记：
package com.huhx.myobserver; /** * huhx 陈慧 */ public class Event { // 触发所有的Listener public static final int ALL = -1; // 触发内部定义的Listener public static final int DEFAULT = 0; public static final int CLICK = 1; public static final int PRESS = 2; public static final int DOWN = 3; public static final int FOCUE = 4; }
二、 定义一个Listener接口，和Java内置的Observer作用类似，注意方法中的参数是MyObservable
package com.huhx.listener; import com.huhx.myobserver.MyObservable; public interface Listener { void actionPerformed(MyObservable o, Object arg); }
三、 定义几个实现Listener的观察者，也就是事件：
模拟点击事件：
package com.huhx.listener; import com.huhx.myobserver.MyObservable; /** * 陈慧 * @author Linux * */ public class ClickListener implements Listener { @Override public void actionPerformed(MyObservable o, Object arg) { if (arg != null) { System.out.println("click: " + arg); } else { System.out.println("click"); } } }
模拟按下事件：
package com.huhx.listener; import com.huhx.myobserver.MyObservable; public class PressListener implements Listener { @Override public void actionPerformed(MyObservable o, Object arg) { System.out.println("press"); } }
模拟定义在内部类中的事件：
package com.huhx.listener; import com.huhx.myobserver.MyObservable; public class DefaultListener implements Listener { @Override public void actionPerformed(MyObservable o, Object arg) { } }
四、 定义一个类似于Observable类的自定义被观察者：
package com.huhx.myobserver; import java.util.Vector; import com.huhx.listener.ClickListener; import com.huhx.listener.Listener; import com.huhx.listener.PressListener; /** * * @author huhx * */ public class MyObservable { private boolean changed = false; private Vector<Listener> obs; Object[] arrLocal; public MyObservable() { obs = new Vector<>(); } protected synchronized void clearChanged() { changed = false; } public void notifyObserverByEvent(int event, Object args) { synchronized (this) { if (!changed) return; arrLocal = obs.toArray(); clearChanged(); } notifyFixObserver(event, args); } private void notifyFixObserver(int event, Object args) { Listener listener = null; for (int i = arrLocal.length - 1; i >= 0; i--) { listener = (Listener) arrLocal[i]; switch (event) { case Event.PRESS: if (listener instanceof PressListener) ((PressListener) listener).actionPerformed(this, args); break; case Event.CLICK: if (listener instanceof ClickListener) ((ClickListener) listener).actionPerformed(this, args); break; case Event.DEFAULT: if (listener instanceof Listener) listener.actionPerformed(this, args); break; case Event.ALL: listener.actionPerformed(this, args); break; default: break; } } } public void notifyObserverByEvent(int event) { notifyObserverByEvent(event, null); } public void notifyObserverByEvent(Object args) { notifyObserverByEvent(Event.ALL, args); } public synchronized void addListener(Listener listener) { if (listener == null) throw new NullPointerException(); if (!obs.contains(listener)) { obs.addElement(listener); } } protected synchronized void setChanged() { changed = true; } }
五、 为了简化Button的使用，我们仿造Java中的做法，先创建一个AbstractButton，用于处理共公的代码：
package com.huhx.myobserver; import com.huhx.listener.Listener; public class AbstractButton extends MyObservable { public void addListeners(Listener listener) { addListener(listener); } public void process(int source, Object args) { setChanged(); switch (source) { case Event.CLICK: notifyObserverByEvent(Event.CLICK, args); break; case Event.PRESS: notifyObserverByEvent(Event.PRESS, args); break; case Event.DEFAULT: notifyObserverByEvent(Event.DEFAULT, args); break; case Event.ALL: notifyObserverByEvent(Event.ALL, args); default: break; } } public void process(int source) { process(source, null); } }
六、 创建一个被观察者，也就是我们的按钮Button
package com.huhx.myobserver; /** * * @author Linux * */ public class MyButtton extends AbstractButton { }
七、 在测试中使用：
package com.huhx.myobserver; import com.huhx.listener.ClickListener; import com.huhx.listener.Listener; public class PersonTest { public static void main(String[] args) { MyButtton buttton = new MyButtton(); buttton.addListener(new Listener() { @Override public void actionPerformed(MyObservable observable, Object object) { System.out.println("listener"); System.out.println(observable + ", object: " + object.toString()); } }); buttton.addListener(new ClickListener()); buttton.process(Event.CLICK); // buttton.process(Event.DEFAULT, "world"); } }
它的输出结果如下：
click: 陈慧
观察者模式的应用
一、观察者模式的优点
- 观察者和被观察者之间是抽象耦合
如此设计，则不管是增加观察者还是被观察者都非常容易扩展，而且在Java中都已经实现的抽象层级的定义，在系统扩展方面更是得心应手。
- 建立一套触发机制
根据单一职责原则，每个类的职责是单一的，那么怎么把各个单一的职责串联成真实世界的复杂的逻辑关系呢？比如，我们去打猎，打死了一只母鹿，母鹿有三个幼崽，因失去了母鹿而饿死，尸体又被两只秃鹰争抢，因分配不均，秃鹰开始斗殴，然后羸弱的秃鹰死掉，生存下来的秃鹰，则因此扩大了地盘……这就是一个触发机制，形成了一个触发链。观察者模式可以完美地实现这里的链条形式。
二、观察者模式的缺点
观察者模式需要考虑一下开发效率和运行效率问题，一个被观察者，多个观察者，开发和调试就会比较复杂，而且在Java中消息的通知默认是顺序执行，一个观察者卡壳，会影响整体的执行效率。在这种情况下，一般考虑采用异步的方式。
多级触发时的效率更是让人担忧，大家在设计时注意考虑。
三、观察者模式的使用场景
- 关联行为场景。需要注意的是，关联行为是可拆分的，而不是“组合”关系。
- 事件多级触发场景。
- 跨系统的消息交换场景，如消息队列的处理机制。