Android EventBus3.0+ 简单使用及源码讲解

前言

EventBus3.0之后添加了一项新功能——订阅者索引，该功能不是强制使用的，若是我们只导入implementation 'org.greenrobot:eventbus:3.1.1'是不能够使用索引的。该功能是在项目编译时生成索引文件，项目运行时执行这些文件，以达到提高运行速度的目的，因为在不使用索引功能情况下，使用的是反射，因此要耗时一些。
本文就主要分析EventBus在不使用索引功能的情况下的源码，最后稍微分析下索引功能的实现。

EventBus使用

方式

//发送对象
//Object obj = ...

//直接发送
EventBus.getDefault().post(obj)
//发送粘性事件
EventBus.getDefault().postSticky(obj)

以上是发送事件的方法，常见就这两种使用方式，可在任意线程使用。

//对象初始化时-注册
EventBus.getDefault().register(this)
//对象销毁时-解绑
EventBus.getDefault().unregister(this)

//实现一个方法，该方法接收想要的Event类型
//这里的MessageEvent自己定义的一种Event类型
@Subscribe(threadMode = ThreadMode.MAIN, sticky = true)
fun onRecived(even: MessageEvent) {
    tv_recived.text = even.message
}

这就是接收事件的使用方法，自定义一个方法，方法名任意，但是参数类型必须是我们想要接收的数据的类或者接口类型，再使用EventBus提供的注解去注释该方法:

• threadMode： 定义接收线程模型，例如MAIN是指当前方法在主线程中执行，默认是POSTING指与调用者保持在同一线程中（保证开销最小）。
• sticky：是否是粘性事件，即订阅者是否可以延时接收。
• priority：接收的优先级。

注意

1. 每次注册、使用之后，一定要注销。例如在一个活动中注册了，若未注销，那么在这个活动进入onStop()之后，仍然能够接收消息（当然包括粘性消息），若此时更新UI，就可能引发程序崩溃。
2. 发送事件之后，所有接收参数类型跟该事件类型相同的订阅方法都会被执行。

源码分析

订阅者注册

我们注意到我们订阅的方法是EventBus实现调用的，那它肯定要收集订阅的方法，因此我们从EventBus.register(this)注册开始分析源码，先弄懂它的注册的机制是怎样的。

    public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        List subscriberMethods = subscriberMethodFinder
                                                  .findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

这几句代码很清楚：
首先找到订阅者的所有订阅方法，放入List集合中，这里使用了SubscriberMethod对象来表示订阅方法，里面包含了method、eventType等字段，这里的eventType就是我们发送事件的对象类型，例如上面的MessageEvent类型。
然后是订阅List中的方法，在这个过程中要检查粘性事件是否发送给订阅者（发送粘性事件的实现）。

接着往下看，我们要找到订阅方法，需要去到SubscriberMethodFinder这个类中去看，它的findSubscriberMethods()方法：

    List findSubscriberMethods(Class subscriberClass) {
        //缓存中拿取
        List 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;
        }
    }

上面的代码就是使用索引查找和不使用索引查找，默认是使用索引查找。下面是findUsingInfo()方法

    private List findUsingInfo(Class subscriberClass) {
        //初始化FindState对象
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            findState.subscriberInfo = getSubscriberInfo(findState);
             //使用索引
            if (findState.subscriberInfo != null) {
                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();
        }
        //生成方法list，回收FindState对象
        return getMethodsAndRelease(findState);
    }

先介绍下新出现的FindState类，它就是一个中间变量，最后是会被回收的，当中主要包含着：

        //就是作为订阅者及其订阅方法的信息
        final List subscriberMethods = new ArrayList<>();
        final Map anyMethodByEventType = new HashMap<>();
        final Map subscriberClassByMethodKey = new HashMap<>();
        final StringBuilder methodKeyBuilder = new StringBuilder(128);

        Class subscriberClass;
        Class clazz;
        boolean skipSuperClasses;
        SubscriberInfo subscriberInfo;

而SubscriberMethod就是一个订阅方法类：

    //包含订阅方法的方法体、注解内容、参数类型
    final Method method;
    final ThreadMode threadMode;
    final Class eventType;
    final int priority;
    final boolean sticky;
    String methodString;

回到上面的方法中去，在索引功能不可用的情况下是进行findUsingReflectionInSingleClass(findState)方法：

private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            //反射拿到方法
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            //失败则使用另外一种方式获取
            methods = findState.clazz.getMethods();
            //跳过父类检索
            findState.skipSuperClasses = true;
        }
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            //要求是公开并只有一个参数的方法
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                Class[] parameterTypes = method.getParameterTypes();
                if (parameterTypes.length == 1) {
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                        Class eventType = parameterTypes[0];
                        //检查能否添加 
                        if (findState.checkAdd(method, eventType)) {
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            //将订阅方法加入进FindState的容器
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
                } 
            }
        }
    }

反射不用多说，这里的checkAdd()方法主要是FindState内部自己的检查，是否能够添加进去，就不贴代码了。最终实现的是将订阅方法全部放入FindState内部的subscriberMethods容器。

再次回到上面的findUsingInfo()方法中去，它的代码还没有执行完，应该执行到最后一步getMethodsAndRelease(findState)：

    private List getMethodsAndRelease(FindState findState) {
        //将订阅方法拿出
        List subscriberMethods = new ArrayList<>(findState.subscriberMethods);
        //释放findState，插入数组
        findState.recycle();
        synchronized (FIND_STATE_POOL) {
            for (int i = 0; i < POOL_SIZE; i++) {
                if (FIND_STATE_POOL[i] == null) {
                    FIND_STATE_POOL[i] = findState;
                    break;
                }
            }
        }
        return subscriberMethods;
    }

这个方法重要的地方在于findState的释放和回收，POOL_SIZE默认是4，那么之前findState的初始化也是优先考虑FIND_STATE_POOL中不为空元素。
到此，我们终于拿到了订阅者中的所有订阅方法，接下来应该回到最上面的register()方法中，继续往下看for (SubscriberMethod subscriberMethod : subscriberMethods) subscribe(subscriber, subscriberMethod);将每一个方法进行订阅：

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;
        //生成订阅者
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions == null) {
            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;
            }
        }

        //投入容器
        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);

        //针对粘性事件，是否post事件出去
        if (subscriberMethod.sticky) {
            //事件类型是否有继承类型
            if (eventInheritance) {
                Set, Object>> entries = stickyEvents.entrySet();
                for (Map.Entry, Object> entry : entries) {
                    Class candidateEventType = entry.getKey();
                    //若事件类型是key类型或者父类类型的话
                    if (eventType.isAssignableFrom(candidateEventType)) {
                        Object stickyEvent = entry.getValue();
                        //post 实现粘性事件
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                    }
                }
            } else {
                Object stickyEvent = stickyEvents.get(eventType);
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
    }

这一大段代码实现的功能很简单，就是将订阅方法投入EventBus的订阅方法容器中去，并在最后判断粘性事件则post一次。
这里的CopyOnWriteArrayList是一种可在并发条件下操作的容器，它在每次操作时都会将数组拷贝一份出去，进行操作，所以它在并发条件下不用加锁。
最后的粘性事件的实现其实很简单：在当前的对象实现订阅者注册时，EventBus检测到某个注册方法是允许接收粘性事件，它就调用stickyEvents.get(eventType);拿到对应事件类型的事件，并单独为这个newSubscriptionpost一次，将该事件单独发送给它，也就是checkPostStickyEventToSubscription(newSubscription, stickyEvent)这句代码。

发起者post

先讲postSticky()，因为它就比post()方法多了一行代码stickyEvents.put(event.getClass(), event)，当然是加了线程锁的，就是将该事件投递进粘性事件的容器里面去。
再讲post()方法：

public void post(Object event) {
        PostingThreadState postingState = currentPostingThreadState.get();
        List