EventBus3.1源码分析

这篇文章将会为大家梳理一下EventBus的基本流程，本人使用的版本号为3.1.1，为了方便阅读，文章中的源码部分将省略部分有关异常捕获与日志相关代码。

使用示例

首先，按照官方的文档来看看一个最简单的EventBus示例是什么样的：

第一步：定义消息实体类

public class MessageEvent {
    public final String message;
    
    public MessageEvent(String message) {
        this.message = message;
    }
}

第二步：使用注解创建订阅方法

@Subscribe
public void onMessageEvent(MessageEvent event) {
    Toast.makeText(getActivity(), event.message, Toast.LENGTH_SHORT).show();
}

第三步：注册与注销订阅（注意与生命周期的绑定）

@Override
public void onStart() {
    super.onStart();
    EventBus.getDefault().register(this);
}
 
@Override
public void onStop() {
    EventBus.getDefault().unregister(this);
    super.onStop();
}

第四步：发送通知消息

EventBus.getDefault().post(new MessageEvent("Hello everyone!"));

这样，一个简单的Demo就完成了，本文将以这个Demo为基础，分析订阅事件从注册到接收并执行都是如何实现的。

1.EventBus.getDefault().register(this);

EventBus.getDefault()

static volatile EventBus defaultInstance;

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

获取EventBus的单例对象，很标准的单例模式，就不细说了。

EventBus.register(Object subscriber)

public void register(Object subscriber) {
    //获取注册订阅的类的Class对象
    Class<?> subscriberClass = subscriber.getClass();
    //查找Class中带有Subscribe注解的方法列表
    List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}

SubscriberMethodFinder.findSubscriberMethods(Class<?> subscriberClass)

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    //METHOD_CACHE为ConcurrentHashMap<Class<?>, List<SubscriberMethod>>，作为方法解析的缓存使用
    List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
    //如果取出的SubscriberMethod不为null，则说明该类已被加载过，那么跳过解析的步骤，直接返回上次解析的结果
    if (subscriberMethods != null) {
        return subscriberMethods;
    }

    //ignoreGeneratedIndex用来设置是否忽略使用Subscriber Index来帮助注解解析，默认设置为false
    //Subscriber Index为EventBus3.0中出现的新特性，在build期间生成，以此增加注解解析的性能
    //关于Subscriber Index的更多信息可以参考官方文档 http://greenrobot.org/eventbus/documentation/subscriber-index/
    if (ignoreGeneratedIndex) {
        subscriberMethods = findUsingReflection(subscriberClass);
    } else {
        subscriberMethods = findUsingInfo(subscriberClass);
    }
    if (subscriberMethods.isEmpty()) {
        //如果类中没有找到Subscriber注解的方法，抛出异常
        throw new EventBusException("Subscriber " + subscriberClass
                + " and its super classes have no public methods with the @Subscribe annotation");
    } else {
        //将Subscriber注解的方法放入缓存并返回
        METHOD_CACHE.put(subscriberClass, subscriberMethods);
        return subscriberMethods;
    }
}

从这个方法可以看出EventBus会将注册的订阅事件以Class对象为key，订阅方法的Method对象为value存入METHOD_CACHE缓存中，避免同一个类多次注册订阅时重复解析的问题，提升解析的性能。

在注解解析方面，EventBus提供了传统的反射解析与使用Subscriber Index两种方式，下面将主要对反射解析方式分别进行分析

SubscriberMethodFinder.findUsingReflection(Class<?> subscriberClass)

private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
    //通过FindState对象池创建FindState对象
    FindState findState = prepareFindState();
    //初始化FindState对象
    findState.initForSubscriber(subscriberClass);
    
    while (findState.clazz != null) {
        //解析这个类中带有Subscribe注解的方法
        findUsingReflectionInSingleClass(findState);
        //向父类进行遍历
        findState.moveToSuperclass();
    }
    //获取解析出的方法，将findState重置并放回对象池中
    return getMethodsAndRelease(findState);
}

private void findUsingReflectionInSingleClass(FindState findState) {
    Method[] methods;
    try {
        // This is faster than getMethods, especially when subscribers are fat classes like Activities
        //getDeclaredMethods方法只会获取到该类所定义的方法，而getMethods方法会获取包括这个类的父类与接口中的所有方法
        methods = findState.clazz.getDeclaredMethods();
    } catch (Throwable th) {
        // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
        // 使用getMethods就已经获得了其父类的所有方法，所以将skipSuperClasses标志位设置为true，在后续过程中不对其父类进行解析
        methods = findState.clazz.getMethods();
        findState.skipSuperClasses = true;
    }
    for (Method method : methods) {
        int modifiers = method.getModifiers();
        //Subscribe注解的方法不应为私有且不应为抽象，静态等
        if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
            Class<?>[] parameterTypes = method.getParameterTypes();
            //Subscribe注解的方法应有且只有一个参数
            if (parameterTypes.length == 1) {
                Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                if (subscribeAnnotation != null) {
                    Class<?> eventType = parameterTypes[0];
                    //调用checkAdd方法判断是否将订阅事件添加进订阅列表中
                    if (findState.checkAdd(method, eventType)) {
                        ThreadMode threadMode = subscribeAnnotation.threadMode();
                        findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                    }
                }
            }
        }
    }
}

在这段代码中出现了一个FindState类对象，其中含有解析相关的配置，解析出的方法等等，整个解析的过程都是围绕着这个对象进行处理。

FindState.checkAdd

final Map<Class, Object> anyMethodByEventType = new HashMap<>();
final StringBuilder methodKeyBuilder = new StringBuilder(128);
final Map<String, Class> subscriberClassByMethodKey = new HashMap<>();

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);
    // 第一级判断，如果existing为null，则代表该eventType为首次添加，直接返回true
    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
            // 该方法只为了将一个不是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
        // 撤销之前的put操作，并返回false
        subscriberClassByMethodKey.put(methodKey, methodClassOld);
        return false;
    }
}

这部分代码的作用主要有两点：

1. 当一个类重载了父类的一个订阅方法，在向上级父类遍历时跳过父类中的这个方法的订阅，也就是说以子类的订阅方法为准
2. 允许一个类有多个方法名不同的方法对同个事件进行订阅

值得一提的是关于methodClassOld.isAssignableFrom(methodClass)这一句代码，有文章提到因为之前的代码中会使用Class.getMethods()方法，会得到这个类以及父类的public方法，所以这句代码的结果可能为true，但是经我测试，如果父类方法被子类重载，那么getMethods方法得到的只会有子类的重载方法一个，父类的方法并不会出现，所以从这方面来说，这句代码依然只能是false。

EventBus.register(Object subscriber, SubscriberMethod subscriberMethod)

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    Class<?> eventType = subscriberMethod.eventType;
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
    CopyOnWriteArrayList<Subscription> 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;
        }
    }

    //将参数类型以订阅者对象为key，参数类型列表为value保存进一个Map中
    List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber);
    if (subscribedEvents == null) {
        subscribedEvents = new ArrayList<>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
    subscribedEvents.add(eventType);
    //对于一般的事件的注册，到这里就已经完成了
    //-----------------------------------------------------------------------------
    
    //针对粘性事件订阅者的处理
    if (subscriberMethod.sticky) {
        //eventInheritance：是否支持事件继承，默认为true。当为true时，post一个事件A时，若A是B的父类，订阅B的订阅者也能接收到事件。
        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<Class>).
            //遍历所有注册的粘性事件进行遍历，如果一个事件为现事件的子类，则将该事件发送出去
            Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
            for (Map.Entry<Class<?>, 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);
        }
    }
}

到现在为止，其实已经可以总结出EventBus中订阅者注册的核心逻辑了，就是筛选出注册的类中带有Subscribe注解的方法，然后将其解析为SubscriberMethod对象，以订阅的事件类型为key，SubscriberMethod对象为value的形式存入subscribedEvents中。

对于粘性事件的发送，其实与之后的一般事件执行逻辑相同，这里就不再深入了。

EventBus.getDefault().post(new MessageEvent(“Hello everyone!”))

EventBus.post(Object event)

public void post(Object event) {
    //从ThreadLocal中取出PostingThreadState对象，PostingThreadState对象只是保存一些消息发送过程中需要的信息
    //使用ThreadLocal保证PostingThreadState对象在各线程间相互独立，以此实现线程安全
    PostingThreadState postingState = currentPostingThreadState.get();
    //从PostingThreadState对象中取出当前线程的消息队列，并将需要发送的消息加入队列中
    List<Object> eventQueue = postingState.eventQueue;
    eventQueue.add(event);

    if (!postingState.isPosting) {
        postingState.isMainThread = isMainThread();
        postingState.isPosting = true;
        if (postingState.canceled) {
            throw new EventBusException("Internal error. Abort state was not reset");
        }
        try {
            //开始遍历执行消息队列
            while (!eventQueue.isEmpty()) {
                postSingleEvent(eventQueue.remove(0), postingState);
            }
        } finally {
            //遍历结束，重置PostingThreadState对象
            postingState.isPosting = false;
            postingState.isMainThread = false;
        }
    }
}

在这段代码中，isMainThread()方法可以用来判断消息发送是否是在主线程中。其中的逻辑非常简单，通过Looper类中的getMainLooper()获取到主线程中的Looper对象，然后再通过Looper类中的myLooper()方法获取当前线程的Looper对象，然后相互比较。

EventBus.postSingleEvent(Object event, PostingThreadState postingState)

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
    Class<?> eventClass = event.getClass();
    boolean subscriptionFound = false;
    //如果该消息支持事件继承，则获取该消息类型的所有父类与接口类型，并分别调用postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass)方法
    if (eventInheritance) {
        //获取消息类型的所有父类与接口
        List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
        int countTypes = eventTypes.size();
        //对于ArrayList而言，使用基本的for循环实现遍历效率更高
        for (int h = 0; h < countTypes; h++) {
            Class<?> clazz = eventTypes.get(h);
            subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
        }
    } else {
        subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
    }
    
    //如果该消息没有订阅者，则根据配置输出相应的log或发送消息
    if (!subscriptionFound) {
        if (logNoSubscriberMessages) {
            logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
        }
        if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                eventClass != SubscriberExceptionEvent.class) {
            post(new NoSubscriberEvent(this, event));
        }
    }
}

EventBus.postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass)

private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
    CopyOnWriteArrayList<Subscription> subscriptions;
    synchronized (this) {
        //从Map中将该消息的订阅事件列表取出
        subscriptions = subscriptionsByEventType.get(eventClass);
    }
    if (subscriptions != null && !subscriptions.isEmpty()) {
        for (Subscription subscription : subscriptions) {
            postingState.event = event;
            postingState.subscription = subscription;
            boolean aborted = false;
            try {
                //将消息发送给订阅者
                postToSubscription(subscription, event, postingState.isMainThread);
                aborted = postingState.canceled;
            } finally {
                postingState.event = null;
                postingState.subscription = null;
                postingState.canceled = false;
            }
            if (aborted) {
                break;
            }
        }
        return true;
    }
    return false;
}

这个方法的主要作用就是获得消息的订阅事件列表，完成对于postingState中参数的赋值，其中对于所有的订阅事件，使用的其实是同一个PostingThreadState对象，只是对于不同的订阅事件，会改变其中的部分参数的值。

EventBus.postToSubscription(Subscription subscription, Object event, boolean isMainThread)

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
    switch (subscription.subscriberMethod.threadMode) {
        case POSTING:
            invokeSubscriber(subscription, event);
            break;
        case MAIN:
            if (isMainThread) {
                invokeSubscriber(subscription, event);
            } else {
                mainThreadPoster.enqueue(subscription, event);
            }
            break;
        case MAIN_ORDERED:
            if (mainThreadPoster != null) {
                mainThreadPoster.enqueue(subscription, event);
            } else {
                // temporary: technically not correct as poster not decoupled from subscriber
                invokeSubscriber(subscription, event);
            }
            break;
        case BACKGROUND:
            if (isMainThread) {
                backgroundPoster.enqueue(subscription, event);
            } else {
                invokeSubscriber(subscription, event);
            }
            break;
        case ASYNC:
            asyncPoster.enqueue(subscription, event);
            break;
        default:
            throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
    }
}

在默认情况下，EventBus会在调用线程中直接执行invokeSubscriber方法调用订阅事件，但当调用线程与期望的执行线程不一致或希望异步调用时，使用Poster来进行不同线程间的调度，每一个Poster中都会持有一个消息队列，并在指定线程执行。

EventBus.invokeSubscriber(Subscription subscription, Object event)

void invokeSubscriber(Subscription subscription, Object event) {
    try {
        subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
    } catch (InvocationTargetException e) {
        //如果捕获到InvocationTargetException异常，则根据配置打印Log或发送异常消息
        handleSubscriberException(subscription, event, e.getCause());
    } catch (IllegalAccessException e) {
        throw new IllegalStateException("Unexpected exception", e);
    }
}

这段代码也就是订阅事件执行部分的最后一段代码了，可以看到逻辑非常的简单，就是通过反射来执行相应的订阅事件。

总结

在上文的分析中可以看出，EventBus的主要逻辑非常简单，核心流程就是注册时先解析出带有相应注解的方法，然后将其的Method对象与其所订阅的消息类型绑定加入到一个集合中，然后发送消息时获取到消息类型所对应的订阅事件的Method对象，通过反射来调用执行。