Java中的监听器（Listener）和观察者模式（Observer Pattern）都是用于处理对象间的事件通知和响应的设计模式。它们的目的是在对象之间建立一种松散的耦合，使得一个对象的状态变化可以通知到其他对象，并且其他对象能够相应地作出变化。
首先我们先用两个实例来感受一下：
观察者模式是一种行为设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都得到通知并被自动更新。
在Java中，观察者模式通常使用java.util.Observable类和java.util.Observer接口来实现。被观察的对象继承Observable类，而观察者实现Observer接口。当被观察对象的状态发生改变时，它会调用notifyObservers()方法，通知所有注册的观察者。
import java.util.Observable;
import java.util.Observer;
// 被观察的对象
class MyObservable extends Observable {
private int data;
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
setChanged(); // 表示状态已改变
notifyObservers(data); // 通知观察者
}
}
// 观察者
class MyObserver implements Observer {
@Override
public void update(Observable o, Object arg) {
if (o instanceof MyObservable) {
System.out.println("Data changed to: " + arg);
}
}
}
public class ObserverPatternExample {
public static void main(String[] args) {
MyObservable observable = new MyObservable();
MyObserver observer = new MyObserver();
observable.addObserver(observer);
observable.setData(42); // 触发通知
}
}
这个代码比较简单，在被观察对象 MyObservable发生改变时，会通知观察者，监听此对象的观察者 MyObserver会同步做出处理。
其中有一步observable.addObserver(observer); 这个是将被观察对象让观察者检测到
其内部实现主要在Observable
源码如下所示
public class Observable {
private boolean changed = false;
private Vector<Observer> obs = new Vector(); //观察者列表
public Observable() {
}
public synchronized void addObserver(Observer o) { //添加观察者
if (o == null) {
throw new NullPointerException();
} else {
if (!this.obs.contains(o)) {
this.obs.addElement(o);
}
}
}
public synchronized void deleteObserver(Observer o) { //删除观察者
this.obs.removeElement(o);
}
public void notifyObservers() { //通知观察者
this.notifyObservers((Object)null);
}
public void notifyObservers(Object arg) { //通知观察者带参执行
Object[] arrLocal;
synchronized(this) {
if (!this.changed) {
return;
}
arrLocal = this.obs.toArray();
this.clearChanged();
}
for(int i = arrLocal.length - 1; i >= 0; --i) {
((Observer)arrLocal[i]).update(this, arg);
}
}
public synchronized void deleteObservers() { //删除所有观察者
this.obs.removeAllElements();
}
protected synchronized void setChanged() {/当改变是可以通知观察者执行
this.changed = true;
}
protected synchronized void clearChanged() {//当改变是可以通知观察者不执行
this.changed = false;
}
public synchronized boolean hasChanged() { //获取观察者是否可以执行
return this.changed;
}
public synchronized int countObservers() {//返回当前观察者个数
return this.obs.size();
}
}
通过源码可以看出addObserver方法可以将观察者加入到这个被观察者的属性中，通过维护一个Vector来维护所有的观察者，观察者实现Observer接口的update方法，来执行通知的方法。
监听器模式并不是一个新的设计模式，它是观察者模式在特定场景下的一种改造和应用。通常，观察者模式的主题在通知观察者时，通知中不包含任何信息。如果这个过程中携带了一些其他信息，那么主题本身就成为了事件源，而携带信息的封装类就成为了事件。此时的观察者模式，也就升级为监听器了。监听器模式是观察者模式的另一种形态。
监听器模式通常包含三个角色：事件源、事件对象、事件监听器。
在Java中，监听器模式通常通过接口和事件对象来实现。
具体实现如下：
// 监听器接口
interface MyListener {
void onDataChanged(int newData);
}
// 发布者类
class EventSource {
private MyListener listener;
public void setListener(MyListener listener) {
this.listener = listener;
}
public void fireEvent(int newData) {
if (listener != null) {
listener.onDataChanged(newData);
}
}
}
// 订阅者类
class MySubscriber implements MyListener {
@Override
public void onDataChanged(int newData) {
System.out.println("Data changed to: " + newData);
}
}
public class ListenerPatternExample {
public static void main(String[] args) {
EventSource eventSource = new EventSource();
MySubscriber subscriber = new MySubscriber();
eventSource.setListener(subscriber);
eventSource.fireEvent(42); // 触发事件
}
}