==> 学习汇总（持续更新）
==> 从零搭建后端基础设施系列（一）-- 背景介绍
一、观察者模式
1.涉及到的类
public interface Observer {
/*
观察者必须要实现这个接口，其实就相当于，A实现了这个接口，B发生改变的时候，顺便调用一下A的update方法。
*/
void update(Observable o, Object arg);
}
//可以理解为，事件源和通知者的结合体
//用大白话讲就是，我的XXX被改变了，然后我要通知一下所有观察我的人
public class Observable {
……
public void notifyObservers(Object arg) {
Object[] arrLocal;
synchronized (this) {
if (!changed)
return;
arrLocal = obs.toArray();
clearChanged(); //只是简单的将标志位置为false，表示消费了这个事件
}
for (int i = arrLocal.length-1; i>=0; i--)
//就是这里！会回调update这个方法
((Observer)arrLocal[i]).update(this, arg);
}
protected synchronized void setChanged() {
changed = true; //想通知观察者，这个方法必须调用
}
protected synchronized void clearChanged() {
changed = false;
}
……
}
2.观察者模式极简单的例子
public class TestEvent {
public static void main(String[] args) {
A a1 = new A();
A a2 = new A();
B b = new B();
//添加两个观察者
b.addObserver(a1);
b.addObserver(a2);
//改变B中的XXX
b.set("A1");
b.set("A2");
}
static class A implements Observer {
@Override
public void update(Observable o, Object arg) {
System.out.println(arg);
}
}
static class B extends Observable {
public void set(String name){
setChanged();
//通知所有观察者，notifyObservers可以传参，也可以不传参
notifyObservers(name);
}
}
}
二、事件监听机制
1.涉及到的类
//就是一个事件类型，规范是，任何自定义类型都需要继承它
public class EventObject implements java.io.Serializable {
……
}
//事件监听器，无任何实现方法，按照规范，任何监听器都需要继承或实现它
public interface EventListener {
}
抛开spring中的广播者不说，这个其实和观察者模式原理一毛一样。
a.首先A维护者一个监听器链表
b.然后当A中XXX发生变化的时候，调用所有监听器的处理方法，并将XXX事件当做参数传进去即可。
2.事件监听机制极简单的例子
public class TestEvent2 {
public static void main(String[] args) {
C c = new C();
//这里注册了两个监听器，相当于，这两个东西想时刻知道C的变化，当C中的XXX变化的时候，会去调用监听器的方法进行处理
c.register(new MyListener("Listener1"));
c.register(new MyListener("Listener2"));
c.set(new MyEvent("A"));
}
//自定义监听器，一定要实现EventListener，虽然不实现也没事，但是都按照规范来会使代码易读
static class MyListener implements EventListener{
String name;
public MyListener(String name){
this.name = name;
}
public void handle(EventObject eventObject){
System.out.println(name + ":" + ((MyEvent)eventObject).getName());
}
}
//自定义事件类型
static class MyEvent extends EventObject{
String name;
public String getName() {
return name;
}
public MyEvent(Object source) {
super(source);
name = (String)source;
}
}
//一个普通的类，可能有N个监听器想监视这个类
static class C{
List<MyListener> myListeners = new ArrayList<>();
public void register(MyListener a){
myListeners.add(a);
}
public void set(EventObject eventObject){
for (MyListener myListener : myListeners){
//当发生变化的时候，去调用监听器的方法处理这个事件
myListener.handle(eventObject);
}
}
}
}
三、观察者模式和事件监听机制对比(java 原生)
| 观察者模式 | 事件监听机制 |
|---|---|
| 需要将所有观察者加入A中 | 需要将所有监听器加入到A中 |
| 当A中的XXX发生变化，通知（调用）所有观察者 | 当A中的XXX发生变化，通知（调用）所有监听器 |
四、springboot中的事件监听机制
1.涉及到的类
//就是springboot自定义的一个事件类型而已
public abstract class ApplicationEvent extends EventObject {
}
//就是springboot自定义的一个事件监听器，并且指定唯一处理事件的方法
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
void onApplicationEvent(E event);
}
//springboot自己新弄的一个事件广播器，说白了它就是依次调用它里面的监听器中的onApplicationEvent方法
public interface ApplicationEventMulticaster {
void addApplicationListener(ApplicationListener<?> listener);
void addApplicationListenerBean(String listenerBeanName);
void removeApplicationListener(ApplicationListener<?> listener);
void removeApplicationListenerBean(String listenerBeanName);
void removeAllListeners();
void multicastEvent(ApplicationEvent event);
void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType);
}
2.事件监听机制极简单的例子
public class TestEvent3 {
public static void main(String[] args) {
MyMulticaster myMulticaster = new MyMulticaster();
//这里注册了两个监听器
myMulticaster.addApplicationListener(new MyListener("Listener1"));
myMulticaster.addApplicationListener(new MyListener("Listener2"));
//将事件广播出去，凡是在这个广播器注册了监听器，那么就可以收到这个事件消息（其实就是这个广播器，回调它们的接口）
myMulticaster.multicastEvent(new MyEvent("A"));
}
//自定义监听器，一定要实现EventListener，虽然不实现也没事，但是都按照规范来会使代码易读
static class MyListener implements ApplicationListener {
String name;
public MyListener(String name){
this.name = name;
}
@Override
public void onApplicationEvent(ApplicationEvent event) {
System.out.println(name + ":" + event);
}
}
//自定义事件类型
static class MyEvent extends ApplicationEvent{
String name;
public String getName() {
return name;
}
public MyEvent(Object source) {
super(source);
name = (String)source;
}
}
//广播器，负责管理监听器，广播消息
static class MyMulticaster implements ApplicationEventMulticaster {
List<ApplicationListener> applicationListeners = new ArrayList<>();
@Override
public void addApplicationListener(ApplicationListener<?> listener) {
applicationListeners.add(listener);
}
@Override
public void addApplicationListenerBean(String listenerBeanName) {
}
@Override
public void removeApplicationListener(ApplicationListener<?> listener) {
applicationListeners.remove(listener);
}
@Override
public void removeApplicationListenerBean(String listenerBeanName) {
}
@Override
public void removeAllListeners() {
}
@Override
public void multicastEvent(ApplicationEvent event) {
//一个个遍历监听器，然后调用它们的处理方法
for (ApplicationListener listener : applicationListeners){
listener.onApplicationEvent(event);
}
}
@Override
public void multicastEvent(ApplicationEvent event, ResolvableType eventType) {
}
}
}
五、总结
一开始我看到这个观察者模式，我还不知道是什么鬼，听着太别扭了。然后看到事件监听机制，才有点感觉，因为这个和C/C++的CALLBACK机制有点像。但是看了一下源码，我又开始疑惑，就觉得，为什么感觉有些绕，没有想象中的简洁。这是因为我把这个用户回调和系统回调搞混了。之前接触过的回调都是C/C++的系统回调，都是系统自动的帮你调用这些方法，这会让人感觉到真的是事件监听机制。然后看了java的，原来这些都得自己撸一遍。总之原理都一样，只是一个是用户自己实现的回调，一个是系统实现的回调。
博客专家