1.测试案例

定义一个事件

package com.example.demo.event;
import org.springframework.context.ApplicationEvent;public class MyEvent extends ApplicationEvent {public MyEvent(Object source) {super(source);}
}

定义两个listener

package com.example.demo.event;import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;@Component
public class Listener1 implements ApplicationListener<MyEvent> {@Overridepublic void onApplicationEvent(MyEvent event) {String source = (String) event.getSource();System.out.println(this.getClass().getName() + ":" + source);}
}

package com.example.demo.event;import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;@Component
public class Listener2 implements ApplicationListener<MyEvent> {@Overridepublic void onApplicationEvent(MyEvent event) {String source = (String) event.getSource();System.out.println(this.getClass().getName() + ":" + source);}
}

注入spring容器里的ApplicationEventPublisher对象，发布事件

package com.example.demo;import com.example.demo.event.MyEvent;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.test.context.junit4.SpringRunner;import javax.annotation.Resource;@RunWith(SpringRunner.class)
@SpringBootTest
public class EventPublisherTest {@Resourceprivate ApplicationEventPublisher eventPublisher;@Testpublic void test() {eventPublisher.publishEvent(new MyEvent("xxx"));}
}

2.DEBUG源码分析

从eventPublisher.publishEvent(new MyEvent("xxx"));进去很容易就能找到，可以发现SimpleApplicationEventMulticaster这个事件发布对象持有所有listenter对象及MyEvent对象,
事件发布过程其实就是遍历拿到每个listener对象并调用它自己的onApplicationEvent（）方法

SimpleApplicationEventMulticaster类的主要方法：

• addApplicationListener(ApplicationListener<?> listener) ：
• addApplicationListenerBean(String listenerBeanName)：
• removeApplicationListener(ApplicationListener<?> listener)：
• removeApplicationListenerBean(String listenerBeanName)：
• multicastEvent(ApplicationEvent event)：广播事件；
• multicastEvent(ApplicationEvent event, @Nullable
  ResolvableType eventType)：广播事件，指定事件的source类型。

3. 异步监听

从上图断点可以看到ApplicationEventMulticaster对象持有有taskExecutor字段为null，导致没有异步执行所有监听器。这里需要想办法这个字段设置线程池即可:
springboot默认会配置一个ThreadPoolTaskExecutor对象在容器里，这里把它拿出来设置给ApplicationEventMulticaster对象即可

package com.example.demo;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.event.SimpleApplicationEventMulticaster;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;import javax.annotation.PostConstruct;
import javax.annotation.Resource;/*** @author Administrator*/
@SpringBootApplication
public class DemoApplication {@Resourceprivate SimpleApplicationEventMulticaster eventMulticaster;@Resourceprivate ThreadPoolTaskExecutor executor;@PostConstructpublic void setEventExecutor() {eventMulticaster.setTaskExecutor(executor);}public static void main(String[] args) {SpringApplication.run(DemoApplication.class, args);}
}

4.ApplicationListener子接口

还可以实现子类的getOrder方法可以实现多个监听器排序；实现supportsEventType，supportsSourceType可以实现按过滤Class过来或按事件源Source的Class过滤

5. 注解支持

这里不通过实现接口来实现监听，顺序排序，按事件类型过滤监听，采用更方便的注解实现，且一个类中就可以实现多个监听

package com.example.demo.event;import org.springframework.context.ApplicationEvent;
import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;@Component
public class Listener3 {@Order(Integer.MIN_VALUE) // 优先级最高@EventListener(MyEvent.class)  // 只监听指定类型的事件public void onApplicationEvent(ApplicationEvent event) {MyEvent myEvent = (MyEvent) event;System.out.println(this.getClass().getName() + ":" + myEvent.getSource());}
}

6. 基于观察者模式高仿spring事件监听

6.1 先定义自定义一个事件

Java中已定义观察者模式事件及监听器顶级接口

package com.example.demo.javanativeevent;import java.util.EventObject;public class MyJavaNativeEvent extends EventObject {public MyJavaNativeEvent(Object source) {super(source);}
}

6.2 定义两个监听器

因为Java提供的EventListener无具体监听方法，且无合适的子接口，故这里自定义一个类似spirng的子接口NativeEventListener。这样后续事件发布就是遍历这种类型接口并调用onApplicationEvent()方法

package com.example.demo.javanativeevent;import java.util.EventListener;
import java.util.EventObject;public interface NativeEventListener extends EventListener {void onApplicationEvent(EventObject event);
}

package com.example.demo.javanativeevent;import java.util.EventObject;public class JavaNativeListener1 implements NativeEventListener {@Overridepublic void onApplicationEvent(EventObject event){String source = (String)event.getSource();System.out.println(this.getClass().getName()+":"+source);}
}

6.3 定义一个持有所有监听器的对象，类似spring的SimpleApplicationEventMulticaster

package com.example.demo.javanativeevent;import java.util.ArrayList;
import java.util.Collections;
import java.util.EventObject;
import java.util.List;/*** TODO** @author majun* @version 1.0* @since 2023-08-13 18:50*/
public class SimpleJavaNativeEventMulticaster {public List<NativeEventListener> eventListeners= Collections.synchronizedList(new ArrayList<>(8));public void addListener(NativeEventListener listener){this.eventListeners.add(listener);}public void multicastEvent(EventObject eventObject){eventListeners.stream().parallel().forEach(listener -> {listener.onApplicationEvent(eventObject);});}
}

6.4 事件发布测试

package com.example.demo.javanativeevent;/*** TODO** @author majun* @version 1.0* @since 2023-08-13 19:01*/
public class EventPublishTest {public static void main(String[] args) {// 注册两个listener，这是spirng把这个过程隐藏在spring容器初始化过程中了SimpleJavaNativeEventMulticaster eventMulticaster = new SimpleJavaNativeEventMulticaster();eventMulticaster.addListener(new JavaNativeListener1());eventMulticaster.addListener(new JavaNativeListener2());// 发布事件eventMulticaster.multicastEvent(new MyJavaNativeEvent("yyyy"));}
}