Android 注解系列之 EventBus3 原理（四）

bus.jpg

前言

在之前的文章 Android 注解系列之APT工具（三） 中，我们介绍了 APT 技术的及其使用方式，也提到了一些知名的开源框架如 Dagger2、ButterKnife、EventBus 都使用了该技术。为了让大家更好的了解 APT 技术的使用，在接下来的文章中我将会着重带领大家来了解 EventBus 中 APT 技术的使用，在了解该知识之前，需要我们对 EventBus 内部原理较为熟悉，如果你已经熟悉其内部机制了，可以跳过该篇文章，直接阅读 Android 注解系列之EventBus3 “加速引擎“（五）。

阅读该篇文章，我们能够学到如下知识点：

• EventBus3 内部原理
• EventBus3 订阅与发送消息原理
• EventBus3 线程切换的原理
• EventBus3 粘性事件的处理

整篇文章结合 EventBus 3.1.1 版本进行讲解。

EventBus 简介

EventBus 对于 Android 程序员来说应该不是很陌生，它是基于观察者模式的事件发布/订阅框架，我们常常用它来实现不同组件的通讯，后台线程通信等。

EventBus-Publish-Subscribe.png

虽然 EventBus 非常简单好用，但是还是会因为 EventBus 满天飞，使程序代码结构非常混乱，难以测试和追踪。即使 EventBus 有很多诟病，但仍然不影响我们去学习其中的原理与编程思想~

大概流程

在了解 EventBus 内部原理之前，我们先了解一下 EventBus 框架的一个大概流程。如下图所示：

EventBus粗暴理解.jpg

上图中绿色为订阅流程，红色为发送事件流程，大家可以结合上图，来理解源码。

在上图中我们在 A.java 中订阅了事件 AEvent，在 B.java 中订阅了事件 AEvent 与 BEvent，下面我们来分析 EventBus 中注册与事件发送的两个流程，在介绍两个流程之前，先介绍一下 Subscription 与 SubscriberMethod 中所包含的内容。

Subscription 类中包含以下内容：

• 当前注册对象
• 对应订阅方法的封装对象 SubscriberMethod

SubscriberMethod 类中包含以下内容：

• 包含 @Subscribe 注解的方法的 Method (java.lang.reflect 包下的对象)。
• @Subscribe 注解中设置的线程模式 ThreadMode
• 方法的注册的事件类型的 Class 对象
• @Subscribe中设置的优先级 priority
• @Subscribe中设置事件是否是粘性事件 sticky

注册流程

当我们通过调用 EventBus.register() 注册 A、B 两个对象时，EventBus 会做以下几件事件：

• 通过内部的 SubscriberMethodFinder 来获取 A、B类中含有 @Subscribe 注解的方法，并将该注解中的内容与对应方法封装为 SubscriberMethod 对象。然后再将当前订阅对象与对应的 SubscriberMethod 再封装为 Subscription 对象。
• 将所有的 Subscription 放在名为 subscriptionsByEventType 类型为 Map, CopyOnWriteArrayList> 数据结构（key 为事件类型的 Class 对象） 中，因为 Subscription 对象内部包含 SubscriberMethod， 那么就能知道订阅的事件类型，所以我们可以根据事件类型来区分 Subscription ，又因为相同事件可以被不同订阅者中的方法来订阅，所以相同类型的事件也就以对应不同的 Subscription。
• 将订阅者中的所有订阅的事件都封装在名为 typesBySubscriber 类型为 Map>>数据结构（key 为订阅对象，value 为该对象订阅的事件类型 Class 对象）。该集合主要用于取消订阅，在下文中我们会进行介绍。

在整个注册流程中，最主要的流程就是 EventBus 通过 SubscriberMethodFinder 去获取类中包含 @Subscribe 注解的订阅方法。在 EventBus 3.0 之前该流程一直都是通过反射的方式去获取。在 3.0 及以后版本，EventBus 采用了 APT 技术，对 SubscriberMethodFinder 查找订阅方法流程进行了优化，使其能在 EventBus.register() 方法调用之前就能知道相关订阅事件的方法，这样就减少了程序在运行期间使用反射遍历获取方法所带来的时间消耗。在下文中我们也会指出具体的优化点。

事件发送流程

知道了 EventBus 的注册过程，再来了解事件的发生流程就非常简单了。因为我们已经通过 subscriptionsByEventType 存储事件对应的 Subscription，只要找到了 Subscription ，那么我们就能从 Subscription 拿到订阅事件的对象 subscriber ，以及对应的订阅方法 Method (java.lang.reflect 包下的对象)。然后通过反射调用：

Subscription 内部包含订阅者及 SubscriberMethod（内部包含订阅方法 Method )

 method.invoke(subscription.subscriber, event)

通过上述方法，就能将对应事件发送到相关订阅者了。当然这里只是简单的介绍了事件是如何发送到相关订阅者的。关于 EventBus 中粘性事件的处理，线程如何切换。会在下文中进行详细介绍。

源码分析

在了解了 EventBus 的内部大概流程后，现在我们通过源码来更深层次的了解其内部实现。还是从订阅过程与事件的发送两个过程进行讲解。

订阅过程源码分析

EventBus 的订阅入口为 register() 方法，如下所示：

  public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        //流程1：获取对应类中所有的订阅方法
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            //流程2：实际订阅
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

在该方法中，主要涉及到 SubscriberMethodFinder 查找方法与实际订阅两个流程，下面我们会对这两个流程进行介绍。

SubscriberMethodFinder 查找方法流程

在该流程中，主要通过 SubscriberMethodFinder 去获取订阅者中所有的 SubscriberMethod ，我们先看 findSubscriberMethods() 方法：

    List findSubscriberMethods(Class subscriberClass) {
        //从缓存中获取订阅者中的订阅方法，如果有则读缓存，如果没有进行查找
        List subscriberMethods = (List)METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        } else {
            if (this.ignoreGeneratedIndex) {//如果忽略索引类，则使用反射。
                subscriberMethods = this.findUsingReflection(subscriberClass);
            } else {//否则使用索引类
                subscriberMethods = this.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;
            }
        }
    }

该方法的逻辑也非常简单，为如下几个步骤：

• 步骤1：先从缓存( METHOD_CACHE )中获取订阅者对应的 SubscriberMethod（订阅方法) ，如果有则从缓存中取。
• 步骤2：如果缓存中没有，则通过布尔变量 ignoreGeneratedIndex，来判断是直接使用反射获取订阅方法，还是通过索引类(EventBus 3.0 使用APT 增加的类）来获取。因为 ignoreGeneratedIndex 默认值为 false ，则默认会走 findUsingInfo() 方法
• 步骤3：将步骤2中获得的订阅方法集合，存储到缓存中，方便下一次获取，提高效率。

因为默认会走 findUsingInfo() 方法，我们继续查看该方法：

    private List findUsingInfo(Class subscriberClass) {
        //步骤1：构建了查询状态缓存池，最多缓存4个类的查询状态
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            //步骤2，获取查找状态对应的订阅信息，这里EventBus 3.0 使用了索引类，
            findState.subscriberInfo = getSubscriberInfo(findState);
            if (findState.subscriberInfo != null) {
                SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
                for (SubscriberMethod subscriberMethod : array) {
                    //将订阅者的所有的订阅方法添加到FindState的集合中
                    if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                        findState.subscriberMethods.add(subscriberMethod);
                    }
                }
            } else {//步骤3：如果订阅信息为null，则通过反射来获取类中所有的方法
                findUsingReflectionInSingleClass(findState);
            }// 继续查找父类的方法
            findState.moveToSuperclass();
        }
        //步骤4，获取findState中的所有方法，并清空对象池
        return getMethodsAndRelease(findState);
    }

• 步骤1：创建与订阅者相关的 FindState 对象。会从 FinState 对象缓存池(最大为4个)中获取，一个订阅者对象对应一个FindState，一个订阅者对象对应一个或多个订阅方法。
• 步骤2：通过 FindState 对象 调用 getSubscriberInfo() 方法去获取订阅者相关的订阅方法信息。该方法使用了 APT 技术，构建了EventBus的索引类。关于具体的优化，会在下篇文章中 Android 注解系列之EventBus3 “加速引擎“（五）进行描述，大家这里有个印象就好了。
• 步骤3：如果通过步骤2获取不到订阅方法信息，则通过反射来获取类中的所有的订阅方法。并将获取的方法，封装到 FindState 中的 subscriberMethods 集合中去。
• 步骤4：将 FindState 对象中的 subscriberMethods 集合返回。

在上述方法中，我们需要注意的是，如果当前订阅着没有相关的订阅方法，那么会依次遍历其父类的订阅方法。还有一个知识点，就是该方法中 FindState 使用了 对象缓存池，不会每次注册一个订阅者就创建 一个FindState 对象。这样就节约了内存的使用。

关于索引类的知识点，会在下篇文章中进行介绍，这里我们直接查看 findUsingReflectionInSingleClass() 方法：

  private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
             //获取当前订阅者中的所有的方法
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            //获取该类的所有public 方法 包括继承的公有方法
            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }
        //循环遍历所有的方法，通过相关注解找到相应的订阅方法。
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            //满足修饰符为 public 并且非抽象、非静态
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                Class[] parameterTypes = method.getParameterTypes();
                //找到参数为1，且该方法包含Subscrile注解的方法
                if (parameterTypes.length == 1) {
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                        Class eventType = parameterTypes[0];
                        if (findState.checkAdd(method, eventType)) {
                            // 创建订阅方法对象，并将对应方法对象，事件类型，线程模式，优先级，粘性事件封装到SubscriberMethod对象中。
                            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”);
            }
        }
    }

该方法的逻辑也非常简单，通过获取 FindState 中的订阅者的 Class 对象，然后通过反射获取所有包含 @Subscribe 注解且参数为 1 的 Method 对象，并读取到该参数的类型EventType，接着读取注解中的 thredMode、priority、sticy，最后将这些数据都统一分装到新建的SubscriberMethod 对象中，最后将该对象添加到 FindState 中的 subscriberMethods 集合中去。

实际订阅方法 subscribe

当找到订阅者所有的方法集合后，最终会遍历调用 subscribe() 方法，查看该方法：

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;

        //步骤1，将每个订阅方法和订阅者封装成Subscription
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);

        //步骤2，获取对应事件中所有的 Subscription，判断是否重复添加
        CopyOnWriteArrayList subscriptions = (CopyOnWriteArrayList)this.subscriptionsByEventType.get(eventType);
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList();
            this.subscriptionsByEventType.put(eventType, subscriptions);
        } else if (subscriptions.contains(newSubscription)) {
            throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event " + eventType);
        }

        //步骤3，根据优先级，将当前新封装的Subscription对象添加到subscriptionsByEventType中去
        int size = subscriptions.size();
        for(int i = 0; i <= size; ++i) {
            if (i == size || subscriberMethod.priority > ((Subscription)subscriptions.get(i)).subscriberMethod.priority) {
                subscriptions.add(i, newSubscription);
                break;
            }
        }

       //步骤4，将当前订阅者中与当前订阅者所订阅的事件类型，添加到typesBySubscriber中去
        List> subscribedEvents = (List)this.typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList();
            this.typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);

        //步骤5，如果该方法有订阅了粘性事件，则从stickyEvents中获取相应粘性事件，并发送
        if (subscriberMethod.sticky) {
            if (eventInheritance) {
                Set, Object>> entries = stickyEvents.entrySet();
                for (Map.Entry, Object> entry : entries) {
                    Class candidateEventType = entry.getKey();
                    if (eventType.isAssignableFrom(candidateEventType)) {
                        Object stickyEvent = entry.getValue();
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                    }
                }
            } else {
                Object stickyEvent = this.stickyEvents.get(eventType);
                this.checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }

    }

在上述方法中主要流程如下：

• 步骤1，将每个订阅方法和订阅者封装成 Subscription。
• 步骤2，获取对应事件中所有的 Subscription ，判断是否重复添加。
• 步骤3，根据 优先级，将当前新封装的 Subscription 对象添加到 subscriptionsByEventType 中去。(设置了优先级后，EvenBus 就可以按照优先级顺序，将事件发送给订阅者)
• 步骤4，将当前订阅者中与当前订阅者所订阅的事件类型，添加到 typesBySubscriber 中去。
• 步骤5，如果该方法有订阅了粘性事件，则从 stickyEvents 中获取相应粘性事件，并发送。

再结合我们最开始所画的 EventBus 大致流程，该方法其实就做了下图红色虚线框中的事：

subscribe()实际做的事.jpg

关于粘性事件的知识点，需要我们了解事件的发送流程，我们会在下文进行详细介绍。

事件发送流程源码分析

事件的发送，主要分为简单事件与粘性事件，分别对应方法为 post() 与 postSticky() 两个方法。这里我们先看简单事件的发送，代码如下:

简单事件的发送

  public void post(Object event) {
     //步骤1，获取当前线程中独立拥有的PostingThreadState，并从中获取事件队列（eventQueue），将发送的事件添加到该队列中
        EventBus.PostingThreadState postingState = (EventBus.PostingThreadState)this.currentPostingThreadState.get();
        List