EventBus使用总结

概述

EventBus是Android开发最常用的一个库了，它给我们带来了很好便利性，轻松实现消息的发布和订阅。但凡事都有两面性，合理的使用就是好事，不合理的使用可能就会有各种问题了，下面我们来看看它的源码实现。

源码分析

EventBus使用简单，注册反注册发送监听都非常简单，易上手。来看一下它的使用吧。

注册：EventBus.getDefault().register(this);
发布：EventBus.getDefault().post(event);
反注册：EventBus.getDefault().unRegister(this);

先看看EventBus的getDefault方法

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

就是获取EventBus实例，这里用的是全局单例，方便使用。

再看看register方法的实现

    public void register(Object subscriber) {
        // 获取观察者的类型
        Class subscriberClass = subscriber.getClass();
        // 通过subscriberMethodFinder找到这个观察者里所有的监听方法
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            // 把类和监听的方法关联起来，放在map中，后续有事件时才能找到对应关系触发监听方法
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

一起看一下subscriberMethodFinder是怎么打到观察者里的监听方法的

    List findSubscriberMethods(Class subscriberClass) {
        // 先从Cache里找，如果有对应关系了直接返回，没有则去建立对应关系
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        // 这里有个判断，是否忽略编译时用工具生成的index文件
        // EventBus有一个工具可以在编译期间就把观察者和注解的监听方法关联起来，生成一个java文件，避免运行时通过反射进行查找，加快了运行速度，提高性能
        if (ignoreGeneratedIndex) {
            // 通过反射的方式去找到所有注解的监听方法
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            // 通过编译生成的java文件进行查找
            subscriberMethods = findUsingInfo(subscriberClass);
        }
        if (subscriberMethods.isEmpty()) {
            throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
        } else {
            // 找到后put到cache里
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

代码通过注释说清楚了监听方法的过程，通过反射就是找使用了@Subscribe注解的函数，并读取其中的配置，比如threadMode等，更于后面发送事件时使用。这里就不贴反射的具体代码了。

要说的就是SubscriberMethod类了，看看这里有哪些成员变量：

public class SubscriberMethod {
    final Method method; //方法，用于反射回调的
    final ThreadMode threadMode; //指定的线程
    final Class eventType; //事件的类型，后续要通过这个找相关的监听方法
    final int priority; //优先级
    final boolean sticky; //是否接收粘性事件
}

找到所有监听的方法后，会通过subscribe方法进行关联，来看具体实现：

    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;
        // Subscription是监听方法subscriberMethod和观察者subscriber绑定关系，用于后面反射调用方法的
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        // subscriptions是此监听方法中的事件类型对应的所有subscriptions，是以事件类型为key的
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
        // 如果不存在则新建一个，再把新找到的SubscriberMethod添加进去，这样后面发送此事件类型时它才能被触发
        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);

        // 如果方法是支持粘性事件的，就会从粘性事件缓存里找到最近一次的事件，直接通过checkPostStickyEventToSubscription进行事件发送
        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).
                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 = stickyEvents.get(eventType);
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
    }

总结下注册的逻辑：

1. 找到观察者里所有的监听方法
2. 循环把所有监听方法和事件类型的关系保存下来
3. 如果支持粘性事件就找最近一次同类型事件进行发送

再来看下发送的源码实现;

先看下相关的类说明：

 /** For ThreadLocal, much faster to set (and get multiple values). */
    final static class PostingThreadState {
        final List