EventBus----Google Guava

已于 2023-04-23 18:18:35 修改
阅读量534 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： java 中间件 文章标签： java
于 2023-04-23 18:14:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chou_qi/article/details/130326938
文章介绍了EventBus作为观察者模式实现的简单消息组件，它用于在同一JVM内的通信。EventBus包括事件（消息）、订阅者和处理方法等概念。同步EventBus在发布事件后会等待所有消费者执行完毕，而异步EventBus则立即返回，消费者在独立线程中并发执行。文中通过示例展示了如何创建EventBus，注册监听器，以及发布消息，并对比了两者的执行特性。

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

简单的消息组件：限定范围同一个jvm中
　　EventBus 是设计模式中的观察者模式（生产者/消费者编程模型）的实现。

EvenBus 中的相关术语

EventBus 术语解释备注
事件（消息）可以向事件总线（EventBus）发布的对象通常是一个类，不同的消息事件用不同的类来代替，消息内容就是类里面的属性
订阅向事件总线注册监听者，以接受事件的行为EventBus.register(Object)，参数就是监听者
监听者提供一个处理方法，希望接受和处理事件的对象通常也是一个类，里面有消息的处理方法
处理方法监听者提供的公共方法，事件总线使用该方法向监听者发送事件；该方法应使用 Subscribe 注解监听者里面添加一个 Subscribe 注解的方法，就可以认为是消息的处理方法
发布消息通过事件总线向所有匹配的监听者提供事件EventBus.post(Object)

EvenBus 的简单使用

添加依赖

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>

EventBus 的使用很简单，笼统来说可分为以下几个步骤。

  1. 创建 EventBus 对象。通常全局或模块内通过单例模式只用一个 EventBus 对象
  2. 创建消息类
  3. 创建监听者类
  4. 注册监听者类。如果有多个 EventBus 对象，监听者类注册在哪个 EventBus 对象下，消息就需要发布到对应的 EventBus
    中
  5. 发布消息

EventBus和AsyncEventBus使用区别

下面的测试案例简单，并且很能说明问题。

EventBus:同步事件总线

1.同步执行，事件发送方在发出事件之后，会等待所有的事件消费方执行完毕后，才会回来继续执行自己后面的代码。
2.事件发送方和事件消费方会在同一个线程中执行，消费方的执行线程取决于发送方。
3.同一个事件的多个订阅者，在接收到事件的顺序上面有不同。谁先注册到Event Bus的，谁先执行，如果是在同一个类中的两个订阅者一起被注册到EventBus的情况，收到事件的顺序跟方法名有关。

AsyncEventBus:异步事件总线

1.异步执行，事件发送方异步发出事件，不会等待事件消费方是否收到，直接执行自己后面的代码。
2.在定义AsyncEventBus时，构造函数中会传入一个线程池。事件消费方收到异步事件时，消费方会从线程池中获取一个新的线程来执行自己的任务。
3.同一个事件的多个订阅者，它们的注册顺序跟接收到事件的顺序上没有任何联系，都会同时收到事件，并且都是在新的线程中，异步并发的执行自己的任务。

同步代码：

EventBus

事件消息:

/**
 * @className: MessageEvent
 * @author: czh
 * @date: 2023/4/21
 * @despriction: 事件消息
 * @version: 1.0.0
 **/
public class MessageEvent {
    private String message;

    public MessageEvent(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

事件监听,@Subscribe注解:

/**
 * @className: SyncEventListener
 * @author: czh
 * @date: 2023/4/21
 * @despriction: 事件监听,@Subscribe注解
 * @version: 1.0.0
 **/
public class SyncEventListener {
    @Subscribe
    public void handleMethod(@NotNull MessageEvent msg) {
        System.out.printf("SynchEventListener handleMethod received message: %s \n", msg.getMessage());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.printf("SynchEventListener handleMethod process message: %s \n", msg.getMessage());
    }

}

同步eventBus测试:

/**
 * @className: TestMain
 * @author: czh
 * @date: 2023/4/21
 * @description: google同步eventBus测试
 * @version: 1.0.0
 **/
public class TestMain {
    public static void main(String[] args) {

        System.out.println("step 1------------TestMain main create eventBus Object identifier: eventBus = new EventBus(\"test\") .");
        EventBus eventBus = new EventBus("test");

        System.out.println("step 2------------TestMain main eventBus new listener:  eventListener = new SyncEventListener().");
        SyncEventListener eventListener = new SyncEventListener();
        System.out.println("step 3------------TestMain main eventBus register event listener:  eventBus.register(eventListener).");
        eventBus.register(eventListener);

        System.out.println("step 4------------TestMain main eventBus post event: eventBus.post(new MessageEvent(\"消息同步发送\" + i))");
        for (int i=0; i<5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("-----------------TestMain main eventBus post event message.");
            eventBus.post(new MessageEvent("消息同步发送" + i));
        }

    }
}

执行输出信息：

step 1------------TestMain main create eventBus Object identifier: eventBus = new EventBus("test") .
step 2------------TestMain main eventBus new listener:  eventListener = new SyncEventListener().
step 3------------TestMain main eventBus register event listener:  eventBus.register(eventListener).
step 4------------TestMain main eventBus post event: eventBus.post(new MessageEvent("消息同步发送" + i))
-----------------TestMain main eventBus post event message.
SynchEventListener handleMethod received message: 消息同步发送0
SynchEventListener handleMethod process message: 消息同步发送0
-----------------TestMain main eventBus post event message.
SynchEventListener handleMethod received message: 消息同步发送1
SynchEventListener handleMethod process message: 消息同步发送1

在上面的代码中，添加了几个 sleep，在实际运行的时候注意输出，所有的事件消息都是顺序输出的。这是因为事件的发送方和事件消费方都在一个线程中，事件发送方只有在发送的事件处理完毕后才会继续执行自己后面的代码。这里可使用
AsyncEventBus 类实现事件的异步处理，也就是将事件处理放到一个线程池里面去执行。

异步代码例子:
AsyncEventBus（EventBus 的异步实现）
Demo1-------------------------------------------------------------------------------------------------------------
事件消息:

/**
 * @className: MessageEvent
 * @author: czh
 * @date: 2023/4/21
 * @despriction: 事件消息
 * @version: 1.0.0
 **/
public class MessageEvent {
    private String message;

    public MessageEvent(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

event bus listener：

/**
 * @className: AsyncEventListener
 * @author: czh
 * @date: 2023/4/21
 * @description: event bus listener
 * @version: 1.0.0
 **/
public class AsyncEventListener {
    @Subscribe
    public void method1( MessageEvent msg) {
        System.out.printf("AsyncEventListener method1 Subscribe received message: %s \n", msg.getMessage());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.printf("AsyncEventListener method1 Subscribe process message: %s \n", msg.getMessage());
    }

    @Subscribe
    public void method2( MessageEvent msg) {
        System.out.printf("AsyncEventListener method2 Subscribe received message: %s \n", msg.getMessage());
        System.out.printf("AsyncEventListener method2 Subscribe process message: %s \n", msg.getMessage());
    }

}

异步eventBus测试：

/**
 * @className: TestMain
 * @author: czh
 * @date: 2023/4/21
 * @description: google异步eventBus测试
 * @version: 1.0.0
 **/
public class TestMain {
    
    public static void main(String[] args) throws InterruptedException {

        System.out.println("step 1------------TestMain main create executor .");
        Executor executor = new Executor() {
            public void execute(Runnable command) {
                new Thread(command).start();
            }
        };

        System.out.println("step 2------------TestMain main create AsyncEventBus with executor: eventBus = new AsyncEventBus(executor) .");
        AsyncEventBus eventBus = new AsyncEventBus(executor);

        System.out.println("step 3------------TestMain main create EventListener: listener = new AsyncEventListener() .");
        AsyncEventListener listener = new AsyncEventListener();

        System.out.println("step 4------------TestMain main eventbus register listener: eventBus.register(listener) .");
        eventBus.register(listener);

        System.out.println("step 5------------TestMain main eventbus post event:  eventBus.post(new MessageEvent(\"异步消息\" + i)); .");
        for (int i = 0; i < 10; i++) {
            System.out.println("-----------------TestMain main eventBus post event message.");
            eventBus.post(new MessageEvent("异步消息" + i));

        }

    }
}

执行输出信息：

step 1------------TestMain main create executor .
step 2------------TestMain main create AsyncEventBus with executor: eventBus = new AsyncEventBus(executor) .
step 3------------TestMain main create EventListener: listener = new AsyncEventListener() .
step 4------------TestMain main eventbus register listener: eventBus.register(listener) .
step 5------------TestMain main eventbus post event:  eventBus.post(new MessageEvent("异步消息" + i)); .
-----------------TestMain main eventBus post event message.
-----------------TestMain main eventBus post event message.
AsyncEventListener method2 Subscribe received message: 异步消息0
AsyncEventListener method2 Subscribe process message: 异步消息0
AsyncEventListener method1 Subscribe received message: 异步消息0
AsyncEventListener method2 Subscribe received message: 异步消息1
AsyncEventListener method2 Subscribe process message: 异步消息1
AsyncEventListener method1 Subscribe process message: 异步消息0
AsyncEventListener method1 Subscribe received message: 异步消息1
AsyncEventListener method1 Subscribe process message: 异步消息1

Demo2-------------------------------------------------------------------------------------------------------------
目录结构介绍：
event:一个自定义的事件类，类的内容随意定义。
eventListeners:定义了两个事件监听者类，类里面的方法加@Subscribe注解。
util:eventBus工具类。
TestMain类，测试函数。

public class CustomEvent    {
    private int age;
    public CustomEvent(int age){
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }
}

public class MessageEvent {
    private String message;

    public MessageEvent(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

public class EventListener1 {
    @Subscribe
    public void test1(CustomEvent event){
        System.out.println(Instant.now() +"监听者1-->订阅者1,收到事件："+event.getAge()+"，线程号为："+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.getAge()+"，线程号为："+Thread.currentThread().getName());
    }
}

public class MessageEventListener {
    @Subscribe
    public void method1(Message msg){
        System.out.println("method1:接收消息," + msg.getMessage());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("method1:处理消息," + msg.getMessage());
    }

    @Subscribe
    public void method2(MessageEvent msgEvent){
        System.out.println("method2:接收消息," + msgEvent.getMessage());
        System.out.println("method2:处理消息," + msgEvent.getMessage());
    }
}

public class EventListener2 {

    @Subscribe
    public void test(CustomEvent event){
        System.out.println(Instant.now() +",监听者2,收到事件："+event.getAge()+"，线程号为："+Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

public class EventBusUtil {
    private static EventBus eventBus;
    private static AsyncEventBus asyncEventBus;

    private static Executor executor = new Executor() {
        public void execute(Runnable command) {
            new Thread(command).start();
        }
    };


    //双重锁单例模式
    private static AsyncEventBus getAsynEventBus(){
        if(asyncEventBus==null){
            synchronized (AsyncEventBus.class){
                if(asyncEventBus==null){
                    asyncEventBus = new AsyncEventBus(executor);
                }
            }
        }
        return asyncEventBus;
    }

    //双重锁单例模式
    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 asyncPost(Object event){
        getAsynEventBus().post(event);
    }

    public static void register(Object object){
        getEventBus().register(object);
        getAsynEventBus().register(object);
    }

}

public class TestMain {
    public static void main(String[] args) {
        EventListener1 listener1 = new EventListener1();
        EventListener2 listener2 = new EventListener2();

        CustomEvent customEvent = new CustomEvent(23);

        EventBusUtil.register(listener1);
        EventBusUtil.register(listener2);

        EventBusUtil.asyncPost(customEvent);

        //EventBusUtil.post(customEvent);
        System.out.println(Instant.now() +",主线程执行完毕："+Thread.currentThread().getName());

        //为了定位 g_sync_eventbus 不生效原因
        //1.message没问题
        MessageEvent messageEvent = new MessageEvent("为了定位g_sync_eventbus不生效原因！");
        //2.listener 错误修复： Message msg -> MessageEvent msgEvent 修复
        MessageEventListener messageEventListener = new MessageEventListener();

        EventBusUtil.register(messageEventListener);
        EventBusUtil.asyncPost(messageEvent);
    }
}

.
.
.

git代码: 代码地址
.
.
.

Google Guava 之 EventBus
HY
05-15 792
Google Guava 之 EventBus
Google Guava EventBus(事件总线)
热门推荐
旧路
07-11 2万+
       EventBus是Guava的事件处理机制，是设计模式中的观察者模式（生产/消费者编程模型）的优雅实现。对于事件监听和发布订阅模式，EventBus非常优雅使用起来也非常的简单,这个可不是吹的是真的非常的简单。        EventBus内部实现原理不复杂(源码不复杂，强烈推荐大家去看下)。我们简单的...
google Guava之EventBus
Meiko记录
07-06 557
EventBus是Guava的事件处理机制，是设计模式中的观察者模式（生产/消费者编程模型）的优雅实现，在应用中可以处理一些异步任务。对于事件监听和发布订阅模式，EventBus是一个非常优雅和简单解决方案，我们不用创建复杂的类和接口层次结构。 EventBus流程图 EventBus实际上是一个消息队列，Event Source发送一个消息到EventBus，然后再由EventBus将消息推送到所监听的Listener。 EventBus基本用法 1. 创建Listener 我们可以通过@Subsc
SpringBoot - Google EventBus、AsyncEventBus
小单的博客专栏
08-30 1719
EventBus 顾名思义，事件总线，是一个轻量级的发布/订阅模式的应用模式，最初设计及应用源与 google guava 库。相比于各种 MQ 中间件更加简洁、轻量，它可以在单体非分布式的小型应用模块内部使用（即同一个JVM范围）。
Vert.x-tcp-eventbus-bridge Java代码示例
frankingly的专栏
01-11 1889
关于 Vert.x-tcp-eventbus-bridge 的详细用法，Vert.x 的官方文档（官方文档1、官方文档2）都写得很简单，简单得还是让人搞不懂如何使用。 从网上找到了一篇介绍如何使用的文章：Vert.x TCP EventBus Bridge补遗。该项目中的例子源码在 github 上。看了源码之后，发现是一个 groovy项目。于是就将例子用 Java 代码重新写了下。总共有如下...
EventBus-master
12-16
这个库的设计灵感来源于 Google 的 Guava 项目中的 EventBus，但针对 Android 平台进行了优化，使得它在处理组件间的异步通信时更加高效且易于使用。在 Android 开发中，EventBus 提供了一种替代传统 Intent、...
guava-26.0-jre.zip
07-28
Guava是Google为Java平台设计并维护的一个开源库，它提供了许多高级功能和实用工具，极大地增强了Java开发的效率和代码质量。Guava 26.0-jre版本是针对Java运行时环境（JRE）优化的一个特定版本，旨在更好地支持Java...
Guava-Event-Bus:Guava的EventBus源码学习
05-24
Guava-Event-Bus 学习笔记 Guava的EventBus源码学习，基于Guava的18.0版本 分析者： ###1. 背景简介 EventBus是google的一个Java工具包其中的一个工具类，类似的有多个版本其中包括移植到Android端的 和改良的，功能...
guava-18.0(guava-18.0.jar和guava-18.0-sources.jar)
07-08
这个压缩包包含的是Guava库的18.0版本，分为两个部分：`guava-18.0.jar`和`guava-18.0-sources.jar`。 `guava-18.0.jar`是Guava库的编译后的二进制版本，包含了所有Guava类和方法的字节码，开发者可以直接在项目中...
Guava Event Bus 详解
m0_61089765的博客
12-26 1813
是的，很像，但是EventBus是JVM内部的事件总线，适合应用内部的解耦，如果应用很大，大家会使用微服务拆分进行解耦，微服务之间的消息通信会使用Kafka、RabbitMQ等等消息中间件，当然如果流量很大，需要削峰填谷，会部署多个实例，通过消息中间件实现多个应用实例之间消息的负载均衡。EventBus是google的Guava库中的一个处理JVM内部组件间通信的事件总线，它基于发布/订阅模式，实现了多组件之间通信的解耦合，事件产生方和事件消费方实现解耦分离，提升了通信的简洁性。
Guava EventBus详解
最新发布
抽象的螺旋
01-30 2066
EventBus是google的Guava库中的一个处理组件间通信的事件总线，它基于发布/订阅模式，实现了多组件之间通信的解耦合，事件生产方和事件消费方实现解耦分离，提升了通行的简介性。当一个事件的发送（事件生产方），需要触发很多事件消费方的时候，我们通常会在事件产生方中，分别的去调用那些事件消费方，这样比较繁琐、复杂，业务也不清晰。事件的产生方与事件的消费方，产生的极大的耦合，如果我们要改动某一个事件消费方，很可能要改动事件的产生方。/*** @desc 事件总线配置*/@Bean。
Google Guava的EventBus(事件总线)基本使用
Rookie_cc的博客
03-03 4900
EventBus是Google.Guava提供的消息发布-订阅组件，采用的是观察者模式(生产/消费者编程模型)， 实现了多组件之间通信的解耦合，事件产生方和事件消费方实现解耦分离，提升了通信的简洁性。 相比MQ它更加轻量，易用，但一般只用于进程内部的通信，不能像MQ一样用于分布式系统的服务与服务之间的通信。 EventBus包含3大核心部分：Event事件，Publisher事件发布者，Subscriber事件订阅者。 下面介绍一下它的使用方法： 一、...
Google Guava EventBus使用
流子的专栏
01-30 912
Guava是Google开源的一个Java基础类库，它在Google内部被广泛使用。Guava提供了很多功能模块比如：集合、并发库、缓存等，EventBus是其中的一个module，本篇主要讲一下EventBus的使用。 简单介绍 EventBus：核心类，代表了一个事件总线。Publish事件也由它发起。 AsyncEventBus：异步事件总线，在分发事件的时候，将其压入一个全局队列的异步分发模式。 Subscriber：对某个事件的处理器抽象，封装了事件的订阅者以及处理器，并负责事件处理。
Google EventBus入门
SihgYu
07-21 660
文章目录简介maven依赖内部方法注册发布执行结果 简介 Guava在guava-libraries中为我们提供了事件总线EventBus库，它是事件发布订阅模式的实现，让我们能在领域驱动设计(DDD)中以事件的弱引用本质对我们的模块和领域边界很好的解耦设计。 首先Guava为我们提供了同步事件EventBus和异步实现AsyncEventBus两个事件总线，他们都不是单例的，官方理由是并不想我们我们的使用方式。当然如果我们想其为单例，我们可以很容易封装它，一个单例模式保证只创建一个实例就对了。 maven
观察者模式实现之EventBus(Google)
08-07 392
观察者模式又叫发布-订阅（publish/subscribe）模式，定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使他们能够自动更新自己，我们第一时间可能会想到消息队列，但如果在同一个JVM进程中要实现这种观察者模式该怎么去做？我们可能会想到JDK内置的java.util.Observer，或者自己写代码，其实Google提供的guava工具包也有类似的实现，这就是EventBus,wiki地址为https://githu...
Google Guava EventBus实例与分析
lppl010_的专栏
03-03 263
http://blog.youkuaiyun.com/z69183787/article/details/49884471
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值