What？EventBus的核心竟然只是这两个Map？

最新推荐文章于 2022-05-14 10:06:35 发布
最新推荐文章于 2022-05-14 10:06:35 发布
阅读量122 收藏
点赞数
文章标签： java ui
原文链接：https://juejin.im/post/5cc27f61f265da038b201fb0
版权

简单介绍一下EventBus

其实EventBus大家都很熟悉了，就不过多去说它了。通常我们叫它事件总线，其实它更像是广播，观察者模式，一方发送消息多方接收。在EventBus的创建订阅过程中，最重要的就是有两个关键的Map，这两个键值对里面存储了我们定义的订阅方法和相关的类，那到底是具体是怎么操作的呢，来源码一探究竟。

下面的代码基于EventBus3.1.1

创建和订阅消息

注册

EventBus的注册很简单，

 @Override
 public void onStart() {
     super.onStart();
     EventBus.getDefault().register(this);
 }

 @Override
 public void onStop() {
     super.onStop();
     EventBus.getDefault().unregister(this);
 }
复制代码

这里一定要记住在onStop中注销，避免在Activity关闭后还跟EventBus有联系，然后造成内存泄漏。

接下来进入到方法中看一看：

单例模式

EventBus.getDefault

    public static EventBus getDefault() {
        if (defaultInstance == null) {
            synchronized (EventBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();
                }
            }
        }
        return defaultInstance;
    }
复制代码

这个方法很简单，就是双重校验单例，继续看register方法：

register方法

EventBus.register

    public void register(Object subscriber) {
        Class<?> subscriberClass = subscriber.getClass();//注册的类
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);//查找订阅方法
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {//循环找到的所有方法
                subscribe(subscriber, subscriberMethod);
            }
        }
    }
复制代码

在register中，传入的参数名为subscriber，意思就是订阅者，类型为Object。在这个方法里有个List的列表，这个SubscriberMethod是什么呢？

public class SubscriberMethod {
    final Method method;//对应的方法
    final ThreadMode threadMode;//线程模式
    final Class<?> eventType;//消息类型
    final int priority;//优先级
    final boolean sticky;//是否支持粘性
    /** Used for efficient comparison */
    String methodString;//用于equal对比
}
复制代码

其实这个类就保存了我们订阅者里面定义的方法里面的所有信息。

线程模式

其中threadMode的定义如下：

  • ThreadMode.POSTING：默认的线程模式，在那个线程发送事件就在对应线程处理事件，避免了线程切换，效率高。

  • ThreadMode.MAIN：如在主线程（UI线程）发送事件，则直接在主线程处理事件；如果在子线程发送事件，则先将事件入队列，然后通过 Handler 切换到主线程，依次处理事件。

  • ThreadMode.MAIN_ORDERED：无论在那个线程发送事件，都先将事件入队列，然后通过 Handler 切换到主线程，依次处理事件。

  • ThreadMode.BACKGROUND：如果在主线程发送事件，则先将事件入队列，然后通过线程池依次处理事件；如果在子线程发送事件，则直接在发送事件的线程处理事件。

  • ThreadMode.ASYNC：无论在那个线程发送事件，都将事件入队列，然后通过线程池处理。

所以在register方法中的这个列表其实就是当前我们这个订阅者类包含所有的接收方法。这里通过subscriberMethodFinder.findSubscriberMethods(subscriberClass)方法获取：

查找订阅事件的方法（接收消息的方法）

SubscriberMethodFinder findSubscriberMethods


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

    List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
        List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);//首先从缓存中获取
        if (subscriberMethods != null) {
            return subscriberMethods;//缓存有的话直接返回
        }

        if (ignoreGeneratedIndex) {//是否忽略注解
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            subscriberMethods = findUsingInfo(subscriberClass);
        }
        if (subscriberMethods.isEmpty()) {
            throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
        } else {
            METHOD_CACHE.put(subscriberClass, subscriberMethods);//加入到缓存中
            return subscriberMethods;
        }
    }

复制代码

这里我们注意到有一个ignoreGeneratedIndex参数，这个属性的值是在构造方法中获取的

subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
                builder.strictMethodVerification, builder.ignoreGeneratedIndex);
复制代码
    /** Forces the use of reflection even if there's a generated index (default: false). */
    public EventBusBuilder ignoreGeneratedIndex(boolean ignoreGeneratedIndex) {
        this.ignoreGeneratedIndex = ignoreGeneratedIndex;
        return this;
    }
复制代码

从官方的注释可以看出，这里默认值是false，所以是调用findUsingInfo方法：


    private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);//初始化查找辅助类
        while (findState.clazz != null) {//这里就是我们register的类
            findState.subscriberInfo = getSubscriberInfo(findState);
            if (findState.subscriberInfo != null) {//初始状态为空，所以执行else
                SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
                for (SubscriberMethod subscriberMethod : array) {
                    if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                        findState.subscriberMethods.add(subscriberMethod);
                    }
                }
            } else {
                findUsingReflectionInSingleClass(findState);
            }
            findState.moveToSuperclass();//查找父类
        }
        return getMethodsAndRelease(findState);//释放资源
    }

复制代码

FindState是查找辅助类，里面存储了关于查找到的订阅方法信息和相关类的信息：

static class FindState {
        final List<SubscriberMethod> subscriberMethods = new ArrayList<>();//订阅的方法
        final Map<Class, Object> anyMethodByEventType = new HashMap<>();//通过消息类型获取方法
        final Map<String, Class> subscriberClassByMethodKey = new HashMap<>();//通过方法获取订阅的类
        final StringBuilder methodKeyBuilder = new StringBuilder(128);

        Class<?> subscriberClass;
        Class<?> clazz;
        boolean skipSuperClasses;
        SubscriberInfo subscriberInfo;
}
复制代码

在这里会执行else里面的findUsingReflectionInSingleClass方法，通过反射来查找订阅方法

SubscriberMethodFinder findUsingReflectionInSingleClass

    private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // This is faster than getMethods, especially when subscribers are fat classes like Activities
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }
        //循环所有的方法
        for (Method method : methods) {
            int modifiers = method.getModifiers();//获取修饰符
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {//public，非abstract、static
                Class<?>[] parameterTypes = method.getParameterTypes();//获取参数类型
                if (parameterTypes.length == 1) {//只能有一个参数
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);//获取Subscribe注解
                    if (subscribeAnnotation != null) {
                        Class<?> eventType = parameterTypes[0];//获取参数类型，也就是我们自定义的消息的类型
                        if (findState.checkAdd(method, eventType)) {//是否添加过这个方法
                            ThreadMode threadMode = subscribeAnnotation.threadMode();//获取线程模式
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));//添加到数组中
                        }
                    }
                } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                    String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                    throw new EventBusException("@Subscribe method " + methodName +
                            "must have exactly 1 parameter but has " + parameterTypes.length);
                }
            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                throw new EventBusException(methodName +
                        " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
            }
        }
    }

复制代码

整个的过程就是遍历所有的方法，然后判断有Subscribe注解的方法，然后将方法的信息加到数组当中。在查找完毕之后，接下来回到register方法

    public void register(Object subscriber) {
        Class<?> subscriberClass = subscriber.getClass();
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }
复制代码

循环订阅

拿到我们刚才的所有订阅方法的数组，然后在循环中执行subscribe方法，这个方法执行订阅操作：

    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class<?> eventType = subscriberMethod.eventType;//获取我们自定义的消息类型
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);//新建一个订阅类，这个类包含了订阅的类和方法两个属性
        //subscriptionsByEventType是以eventType为key，Subscription数组为value的map
        CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions == null) {//为空的话创建数组，并加入到map中
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);
        } else {
            if (subscriptions.contains(newSubscription)) {//已经订阅过，抛出异常
                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                        + eventType);
            }
        }
        
        int size = subscriptions.size();
        for (int i = 0; i <= size; i++) {
            if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {//将优先级更高的订阅方法加入到数组中
                subscriptions.add(i, newSubscription);
                break;
            }
        }
        //typesBySubscriber是以对象为key，订阅的方法的数组为value的map
        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);
        //粘性事件相关
        if (subscriberMethod.sticky) {
            if (eventInheritance) {
                // Existing sticky events of all subclasses of eventType have to be considered.
                // Note: Iterating over all events may be inefficient with lots of sticky events,
                // thus data structure should be changed to allow a more efficient lookup
                // (e.g. an additional map storing sub classes of super classes: Class -> List<Class>).
                Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
                for (Map.Entry<Class<?>, Object> entry : entries) {
                    Class<?> candidateEventType = entry.getKey();
                    if (eventType.isAssignableFrom(candidateEventType)) {
                        Object stickyEvent = entry.getValue();
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                    }
                }
            } else {
                Object stickyEvent = stickyEvents.get(eventType);
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
    }
复制代码

完

其实EventBus的register方法的内部具体做的事情很简单，总的来说就是两步：

  1. 通过反射查找我们使用了Subscribe注解的订阅方法
  2. 循环遍历找到的方法，然后加到关键的两个map中（subscriptionsByEventType和typesBySubscriber）
subscriptionsByEventType：以eventType为key，Subscription数组为value
typesBySubscriber：以对象为key，订阅的方法的数组为value
weixin_33924770
关注
用Map写一个EventBus事件总线
Jiuto_crx的博客
03-15 212
用Map写一个EventBus事件总线 本文所写的EventBus类代码可在dc-utils中查看 前置知识 Map文档 设计模式 EventBus class EventBus { constructor () { this.events = new Map() } // 监听事件 addListener (type, cb) { if (!type || !cb) return; // 必传事件名与回调，此处未作处理直接return，可做
EventBus源码追踪
kanglupeng的专栏
04-28 149
有过Android开发经验的人相信对EventBus应该都有所了解，EventBus是一个开源库，它使用观察者模式对模块间的通信进行解藕。 下面是一个Android中使用EventBus的实例，相信大家都不陌生： class MainActivity : AppCompatActivity() { private val TAG = "MainActivity" overr...
EventBus源码解读详细注释（4）register时刷新的两个map
聚精会神搞建设
03-20 1074
EventBus中有两个重要的map，一个是事件到订阅者列表的map，另一个是订阅者到事件列表的map，每次register的时候都要动态刷新这两个map的数据。正是因为有了这两个map，EventBus在post事件的时候才可以根据事件类型找到所有订阅了此事件的订阅者，然后使用反射调用订阅者的事件处理方法。 先看看EventBus中这两个map是如何定义的 /*事件到订阅者列表的map，
AndroidUtil - 极简EventBus - 结合map，handler和线程池
BlueYangDroid的专栏
09-08 327
import android.os.Bundle; import android.os.Handler; import android.os.Looper; import java.util.ArrayList; import java.util.HashMap; import java.util.concurrent.ExecutorService; import java.util.conc...
EventBus执行原理详解
文化园
03-30 8718
EventBus发送事件原理是，subscriptionsByEventType通过事件类型EventType.class获取到订阅方法包装类List集合。然后通过postToSubscription方法，在方法中匹配发送事件的线程模式threadMode，例如匹配到主线程时，会直接通过反射调用订阅方法subscription.subscriberMethod.method.invoke(subscription.subscriber, event)实现事件的发布-订阅执行。......
EventBus使用详解
热门推荐
川峰的博客
06-03 2万+
EventBus是一个基于发布者/订阅者模式的事件总线框架。 发布者/订阅者模式，也就是观察者模式（定义了对象之间的一种一对多的依赖关系，当一个对象状态发生改变时，它的所有依赖者都会收到通知并自动更新）。在EventBus中，当发布者发布事件时，所有订阅该事件的事件处理方法将被调用。 EventBus的优点： 解耦和简化Activities, Fragments等组件以及后台线程之间的通信，分...
Android消息传递机制总结
WangShuo的专栏
11-23 1761
由于直播项目的推流SDK，拉流SDK已经稳定。所以这段时间一直开发业务层新需求。业务层的核心灵魂就是层层的消息传递，今天就来总结一下andorid的应用层的各种消息传递。1.线程间通讯 ——— Handler，HandlerThread等。 2.组件间通信 ——— BroadcastReceiver，接口回调等。 3. 第三方通信 ——— EventBus，rxBus 4.进程间通
Amap【高德】/Google-开发，无人机航迹规划演示
唯爱丶卡卡西的博客
07-14 4222
ps：又到了周五，才有时间来写点博客记录下，这篇文章的所描述的内容是我2017年后 做的一个功能，也是我们的产品经理结合 航迹规划 以及我们所提供的 能做到的一些地图开发结合，做的一个自创性的 开发吧。其实开始做的时候挺不自信的，因为第一，地图sdk 并不是非常了解，再说，里面有好多效果和功能  ，主要是一个动态修改航点和航线这个效果，在评估的时候，着实让我觉得头疼。而且领导还说项目很急，让我一周
VUE框架：基础知识及核心原理
Zwx886的博客
10-23 1477
VUE框架第一部分：基础知识及核心原理 VUE基础概念 https://cn.vuejs.org Vue (读音 /vjuː/，类似于 view) 是一套用于构建用户界面的渐进式框架特点：易用、灵活、高效全家桶：vue + components（vue element / iview…） + vue-router + vuex + vue-cli 类库 vs 插件 vs 组件 vs 框架 ...
Vue3学习
ianutt的博客
05-14 772
Vue3学习
js实现一个基本的Event Bus
weixin_43837268的博客
08-19 1838
// 组件通信，一个触发与监听的过程 class EventEmitter { constructor () { // 存储事件 this.events = this.events || new Map() } // 监听事件 addListener (type, fn) { if (!this.events.get(type)) { this...
EventBus原理深度解析（Guava）
qq_23107097的博客
12-10 1万+
一、问题描述 在工作中，经常会遇见使用异步的方式来发送事件，或者触发另外一个动作：经常用到的框架是MQ（分布式方式通知）。如果是同一个jvm里面通知的话，就可以使用EventBus。由于EventBus使用起来简单、便捷，因此，工作中会经常用到。深入理解该框架的原理就很有必要。 二、框架解析 2.1、组织结构 eventbus的组织结构如下： eventbus主要有以下几部分组成： 1、eventbus、asyncEventBus：事件发送器。 2、event：事件承载单元。 3、.
EventBus3.0 List事件遇到的坑
Liberation的博客
12-06 2101
当你需要发送接收List类型的对象时，务必做个类型判断。。。否则会出险 java.lang.ClassCastException 具体操作如下*instanceof to avoid some bugs...*/ @Subscribe(sticky = true) public void getMemLis(List<MettingMem.Mem> mettings) {
三幅图弄懂EventBus核心原理
有图有真相
04-16 3325
前言 好多分析EventBus的文章，喜欢上来就贴源码，我看了好多次总是迷迷糊糊的，这次花时间彻底整理一下EventBus，发现EventBus核心其实就是三幅图，这三幅图涉及的是三个HashMap表，弄懂这三幅图那么EventBus就懂了。 第一幅图subscriptionsByEventType 1、第一幅图typesBySubscriber 先看一段在activity中注册和反注册Even...
Android使用EventBus进行页面间的传值操作
qq_40310480的博客
02-28 1572
前几天Android项目做个人信息修改那块,要求是修改完之后回到主页个人信息要修改为新的信息,起初想用Intent直接携带Bundle跳转传值的,
Eventbus 学习完毕后的总结
我的博客
03-15 1302
EventBus方法： onEventMainThread(发送时实参类型) 将接收到的数据，在主线程中执行 onEventPostThread(发送时实参类型) 将接收到的数据，在发送时的线程中进行执行 onEventAsync(发送时实参类型) 将接收到的数据，直接放在线程池中进行执行 onEventBackGroundThread(发送时实参类型) 将
Android EventBus3.0深入理解 三 使用多个EventBus
z979451341的博客
01-16 5053
EventBus.getDefault()是通过单例模式来获取一个默认实例，EventBus允许我们创建EventBus实例，我个人觉得自己创建的EventBus基本要保持全局，所以我自己单独弄一个类使用单例模式来创建和获取EventBus public class EventBusBase { private static EventBus eventBus; publi
使用EventBus来实现数据的传递
Seek42的专栏
04-22 6948
EventBus是Android的一个开源项目，它最重要的功能就是可以简化各个组件之间的消息传递，类似于Android自身的广播。但又比广播使用起来方便的多的多。 如果我们想要一个广播来传递消息，我们要先在发射端定义一个Intent，然后putExtra什么的，再sendBroadcast，接收端也得注册一个BroadcastReceiver，又得添加Filter之类的，还得在onReceive
面试题之---EventBus源码解析
qq_38859786的博客
05-11 7816
(一)介绍 1,EvenetBus是一种发布-订阅事件总线.代码简洁,开销小,并很好的实现了发送者和接收者的解耦.(是一种观察者模式) 优点： 代码简单，速度快； 解耦； 体积小，jar大概50k; 稳定，大概有1亿+的应用中使用 2,三要素: A,Event:事件, B,Publisher:发布者,可以在任意线程发布事件 C,Subscrible:订阅者, 3,通常情况下安卓...
如何在Vue中创建一个全局的eventBus实例？
最新发布
09-14
在Vue中创建一个全局的eventBus实例，可以通过创建一个单独的Vue实例来实现，这个实例作为事件的中心，允许在任何组件之间进行事件的监听和触发。以下是创建全局eventBus实例的步骤： 1. 创建一个新的Vue实例，将其赋值给一个变量，例如`eventBus`，这个实例不需要挂载任何DOM元素，也不需要数据，只作为事件的中介。 ```javascript // event-bus.js import Vue from 'vue'; export const EventBus = new Vue(); ``` 2. 在组件中使用这个`eventBus`实例进行事件的监听和触发。为了代码的可维护性和复用性，通常会创建一个单独的文件来导出`eventBus`实例。 - 在需要触发事件的组件中： ```javascript import { EventBus } from './event-bus'; export default { methods: { sendMessage() { EventBus.$emit('message', 'Hello from component A!'); } } }; ``` - 在需要接收事件的组件中： ```javascript import { EventBus } from './event-bus'; export default { created() { EventBus.$on('message', (message) => { console.log(message); // 'Hello from component A!' }); }, beforeDestroy() { EventBus.$off('message'); } }; ``` 注意：在使用`$on`监听事件后，应当在组件销毁时使用`$off`来移除事件监听，以避免内存泄漏。 3. 在实际的项目中，`event-bus.js`文件可以放在`src`目录下的`utils`或`mixins`文件夹中，方便管理和复用。 使用eventBus可以非常方便地在Vue组件间进行通信，特别是对于简单的父子组件通信或跨级组件通信。但对于复杂的应用，建议使用Vuex来进行状态管理，以避免维护上的困难。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值