手写 EventBus：从零到一实现自己的事件总线库

已于 2023-06-08 17:27:05 修改
阅读量1.7k 收藏 2
点赞数 1
文章标签： java android
于 2023-05-05 19:43:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lucasxu01/article/details/130513860
版权

简介：在本文中，我们将详细介绍如何从头开始实现一个轻量级的 EventBus 库。我们将以 XEventBus 为例，阐述整个实现过程，以及在实现过程中遇到的关键问题和解决方法。
XEventBus 地址：https://github.com/LucasXu01/XBus

一 引言

什么是 EventBus？

EventBus 是一个基于发布/订阅模式的事件总线库，用于在组件之间进行解耦的异步通信。它允许组件（如 Activity、Fragment、Service 等）之间相互发送和接收事件，而无需显式地引用和调用彼此的实例。这样，组件之间的耦合性降低，代码更易于维护和扩展。

XBus 简介及设计目标

为了学习和掌握 EventBus 的实现原理和关键技术，我们将通过本文带领大家从零开始实现一个自己的轻量级的事件总线库 XBus。

XBus 是一个轻量级的事件总线库，旨在提供简单、高效、易用的事件通信机制。我们的设计目标如下：

  1. 易用性：XBus 的 API 设计简洁明了，易于集成和使用。
  2. 高性能：提供过反射和注解处理器（APT）生成订阅者方法索引，后者可提高事件查找和调用的性能。
  3. 可扩展性：XEventBus 具有良好的可扩展性，可以根据需求添加更多功能，如优先级控制、延时处理等。

二 XBus 设计与实现

在这一节中，我们将结合代码详细介绍 XEventBus 的设计与实现。

XEventBus 的实现思路包括以下几个方面：

  1. 使用 XEventBus 类作为事件总线的核心，管理订阅者与订阅方法之间的关系。
  2. 通过 SubscribedMethod 类封装订阅者方法的信息，包括所在类、参数类型、线程模式、优先级和方法名。
  3. 使用 Subscription 类表示订阅关系，包含订阅者对象和订阅方法，方便在事件发布时找到对应的订阅者方法并执行。
  4. 利用subscriptionsByEventType和typesBySubscriber两个集合分别存储EventType类与所有注册方法、Subscriber和其注册的所有event的，并基于这两个集合进行事件订阅的查询和订阅者的注册反注册。
  5. 利用注解处理器（APT）在编译期间生成订阅者方法的查找和调用逻辑，避免运行时使用反射，提高性能。

通过这种设计，XEventBus 实现了一个简单、高效、易用的事件总线，可以方便地在不同组件之间进行事件通信。

订阅事件和订阅者：

subscriptionsByEventType image-20230505171338467

subsciption的结构

image-20230505165450269

XEventBus

XEventBus 类是该库的核心类，它维护了一个 Map<Class<?>, List<Subscription>> 结构，用于存储订阅者和它们对应的订阅方法列表。通过 register 和 unregister 方法，实现订阅和取消订阅的功能。

public class XEventBus {
    private static final Map<Class<?>, List<Subscription>> subscriptionsByEventType = new ConcurrentHashMap<>();

    public void register(Object subscriber) {
        //...
    }

    public void unregister(Object subscriber) {
        //...
    }

    public void post(Object event) {
        //...
    }
}

SubscribedMethod

SubscribedMethod 类封装了订阅者方法的相关信息，包括所在类、参数类型、线程模式、优先级和方法名。在事件发布时，EventBus 将根据这些信息找到并调用订阅者方法。

public class SubscribedMethod {
    private final Class<?> subscriberClass;
    private final Class<?> eventType;
    private final ThreadMode threadMode;
    private final int priority;
    private final String methodName;

    //... constructor and getters
}

Subscription

Subscription 类表示一个订阅关系，包括订阅者对象（Subscriber）和订阅方法（SubscribedMethod）。当事件发布时，EventBus 会遍历所有的 Subscription，根据事件类型找到匹配的订阅者方法并执行。

public class Subscription {
    private final Object subscriber;
    private final SubscribedMethod subscribedMethod;

    //... constructor and getters
}

Subscriber

Subscriber 类表示订阅者对象，包含了订阅者实例和其订阅的事件方法。Subscriber 类主要用于在 EventBus 内部管理订阅关系。

public class Subscriber {
    private final Object subscriberInstance;
    private final List<SubscribedMethod> subscribedMethods;

    //... constructor and getters
}

MethodHandle

MethodHandle 接口用于处理订阅者方法的查找和调用。通过注解处理器（APT）生成具体的实现类，实现在编译期间就能获取订阅者方法信息，提高运行时性能。

public interface MethodHandle {
    List<SubscribedMethod> getAllSubscribedMethods(Object subscriber);

    void invokeMethod(Subscription subscription, Object event);
}

在 XEventBus 的实现中，注解处理器 MyEventBusAnnotationProcessor 负责在编译期间查找所有使用 @Subscribe 注解的方法，并生成 AptMethodFinder 类，实现 MethodHandle 接口。这样，在运行时，XEventBus 无需使用反射，可以直接调用订阅者方法，提高性能。

// MyEventBusAnnotationProcessor
public class MyEventBusAnnotationProcessor extends AbstractProcessor {
    //... processing logic
}

// Generated AptMethodFinder
public class AptMethodFinder implements MethodHandle {
    //... implementation
}

通过上述代码实现，XEventBus 可以在不同组件之间进行高效的事件通信。在编译期间，MyEventBusAnnotationProcessor 注解处理器会自动生成 AptMethodFinder 类，实现了 MethodHandle 接口。这使得 XEventBus 在运行时能够直接调用订阅者方法，而不需要使用反射，从而提高了性能。

三 实现订阅者方法查找与注册

为了实现 XEventBus 中订阅者方法的查找与注册，我们需要使用注解处理器（APT）在编译期间生成相应的代码。这将避免在运行时使用反射，从而提高性能。

使用注解处理器（APT）实现订阅者方法查找

我们在 MyEventBusAnnotationProcessor 注解处理器中遍历所有使用 @Subscribe 注解的方法，将它们按照所属类进行分类。接着，为每个类生成一个查找订阅者方法的静态方法，该方法返回一个包含所有订阅者方法信息的 SubscribedMethod 列表。

for (Element element : elements) {
    // 省略代码...

    CreateMethod createMethod = mCachedCreateMethod.get(qualifiedName);
    if (createMethod == null) {
        createMethod = new CreateMethod(typeElement);
        mCachedCreateMethod.put(qualifiedName, createMethod);
    }

    // 省略代码...
}

注册订阅者方法到 EventBus 中

在 EventBus 类中，我们提供了 register() 方法，用于将订阅者方法注册到事件总线中。注册过程中，EventBus 会调用 AptMethodFinder 类中的 getAllSubscribedMethods() 方法，获取订阅者类中所有订阅者方法的信息，并将它们封装成 Subscription 对象，存储在事件总线的内部数据结构中。

public void register(Object subscriber) {
    List<SubscribedMethod> subscribedMethods = methodHandle.getAllSubscribedMethods(subscriber);
    // 省略代码...
}

生成订阅者方法的索引和对应的方法调用

在 MyEventBusAnnotationProcessor 注解处理器中，我们为每个订阅者类生成一个查找订阅者方法的静态方法，该方法返回一个包含所有订阅者方法信息的 SubscribedMethod 列表。同时，我们还需要为 AptMethodFinder 类生成一个 invokeMethod() 方法，用于执行具体的订阅者方法。

这样，在 EventBus 发布事件时，可以直接通过 AptMethodFinder 的 invokeMethod() 方法调用订阅者方法，而无需使用反射。

通过以上步骤，我们实现了订阅者方法的查找与注册，从而使 XEventBus 能够在不同组件之间高效地传递事件。

四 实现事件发布与订阅者方法调用

在 XEventBus 中，我们实现了事件的发布与订阅者方法的调用。接下来，我们将讨论这些关键功能的实现细节。

事件发布

在 EventBus 类中，我们提供了 post() 方法，用于发布事件。当调用此方法时，EventBus 将遍历内部数据结构中的所有订阅者，并根据事件类型找到对应的订阅者方法。

public void post(Object event) {
    List<Subscription> subscriptions = mEventTypeSubscriptions.get(event.getClass());
    if (subscriptions != null) {
        // 省略代码...
    }
}

通过 MethodHandle 接口查找订阅者方法

为了避免使用反射调用订阅者方法，我们使用 MethodHandle 接口，它允许我们在编译期生成的代码中直接调用订阅者方法。在 EventBus 类中，我们将 MethodHandle 作为一个成员变量，并在构造函数中初始化。

public EventBus() {
    this.methodHandle = new AptMethodFinder();
}

调用订阅者方法

当我们找到订阅者方法时，我们使用 MethodHandle 接口的 invokeMethod() 方法来调用它。这样，我们可以避免使用反射，从而提高性能。

private void invokeSubscriber(Subscription subscription, Object event) {
    try {
        methodHandle.invokeMethod(subscription.subscriber, subscription.subscribedMethod, event);
    } catch (Exception e) {
        // 省略代码...
    }
}

支持不同线程模型的订阅者方法调用

XEventBus 支持多种线程模型，如主线程、后台线程等。我们可以在 @Subscribe 注解中指定线程模型。为了实现这一功能，我们在 Subscription 类中保存订阅者方法的线程模型，并在调用订阅者方法时根据线程模型执行相应的操作。

private void invokeSubscriber(Subscription subscription, Object event) {
    ThreadMode threadMode = subscription.subscribedMethod.threadMode;
    switch (threadMode) {
        case MAIN:
            // 省略代码...
            break;
        case BACKGROUND:
            // 省略代码...
            break;
        // 更多线程模型...
    }
}

通过以上实现，我们使 XEventBus 能够根据订阅者方法的线程模型在不同线程中调用订阅者方法，从而实现了灵活的事件发布与订阅。

五 实现订阅者方法的反注册

为了避免内存泄漏和不必要的事件接收，我们需要提供反注册功能，以便在不再需要接收事件的时候移除订阅者方法。以下是反注册功能的实现细节。

移除订阅者方法

我们在 EventBus 类中提供了一个名为 unregister() 的方法，用于移除订阅者方法。在调用此方法时，我们将遍历订阅者方法并从内部数据结构中删除它们。

public void unregister(Object subscriber) {
    List<Class<?>> subscribedEventTypes = mSubscriberEventTypes.get(subscriber);
    if (subscribedEventTypes != null) {
        for (Class<?> eventType : subscribedEventTypes) {
            removeSubscriber(subscriber, eventType);
        }
    }
}

private void removeSubscriber(Object subscriber, Class<?> eventType) {
    List<Subscription> subscriptions = mEventTypeSubscriptions.get(eventType);
    if (subscriptions != null) {
        // 省略代码...
    }
}

清理资源

在反注册订阅者方法时，我们需要确保清理相关的资源。首先，我们从 mSubscriberEventTypes 中删除订阅者。然后，我们检查事件类型是否还有其他订阅者，如果没有，则从 mEventTypeSubscriptions 中删除该事件类型。

private void removeSubscriber(Object subscriber, Class<?> eventType) {
    List<Subscription> subscriptions = mEventTypeSubscriptions.get(eventType);
    if (subscriptions != null) {
        Iterator<Subscription> iterator = subscriptions.iterator();
        while (iterator.hasNext()) {
            Subscription subscription = iterator.next();
            if (subscription.subscriber == subscriber) {
                iterator.remove();
            }
        }
        
        // 清理资源
        if (subscriptions.isEmpty()) {
            mEventTypeSubscriptions.remove(eventType);
        }
    }
    mSubscriberEventTypes.remove(subscriber);
}

通过实现反注册功能，我们使得 XEventBus 可以灵活地处理订阅者的生命周期，避免了潜在的内存泄漏问题。同时，这也有助于提高事件分发的性能，因为我们不再需要为不再关心的事件处理订阅者方法。

六 XEventBus 的优化与拓展

为了提高 XEventBus 的性能和灵活性，我们可以考虑以下几个方面：

增加缓存策略，提高性能

在 XEventBus 中，我们可以使用缓存策略来减少重复的订阅者方法查找和事件发布。例如，我们可以使用一个 HashMap 来存储已经注册过的订阅者方法，以便在需要时快速查找。同时，在事件发布时，我们可以对订阅者方法的调用结果进行缓存，避免重复计算。

private static final Map<Class<?>, List<SubscribedMethod>> METHOD_CACHE = new HashMap<>();

支持优先级和延时处理的订阅者方法

在某些场景下，我们可能需要对订阅者方法的执行顺序进行控制。为此，我们可以为订阅者方法添加优先级属性。通过在 @Subscribe 注解中添加 priority 属性，我们可以实现订阅者方法的优先级控制。

@Subscribe(priority = 1)
public void onEvent(Event event) {
    // ...
}

此外，我们还可以通过添加 delay 属性来实现延时处理。例如，当 delay 设为 1000 时，订阅者方法将在事件发布后的 1000 毫秒后执行。

@Subscribe(delay = 1000)
public void onEvent(Event event) {
    // ...
}

扩展更多功能，如事件粘性等

除了以上提到的优化，我们还可以为 XEventBus 添加更多功能，如支持粘性事件。粘性事件是指在订阅者注册后，仍然可以接收到在注册之前发布的事件。我们可以通过在 @Subscribe 注解中添加一个 sticky 属性来实现这个功能。

@Subscribe(sticky = true)
public void onStickyEvent(Event event) {
    // ...
}

在实现粘性事件时，我们需要在 XEventBus 中维护一个粘性事件的集合。当订阅者注册时，如果其订阅方法设置了 sticky 属性，那么将会收到集合中保存的对应类型的粘性事件。

这样，通过对 XEventBus 的优化与拓展，我们可以实现一个功能更加丰富、性能更优的事件总线。

七 XBus 实战演示

XBus的开源地址。关于XBus的具体使用可以参考。简述如下。

快速使用：

根build.gradle中添加仓库来源地址

allprojects {
    repositories {
        ...
        maven {
            url 'https://lucasxu01.github.io/maven-repository/'
        }
        
    }
}

app项目级别build.gradle中添加依赖

    implementation 'com.lucas:xbus:1.0.0'
    implementation 'com.lucas:xbus-annotations:1.0.0'
    annotationProcessor 'com.lucas:xbus-apt-processor:1.0.0'

Antivity的onCreate方法中注册bus：

XEventBus.getDefault().register(MainActivity.this);

定义一个自己的Event事件：

public class WorkEvent {
    private int num;

    public WorkEvent(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }
}

对应的Activity中注册方法

    @Subscribe(priority = 1)
    public void onEvent(final WorkEvent event) {
         Log.e(TAG, "onEvent: " + " Thread, WorkEvent num=" + event.getNum());
    }

发送事件进行调用

XEventBus.getDefault().post(new WorkEvent(5))

其他功能

若想使用apt方式代替注解，可在bus注册时这样注册：

AptMethodFinder aptMethodFinder = new AptMethodFinder();
XEventBus.builder().setMethodHandle(aptMethodFinder).build().register(this);

八 Android中消息总线的其他实现方式

简单介绍一下其他技术方案实现的技术总线。

基于RxJava

RxBus是基于RxJava实现的，需要额外导入RxJava RxAndroid等库，因此库体积还是较大的。使用RxBus你得了解rxjava的原理，对于不使用rxjava的项目来说，成本太高了，而且容易内存泄露。想了解具体实现细节的可参考《使用RxJava实现的EventBus》。

使用起来大概是如下：

RxBus.getInstance().toObservable(MsgEvent.class).subscribe(new Observer<MsgEvent>() {
            @Override
            public void onSubscribe(Disposable d) {
                
            }

            @Override
            public void onNext(MsgEvent msgEvent) {
                //处理事件
            }

            @Override
            public void onError(Throwable e) {
                  
            }

            @Override
            public void onComplete() {

            }
        });

        
RxBus.getInstance().post(new MsgEvent("Java"));

基于ASM

ASM（Abstract Syntax Machine）是一个Java字节码操作和分析框架。ASM用于动态生成、转换或者操作Java字节码。在Android中，ASM通常用于性能优化、代码注入、AOP（面向切面编程）等场景。然而，它并不是一个事件总线的典型实现方式。基于ASM实现的时间总线有：BusUtils；

如果你确实想使用ASM实现事件总线，可以尝试以下方法：

  1. 使用ASM扫描已编译的Java字节码，识别出包含特定注解（例如@Subscribe）的类和方法。
  2. 对于扫描到的类和方法，使用ASM在运行时动态修改字节码，注入事件总线的逻辑代码，例如注册、注销和发送事件。
  3. 在事件发送方，通过反射或者其他方式调用相应的方法来触发事件。

这种实现方式在实践中可能非常复杂，容易出现问题，而且可能导致性能和兼容性问题。因此，我们建议在实现事件总线时，优先考虑使用更为成熟、简便的方案，如EventBus、LiveData和ViewModel或RxJava，这些方法在通信和解耦方面表现出色，更为简便和高效，易于使用。

基于LiveData

LiveData是Android Architecture Components库的一部分，它是一个可观察的数据持有类，能够在数据发生变化时通知订阅者。使用LiveData实现事件总线可以确保通信在主线程上执行，而且与应用程序的生命周期紧密结合，从而避免内存泄漏。

以下是实现基于LiveData的Bus的简要步骤：

  1. 创建一个单例的Bus类，用于存放多个LiveData对象，每个LiveData对象负责一种类型的事件。
  2. 在Bus类中，为每种类型的事件提供注册和发送方法。注册方法用于订阅事件，发送方法用于发布事件。
  3. 在需要接收事件的组件（如Activity、Fragment等）中，调用Bus类的注册方法来订阅事件。订阅时，需要传入一个Observer对象，用于处理收到的事件。
  4. 当事件发生时，调用Bus类的发送方法发布事件。订阅者会收到通知，并通过Observer对象处理事件。
  5. 在组件的生命周期结束时，LiveData会自动取消订阅，无需手动注销订阅者。

基于LiveData的事件总线具有以下优点：

  • 生命周期感知：LiveData与组件生命周期紧密结合，可以在组件销毁时自动取消订阅，避免内存泄漏。
  • 线程安全：LiveData确保事件通知在主线程上执行，避免了多线程同步的问题。
  • 简单易用：LiveData的API简单易用，与Android架构组件库兼容良好。

基于Flow

Flow是Kotlin协程库的一部分，它提供了一种声明式、响应式的编程模型，能够更方便地处理异步事件流。使用Flow实现事件总线可以确保通信在主线程上执行，同时提供了更丰富的操作符和组合方式，能够处理更复杂的场景。

以下是实现基于Flow的Bus的简要步骤：

  1. 创建一个单例的Bus类，用于存放多个Flow对象，每个Flow对象负责一种类型的事件。
  2. 在Bus类中，为每种类型的事件提供注册和发送方法。注册方法用于订阅事件，发送方法用于发布事件。
  3. 在需要接收事件的组件（如Activity、Fragment等）中，调用Bus类的注册方法来订阅事件。订阅时，需要传入一个lambda表达式，用于处理收到的事件。
  4. 当事件发生时，调用Bus类的发送方法发布事件。订阅者会收到通知，并通过lambda表达式处理事件。
  5. 在组件的生命周期结束时，可以通过协程取消订阅，避免内存泄漏。

基于Flow的事件总线具有以下优点：

  • 声明式编程模型：Flow提供了一种声明式、响应式的编程模型，能够更方便地处理异步事件流，从而提供更丰富的操作符和组合方式，能够处理更复杂的场景。
  • 线程安全：Flow确保事件通知在主线程上执行，避免了多线程同步的问题。
  • 协程支持：Flow与Kotlin协程库紧密结合，可以方便地在协程中使用。

九 总结

本文实现过程的总结

本文从设计到实现，详细介绍了一个简单的 EventBus 系统 - XEventBus。我们首先讨论了 EventBus 的基本概念、应用场景和优势，并阐述了 XEventBus 的设计目标。接着，我们通过分析 XEventBus 的核心组件和实现细节，介绍了订阅者方法查找、注册、事件发布和订阅者方法调用等核心功能。最后，我们还探讨了 XEventBus 的优化与拓展，包括缓存策略、优先级控制、延时处理和粘性事件等。

EventBus 的适用场景与局限性

EventBus 主要适用于组件之间的松耦合通信，特别是在 Android 应用开发中，它可以简化 Activity、Fragment、Service 之间的消息传递。然而，EventBus 也有一定的局限性，例如：

  • 对于大型项目，过多的事件订阅可能导致代码难以维护。
  • EventBus 无法保证事件的传递顺序，有时可能需要手动处理事件的执行顺序。
  • EventBus 在跨进程通信时存在局限性，需要额外的技术支持。

对 EventBus 未来发展的展望

尽管 EventBus 具有一定的局限性，但在适当的场景下，它仍然是一个非常有用的工具。随着技术的发展，我们可以期待 EventBus 的功能将不断完善，例如：

  • 提供更强大的事件过滤和路由机制，以便更精确地控制事件的传递。
  • 支持跨进程通信，使其适用于更广泛的场景。
  • 增强事件调试和追踪能力，帮助开发者更容易地定位问题。

总之，本文通过实现 XEventBus，希望能为读者提供一个 EventBus 的入门示例，以便更好地理解和应用 EventBus 这一有用的工具。

参考文章

https://www.jianshu.com/p/a5e89082d1b9

https://blog.csdn.net/u011213403/article/details/121267330

https://juejin.cn/post/6844903896700157966#heading-15

https://www.jianshu.com/p/2a8f9ac32e13

许进进
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
EventBus：C＃事件总线实现
02-05
1.简单介绍 事件总线这个概念对您来说可能很陌生，但提到观察者（发布-订阅）模式，你也许就很熟悉。事件总线是对发布-订阅模式的一种实现。它是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解分解的目的。 我们来看看事件总线的处理流程： 事件总线就相当于一个介于发布者和订阅者中间的主轴。它隔离了出版物和订阅者之间的直接依赖，接管了所有事件的发布和订阅逻辑，并负责事件的中转。 2.实现原理 3.事件总线的实现要点 事件总线维护一个事件源与事件处理的映射字典； 通过单例模式，确保事件总线的唯一入口； 利用反射或依赖注入完成事件源与事件处理的初始化绑定； 提供统一的
开源bbs源码java-Eventbus:事件总线的简单实现
06-06
如果你不知道事件总线是什么，那么没有关系，下面我们先来看这么一个场景： 你是否在开发的过程中遇到过想在Activity-B中回调Activity-A中的某个函数，但Activity又不能手动创建对象来设置一个Listener什么的？ 你...
观察者模式和发布订阅者模式与EventBus
程序媛的梦工厂
02-01 415
eventBus
EventBus的手写
奋斗&努力
03-30 337
在上一篇文章我讲了EventBus源码，现在我们来手写一下EventBus 使用 MainActiviity public class MainActivity extends AppCompatActivity { private TextView mTv; @Override protected void onCreate(Bundle savedIn...
手写EventBus
wang_yong_hui_1234的博客
07-07 832
前言 EventBus是一种用于Android的事件发布-订阅总线，由GreenRobot开发，Gihub地址是：EventBus。它简化了应用程序内各个组件之间进行通信的复杂度，尤其是碎片之间进行通信的问题，可以避免由于使用广播通信而带来的诸多不便。 像这样的框架如何进行实现呢，我们就手写一个。 ...
JavaScript手写系列(二)———EventBus
Salange1的博客
10-25 661
Vue中的组件传参是日常开发中常遇到的需求，其中事件总线就是其中非常好用的一种，之前其实是比较排斥这种用法的，就是因为用的少，不了解所以出于对未知事物的恐惧，比较排斥。最近刷到一篇手写的文章，看完才明白其中的大概原理，今天就以我自己的理解来给大家讲讲基本实现。我们可以把简单理解为一个公众号，其中公众号作者拥有发布()消息的能力，用户拥有订阅()公众号的能力，公众号作者发布文章后，用户会收到文章内容推送，如果用户不喜欢推送的文章则可以选择取消订阅()公众号的能力。接下来我们就来简单实现一下这些功能。 代码验证
EventBus解析并实现手写EventBus
gwz10250330的博客
05-25 944
前言 其实在我们开发当中需要应用组件与后台线程间进行通信，比如在子线程中进行请求数据，当数据请求完毕后通过Handler或者是广播通知UI，而两个Fragment之家可以通过Listener进行通信等等。当我们的项目越来越复杂，使用Intent、Handler、Broadcast进行模块间通信、模块与后台线程进行通信时，代码量大，而且高度耦合；最近公司正在做了一款项目是要求模块化来做，前期考虑是想...
C#写一个简单的EventBus事件总线
Vampirewal的博客
03-03 681
一个简单的EventBus事件总线
简单的手写EventBus通信
主要是学习笔记和一些学习心得~
03-17 3090
简单的手写实现EventBus通信，简单的概述一下原理。
MQTTnet.EventBus:使用MQTTnet实现事件总线
05-09
MQTTnet.EventBus快速开始在您的ASP.NET Core Startup.cs文件中，添加以下内容public void ConfigureServices ( IServiceCollection services ){ // ... var retryCount = 5 ; services . AddMqttEventBus ( cfg => ...
EventBus:[已弃用] PHP 的独立事件总线库
07-01
此包已被弃用，请改用 。
EventBus:事件总线
05-08
事件总线 安装 对于节点 npm install ovaldi-event-bus 凉亭 bower install event-bus 对于Require.js require.config({ paths: { "eventbus": "path/to/eventbus.js" } }); require(["eventbus"], function ...
手写eventBus
CAPEVERDE77的博客
04-21 181
在vue中，我们有时会用eventBus进行简易组件通信，那么这个eventBus究竟是如何实现的呢？ eventBus其实是一个典型的观察订阅模式，我们需要实现： 1、订阅事件on 2、触发事件emit 3、移除事件off 思路还是很简单的，我们直接看一下代码： class EventBus { constructor(){ this.eventContainer = this.eventContainer || new Map() //用一个容器存放事件 } on
动手实现一个EventBus
hefrankeleyn的博客
10-23 490
根据Google Guava中的EventBus，动手实现一个简单的EventBus，深入理解其原理。
EventBus系列：模仿EventBus，自定义注解
知道这个有什么用？
10-10 315
找到带有@Subscribe注解的方法，并且调用。
EventBus 事件机制详解（Google Guava）
jeffersonchern的博客
07-28 643
EventBus讲解和实例，特别容易理解。
EventBus(事件总线)的使用和源码的简单解析
Tai_Monster的博客
04-29 5866
事件总线（EventBus）是一种广泛用于软件架构中的设计模式，用于实现解耦和松散耦合的通信机制。它可以帮助组织和管理应用程序中不同组件之间的通信，以提高应用程序的可维护性、可扩展性和灵活性。 在事件总线模式中，不同的组件通过订阅和发布事件来进行通信。发布者发布一个事件，订阅者可以订阅该事件并在事件发生时执行相关的操作。事件总线充当了中介者的角色，它负责管理所有的事件和订阅者，并确保事件正确地传递到所有订阅者。 事件总线模式可以在很多场景中使用，例如 Android 应用程序中的通信、分布式系统中的消息
EventBus三之手写EventBus
C安君的博客
01-16 547
目录 项目模块描述 eventbus_annotation模块 eventbus_compiler模块 eventbus模块 代码传送门 项目模块描述 eventbus类图 eventbus时序图 eventbus_annotation 实现 a）定义注解类Subscribe @Target(ElementType.METHOD) // 该注解作用在方法之上 @Retention(Ret...
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 821
都是符合我们的预期的。
spring-integration-eventbus:基于 Spring Integration 框架的以解耦方式连接事件发布 代码
05-26
以下是使用 Spring Integration 实现的事件总线示例代码： 首先，定义一个事件类： ```java public class MyEvent { private String message; public MyEvent(String message) { this.message = message; } public String getMessage() { return message; } } ``` 然后，定义一个事件发布器： ```java public class MyEventPublisher { private ApplicationEventPublisher publisher; public MyEventPublisher(ApplicationEventPublisher publisher) { this.publisher = publisher; } public void publishEvent(String message) { MyEvent event = new MyEvent(message); publisher.publishEvent(event); } } ``` 在 Spring 配置文件中，需要配置一个 `ApplicationEventMulticaster` 和一个 `MyEventPublisher`： ```xml <bean id="applicationEventMulticaster" class="org.springframework.context.event.SimpleApplicationEventMulticaster"> <property name="taskExecutor"> <bean class="org.springframework.core.task.SimpleAsyncTaskExecutor"/> </property> </bean> <bean id="myEventPublisher" class="com.example.MyEventPublisher"> <constructor-arg ref="applicationEventPublisher"/> </bean> ``` 最后，在需要使用事件总线的地方，可以注入 `MyEventPublisher` 并发布事件： ```java @Autowired private MyEventPublisher myEventPublisher; public void doSomething() { myEventPublisher.publishEvent("Hello world!"); } ``` 通过上述配置和代码，我们就可以实现基于 Spring Integration 框架的事件总线了。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

许进进

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值