/**
* Desc: 事件对象
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class HelloEvent {
private String eventName;
}
@Data
@NoArgsConstructor
public class WorldEvent extends HelloEvent {
private int eventNo;
public WorldEvent(String name, int no) {
setEventName(name);
setEventNo(no);
}
}
/**
* Desc: 事件监听器，可以监听多个事件。处理方法添加 @Subscribe 注解即可。
*/
public class GeventListener {
/**
* 监听 HelloEvent 类型及其父类型（Object）的事件
*/
@Subscribe
public void processEvent(HelloEvent event){
System.out.println("process hello event, name:" + event.getEventName());
}
/**
* 监听 WorldEvent 类型及其父类型（HelloEvent 和 Object）的事件
*/
@Subscribe
public void processWorldEvent(WorldEvent event) {
System.out.println("process world eventV1, no:" + event.getEventNo() + ", name:" + event.getEventName());
}
/**
* 注册多个监听器 监听同一事件
* @param event
*/
@Subscribe
public void processWorldEventV2(WorldEvent event) {
System.out.println("process world eventV2, no:" + event.getEventNo() + ", name:" + event.getEventName());
}
@Subscribe
public void processObject(Object object) {
System.out.println("process common event, class:" + object.getClass().getSimpleName());
}
}
public class GuavaTest {
public static void main(String[] args) {
EventBus eventBus = new EventBus();
GeventListener listener = new GeventListener();
eventBus.register(listener);
eventBus.post(new HelloEvent("hello"));
eventBus.post(new WorldEvent("world", 23333));
}
}
结果如下：
//HelloEvent被两个监听器处理（HelloEvent类及Object类的监听器）
process hello event, name:hello
process common event, class:HelloEvent
//WorldEvent被四个监听器处理（两个自己的，两个父类的）
process world eventV1, no:23333, name:world
process world eventV2, no:23333, name:world
process hello event, name:world
process common event, class:WorldEvent
public class AnotherListener {
/**
* 监听 WorldEvent 类型及其父类型（HelloEvent 和 Object）的事件
*/
@Subscribe
public void processAnotherWorldEvent(WorldEvent event) {
System.out.println("process another world event, no:" + event.getEventNo() + ", name:" + event.getEventName());
}
}
public class GuavaTest {
public static void main(String[] args) {
EventBus eventBus = new EventBus();
GeventListener listener = new GeventListener();
eventBus.register(listener);
eventBus.post(new HelloEvent("hello"));
EventBus anotherEventBus = new EventBus();
AnotherListener anotherListener = new AnotherListener();
anotherEventBus.register(anotherListener);
anotherEventBus.post(new WorldEvent("AnotherWorld", 666));
}
}
结果是
//eventBus结果与之前相同
process hello event, name:hello
//anotherEventBus 发布的事件，只被其注册的监听器处理
process common event, class:HelloEvent
process another world event, no:666, name:AnotherWorld
适用场景：
按照类区分事件
订阅 事件簇
支持自定义event，可以根据event自己写分发器
事件隔离
spring event
spring 新版事件机制也比较简单，看代码。
/**
* 继承 ApplicationEvent 的事件
*/
@Data
public class HelloEvent extends ApplicationEvent {
private String eventName;
public HelloEvent(String eventName) {
super(eventName);
setEventName(eventName);
}
}
/**
* 自定义事件
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class CustomerEvent {
private String name;
private Boolean isCustomer;
}
/**
* 监听器类，spring也支持一个类中监听多个事件
*/
@Component("springListener")
public class SpringListener {
/**
* 监听所有ApplicationEvent类型 及其子类型 的事件
*/
@EventListener
public void processApplicationEvent(ApplicationEvent event) {
System.out.println("process common event, class:" + event.getClass().getSimpleName());
}
/**
* 监听 HelloEvent类型 事件
*/
@EventListener
public void processHelloEvent(HelloEvent event) {
System.out.println("process helloEvent, name:" + event.getEventName());
}
/**
* 监听 CustomerEvent 类型事件，但是需要满足condition条件,即isCustomer=true
*/
@EventListener(condition = "#event.isCustomer")
public void processCustomerEvent(CustomerEvent event) {
System.out.println("process customer CustomerEvent, name:" + event.getName());
}
/**
* 监听 CustomerEvent 类型事件，但是需要满足condition条件,即name="miaomiao"
*/
@EventListener(condition = "#event.getName().equals('miaomiao')")
public void processMiaoMiaoEvent(CustomerEvent event) {
System.out.println("process miaomiao's CustomerEvent, name:" + event.getName());
}
/**
* 支持异步处理事件
*/
@Async
@EventListener
public void processAsyncCustomerEvent(CustomerEvent event) {
System.out.println("Async process CustomerEvent, name:" + event.getName());
}
}
//执行类，测试入口
@SpringBootApplication
@ComponentScan(basePackages = {"com.example.manyao.async"})
public class DemoApplication {
public static void main(String[] args) throws TException {
SpringApplication.run(DemoApplication.class, args);
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
String[] names = context.getBeanDefinitionNames();
for(int i=0; i
结果是
//以下是spring上下文event，继承自 ApplicationContextEvent。 用于用户参与上下文生命周期的入口。因为是ApplicationEvent子类型，所以，由processApplicationEvent处理。
process common event, class:ContextRefreshedEvent
process common event, class:EmbeddedServletContainerInitializedEvent
process common event, class:ApplicationReadyEvent
process common event, class:ContextRefreshedEvent
//以下是上下文中的bean
springListener
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalRequiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
++++++++++
//HelloEvent 继承 ApplicationEvent，会被processApplicationEvent处理
process common event, class:HelloEvent
//监听 HelloEvent类型 的 processHelloEvent 处理
process helloEvent, name:helloEvent
//非 ApplicationEvent 的事件，则为 PayloadApplicationEvent
process common event, class:PayloadApplicationEvent
//isCustomer=true,符合processCustomerEvent处理条件
process customer CustomerEvent, name:customer
//监听CustomerEvent类型，处理结果
Async process CustomerEvent, name:customer
process common event, class:PayloadApplicationEvent
//符合processMiaoMiaoEvent条件
process miaomiao's CustomerEvent, name:miaomiao
Async process CustomerEvent, name:miaomiao
//spring 上下文事件
process common event, class:ContextClosedEvent
