十、guava eventbus

已于 2023-04-09 20:58:18 修改
阅读量412 收藏 2
点赞数 1
分类专栏： guava 文章标签： guava
于 2023-04-07 21:18:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43476824/article/details/130020698
版权

EventBus 是 Guava 的事件处理机制，是观察者模式（生产/消费模型）的一种实现。根据发送对象的类型，查找所有匹配的订阅处理器进行处理。

1. 事件默认在当前线程直接调用处理

1.1.简单使用示例

package org.example.model.guava;

import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.Test;

public class EventBusTest {
    @AllArgsConstructor
    @Data
    public static class Person {
        private String name;
        private int age;
    }

    public static class SimpleListener {
        @Subscribe
        // Subscribe注解标注的方法为订阅处理器，处理String类型的事件
        public void doSomething(String event) {
            System.out.println(this.getClass().getSimpleName() + ":" + event);
        }

        @Subscribe
        public void doSomething2(String event) {
            System.out.println(this.getClass().getSimpleName() + "2:" + event);
        }

        @Subscribe
        // 订阅处理Person类型的事件
        public void personListener(Person person) {
            System.out.println(this.getClass().getSimpleName() + ":" + person);
        }
    }

    @Test
    public void test() {
        EventBus eventBus = new EventBus();

        // 注解监听者
        eventBus.register(new SimpleListener());

        // 发送事件
        eventBus.post("发送字符串！");
        eventBus.post(new Person("张三", 20));
    }
}

执行结果：

SimpleListener2:发送字符串！
SimpleListener:发送字符串！
SimpleListener:EventBusTest.Person(name=张三, age=20)

1.2 监听器有继承关系时

    监听器有继承关系时，父类和子类所有被Subscribe注解标记的方法都会被注册为事件订阅处理器。

package org.example.model.guava;

import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import lombok.AllArgsConstructor;
import lombok.Data;
import org.junit.Test;

public class EventBusTest {
    @AllArgsConstructor
    @Data
    public static class Person {
        private String name;
        private int age;
    }

    public static abstract class absListener {
        @Subscribe
        public void doSomething2(String event) {
            System.out.println(this.getClass().getSimpleName() + "2:" + event);
        }

        @Subscribe
        public void personListener(Person person) {
            System.out.println(this.getClass().getSimpleName() + ":" + person);
        }

    }

    public static class SimpleListener extends absListener {
        @Subscribe
        public void doSomething(String event) {
            System.out.println(this.getClass().getSimpleName() + ":" + event);
        }
    }

    @Test
    public void test() {
        EventBus eventBus = new EventBus();
        eventBus.register(new SimpleListener());
        eventBus.post("发送字符串！");
        eventBus.post(new Person("张三", 20));
    }
}

执行结果：

SimpleListener:发送字符串！
SimpleListener2:发送字符串！
SimpleListener:EventBusTest.Person(name=张三, age=20)

1.3 事件对象有继承关系时

    事件对象有继承关系时，由于子类型可以转换为父类型，订阅父类型的处理器可以订阅到子类型进行处理：

package org.example.model.guava;

import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.experimental.SuperBuilder;
import org.junit.Test;

public class EventBusTest {
    @AllArgsConstructor
    @SuperBuilder
    @Data
    public static class Person {
        private String name;
        private int age;
    }

    @SuperBuilder()
    public static class Man extends Person {
    }

    public static class SimpleListener {
        @Subscribe
        public void personListener(Person person) {
            System.out.println(this.getClass().getSimpleName() + "---Person:" + person);
        }

        @Subscribe
        public void manListener(Man man) {
            System.out.println(this.getClass().getSimpleName() + "---Man:" + man);
        }
    }

    @Test
    public void test() {
        EventBus eventBus = new EventBus();
        eventBus.register(new SimpleListener());
        eventBus.post(Man.builder().name("张三").age(20).build());
    }
}

执行结果：

SimpleListener---Man:EventBusTest.Person(name=张三, age=20)
SimpleListener---Person:EventBusTest.Person(name=张三, age=20)

1.4 订阅处理器执行异常不会影响其他订阅处理器执行

package org.example.model.guava;

import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import org.junit.Test;

public class EventBusTest {
    public static class SimpleListener {
        @Subscribe
        public void listener1(String event) {
            System.out.println(this.getClass().getSimpleName() + "---1111:" + event);
            throw new RuntimeException();
        }

        @Subscribe
        public void listener2(String event) {
            System.out.println(this.getClass().getSimpleName() + "---2222:" + event);
        }
    }

    @Test
    public void test() {
        EventBus eventBus = new EventBus();
        eventBus.register(new SimpleListener());
        eventBus.post("异常测试");
    }
}

执行结果：

 listener1异常并没有影响listener2的执行。

1.5 自定义异常处理

   在创建EventBus时，可以传入自定义的异常处理方法：

package org.example.model.guava;

import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import org.junit.Test;

public class EventBusTest {
    public static class SimpleListener {
        @Subscribe
        public void listener1(String event) {
            System.out.println(this.getClass().getSimpleName() + "---1111:" + event);
            throw new RuntimeException();
        }

        @Subscribe
        public void listener2(String event) {
            System.out.println(this.getClass().getSimpleName() + "---2222:" + event);
        }
    }

    @Test
    public void test() {
        // 创建eventbus时，自定义异常处理方法
        EventBus eventBus = new EventBus((exception, context) ->
        {
            // 异常时，可以从context获取eventbus， event，监听器和监听器中发送异常的的事件订阅方法
            System.out.println("ExceptionHandler EventBus:" + context.getEventBus());
            System.out.println("ExceptionHandler Event:" + context.getEvent());
            System.out.println("ExceptionHandler Subscriber:" + context.getSubscriber());
            System.out.println("ExceptionHandler SubscriberMethod:" + context.getSubscriberMethod());
        });
        eventBus.register(new SimpleListener());
        eventBus.post("异常测试");
    }
}

1.6 DeadEvent处理没有订阅的事件

package org.example.model.guava;

import com.google.common.eventbus.DeadEvent;
import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import org.junit.Test;

public class EventBusTest {
    public static class SimpleListener {
        @Subscribe
        // 匹配不到任何事件订阅，会使用DeadEvent处理
        public void listener1(DeadEvent event) {
            System.out.println(this.getClass().getSimpleName() + ":" + event);
        }
    }

    @Test
    public void test() {
        EventBus eventBus = new EventBus();
        eventBus.register(new SimpleListener());
        eventBus.post("没有被订阅的消息");
    }
}

1.7 使用eventbus和nio监听文件变化的示例

package org.example.model.guava;

import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import org.junit.Test;

import java.io.IOException;
import java.nio.file.*;
import java.util.Optional;


public class EventBusTest {
    @SneakyThrows
    @Test
    public void test() {
        // 创建eventbus时，自定义异常处理方法
        EventBus eventBus = new EventBus();
        eventBus.register(new FileChangeListener());
        DirectoryMonitor monitor = new DirectoryMonitor(eventBus, "D:\\java\\test1\\apache1");
        monitor.start();
    }

    @RequiredArgsConstructor
    public static class DirectoryMonitor {
        private final EventBus eventBus;
        private final String path;
        private WatchService watchService;
        private volatile boolean start;

        public void start() throws IOException {
            watchService = FileSystems.getDefault().newWatchService();
            Path monitorPath = Paths.get(path);
            monitorPath.register(watchService, StandardWatchEventKinds.ENTRY_CREATE,
                    StandardWatchEventKinds.ENTRY_MODIFY, StandardWatchEventKinds.ENTRY_DELETE);
            start = true;
            WatchKey watchKey = null;
            while (start) {
                try {
                    watchKey = watchService.take();
                    watchKey.pollEvents().forEach(eventBus::post);
                } catch (InterruptedException e) {
                } finally {
                    Optional.ofNullable(watchKey).ifPresent(WatchKey::reset);
                }
            }
        }

        public void stop() throws IOException {
            start = false;
            Thread.currentThread().interrupt();
            watchService.close();
        }
    }

    public static class FileChangeListener {
        @Subscribe
        public void onChange(WatchEvent<?> event) {
            System.out.println(event.context() + "--" + event.kind());
        }
    }
}

在目录 D:\java\test1\apache1 下创建/修改/删除 1.txt，控制台打印如下：

1.txt--ENTRY_CREATE
1.txt--ENTRY_MODIFY
1.txt--ENTRY_DELETE

2. 使用线程池异步处理事件

2.1 使用AsyncEventBus发送异步事件

AsyncEventBus创建时，需要传入使用的线程池：

package org.example.model.guava;

import com.google.common.eventbus.AsyncEventBus;
import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import lombok.SneakyThrows;
import org.junit.Test;

import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class EventBusTest {
    @SneakyThrows
    @Test
    public void test() {
        // 异步事件处理需要提供线程池
        EventBus eventBus = new AsyncEventBus(Executors.newFixedThreadPool(2));
        eventBus.register(new SimpleListener());
        eventBus.post("需要异步处理的事件");

        // 延迟4秒，等待事件处理结束
        TimeUnit.SECONDS.sleep(4);
    }

    public static class SimpleListener {
        @SneakyThrows
        @Subscribe
        public void listener1(String event) {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + "--listener1 start: " + event);
            TimeUnit.SECONDS.sleep(3);
            System.out.println(threadName + "--listener1 end: " + event);
        }

        @SneakyThrows
        @Subscribe
        public void listener2(String event) {
            String threadName = Thread.currentThread().getName();
            System.out.println(threadName + "--listener2 start: " + event);
            TimeUnit.SECONDS.sleep(2);
            System.out.println(threadName + "--listener2 end: " + event);
        }
    }
}

listener1和listener2会使用不同的线程处理，打印结果如下：

pool-1-thread-1--listener2 start: 需要异步处理的事件
pool-1-thread-2--listener1 start: 需要异步处理的事件
pool-1-thread-1--listener2 end: 需要异步处理的事件
pool-1-thread-2--listener1 end: 需要异步处理的事件

不听话的小耳朵
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
guava中EventBus(事件总线)源码分析与使用
mask哥
06-30 1335
1.EventBus:事件发布-订阅消息总线,简化应用程序内各组件间、进行模块间通信、解耦。允许对象通过观察者模式相互通信。 2.EventBus实现框架： greenrobot的EventBus guava中EventBus 3.EventBus的工作模式 Publisher（发布者）通过post（）方法，把Event事件发布出去，Subscriber（订阅者）在onEvent（）方法中接收事件。 发布者：...
SpringBoot 异步任务-Guava 中EventBus
瑶山的博客
11-08 2944
目录 EventBus事件总线模式 pom 简单使用 创建消息接受类 测试类： 输出结果: 结论： 结合Spring使用 注入Bean MyEventListener 消息基类 创建监听 发送消息 项目启动/测试 扩展 多线程 观察者模式和发布订阅模式的区别
EventBus使用详解(二)——EventBus使用进阶
热门推荐
启舰
11-04 13万+
前言：这段时间感觉自己也有点懒了，真是内心有点自责呢，除了工作，也没做点什么，EventBus也是一周前总结出来的，只能以写博客为名来弥补内心的罪恶感了，集合同事们做的项目，虽然上周开动了，但总感觉大家积极性不高，如何才能做一个合格的管理者，还真是一个考验。follow your heart!! just do it! 相关文章： 1、《EventBus使用详解(一)——初步使用E...
Guava的EventBus
莫失莫忘的博客
01-02 753
一、用来干啥 EventBus是Guava包内的一个 实现订阅/通知的一个组件，可以用来实现进程内的消息通知。（分布式系统要使用MQ消息队列进行通信） 二、怎么做 引入依赖： <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>
Google Guava的EventBus(事件总线)基本使用
Rookie_cc的博客
03-03 3848
EventBus是Google.Guava提供的消息发布-订阅组件，采用的是观察者模式(生产/消费者编程模型)， 实现了多组件之间通信的解耦合，事件产生方和事件消费方实现解耦分离，提升了通信的简洁性。 相比MQ它更加轻量，易用，但一般只用于进程内部的通信，不能像MQ一样用于分布式系统的服务与服务之间的通信。 EventBus包含3大核心部分：Event事件，Publisher事件发布者，Subscriber事件订阅者。 下面介绍一下它的使用方法： 一、...
Guava-Event-Bus:Guava的EventBus源码学习
05-24
Guava的EventBus源码学习，基于Guava的18.0版本 分析者： ###1. 背景简介 EventBus是google的一个Java工具包其中的一个工具类，类似的有多个版本其中包括移植到Android端的 和改良的，功能基本都是一样的。此处主要...
camel-guava-eventbus-2.11.0-sources.jar
03-14
jar包，亲测可用
EventBus与Spring Event区别详解(EventBus 事件机制,Spring Event事件机制)
08-25
EventBus是Google Guava项目的一部分，提供了一个轻量级的事件机制实现。它基于观察者模式（或发布订阅模式），主要分为三部分：发布者、监听者、事件。EventBus的使用非常简单，只需要定义事件对象、事件监听器和...
fact-bus:基于guava整合spring实现EventBus；具体详情请访问：https
05-01
SNAPSHOTMaven依赖<dependency><groupId>com.woter.fact</groupId><artifactId>fact-bus</artifactId><version>1.0.0-SNAPSHOT</version></dependency>功能描述fact-bus 是基于guava整合spring实现EventBus；...
camel-guava-eventbus-2.11.1.jar
03-14
jar包，亲测可用
京东一面：20种异步，你知道几种？ 含协程
最新发布
架构师尼恩
02-06 5792
调用方在调用过程中，持续阻塞，一直到返回结果。同步获取结果的方式是： 主动等待。调用方在调用过程中，不会阻塞， 不直接等待返回结果， 而是执行其他任务。异步获取结果的方式是 ： 被动通知或者 被动回调。1、定义发送事件对象2、定义事件监听器可以添加条件condition，限制监听具体的事件try {// 休眠5秒 TimeUnit . SECONDS . sleep(5);} }3、定义发送接口以及实现类entity . setMsg("新用户注册同步调用");} }
观察者模式与spring guava事件
trayvontang的博客
02-06 364
1. 观察者模式 观察者模式，也叫发布/订阅(Publish/Subscribe)模式，观察者模式比较简单，但是非常常用，当然也非常实用。 观察者模式最大的好处是，当业务逻辑变得复杂之后，通过观察者模式可以减轻耦合。 举个简单的例子，一个简单的用户充值事件，当业务复杂之后，除了处理订单之外，可能还需要送券、奖励积分金币、提示VIP等级、送抽奖等激励活动、处理邀请码、发送重要事件记录日志、处理重要事件异常操作等等。 如果这些逻辑都放在“用户充值”这个流程之中，那肯定逻辑耦合爆炸。所以，一般不这么干。 如果用户
基于guava框架中事件总实现具体事件的监听
李杰的博客
05-31 451
文章目录 Guava的EventBus可以简化生产/消费模型。EventBus通过非常简单的方式，实现了观察者模式中的监听注册，事件分发。 public class GuavaListener { // 只有通过@Subscribe注解的方法才会被注册进EventBus，即可实现对多个消息的订阅 @Subscribe public void receiveMessage(String message) { System.out.println(message);
google Guava之EventBus
栋先生
06-03 1万+
EventBus基本用法 1. 创建Listener 2. 创建EventBus并发送消息 Listener之间的继承关系 Subscriber 不同类型参数的Subscribe event 继承关系的event DeadEvent EventBus之异常处理 EventBus是Guava的事件处理机制，是设计模式中的观察者模式（生产/消费者编程模型）的优雅实现，在应...
使用Guava的eventbus完成异步事件的简单例子
专注技术
12-19 1万+
Guava的事件总线EventBus库是事件发布订阅模式的实现，让我们能在领域驱动设计(DDD)中以事件的弱引用本质对我们的模块和领域边界很好的解耦设计。
Guava事件总线EventBus阻塞行为解读
u014249527的博客
07-03 1695
google guava库的事件总线组件EventBus，是观察者模式（进程内事件发布/订阅）的一个比较优雅的实现。之前项目一直没什么机会使用（之前事件解耦多用消息中间件），最近自个儿摸索DDD，在进程内领域事件的实现时，采用了EventBus,总体使用比较顺利，其提供的api也比较简单，在这里就不详诉使用方式了。今天就如标题所说，谈谈EventBus post事件时的阻塞行为。 具体遇到的令我困惑的行为是,在不同线程里post事件，貌似也会相互阻塞。以下是实验代码： public static void
在Spring应用中以很“Spring”的方式使用Google Guava EventBus
Details Inside Spring
01-23 7548
概述 由Google提供的Guava EventBus是一个很不错的进程内事件总线机制。在非Spring应用中，使用 Guava EventBus是可以的，但各种组件，比如事件总线，事件监听器都是通过java new关键字创建出来的。这种开发人员自己管理对象生命周期的方式，在Spring应用中，就显得很不“Spring”，因为我们知道，Spring应用一个很大的特点就在于所有对象实例都尽量由Sp
Guava教程-EventBus
Ricky
04-29 6668
Guava为我们提供了事件总线EventBus库，它是事件发布-订阅模式的实现，让我们能在领域驱动设计(DDD)中以事件的弱引用本质对我们的模块和领域边界很好的解耦设计。事件Guava 发布-订阅模式 中传递的事件，是一个普通的POJO类。 class OrderEvent { private String message; public OrderEvent(String mess
Guava系列之EventBus
果子爸聊技术
06-21 1万+
EventBus是Guava中实现的用于发布/订阅模式的事件处理组件，它是设计模式中观察者模式的优雅实现，关于观察者模式可以看一下我的另一篇博客：设计模式学习-观察者模式 EventBus简化了观察者模式，无须创建复杂的类和接口层次结构 EventBus的基本用法 1、定义事件对象 public class Event { private String message; public Event(String message){ this.message = message;
Java与Guava核心库解析
"Java&Guava 讲义" 在本次讲义中，主要涵盖了Java语言的基础知识以及Google的Guava库的应用。Java是一种编译解释型的语言，它以面向对象编程为主要特性，与C++不同，Java的编译结果是.class文件，即字节码文件，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值