EventBus源码分析

本篇文章将从EventBus的常用使用步骤去逐步分析它的源码和内部实现，其中会额外提到粘性事件、观察者模式和接口回调的区别以及EventBus线程调度相关知识。

下面就从以下的使用流程去逐步分析EventBus的源码。

初始化->注册->发送事件->解除注册

初始化

使用EventBus时我们一般通过调用getDefault来获取EventBus对象，EventBus的获取实例方法仍然是一个单例来实现，再继续看，发现是熟悉的双重锁，但是接下来的构造函数和我们通常写的会有不同，们一我般会把构造函数用private封闭，但是这里并没有修改修饰符，而是直接调用了它的有参构造函数，传入一个builder进行构造，接着就成功完成了EventBus的初始化。

这里之所以不修改修饰符，源码注释里也给了说明

Creates a new EventBus instance; each instance is a separate scope in which events are delivered.To use a central bus, consider {@link #getDefault()}.

    //双重锁单例
    public static EventBus getDefault() {
        if (defaultInstance == null) {
            synchronized (EventBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();
                }
            }
        }
        return defaultInstance;
    }

    //这里并没有对构造函数封闭，和一般的单例不同，它允许直接调用构造函数创建实例
    //this调用它自己的有参构造函数，并把DEFAULT_BUILDER当参数传入
    public EventBus() {
        this(DEFAULT_BUILDER);
    }

    //默认builder
    private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();

    //使用建造者模式 创建不同的EventBus实例
    EventBus(EventBusBuilder builder) {
        logger = builder.getLogger();
        ...
    }

注册

首先使用反射方法获取到传入对象的类型，接着通过subscriberMethodFinder的查找方法去寻找该订阅者希望订阅的方法，接着锁住当前实例，不断去遍历刚才找出的方法，调用subscribe去进行订阅。

所以整个注册过程就是 找出想要订阅的方法->为当前对象类型订阅这些方法。

希望订阅的方法：我把如下这类似方法在当前阶段称为希望订阅的方法是因为在这时，这些方法并没有成功进行订阅，在执行EventBus中的订阅逻辑后才能将其称为订阅方法。

@Subscribe(threadMode = ThreadMode.MAIN)
public void XXX(MessageEvent messageEvent) {
    ...
}

注册逻辑： 

    public void register(Object subscriber) {
        //首先获取到传入的对象的类型
        Class subscriberClass = subscriber.getClass();
        //找出当前订阅者订阅了的所有方法并存入集合
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            //遍历刚找出的方法 依次进行订阅
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

    "其中SubscriberMethod记录了以下几种信息"
    包括线程模式、对象类型、优先级、粘性等
    final Method method;
    final ThreadMode threadMode;
    final Class eventType;
    final int priority;
    final boolean sticky;

简单了解了下它的注册方法，接着我们去看看它是怎样找出订阅方法的还有就是怎么进行订阅的，这就对应着findSubscriberMethods 和 subscribe 这两个方法。

• findSubscriberMethods ：

    //方法缓存（使用的是ConcurrentHashMap以键值对的形式存入Map，key为传入对象类型，value为方法list）
    private static final Map, List> METHOD_CACHE = new ConcurrentHashMap<>();    

    List findSubscriberMethods(Class subscriberClass) {
        //首先直接从缓存中去获取传入对象类型的相关订阅方法
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        //如果方法列表不为空直接返回
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        if (ignoreGeneratedIndex) {
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            subscriberMethods = findUsingInfo(subscriberClass);
        }
        //如果注册方法为空则抛出异常（说明没有用@Subscribe注解，或者没有订阅方法）
        //如果有的话则将其放入METHOD_CACHE中
        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的值来判断用哪个方法去查找订阅方法，接着就将查找到的方法放入方法缓存list里面。

在上面findSubscriberMethods中其实是有两类找出subscriberMethods的方法，一类是从METHOD_CACHE中去查找Map当中是否已经存有注册方法，第二类就是通过反射用那两种方法去找，但实际上都会调用到findUsingReflectionInSingleClass去查找相关订阅方法。

首先看下findUsingReflection方法 

    private List findUsingReflection(Class subscriberClass) {
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            //调用查找订阅方法的方法
            findUsingReflectionInSingleClass(findState);
            //依次获取该class的父类，向上遍历并且向上move的过程会跳过系统class
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }

    void moveToSuperclass() {
            if (skipSuperClasses) {
                clazz = null;
            } else {
                clazz = clazz.getSuperclass();
                String clazzName = clazz.getName();
                /** Skip system classes, this just degrades performance. */
                if (clazzName.startsWith("java.") || clazzName.startsWith("javax.") || clazzName.startsWith("android.")) {
                    clazz = null;
                }
            }
        }

在上述findUsingReflection当中，我们能够看到非常关键的一点，那就是EventBus支持事件订阅的继承。

接着在findUsingReflectionInSingleClass这个方法当中，整个过程是通过反射去判断方法是否符合“要求”，包括作用域（public）、形参长度、是否有注解 ，在经过一系列的判断之后将所有满足条件的method存入subscriberMethods这个ArrayList当中。

    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) {
            "判断作用域（是否为public）"
            //先获取该方法的修饰符如果为public且不为abstract、static才能通过筛选
            int modifiers = method.getModifiers();
            //按位与操作符相同为1不同为0
            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) {
                        //取得Event事件，调用checkAdd进行判断
                        "下面的checkAdd源码"
                        Class eventType = parameterTypes[0];
                        if (findState.checkAdd(method, eventType)) {
                            //获取到当前注解指定的线程模式（threadMode）
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            //将这个订阅方法加入ArrayList中存储
                            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");
            }
        }
    }


    //这个检测方法主要由两级检测，第一级速度快，单纯的对event的类型进行检测
    //第二级是对其签名的检测
    boolean checkAdd(Method method, Class eventType) {
            // 2 level check: 1st level with event type only (fast), 2nd level with complete signature when required.
            // Usually a subscriber doesn't have methods listening to the same event type.
            Object existing = anyMethodByEventType.put(eventType, method);
            if (existing == null) {
                return true;
            } else {
                if (existing instanceof Method) {
                    if (!checkAddWithMethodSignature((Method) existing, eventType)) {
                        // Paranoia check
                        throw new IllegalStateException();
                    }
                    // Put any non-Method object to "consume" the existing Method
                    anyMethodByEventType.put(eventType, this);
                }
                return checkAddWithMethodSignature(method, eventType);
            }
        }

接着是findUsingInfo这个方法

    private List findUsingInfo(Class subscriberClass) {
        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();
        }
        return getMethodsAndRelease(findState);
    }

到现在，我们已经找出了该对象（如：activity）所有订阅方法（根据作用域、形参数量、注解等筛选出的），接着我们要做的就是将这些方法进行订阅（subscribe）。

• subscribe方法

    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;
        //将所有的观察者和订阅方法封装成一个subscription对象
        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();
        //根据方法的优先级来让其加入到subscription列表当中
        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);

        "对sticky的event的处理"
        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);
            }
        }
    }

在subscribe方法中，我们看到了EventBus对粘性事件（Sticky = true）的处理，所以这里有必要提一下粘性事件相关概念。我们看其中的逻辑，都调用了checkPostStickyEventToSubscription方法，接着跟进这个方法，我们看到的是postToSubscription这个在发送过程中起关键作用的代码，事件发送（post）我们等下再分析，但是我们必须弄清楚为什么在注册过程当中，一般事件都是将其存入事件列表就行了，为什么粘性事件在注册阶段就进行了事件发送的操作。所以我们得首先了解什么是粘性事件，以及为什么需要此类事件。

粘性事件：

粘性事件和一般的事件有所不同，普通的事件通常是先注册再发布，而粘性事件一般是先发布再订阅。那么为什么会需要用到粘性事件呢？设想一个例子，我们要从Activity A往Activity B发送事件，让B根据A的消息执行相关逻辑，那么在这个例子当中，我们的B就是一个订阅者，A就是发布者，但如果B这个订阅者在A发布之后还未启动，那它是收不到这个消息的，所以粘性事件的存在就解决了这个问题，反正我这个事件先发布在这里，你有空了就来订阅就行，所以粘性事件也是解决了这种常见的问题。

所以，我们在了解了粘性事件的作用和工作原理之后，我们再来看注册这里的代码就能够理解了，就对应着上面那句话“为什么粘性事件在注册阶段就进行了事件发送的操作”，我们看上面的代码对粘性事件的处理部分可以发现，它首先取出了所有的粘性事件，因为它不知道你要的是哪一个粘性事件，所以得全部取出来遍历去判断，如果判断成功之后呢，这里就进入到了普通事件到发布阶段要做的操作，所以也就能理解为什么粘性事件在注册阶段就完成了事件的发送。

在执行完了subscribe方法之后，我们就相应的完成了事件的订阅。

接着进入更为关键的事件发送（post）流程。

发送事件

 我们还是从使用去看，以下是最简单的post event的代码。

EventBus.getDefault().post(messageEvent);

 在事件发送的这个过程当中

    public void post(Object event) {
        //PostingThreadState当中维护了线程相关参数
        //currentPostingThreadState是一个Thread Local，这里对于Thread Local而言设置和读取都快很多
        PostingThreadState postingState = currentPostingThreadState.get();
        List