您的位置:首页 > 编程语言 > Java开发

springboot之事件监听机制

2020-07-16 04:35 639 查看

一、观察者模式

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的,原来这些都得自己撸一遍。总之原理都一样,只是一个是用户自己实现的回调,一个是系统实现的回调。
————————————————
版权声明:本文为CSDN博主「aa1215018028」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明

内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: