google Guava之EventBus

最新推荐文章于 2025-07-14 08:22:07 发布
原创 最新推荐文章于 2025-07-14 08:22:07 发布 · 1.1w 阅读 · 28 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Google #EventBus #Guava #观察者模式 #异步

本文深入解析Guava的EventBus组件，介绍如何利用观察者模式处理异步任务，涵盖基本用法、不同类型的事件监听、事件继承关系处理及异常管理等内容。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录


EventBus是Guava的事件处理机制，是设计模式中的观察者模式（生产/消费者编程模型）的优雅实现，在应用中可以处理一些异步任务。对于事件监听和发布订阅模式，EventBus是一个非常优雅和简单解决方案，我们不用创建复杂的类和接口层次结构。

EventBus流程图

EventBus实际上是一个消息队列，Event Source发送一个消息到EventBus，然后再由EventBus将消息推送到所监听的Listener。

EventBus基本用法

1. 创建Listener

我们可以通过@Subscribe注解将任意的类的方法变为一个Listener。

public class SimpleListener {
    private final static Logger LOGGER = LoggerFactory.getLogger(SimpleListener.class);

    /**
     * 一个简单的Listener方法
     * @param event Guava规定此处只能有一个参数
     */
    @Subscribe
    public void doAction(final String event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Received event [{}] and will take a action", event);
        }
    }
}

2. 创建EventBus并发送消息

然后我们可以定义一个EventBus，先将上面的这个Listener类进行注册，通过Post方法即可向其发送消息。

public class SimpleEventBusExample {
    public static void main(String[] args) {
        final EventBus eventBus = new EventBus();
        //注册Listener
        eventBus.register(new SimpleListener());
        System.out.println("post the simple event.");
        //向订阅者发送消息
        eventBus.post("Simple Event");
    }
}

Output:
post the simple event.
2018-05-20 22:24:12:INFO main com.guava.eventbus.listeners.SimpleListener - Received event [Simple Event] and will take a action

Listener之间的继承关系

本小节我们来测试一下，当两个Listener之间有继承关系时，只注册子类的Listener到EventBus。然后发送向EventBus发送消息，父类Listener是否会接收到消息呢？

首先定义一个抽象类的Listener。

public abstract class AbstractListener {
    private final static Logger LOGGER = LoggerFactory.getLogger(AbstractListener.class);

    @Subscribe
    public void commonTask(final String event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Received event [{}] will be handle by {}.{}", new Object[]{event,this.getClass().getSimpleName(),"commonTask"});
        }
    }
}

然后定义两个实现类BaseListener和ConcreteListener。

public class BaseListener extends AbstractListener{
    private final static Logger LOGGER = LoggerFactory.getLogger(AbstractListener.class);

    @Subscribe
    public void baseTask(final String event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Received event [{}] will be handle by {}.{}", new Object[]{event,this.getClass().getSimpleName(),"baseTask"});
        }
    }
}

public class ConcreteListener extends BaseListener {

    private final static Logger LOGGER = LoggerFactory.getLogger(AbstractListener.class);

    @Subscribe
    public void conTask(final String event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Received event [{}] will be handle by {}.{}", new Object[]{event,this.getClass().getSimpleName(),"conTask"});
        }
    }
}

定义EventBus：

public class InheritListenersEventBusExample {
    public static void main(String[] args) {
        final EventBus eventBus = new EventBus();
        eventBus.register(new ConcreteListener());
        System.out.println("post the string event.");
        eventBus.post("I am String event");
        System.out.println("post the int event.");
        eventBus.post(1000);
    }
}

结论：注册了一个Listener，使用eventBus发送消息它的父类的Subscribe也会对此消息进行处理。

Subscriber

不同类型参数的Subscribe

本小节我们来测试一下，向EventBus发送消息后，当有多个不同类型的Subscribe时，它们是怎么进行通信的呢？

定义Subscribe

public class MultipleEventListeners {
    private final static Logger LOGGER = LoggerFactory.getLogger(MultipleEventListeners.class);

    @Subscribe
    public void task1(final String event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Received event [{}] and will take a action by ==task1==", event);
        }
    }

    @Subscribe
    public void task2(final String event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Received event [{}] and will take a action by ==task2==", event);
        }
    }

    @Subscribe
    public void intTask(final Integer event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Received event [{}] and will take a action by ==intTask==", event);
        }
    }
}

定义EventBus：

public class MultipleEventBusExample {
    public static void main(String[] args) {
        final EventBus eventBus = new EventBus();
        eventBus.register(new MultipleEventListeners());
        System.out.println("post the string event.");
        eventBus.post("I am String event");
        System.out.println("post the int event.");
        eventBus.post(1000);
    }
}

Output:
post the string event.
2018-05-20 22:28:23:INFO main com.guava.eventbus.listeners.MultipleEventListeners - Received event [I am String event] and will take a action by task1
2018-05-20 22:28:23:INFO main com.guava.eventbus.listeners.MultipleEventListeners - Received event [I am String event] and will take a action by task2
post the int event.
2018-05-20 22:28:23:INFO main com.guava.eventbus.listeners.MultipleEventListeners - Received event [1000] and will take a action by intTask

结论：eventBus会根据Listener的参数类型的不同，分别向不同的Subscribe发送不同的消息。

event

继承关系的event

本小节来测试：当event之间具有继承关系时，listener之间怎么调用？

定义两个具有继承关系的event：

public class Apple extends Fruit {

    public Apple(String name) {
        super(name);
    }
}
public class Fruit {
    private final String name;

    public Fruit(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override public String toString() {
        return "Fruit{" +
            "name='" + name + '\'' +
            '}';
    }
}

定义对应的Listener：

public class FruitEaterListener {
    private final static Logger LOGGER = LoggerFactory.getLogger(FruitEaterListener.class);

    @Subscribe
    public void eat(Fruit event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Fruit eat[{}]. ", event);
        }
    }
    @Subscribe
    public void eat(Apple event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Apple eat[{}]. ", event);
        }
    }
}

定义EventBus：

public class InheritEventsBusExample {
    public static void main(String[] args) {
        final EventBus eventBus = new EventBus();
        eventBus.register(new FruitEaterListener());
        eventBus.post(new Apple("apple"));

        System.out.println("---------------------");
        eventBus.post(new Fruit("Fruit"));
    }
}

Output:
2018-06-03 16:55:32:INFO main com.guava.eventbus.listeners.FruitEaterListener - Apple eat[Fruit{name=‘apple’}].
2018-06-03 16:55:32:INFO main com.guava.eventbus.listeners.FruitEaterListener - Fruit eat[Fruit{name=‘apple’}].
2018-06-03 16:55:32:INFO main com.guava.eventbus.listeners.FruitEaterListener - Fruit eat[Fruit{name=‘Fruit’}].

结论：当作为参数的event之间有继承关系时，使用eventBus发送消息，eventt的父类listener也会对此消息进行处理。

DeadEvent

当EventBus发布了一个事件，但是注册的订阅者中没有找到处理该事件的方法，那么EventBus就会把该事件包装成一个DeadEvent事件来重新发布；我们在应用中可以提供如下的事件处理方法来处理DeadEvent。

创建listener:


public class DeadEventListener {
    @Subscribe
    public void handle(DeadEvent event){
        //获取事件源
        System.out.println(event.getSource());//DEAD-EVENT-BUS
        //获取事件
        System.out.println(event.getEvent());//DeadEventListener event
    }
}

创建EventBus：

public class DeadEventBusExample {
    public static void main(String[] args) {
        //重写EventBus的toString方法，使eventBus的名称为DEAD-EVENT-BUS
        final EventBus eventBus = new EventBus(){
            @Override public String toString() {
                return "DEAD-EVENT-BUS";
            }
        };
        DeadEventListener deadEventListener = new DeadEventListener();
        eventBus.register(deadEventListener);
        eventBus.post("DeadEventListener event");
        eventBus.post("DeadEventListener event");

    }
}

Output:
DEAD-EVENT-BUS
DeadEventListener event
DEAD-EVENT-BUS
DeadEventListener event

EventBus之异常处理

在默认情况下，EventBus不会对异常信息进行处理，异常信息也不会终止EventBus的运行，只会简单的打印出异常堆栈信息。

定义一个Listener：

public class ExceptionListener {

    private final static Logger LOGGER = LoggerFactory.getLogger(ExceptionListener.class);

    @Subscribe
    public void m1(final String event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Received event [{}] and will take m1", event);
        }
    }
    @Subscribe
    public void m2(final String event){
        if (LOGGER.isInfoEnabled()){
            LOGGER.info("Received event [{}] and will take m2", event);
        }
    }
    @Subscribe
    public void m3(final String event){
        throw new RuntimeException();
    }
}

定义一个EventBus：

public class ExceptionEventBusExample {
    public static void main(String[] args) {
        //在默认情况下，EventBus不会对异常信息进行处理，异常信息也不会终止EventBus的运行，只会简单的打印出异常堆栈信息。
        //在EventBus构造函数中传入SubscriberExceptionHandler来对异常信息进行处理
        //下面是通过lambda表达式来实现SubscriberExceptionHandler接口
        final EventBus eventBus = new EventBus((exception,context) -> {
            System.out.println(context.getEvent());//Exception event
            System.out.println(context.getEventBus());//defalut
            System.out.println(context.getSubscriber());//ExceptionListener
            System.out.println(context.getSubscriberMethod());//m3
        });
        eventBus.register(new ExceptionListener());
        eventBus.post("Exception event");
    }
}

Output:
2018-06-03 18:16:25:INFO main com.guava.eventbus.listeners.ExceptionListener - Received event [Exception event] and will take m2
Exception event
EventBus{default}
com.guava.eventbus.listeners.ExceptionListener@7a0ac6e3
public void com.guava.eventbus.listeners.ExceptionListener.m3(java.lang.String)
2018-06-03 18:16:25:INFO main com.guava.eventbus.listeners.ExceptionListener - Received event [Exception event] and will take m1

结论：在默认情况下，EventBus不会对异常信息进行处理，异常信息也不会终止EventBus的运行，只会简单的打印出异常堆栈信息。可以在EventBus构造函数中传入一个SubscriberExceptionHandler对象来对异常信息进行处理。上述代码是通过lambda表达式来实现了一个SubscriberExceptionHandler接口。

本文源代码地址： EventBus

Google Guava 之 EventBus
HY
05-15 801
Google Guava 之 EventBus
Google Guava EventBus使用
流子的专栏
01-30 920
Guava是Google开源的一个Java基础类库，它在Google内部被广泛使用。Guava提供了很多功能模块比如：集合、并发库、缓存等，EventBus是其中的一个module，本篇主要讲一下EventBus的使用。 简单介绍 EventBus：核心类，代表了一个事件总线。Publish事件也由它发起。 AsyncEventBus：异步事件总线，在分发事件的时候，将其压入一个全局队列的异步分发模式。 Subscriber：对某个事件的处理器抽象，封装了事件的订阅者以及处理器，并负责事件处理。
Guava EventBus详解
抽象的螺旋
01-30 2080
EventBus是google的Guava库中的一个处理组件间通信的事件总线，它基于发布/订阅模式，实现了多组件之间通信的解耦合，事件生产方和事件消费方实现解耦分离，提升了通行的简介性。当一个事件的发送（事件生产方），需要触发很多事件消费方的时候，我们通常会在事件产生方中，分别的去调用那些事件消费方，这样比较繁琐、复杂，业务也不清晰。事件的产生方与事件的消费方，产生的极大的耦合，如果我们要改动某一个事件消费方，很可能要改动事件的产生方。/*** @desc 事件总线配置*/@Bean。
Android EventBus使用方法与底层原理详解
最新发布
JMY_2016的博客
07-14 1402
创建一个简单的 Java 类来表示你想要传递的数据或通知。
Guava Event Bus 详解
m0_61089765的博客
12-26 1830
是的，很像，但是EventBus是JVM内部的事件总线，适合应用内部的解耦，如果应用很大，大家会使用微服务拆分进行解耦，微服务之间的消息通信会使用Kafka、RabbitMQ等等消息中间件，当然如果流量很大，需要削峰填谷，会部署多个实例，通过消息中间件实现多个应用实例之间消息的负载均衡。EventBus是google的Guava库中的一个处理JVM内部组件间通信的事件总线，它基于发布/订阅模式，实现了多组件之间通信的解耦合，事件产生方和事件消费方实现解耦分离，提升了通信的简洁性。
Guava-Event-Bus:Guava的EventBus源码学习
05-24
Guava-Event-Bus 学习笔记 Guava的EventBus源码学习，基于Guava的18.0版本 分析者： ###1. 背景简介 EventBus是google的一个Java工具包其中的一个工具类，类似的有多个版本其中包括移植到Android端的 和改良的，功能基本都是一样的。此处主要是对Guava版的EventBus分析，关于。 ###2. 功能简介 ####2.1 EventBus介绍 EventBus 是一个基于事件的一个发布/订阅框架，通过解耦发布者和订阅者简化事件传递，这里的事件可以理解为消息，本文中统一称为事件也就是 Event。通过EventBus可以简化生产者/消费者 这种模型，同时又可以通过Executor来控制线程，使用起来非常优雅灵活。异步的则使用AsyncEventBus，如果需要强制使EventBus同步执行则可以使用@AllowConcurrentE
Google Guava中EventBus使用不当会导致什么故障？
BUG_zhentan的博客
05-20 1577
4.26号凌晨3点业务服务开始报警，现象表现为消费用户消息的kafka集群出现堆积，导致用户在聊天室房间内的状态更新延迟,最终用户在聊天室房间的IM长链接断开，用户在聊天室中无法发消息，无法上麦。 在问题排查过程中，了解问题流程图如下： 其中主要分为5个模块，分别为：用户、im长链接器、kafka、im-session服务、api服务。 当用户与im-connector建立完长链接以后，用户进入、退出聊天室以及与聊天室的心跳事件均会通过im-connector写入下游的kafka.
Guava之EventBus源码分析
一份努力一份收获
03-18 861
事件总线。有助于深入理解代码的功能和实现细节。可以了解代码背后的逻辑、算法、数据结构和设计模式等方面，从而更好地理解代码的作用和功能。可以学习到业界的最佳实践和设计模式。这有助于提高自己的编程水平，使你能够编写更高质量、可扩展性和可维护性的代码。
Eventbus的详细使用
11-15
主要介绍了eventbus的使用方法，替代Handle,来实现数据的接收与发送。
Google Guava EventBus(事件总线)
热门推荐
旧路
07-11 2万+
       EventBus是Guava的事件处理机制，是设计模式中的观察者模式（生产/消费者编程模型）的优雅实现。对于事件监听和发布订阅模式，EventBus非常优雅使用起来也非常的简单,这个可不是吹的是真的非常的简单。        EventBus内部实现原理不复杂(源码不复杂，强烈推荐大家去看下)。我们简单的...
EventBus----Google Guava
仗剑执天涯的专栏
04-23 538
guava event bus
Guava系列之EventBus
果子爸聊技术
06-21 1万+
EventBus是Guava中实现的用于发布/订阅模式的事件处理组件，它是设计模式中观察者模式的优雅实现，关于观察者模式可以看一下我的另一篇博客：设计模式学习-观察者模式 EventBus简化了观察者模式，无须创建复杂的类和接口层次结构 EventBus的基本用法 1、定义事件对象 public class Event { private String message; public Event(String message){ this.message = message;
Google Guava的EventBus(事件总线)基本使用
Rookie_cc的博客
03-03 4952
EventBus是Google.Guava提供的消息发布-订阅组件，采用的是观察者模式(生产/消费者编程模型)， 实现了多组件之间通信的解耦合，事件产生方和事件消费方实现解耦分离，提升了通信的简洁性。 相比MQ它更加轻量，易用，但一般只用于进程内部的通信，不能像MQ一样用于分布式系统的服务与服务之间的通信。 EventBus包含3大核心部分：Event事件，Publisher事件发布者，Subscriber事件订阅者。 下面介绍一下它的使用方法： 一、...
Guava EventBus
随心的专栏
12-17 464
文章目录1. EventBus基本用法2. 特殊事件为Dead Event3. Event的继承 EventBus是Guava的事件处理机制，是设计模式中的观察者模式（生产/消费者编程模型）的优雅实现。对于事件监听和发布订阅模式，EventBus是一个非常优雅和简单解决方案，我们不用创建复杂的类和接口层次结构。 1. EventBus基本用法 使用Guava之后, 如果要订阅消息, 就不用再继承指...
Guava_eventBus
maqingbin8888的专栏
03-16 452
pom.xml <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>18.0</version> </dependency> 事件 publ
使用Google的Guava工具EventBus-观察者模式
dagecao的博客
09-09 176
转：https://blog.youkuaiyun.com/u010739551/article/details/80482701
goole guava eventbus
01-22
### Google Guava EventBus 库文档与使用示例 #### 简介 Guava 的 `EventBus` 是一种发布-订阅模式的事件总线实现，允许组件之间解耦通信。通过定义事件类并注册监听器来处理这些事件，可以简化应用程序内部的消息传递机制[^1]。 #### 基本概念 - **事件 (Events)**: 表示应用内发生的特定情况的对象实例。 - **监听者 (Listeners)**: 实现方法响应某些类型的事件对象。 - **发布者 (Publisher)**: 负责创建并向 `EventBus` 发布新事件实例的实体。 - **订阅者 (Subscriber)**: 注册到 `EventBus` 上以接收感兴趣类型事件的方法或函数。 #### 使用说明 ##### 创建和配置 `EventBus` ```java // 初始化一个新的 EventBus 对象 EventBus eventBus = new EventBus(); ``` ##### 定义事件类 ```java public class MyCustomEvent { private final String message; public MyCustomEvent(String msg) { this.message = msg; } @Override public String toString() { return "MyCustomEvent{" + "message='" + message + '\'' + '}'; } } ``` ##### 编写监听者逻辑 ```java public class EventListener { // 订阅该事件的方法名前需加上@Subscribe注解 @Subscribe public void handleMyCustomEvent(MyCustomEvent event){ System.out.println("Received custom event:" +event); } } ``` ##### 将监听者注册至 `EventBus` ```java EventListener listenerInstance = new EventListener(); // 向 EventBus 中添加监听者 eventBus.register(listenerInstance); ``` ##### 发送事件给所有已注册的监听者 ```java // 构造一个自定义事件实例 MyCustomEvent myEvent = new MyCustomEvent("Hello, world!"); // 通过调用 post 方法向所有的监听者广播此事件 eventBus.post(myEvent); ``` 以上就是如何利用 Guava 提供的 `EventBus` 来构建松散耦合的应用程序模块间通讯的方式。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值