EventBus源码分析

相信大家都有在项目中使用过EventBus。EventBus是一个性能高效的基于观察者模式的事件发布与订阅框架。借助EventBus，我们只需几行代码便能实现组件之间、线程之间的通信，达到解耦的目的。

这篇文章不对EventBus的使用进行介绍，而是格物致知，探究EventBus的源码。

1. 入口

一般使用时是通过EventBus.getDefault()来调用注册、发布与注销的方法。因此，我们从getDefault()这个入口开始分析。

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

这里使用了双重检验锁(单例模式的一种实现方式)的来保证EventBus实例的唯一性。接着进入构造函数看看：

public EventBus() {
    this(DEFAULT_BUILDER);
}

EventBus(EventBusBuilder builder) {
    subscriptionsByEventType = new HashMap<>();
    typesBySubscriber = new HashMap<>();
    stickyEvents = new ConcurrentHashMap<>();
    mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
    backgroundPoster = new BackgroundPoster(this);
    asyncPoster = new AsyncPoster(this);
    indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
    subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
            builder.strictMethodVerification, builder.ignoreGeneratedIndex);
    logSubscriberExceptions = builder.logSubscriberExceptions;
    logNoSubscriberMessages = builder.logNoSubscriberMessages;
    sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
    sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
    throwSubscriberException = builder.throwSubscriberException;
    eventInheritance = builder.eventInheritance;
    executorService = builder.executorService;
}

在无参构造函数内调用了带有EventBusBuilder参数的构造函数，这里使用了Builder模式，将参数的构建过程交给EventBusBuilder。Builder模式是一种常见的设计模式，例如在sdk开发中参数过多时，将参数的构建过程交给Param：

Param param = Param.instance().param1(value1).param2(value2)......;
SDK.init(context, param);

在EventBus的构造函数内，进行了初始化的工作。这些参数的含义对后面的分析很重要，这里简单介绍下这些属性的作用：

• subscriptionsByEventType：以EventType(Event对象的Class类)为key，Subscription(订阅者以及一个订阅方法)数组为value。根据EventType可以查询到相应的订阅者及订阅方法。
• typesBySubscriber：以Subscriber(订阅者，即调用register方法的类)为key，EventType数组为value。根据订阅者可以查询到它订阅的所有事件。
• stickyEvents：以EventType为key，Event为value。用来保存粘性事件。
• mainThreadPoster、backgroundPoster、asyncPoster：EventBus支持四种ThreadMode，POSTING、MAIN、BACKGROUND、ASYNC。POSTING直接在发布事件的线程处理，这三个poster分别用来支持剩下的三种Mode。
• indexCount：索引类数目，索引类指的是EventBus利用注解处理器生成的保存订阅者信息的类。如果lib中也用了EventBus，就可能存在多个索引类。
• subscriberMethodFinder：查找及缓存订阅者信息的类。
• logSubscriberExceptions：当事件处理过程发生异常时是否打印日志，默认为true。
• logNoSubscriberMessages：当事件没有订阅者订阅时是否打印日志，默认为true。
• sendSubscriberExceptionEvent：当事件处理过程发生异常时是否发送SubscriberExceptionEvent，默认为true。当为true时，订阅者可以订阅SubscriberExceptionEvent事件。
• sendNoSubscriberEvent：当事件没有订阅者订阅时是否发送NoSubscriberEvent，默认为true。当为true时，订阅者可以订阅NoSubscriberEvent事件。
• throwSubscriberException：当事件处理过程发生异常时是否抛出EventBusException，默认为false。
• eventInheritance：是否支持事件继承，默认为true。当为true时，post一个事件A时，若A是B的子类或者A实现了接口B，订阅B的订阅者也能接收到事件。
• executorService：线程池，负责线程调度。

因此，通过EventBus.getDefault()我们就可以得到一个默认配置的EventBus单例，也支持通过EventBusBuilder来自定义配置。

2. 注册订阅者

接下来看下通过EventBus.getDefault().register()注册订阅者时发生了什么？

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

当注册订阅者时，会通过SubscriberMethodFinder的findSubscriberMethods来获取SubscriberMethod数组，SubscriberMethod保存了订阅方法的信息。打开SubscriberMethod可以发现一点，在SubscriberMethod有Method对象以及methodString，其实methodString也是通过method反射获取到的，这里利用一个变量保存起来，避免每次都通过反射获取降低性能。类似的，在EventBus其实还有很多这种细微的优化。

得到SubscriberMethod数组后，依次进行注册。先看看获取到SubscriberMethod数组后，是如何通过subscribe进行订阅的：

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);

    // 粘性事件处理, 将在第五小节分析
}

3-30行容易理解，主要是将EventType -> Subscription的映射加入到subscriptionsByEventType，将Subscriber -> EventType的映射与加入到typesBySubscriber中。subscriptionsByEventType里每个事件的Subscription是按照优先级排序的，优先级高的订阅者可以中途通过cancelEventDelivery来拦截。

31行后面部分的代码部分涉及到粘性事件，将在第五小节中分析。

回过头看看findSubscriberMethods是如何获取到SubscriberMethod数组的：

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;
    }
}

在findSubscriberMethods方法内，如果METHOD_CACHE中没有的话才进行查找的工作。然后根据ignoreGeneratedIndex判断查找的方式。

EventBus3.0里使用了一项“秘密武器”使得效率大大提升，这个武器其实就是之前文章里提过的注解处理器。如果ignoreGeneratedIndex是false的话，就采用注解处理器生成索引类去获取SubscriberMethod；否则采用反射的方式。

• butterknife源码分析：如何处理注解—反射与注解处理器
  http://blog.csdn.net/u012933743/article/details/54972050

2.1. 索引获取SubscriberMethod

ignoreGeneratedIndex默认为false，因此会调用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);
}

在findUsingInfo开始时，会通过prepareFindState获取FindState对象，FindState保存了在查找SubscriberMethod时的一些属性，并封装了检验合法性的方法。prepareFindState里从对象池FIND_STATE_POOL里取一个已经创建好的对象，然后通过initForSubscriber去初始化。这也是一个细微的优化，利用对象池避免了频繁的对象创建。

private FindState prepareFindState() {
    synchronized (FIND_STATE_POOL) {
        for (int i = 0; i < POOL_SIZE; i++) {
            FindState state = FIND_STATE_POOL[i];
            if (state != null) {
                FIND_STATE_POOL[i] = null;
                return state;
            }
        }
    }
    return new FindState();
}

得到FindState后，先通过getSubscriberInfo获取订阅者信息SubscriberInfo：

private SubscriberInfo getSubscriberInfo(FindState findState) {
    if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
        SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
        if (findState.clazz == superclassInfo.getSubscriberClass()) {
            return superclassInfo;
        }
    }
    if (subscriberInfoIndexes != null) {
        for (SubscriberInfoIndex index : subscriberInfoIndexes) {
            SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
            if (info != null) {
                return info;
            }
        }
    }
    return null;
}

在getSubscriberInfo方法内，第一个判断其实进不去，因为findState.subscriberInfo.getSuperSubscriberInfo()始终返回null。然后直接SubscriberInfoIndex的getSubscriberInfo来获得订阅者信息SubscriberInfo。SubscriberInfoIndex就是采用注解处理器生成的索引类，包含了订阅者及其订阅方法的信息。

回到刚刚findUsingInfo的方法，得到SubscriberInfo后，获取订阅者内的SubscriberMethod数组。对于每个SubscriberMethod，调用FindState的checkAdd进行检验，如果检验通过的话，加入到FindState的subscriberMethods内。看看checkAdd方法对什么进行检验？

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);
    }
}

private boolean checkAddWithMethodSignature(Method method, Class eventType) {
    methodKeyBuilder.setLength(0);
    methodKeyBuilder.append(method.getName());
    methodKeyBuilder.append('>').append(eventType.getName());

    String methodKey = methodKeyBuilder.toString();
    Class methodClass = method.getDeclaringClass();
    Class methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
    if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
        // Only add if not already found in a sub class
        return true;
    } else {
        // Revert the put, old class is further down the class hierarchy
        subscriberClassByMethodKey.put(methodKey, methodClassOld);
        return false;
    }
}

checkAdd方法第一步先检验之前否有订阅过同一个EventType，如果有，在checkAddWithMethodSignature里再进一步检查key为methodName>eventTypeName的字符串是否存在。这里也是一个优化点，利用第一步检查，多数情况下避免了第二步利用了反射去获取methodName>eventTypeName对应的key。

通过这个校验我们知道两点：
① 允许一个类有多个方法名不同的方法对同个事件进行订阅。
② 如果子类重载了父类的订阅方法，以子类的为准。在checkAddWithMethodSignature检查method>eventTypeName时，如果methodClassOld为null或者methodClassOld为method为父类或本身时才返回true，说明子类重载这个订阅方法时，以子类的为准。

很多人认为在寻找SubscriberMethod时，是从子类到父类的，那isAssignableFrom似乎一直返回false，那意义是什么？其实这个作用主要发挥在反射时的，将在反射时介绍。

如果返回的SubscriberInfo为null的话，说明没有索引类。因此findUsingReflectionInSingleClass使用效率较低的反射方式。找到SubscriberMethod后，通过moveToSuperclass一层层向上寻找。最后getMethodsAndRelease重置FindState内的临时变量，并放置到对象池中。

2.2. 反射获取SubscriberMethod

如果ignoreGeneratedIndex为true时，采用反射的方式获取SubscriberMethod。而且如果使用了EventBus3.0，却不配置使用索引类，这样其实最后都会“降级”为反射。

值得注意的是，如果采用EventBus3.0却不使用注解处理器的方式效率是比EventBus2.4还要低的。因为EventBus2.4是固定订阅方法名为onEvent+ThreadMode的形式，而3.0方法名是自定义的，需要添加@Subscribe注解，相比之下多了反射获取注解的时间。

private List findUsingReflection(Class subscriberClass) {
    FindState findState = prepareFindState();
    findState.initForSubscriber(subscriberClass);
    while (findState.clazz != null) {
        findUsingReflectionInSingleClass(findState);
        findState.moveToSuperclass();
    }
    return getMethodsAndRelease(findState);
}

采用反射方式SubscriberMethod的流程也差不多，调用findUsingReflectionInSingleClass获取此类的SubscriberMethod后，一层层向上。最后释放FindState内的临时变量，并放置到对象池中。

看看如何通过findUsingReflectionInSingleClass获取一个类的SubscriberMethod：

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;
    }
    // 遍历Method，寻找包含@Subscribe注解的方法，并对合法性进行检测。
    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.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");
        }
    }
}

在findUsingReflectionInSingleClass，先获取类里面的Method，通过getDeclaredMethods()或者getMethods()。这两个区别在于：getDeclaredMethods()返回这个类所有的方法，而getMethods()返回的是这个类及其父类的public的方法。因为在Activity这种继承关系很复杂的类里，getMethods()返回包含了很多系统的方法，大大降低了效率。

获取到Method数组后，校验包含@Subscribe注解的方法是不是为Public，是不是不含有abstract、static、bridge、synthtic修饰符，参数是不是只有一个。通过的话，再调用FindState的checkAdd校验，然后加到FindState的subscriberMethods里。

前面我们提到checkAdd内调用到的isAssignableFrom似乎没有意义，既然在寻找SubscriberMethod时，是一层层向上的，是不是isAssignableFrom一直返回false？其实不然，getMethods会得到这个类以及父类的public方法，因此isAssignableFrom是可能返回true的。

到这里注册订阅者的流程就结束了。

3. 发送事件

发送事件时，通过EventBus.getDefault.post(Event)来发送：

/** Posts the given event to the event bus. */
public void post(Object event) {
    PostingThreadState postingState = currentPostingThreadState.get();
    List