Android 主流开源框架（八）EventBus 源码解析（含面试相关文问题解答）

前言

最近有个想法——就是把 Android 主流开源框架进行深入分析，然后写成一系列文章，包括该框架的详细使用与源码解析。目的是通过鉴赏大神的源码来了解框架底层的原理，也就是做到不仅要知其然，还要知其所以然。

这里我说下自己阅读源码的经验，我一般都是按照平时使用某个框架或者某个系统源码的使用流程入手的，首先要知道怎么使用，然后再去深究每一步底层做了什么，用了哪些好的设计模式，为什么要这么设计。

系列文章：

• Android 主流开源框架（一）OkHttp 铺垫-HttpClient 与 HttpURLConnection 使用详解
• Android 主流开源框架（二）OkHttp 使用详解
• Android 主流开源框架（三）OkHttp 源码解析
• Android 主流开源框架（四）Retrofit 使用详解
• Android 主流开源框架（五）Retrofit 源码解析
• Android 主流开源框架（六）Glide 的执行流程源码解析
• Android 主流开源框架（七）Glide 的缓存机制
• Android 主流开源框架（八）EventBus 源码解析
• 更多框架持续更新中...

更多干货请关注 AndroidNotes

一、使用示例

1.1 基本用法

（1）定义事件
这个事件就是需要传递的实体类。

public class MessageEvent {

    public final String message;

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

（2）准备订阅者
声明用来处理事件的订阅方法。

@Subscribe(threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {
    Toast.makeText(this, event.message, Toast.LENGTH_SHORT).show();
}

（3）注册与解除注册
注册与解除注册订阅者，与第（2）步放在同一个类中。

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

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

（4）发送事件
可以在任何地方发送事件。

EventBus.getDefault().post(new MessageEvent("普通事件"));

1.2 粘性事件

普通事件是先注册和准备订阅者，然后再发送事件才能收到。而粘性事件在发送事件之后再注册和准备订阅者也能收到事件。

使用上与普通事件的区别是第（2）步需要增加 “sticky = true” 声明为粘性事件，第（4）步 post 方法改成 postSticky 方法，如下：

准备订阅者：

@Subscribe(threadMode = ThreadMode.MAIN, sticky = true)
public void onMessageEvent(StickyMessageEvent event) {
    Toast.makeText(this, event.message, Toast.LENGTH_SHORT).show();
}

发送事件：

EventBus.getDefault().postSticky(new StickyMessageEvent("粘性事件"));

接下来我们就根据这几步进行源码分析。

二、源码分析

源码版本：3.2.0

2.1 Subscribe 注解

/*Subscribe*/
public @interface Subscribe {
    //（1）
    ThreadMode threadMode() default ThreadMode.POSTING;
    //（2）
    boolean sticky() default false;
    //（3）
    int priority() default 0;
}

源码中我标注了 3 个关注点，分别如下：

• （1）：指定线程模式，即指定订阅方法在哪个线程执行，线程模式一共有 5 种：POSTING（默认模式）、MAIN、MAIN_ORDERED、BACKGROUND、ASYNC，关于它们的区别放到后面再分析。
• （2）：是否是粘性事件
• （3）：指定优先级，默认为 0。在相同线程模式下，优先级越高的订阅方法越先收到事件。

以上设置都是在 “准备订阅者” 那里配置的，如下：

@Subscribe(threadMode = ThreadMode.MAIN, sticky = true, priority = 1)
public void onMessageEvent(StickyMessageEvent event) {
    Toast.makeText(this, event.message, Toast.LENGTH_SHORT).show();
}

2.2 注册

在看注册方法之前我们先看下是怎么获取 EventBus 实例的，即 EventBus#getDefault() 中的 getDefault 方法：

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

可以看到，这里是通过双重校验锁的单例模式来获取 EventBus 的实例。

看一下它的构造方法：

    /*EventBus*/
    private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
    private final Map>> typesBySubscriber;
    private final Map, Object> stickyEvents;

    public EventBus() {
        this(DEFAULT_BUILDER);
    }

    EventBus(EventBusBuilder builder) {
        logger = builder.getLogger();
        //（1）start
        subscriptionsByEventType = new HashMap<>();
        typesBySubscriber = new HashMap<>();
        stickyEvents = new ConcurrentHashMap<>();
        //（1）end

        mainThreadSupport = builder.getMainThreadSupport();
        //（2）
        mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
        //（3）
        backgroundPoster = new BackgroundPoster(this);
        //（4）
        asyncPoster = new AsyncPoster(this);
        indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
        //（5）
        subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
                builder.strictMethodVerification, builder.ignoreGeneratedIndex);
        /*一些 boolean 类型的常量赋值*/
        logSubscriberExceptions = builder.logSubscriberExceptions;
        logNoSubscriberMessages = builder.logNoSubscriberMessages;
        sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
        sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
        throwSubscriberException = builder.throwSubscriberException;
        eventInheritance = builder.eventInheritance;

        //（6）
        executorService = builder.executorService;
    }

首先是调用无参构造方法，然后传入一个 DEFAULT_BUILDER 来调用有参构造，这个 DEFAULT_BUILDER 是 EventBusBuilder，它是一个 EventBus 的建造器，里面封装了一些 EventBus 所需要的参数等。
源码中我标记了 6 个关注点，分别如下：

• （1）：可以看到这里创建的 3 个对象都是 map 集合，具体保存了什么这里看不出来，我们后面再分析。
• （2）：创建了一个 mainThreadPoster 对象，该对象主要用来将线程模型为 MAIN 和 MAIN_ORDERED 的事件加入到队列中，然后进行处理。点击 createPoster 方法进去看看是怎么创建的：

/*MainThreadSupport*/
public interface MainThreadSupport {

    ...

    Poster createPoster(EventBus eventBus);

    class AndroidHandlerMainThreadSupport implements MainThreadSupport {

        ...

        @Override
        public Poster createPoster(EventBus eventBus) {
            return new HandlerPoster(eventBus, looper, 10);
        }
    }

}

/*HandlerPoster*/
public class HandlerPoster extends Handler implements Poster {
    ...
}

可以看到这里创建了一个 HandlerPoster，所以这里的 mainThreadPoster 实际上是一个 HandlerPoster。

• （3）创建了一个 BackgroundPoster 对象，该对象主要用来将线程模型为 BACKGROUND 的事件加入到队列中，然后进行处理。
• （4）创建了一个 AsyncPoster 对象，该对象主要用来将线程模型为 ASYNC 的事件加入到队列中，然后进行处理。
• （5）创建了一个 SubscriberMethodFinder 对象，该对象主要用来获取注册类上所有订阅方法的集合。
• （6）从 EventBusBuilder 中取出一个创建好的线程池（CachedThreadPool）赋值给 executorService。

接下来看下 register 方法：

    /*EventBus*/
    public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        //（1）
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            //（2）
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

源码中我标记了 2 个关注点，分别如下：

• EventBus#register() 中的关注点（1）——findSubscriberMethods()
  主要是获取注册类上所有订阅方法的集合，也就是使用示例中 “准备订阅者” 那步加了 @Subscribe 注解的那些方法。点进去看看：

    /*SubscriberMethodFinder*/
    private static final Map, List> METHOD_CACHE = new ConcurrentHashMap<>();
    private final boolean ignoreGeneratedIndex;

    List findSubscriberMethods(Class subscriberClass) {
        //（1）
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        //（2）
        if (ignoreGeneratedIndex) {
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            //（3）
            subscriberMethods = findUsingInfo(subscriberClass);
        }
        // 订阅方法为空，说明注册类中不存在 @Subscribe 注解的方法。
        if (subscriberMethods.isEmpty()) {
            throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
        } else {
            //（4）
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

源码中我标记了 4 个关注点，分别如下：

• （1）：从 METHOD_CACHE 集合中查找是否已经缓存了该注册类上的订阅方法。
• （2）：ignoreGeneratedIndex 是在 EventBus 的有参构造中通过 EventBusBuilder 配置的，我们没配置，默认是 false，所以直接走关注点（3）。
• （3）：查找所有订阅方法。
• （4）：找到所有订阅方法后缓存到 METHOD_CACHE 集合中。

下面具体看看关注点（3）中内部是怎么实现的：

    /*SubscriberMethodFinder*/
    private List findUsingInfo(Class subscriberClass) {
        //（1）
        FindState findState = prepareFindState();
        //（2）
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            //（3）
            findState.subscriberInfo = getSubscriberInfo(findState);
            // 默认 subscriberInfo 为 null，不会走这里
            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 {
                //（4）
                findUsingReflectionInSingleClass(findState);
            }
            findState.moveToSuperclass();
        }
        //（5）
        return getMethodsAndRelease(findState);
    }

源码中我标记了 5 个关注点，分别如下：

• （1）：调用 prepareFindState 方法返回一个 FindState 对象，看一下 FindState：

/*SubscriberMethodFinder*/
class SubscriberMethodFinder {
    static class 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;

        void initForSubscriber(Class subscriberClass) {
            this.subscriberClass = clazz = subscriberClass;
            skipSuperClasses = false;
            subscriberInfo = null;
        }

        // 查找完成进行回收
        void recycle() {
            subscriberMethods.clear();
            anyMethodByEventType.clear();
            subscriberClassByMethodKey.clear();
            methodKeyBuilder.setLength(0);
            subscriberClass = null;
            clazz = null;
            skipSuperClasses = false;
            subscriberInfo = null;
        }

        ...

    }
}

可以看到，FindState 是 SubscriberMethodFinder 中的静态类，主要用来辅助查找订阅方法。

继续看下 prepareFindState 方法是怎么返回 FindState 对象的：

    /*SubscriberMethodFinder*/
    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();
    }

首先从 FIND_STATE_POOL 中取出可用的 FindState，如果没有则重新创建一个 FindState。

• （2）：初始化刚刚 FindState 类中的那些变量。

• （3）：点击 getSubscriberInfo 方法进去看看：

    /*SubscriberMethodFinder*/
    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;
    }

其中 subscriberInfo 是刚刚关注点（2）中初始化的 null，subscriberInfoIndexes 是在 EventBus 的有参构造中通过 EventBusBuilder 配置的，我们没配置，也为 null，所以这个方法默认只会返回 null。

• （4）：点击 findUsingReflectionInSingleClass 方法进去看看：

    /*SubscriberMethodFinder*/
    private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // 反射获取注册类中的所有方法
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            try {
                // 反射获取注册类中的所有方法
                methods = findState.clazz.getMethods();
            } catch (LinkageError error) {
                ...
            }
            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) {
                        // 获取方法上的第一个参数，也就是事件类型（即使用示例中 MessageEvent 的类型）
                        Class eventType = parameterTypes[0];
                        if (findState.checkAdd(method, eventType)) {
                            // 获取线程模式
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            // 将方法、事件类型、线程模式、优先级、是否是粘性事件封装到 SubscriberMethod 对象，然后添加到 FindState 类中的 subscriberMethods 集合中存起来
                            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");
            }
        }
    }

上面的注释写的很清楚了，主要是通过反射获取注册类中的所有方法，然后遍历方法，判断如果带有 Subscribe 注解的方法，就将该方法、事件类型、线程模式、优先级、是否是粘性事件封装到 SubscriberMethod 对象，然后添加到 FindState 类中的 subscriberMethods 集合中存起来。

• （5）：点击 getMethodsAndRelease 方法进去看看：

    /*SubscriberMethodFinder*/
    private List getMethodsAndRelease(FindState findState) {
        List subscriberMethods = new ArrayList<>(findState.subscriberMethods);
        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 中取出保存的所有订阅方法的信息，这时候 FindState 就没用了，那么需要调用 recycle 方法将里面的一些集合、变量等进行回收。但是 FindState 经常要用到，所以会把它缓存到 FIND_STATE_POOL 中，这样下次就不用重新创建 FindState 了，提高性能。最后将 subscriberMethods 返回。

这样 findSubscriberMethods 方法就看完了，继续看 EventBus#register() 中的关注点（2），即 subscribe 方法。

• EventBus#register() 中的关注点（2）——subscribe()
  主要是循环获取每个订阅方法进行订阅，实际内部只是给 subscriptionsByEventType、typesBySubscriber 集合添加数据。点进去看看：

    /*EventBus*/
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        // 获取事件类型
        Class eventType = subscriberMethod.eventType;
        //（1）
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        //（2）start
        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);
            }
        }
        //（2）end

        int size = subscriptions.size();
        //（3）
        for (int i = 0; i <= size; i++) {
            if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
                subscriptions.add(i, newSubscription);
                break;
            }
        }

        //（4）start
        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);
        //（4）end

        //（5）
        if (subscriberMethod.sticky) {
            ...
        }
    }

源码中我标注了 5 个关注点，分别如下：

• （1）：将注册类与订阅方法封装到 Subscription。
• （2）：subscriptionsByEventType 就是一开始在 EventBus 有参构造方法中创建的 HashMap，终于用到了！这里首先通过 eventType 去 subscriptionsByEventType 中查找是否已经有 Subscription 集合，没有则创建一个，然后添加到 subscriptionsByEventType 中。所以 subscriptionsByEventType 是一个存储 key 为事件类型，value 为 Subscription 集合的 HashMap。
• （3）：根据设置的优先级将 newSubscription 添加到 subscriptions 集合中，也就是将优先级越高的排在集合中越前的位置。
• （4）：typesBySubscriber 也是一开始在 EventBus 有参构造方法中创建的 HashMap，这里首先通过 subscriber 去 typesBySubscriber 中查找是否已经有 eventType 集合，没有则创建一个，然后添加到 typesBySubscriber 中，最后一句是添加事件到事件集合中。所以 typesBySubscriber 是一个存储 key 为注册类（对应使用示例中的 EventBusFirstActivity），value 为事件类型集合的 HashMap。typesBySubscriber 的作用是判断某个对象是否注册过，防止重复注册。也就是下面这个方法：

    /*EventBus*/
    public synchronized boolean isRegistered(Object subscriber) {
        return typesBySubscriber.containsKey(subscriber);
    }

• （5）：粘性事件相关逻辑，放到最后再分析。

这样，注册方法也就分析完了。

小结
通过反射获取注册类上所有的订阅方法，然后将这些订阅方法进行包装保存到 subscriptionsByEventType 集合。这里还用 typesBySubscriber 集合保存了事件类型集合，用来判断某个对象是否注册过。

2.3 解除注册

看一下解除注册的 unregister 方法：

    /*EventBus*/
    public synchronized void unregister(Object subscriber) {
        // 根据注册类获取 typesBySubscriber 集合中保存的事件类型集合
        List> subscribedTypes = typesBySubscriber.get(subscriber);
        if (subscribedTypes != null) {
            for (Class eventType : subscribedTypes) {
                // 看下面
                unsubscribeByEventType(subscriber, eventType);
            }
            // 移除 typesBySubscriber 中保存的事件类型集合
            typesBySubscriber.remove(subscriber);
        } else {
            logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }

    /*EventBus*/
    private void unsubscribeByEventType(Object subscriber, Class eventType) {
        // 根据事件类型获取 subscriptionsByEventType 集合中保存的 Subscription 集合
        List subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions != null) {
            int size = subscriptions.size();
            for (int i = 0; i < size; i++) {
                Subscription subscription = subscriptions.get(i);
                if (subscription.subscriber == subscriber) {
                    subscription.active = false;
                    // 从 Subscription 集合中移除 Subscription
                    subscriptions.remove(i);
                    i--;
                    size--;
                }
            }
        }
    }

可以看到，unregister 方法非常简单，上面都有注释了，我们直接来个小结。

小结
注册的时候使用 subscriptionsByEventType 集合保存了所有订阅方法信息，使用 typesBySubscriber 集合保存了所有事件类型。那么解注册的时候就是为了移除这两个集合中保存的内容。

2.4 发送普通事件

看一下发送事件的 post 方法：

    /*EventBus*/
    private final ThreadLocal currentPostingThreadState = new ThreadLocal() {
        @Override
        protected PostingThreadState initialValue() {
            return new PostingThreadState();
        }
    };

    public void post(Object event) {
        //（1）start
        PostingThreadState postingState = currentPostingThreadState.get();
        List