事件总线在 进行JAVA模块解耦 ，价值巨大
实际开发中，常常 通过事件总线EventBus/AsyncEventBus进行JAVA模块解耦 ， 比如，在顶级开源组件 hotkey的源码中， 就多次用到 EventBus/AsyncEventBus进行JAVA模块解耦
所以，专门写一篇文章，介绍这个 非常适用的技巧和组件。
此文不断更新， 最新版本，请参见 此文的博客园 版本：
通过事件总线EventBus/AsyncEventBus进行JAVA模块解耦 （史上最全 + 最新版本）
使用事件总线EventBus/AsyncEventBus进行发布订阅JAVA模块解耦
EventBus 是 Guava 的事件处理机制，是观察者模式（生产/消费模型）的一种实现。
观察者模式在我们日常开发中使用非常广泛，例如在订单系统中，订单状态或者物流信息的变更会向用户发送APP推送、短信、通知卖家、买家等等；审批系统中，审批单的流程流转会通知发起审批用户、审批的领导等等。
Observer模式也是 JDK 中自带就支持的，其在 1.0 版本就已经存在 Observer，不过随着 Java 版本的飞速升级，其使用方式一直没有变化，许多程序库提供了更加简单的实现，例如 Guava EventBus、RxJava、EventBus 等
为什么要用 EventBus ，其优点 ？
EventBus 优点
相比 Observer 编程简单方便通过自定义参数可实现同步、异步操作以及异常处理单进程使用，无网络影响
缺点
只能单进程使用项目异常重启或者退出不保证消息持久化
如果需要分布式使用还是需要使用 MQ
EventBus介绍：
EventBus是google的Guava库中的一个处理组件间通信的事件总线，它基于发布/订阅模式，实现了多组件之间通信的解耦合，事件产生方和事件消费方实现解耦分离，提升了通信的简洁性。
为什么使用事件总线？
当一个事件的发生(事件产生方)，需要触发很多事件(事件消费方)的时候，我们通常会在事件产生方中，分别的去调用那些事件消费方，这样往往是很浪费资源。事件的产生方与事件的消费方，产生了极大的耦合，如果我们要改动某一个事件消费方，我们很可能还要改动事件的产生方。
使用场景：
在工作中，经常会遇见使用异步的方式来发送事件，或者触发另外一个动作：经常用到的框架是MQ（分布式方式通知）。
如果是同一个jvm里面通知的话，就可以使用EventBus。由于EventBus使用起来简单、便捷，因此，工作中会经常用到。
EventBus 是线程安全的，分发事件到监听器，并提供相应的方式让监听器注册它们自己。
EventBus允许组件之间进行 “发布-订阅” 式的通信，而不需要这些组件彼此知道对方。
EventBus是专门设计用来替代传统的Java进程内的使用显示注册方式的事件发布模式。
EventBus不是一个通用的发布-订阅系统，也不是用于进程间通信。
EventBus的三个关键点
EventBus有三个关键要素：
1、事件（Event)
事件是EventBus之间相互通信的基本单位，一个Event可以是任何类型。
对，没错，就是Object，只要你想将任意一个Bean作为事件，这个类不需要做任何改变，就可以作为事件Event。不过在项目中不会这么随便（除非对代码严谨度没什么要求。。）
，一般会定义特定的事件类，类名以Event作为后缀，里面定义一些变量或者函数等。
2、事件发布者（Publisher）
事件发布者，就是发送事件到EventBus事件总线的一方，事件发布者调用Post()方法，将事件发给EventBus。
你可以在程序的任何地方，调用EventBus的post()方法，发送事件给EventBus，由EventBus发送给订阅者们。
3、事件订阅者（Subscriber）
事件订阅者，就是接收事件的一方，这些订阅者需要在自己的方法上，添加@Subscribe注解声明自己为事件订阅者。不过只声明是不够的，还需要将自己所在的类，注册到EventBus中，EventBus才能扫描到这个订阅者。
EventBus的事件发布和接收
接收事件
一个对象接收事件时，将这样做：
暴露一个public方法 ，称之为事件订阅者（subscriber）， 这个方法接收一个参数，参数的类型是事件期望的类型。 用@Subscribe注解标计这个方法 通过一个EventBus实例的register(Object)方法注册自己
提交事件
提交事件时，将简单的把事件对象作为参数，去调用 EventBus实例的pose(Object)方法。
EventBus实例将根据事件对象的类型，决定如何路由这个事件对象给所有已注册的监听器。
事件的路由是基于事件对象的类型，所以，对象的类型是路由的关键，也是订阅者注册的关键。
一个事件将被交付给可以被分配的任意的订阅者。
当post方法被调用后，所有对这个事件进行注册的订阅者，会按顺序进行消费， 所以订阅者会快速合理地运行。
如果一个事件可能触发一个扩展的过程(比如数据库负载),生成一个线程或队列之后处理，可以使用异步的AsyncEventBus。
订阅方法
事件订阅者的方法必需只能接受一个参数：事件对象。 订阅者方法如果抛出异常，EventBus实例将捕获和记录异常。
很少有方案这样去处理错误，只是在开发时可用于帮助我们发现问题时会这样做。
EventBus实例保证在同时不会有多个线程调用，除非这个方法通过@AllowConcurrentEvents注解明确允许。
如果这个注解没有出现，订阅者方法也无需担心方法被重入，除非在EventBus实例之外有代码调用该方法。
死事件
如果一个事件被提交了，但是没有相应的订阅者接受它，就可以认为这是一个死事件。
然后会给系统一个机会来处理这个死事件。
可以通过包装一个类DeadEvent的实例来处理这个死事件。然后可以写一个类专门负责订阅死事件。
如果一个订阅者监听的事件对象是所有事件的父类，比如这个事件订阅了一个Object的事件对象，那么将不会出现死事件。
案例1：EventBus同步事件总线
首先导入guava的依赖
其次看下本案例目录结构：
目录结构：
center:
定义和封装 eventbus 消息总线。
event:
一个自定义的事件类，一个普通的java类
类的内容随意定义。
subscribe:
定义了两个事件监听者类，类里面的方法加@Subscribe注解。
testCase：
测试方法。
同步eventbus 事件总线封装
定义和封装 eventbus 消息总线。
package eventbus.center;
import com.google.common.eventbus.EventBus;
public class EventBusCenter {
private static EventBus eventBus;
//双重锁单例模式
private static EventBus getEventBus(){
if(eventBus==null){
synchronized (EventBus.class){
if(eventBus==null){
eventBus = new EventBus();
}
}
}
return eventBus;
}
public static void post(Object event){
getEventBus().post(event);
}
public static void register(Object object){
getEventBus().register(object);
}
}
事件定义
package eventbus.event;
/**
* @desc 自定义事件类
**/
public class CustomEvent {
private int data;
public CustomEvent(int data){
this.data = data;
}
public int getData(){
return this.data;
}
}
定义: 订阅者1
package eventbus.subscribe;
import com.google.common.eventbus.Subscribe;
import eventbus.event.CustomEvent;
import java.time.Instant;
/**
* @desc 事件监听 1
**/
public class Subscriber1 {
@Subscribe
public void test1(CustomEvent event){
System.out.println(Instant.now() +"监听者1-->回调1,收到事件："+event.getData()+"，线程号为："+Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Subscribe
public void test2(CustomEvent event){
System.out.println(Instant.now() +"监听者1-->回调2,收到事件："+event.getData()+"，线程号为："+Thread.currentThread().getName());
}
}
定义: 订阅者2
package eventbus.subscribe;
import com.google.common.eventbus.Subscribe;
import eventbus.event.CustomEvent;
import java.time.Instant;
/**
* @desc 事件监听 2
**/
public class Subscriber2 {
@Subscribe
public void test1(CustomEvent event){
System.out.println(Instant.now() +"监听者2-->回调1,收到事件："+event.getData()+"，线程号为："+Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Subscribe
public void test2(CustomEvent event){
System.out.println(Instant.now() +"监听者2-->回调2,收到事件："+event.getData()+"，线程号为："+Thread.currentThread().getName());
}
}
订阅者总结
可以看到，两个订阅者，两个订阅者订阅的都是同一个事件对象。
每个订阅者，又定义了两个回调方法，
待会观察一下EventBus同步的方式下，收到事件之后订阅者们的处理方式。
定义测试用例
@Test
public void testEventBus() {
Subscriber1 listener1 = new Subscriber1();
Subscriber2 listener2 = new Subscriber2();
CustomEvent customEvent = new CustomEvent(23);
EventBusCenter.register(listener1);
EventBusCenter.register(listener2);
EventBusCenter.post(customEvent);
System.out.println(Instant.now() +",主线程执行完毕："+Thread.currentThread().getName());
}
上面是测试类，创建了2个订阅者的对象，，并且注册给了EventBus，调用EventBus的同步post方法执行。
结果如下：
执行结果
同步EventBus总结规律：
可以看到每一个事件的消费方在执行时，都是用的调用方的线程，并且同一时间只能同时执行一个订阅者的方法。
从Subscriber1里的方法比Subscriber2里的方法先执行可以看出：
先注册到EventBus的订阅者在收到事件后会先执行。
案例2：EventBus异步事件总线
AsyncEventBus: 异步事件总线
1.异步执行，事件发送方异步发出事件，不会等待事件消费方是否收到，直接执行自己后面的代码。
2.在定义AsyncEventBus时，构造函数中会传入一个线程池。
事件消费方收到异步事件时，消费方会从线程池中获取一个新的线程来执行自己的任务。
3.同一个事件的多个订阅者，它们的注册顺序跟接收到事件的顺序上没有任何联系，都会同时收到事件，并且都是在新的线程中，异步并发的执行自己的任务。
异步eventbus 事件总线封装
定义和封装 异步eventbus 消息总线。
package eventbus.center;
import com.google.common.eventbus.AsyncEventBus;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
/**
* @desc 事件总线工具类
**/
public class AsyncEventBusCenter {
private static AsyncEventBus asyncEventBus;
private static Executor executor = Executors.newFixedThreadPool(2);
//双重锁单例模式
private static AsyncEventBus getAsynEventBus(){
if(asyncEventBus==null){
synchronized (AsyncEventBus.class){
if(asyncEventBus==null){
asyncEventBus = new AsyncEventBus(executor);
}
}
}
return asyncEventBus;
}
//异步方式发送事件
public static void post(Object event){
getAsynEventBus().post(event);
}
public static void register(Object object){
getAsynEventBus().register(object);
}
}
定义测试用例
@Test
public void testAsyncEventBus() {
Subscriber1 listener1 = new Subscriber1();
Subscriber2 listener2 = new Subscriber2();
CustomEvent customEvent = new CustomEvent(23);
AsyncEventBusCenter.register(listener1);
AsyncEventBusCenter.register(listener2);
AsyncEventBusCenter.post(customEvent);
try {
Thread.sleep(10*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Instant.now() +",主线程执行完毕："+Thread.currentThread().getName());
}
上面是测试类，创建了2个订阅者的对象，并且注册给了EventBus，调用EventBus的同步post方法执行。
结果如下：
执行结果
异步EventBus总结规律：
这里由于并行执行，订阅者的方法中有sleep，因此也让生产者主线程进行了10秒的等待。
注意：这里的生产者和消费者（订阅者）异步执行。
异步执行，两个订阅者同时执行，并且是为事件消费方重新开的一个新的线程去执行自己的任务，互相不等待。
1.如果线程足够，同一个事件的多个订阅者，它们的注册顺序跟接收到事件的顺序，上没有任何联系，都会同时收到事件，并且都是在新的线程中，异步并发的执行自己的任务。
2.如果线程不够，谁先注册到EventBus的，谁先执行。
四、EventBus和AsyncEventBus使用区别
上面的测试案例简单，并且很能说明问题。
EventBus: 同步事件总线
1.同步执行，事件发送方在发出事件之后，会等待所有的事件消费方执行完毕后，才会回来继续执行自己后面的代码。
2.事件发送方和事件消费方会在同一个线程中执行，消费方的执行线程取决于发送方。
3.同一个事件的多个订阅者，在接收到事件的顺序上面有不同。
谁先注册到EventBus的，谁先执行，如果是在同一个类中的两个订阅者一起被注册到EventBus的情况，收到事件的顺序跟方法名有关。
AsyncEventBus: 异步事件总线
1.异步执行，事件发送方异步发出事件，不会等待事件消费方是否收到，直接执行自己后面的代码。
2.在定义AsyncEventBus时，构造函数中会传入一个线程池。
事件消费方收到异步事件时，消费方会从线程池中获取一个新的线程来执行自己的任务。
3.如果线程足够，同一个事件的多个订阅者，它们的注册顺序跟接收到事件的顺序，上没有任何联系，都会同时收到事件，并且都是在新的线程中，异步并发的执行自己的任务。
4.如果线程不够，谁先注册到EventBus的，谁先执行。
建议
生产环境中，建议大家使用异步的 事件总线
参考文献：
疯狂创客圈 JAVA 高并发 总目录 ThreadLocal 史上最全 4000页《尼恩 Java 面试宝典 》的 35个面试专题 价值10W的架构师知识图谱
4、尼恩 架构师哲学
5、尼恩 3高架构知识宇宙
https://blog.csdn.net/oppo5630/article/details/80173520
https://blog.csdn.net/qq_38345296/article/details/100539989
推荐阅读：
《 场景题：假设10W人突访，你的系统如何做到不 雪崩？》 《尼恩Java面试宝典》 《Springcloud gateway 底层原理、核心实战 (史上最全)》 《Flux、Mono、Reactor 实战（史上最全）》 《sentinel （史上最全）》 《Nacos (史上最全)》 《分库分表 Sharding-JDBC 底层原理、核心实战（史上最全）》 《TCP协议详解 (史上最全)》 《clickhouse 超底层原理 + 高可用实操 （史上最全）》 《nacos高可用（图解+秒懂+史上最全）》 《队列之王： Disruptor 原理、架构、源码 一文穿透》 《环形队列、 条带环形队列 Striped-RingBuffer （史上最全）》 《一文搞定：SpringBoot、SLF4j、Log4j、Logback、Netty之间混乱关系（史上最全） 《单例模式（史上最全） 《红黑树（ 图解 + 秒懂 + 史上最全）》 《分布式事务 （秒懂）》 《缓存之王：Caffeine 源码、架构、原理（史上最全，10W字 超级长文）》 《缓存之王：Caffeine 的使用（史上最全）》 《Java Agent 探针、字节码增强 ByteBuddy（史上最全）》 《Docker原理（图解+秒懂+史上最全）》 《Redis分布式锁（图解 - 秒懂 - 史上最全）》 《Zookeeper 分布式锁 - 图解 - 秒懂》 《Zookeeper Curator 事件监听 - 10分钟看懂》 《Netty 粘包 拆包 | 史上最全解读》 《Netty 100万级高并发服务器配置》 《Springcloud 高并发 配置 （一文全懂）》
文章链接
您阅读本篇文章共花了：
发表评论