Java监听器与观察者模式

Java监听器与观察者模式

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 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); // 触发事件
    }
}