一文彻底搞懂EventBus3.0事件总线框架原理-eventbus原理

[[412323]]

1、关于架构师学习的知识点很多，学到手才是自己的;

2、之前发过文章有自定义注解、设计模式、反射、多线程、组件化等;

3、实际开发中EventBus事件总线用到的很多，今天我们就解析下原理和用到的知识点;

4、在eventbus源码中可以学习到很多的知识点如下：

单例模式，而且是双重校验的单例，确保在不同线程中也只存在一个EvenBus的实例;

观察者模式：定义了对象之间的一对多依赖，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新;

自定义注解等等。

一、EventBus介绍

1、什么是EventBus

由greenrobot 组织贡献(该组织还贡献了greenDAO),一个Android事件发布/订阅轻量级框架，通过解耦发布者和订阅者简化Android事件传递;

EventBus可以代替Android传统的Intent,Handler,Broadcast或接口函数,在Fragment,Activity,Service线程之间传递数据，执行方法;

EventBus 是一款在 Android 开发中使用的发布/订阅事件总线框架，基于观察者模式，将事件的接收者和发送者分开，简化了组件之间的通信，使用简单、效率高、体积小 ;

2、eventbus功能和优势

通过解耦发布者和订阅者简化Android事件传递;

用于线程间的通讯代替handler或用于组件间的通讯代替Intent;

简化了组件间的通讯;

分离了事件的发送者和接受者;

在Activity、Fragment和线程中表现良好;

避免了复杂的和易错的依赖关系和生命周期问题;

使得代码更简洁,性能更好;

二、EventBus原理

EventBus 背后的实现原理主要包括如下几个方面的内容：

Subscribe注解

注册事件订阅方法

1、Subscribe注解

EventBus3.0 开始用Subscribe注解配置事件订阅方法

@Subscribe 
public void handleEvent(String event) { 
    // do something 
}

具体看下Subscribe注解的实现：

@Documented 
@Retention(RetentionPolicy.RUNTIME) 
@Target({ElementType.METHOD}) 
public @interface Subscribe { 
    // 指定事件订阅方法的线程模式，即在那个线程执行事件订阅方法处理事件，默认为POSTING 
    ThreadMode threadMode() default ThreadMode.POSTING; 
    // 是否支持粘性事件，默认为false 
    boolean sticky() default false; 
    // 指定事件订阅方法的优先级，默认为0，如果多个事件订阅方法可以接收相同事件的，则优先级高的先接收到事件 
    int priority() default 0; 
}

在使用Subscribe注解时可以根据需求指定threadMode、sticky、priority三个属性;

其中threadMode属性有如下几个可选值：

ThreadMode.POSTING，默认的线程模式，在那个线程发送事件就在对应线程处理事件，避免了线程切换，效率高;

ThreadMode.MAIN，如在主线程(UI线程)发送事件，则直接在主线程处理事件;如果在子线程发送事件，则先将事件入队列，然后通过 Handler 切换到主线程，依次处理事件;

ThreadMode.MAIN_ORDERED，无论在那个线程发送事件，都先将事件入队列，然后通过 Handler 切换到主线程，依次处理事件;

ThreadMode.BACKGROUND，如果在主线程发送事件，则先将事件入队列，然后通过线程池依次处理事件;如果在子线程发送事件，则直接在发送事件的线程处理事件;

ThreadMode.ASYNC，无论在那个线程发送事件，都将事件入队列，然后通过线程池处理;

2、注册事件订阅方法

注册事件的方式如下：

EventBus.getDefault().register(this);

其中getDefault()是一个单例方法，保证当前只有一个EventBus实例：

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) { 
        logger = builder.getLogger(); 
        subscriptionsByEventType = new HashMap<>(); 
        typesBySubscriber = new HashMap<>(); 
        stickyEvents = new ConcurrentHashMap<>(); 
        mainThreadSupport = builder.getMainThreadSupport(); 
        mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null; 
        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; 
    }

DEFAULT_BUILDER就是一个默认的EventBusBuilder：

private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();

有了EventBus的实例就可以进行注册了：

public void register(Object subscriber) { 
        // 得到当前要注册类的Class对象 
        Class<?> subscriberClass = subscriber.getClass(); 
        // 根据Class查找当前类中订阅了事件的方法集合，即使用了Subscribe注解、有public修饰符、一个参数的方法 
        // SubscriberMethod类主要封装了符合条件方法的相关信息： 
        // Method对象、线程模式、事件类型、优先级、是否是粘性事等 
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass); 
        synchronized (this) { 
            // 循环遍历订阅了事件的方法集合，以完成注册 
            for (SubscriberMethod subscriberMethod : subscriberMethods) { 
                subscribe(subscriber, subscriberMethod); 
            } 
        } 
    }

可以看到register()方法主要分为查找和注册两部分，首先来看查找的过程，从findSubscriberMethods()开始：

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) { 
        // METHOD_CACHE是一个ConcurrentHashMap，直接保存了subscriberClass和对应SubscriberMethod的集合，以提高注册效率，赋值重复查找。 
        List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass); 
        if (subscriberMethods != null) { 
            return subscriberMethods; 
        } 
        // 由于使用了默认的EventBusBuilder，则ignoreGeneratedIndex属性默认为false，即是否忽略注解生成器 
        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()流程很清晰，即先从缓存中查找，如果找到则直接返回，否则去做下一步的查找过程，然后缓存查找到的集合，根据上边的注释可知findUsingInfo()方法会被调用：

private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) { 
        FindState findState = prepareFindState(); 
        findState.initForSubscriber(subscriberClass); 
        // 初始状态下findState.clazz就是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.clazz为subscriberClass的父类Class，即需要遍历父类 
            findState.moveToSuperclass(); 
        } 
        // 查找到的方法保存在了FindState实例的subscriberMethods集合中。 
        // 使用subscriberMethods构建一个新的List<SubscriberMethod> 
        // 释放掉findState 
        return getMethodsAndRelease(findState); 
    }

findUsingInfo()方法会在当前要注册的类以及其父类中查找订阅事件的方法，这里出现了一个FindState类，它是SubscriberMethodFinder的内部类，用来辅助查找订阅事件的方法，具体的查找过程在findUsingReflectionInSingleClass()方法，它主要通过反射查找订阅事件的方法：

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) { 
            // 获得方法的修饰符 
            int modifiers = method.getModifiers(); 
            // 如果是public类型，但非abstract、static等 
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) { 
                // 获得当前方法所有参数的类型 
                Class<?>[] parameterTypes = method.getParameterTypes(); 
                // 如果当前方法只有一个参数 
                if (parameterTypes.length == 1) { 
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class); 
                    // 如果当前方法使用了Subscribe注解 
                    if (subscribeAnnotation != null) { 
                        // 得到该参数的类型 
                        Class<?> eventType = parameterTypes[0]; 
                        // checkAdd()方法用来判断FindState的anyMethodByEventType map是否已经添加过以当前eventType为key的键值对，没添加过则返回true 
                        if (findState.checkAdd(method, eventType)) { 
                             // 得到Subscribe注解的threadMode属性值，即线程模式 
                            ThreadMode threadMode = subscribeAnnotation.threadMode(); 
                            // 创建一个SubscriberMethod对象，并添加到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"); 
            } 
        } 
    }

到此register()方法中findSubscriberMethods()流程就分析完了，我们已经找到了当前注册类及其父类中订阅事件的方法的集合。接下来分析具体的注册流程，即register()中的subscribe()方法：

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) { 
        // 得到当前订阅了事件的方法的参数类型 
        Class<?> eventType = subscriberMethod.eventType; 
        // Subscription类保存了要注册的类对象以及当前的subscriberMethod 
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod); 
        // subscriptionsByEventType是一个HashMap，保存了以eventType为key,Subscription对象集合为value的键值对 
        // 先查找subscriptionsByEventType是否存在以当前eventType为key的值 
        CopyOnWriteArrayList<Subscription> subscriptions = subscriptionsByEventType.get(eventType); 
        // 如果不存在，则创建一个subscriptions，并保存到subscriptionsByEventType 
        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); 
            } 
        } 
        // 添加上边创建的newSubscription对象到subscriptions中 
        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; 
            } 
        } 
        // typesBySubscribere也是一个HashMap，保存了以当前要注册类的对象为key，注册类中订阅事件的方法的参数类型的集合为value的键值对 
        // 查找是否存在对应的参数类型集合 
        List<Class<?>> subscribedEvents = typesBySubscriber.get(subscriber); 
        // 不存在则创建一个subscribedEvents，并保存到typesBySubscriber 
        if (subscribedEvents == null) { 
            subscribedEvents = new ArrayList<>(); 
            typesBySubscriber.put(subscriber, subscribedEvents); 
        } 
        // 保存当前订阅了事件的方法的参数类型 
        subscribedEvents.add(eventType); 
        // 粘性事件相关的，后边具体分析 
        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<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); 
            } 
        } 
    }

这就是注册的核心流程，所以subscribe()方法主要是得到了subscriptionsByEventType、typesBySubscriber两个 HashMap。我们在发送事件的时候要用到subscriptionsByEventType，完成事件的处理。当取消 EventBus 注册的时候要用到typesBySubscriber、subscriptionsByEventType，完成相关资源的释放;

3、取消注册

EventBus 取消注册：

EventBus.getDefault().unregister(this);

核心的方法就是unregister()：

public synchronized void unregister(Object subscriber) { 
        // 得到当前注册类对象 对应的 订阅事件方法的参数类型 的集合 
        List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber); 
        if (subscribedTypes != null) { 
            // 遍历参数类型集合，释放之前缓存的当前类中的Subscription 
            for (Class<?> eventType : subscribedTypes) { 
                unsubscribeByEventType(subscriber, eventType); 
            } 
            // 删除以subscriber为key的键值对 
            typesBySubscriber.remove(subscriber); 
        } else { 
            logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass()); 
        } 
    } 
继续看unsubscribeByEventType()方法： 
private void unsubscribeByEventType(Object subscriber, Class<?> eventType) { 
        // 得到当前参数类型对应的Subscription集合 
        List<Subscription> subscriptions = subscriptionsByEventType.get(eventType); 
        if (subscriptions != null) { 
            int size = subscriptions.size(); 
            // 遍历Subscription集合 
            for (int i = 0; i < size; i++) { 
                Subscription subscription = subscriptions.get(i); 
                // 如果当前subscription对象对应的注册类对象 和 要取消注册的注册类对象相同，则删除当前subscription对象 
                if (subscription.subscriber == subscriber) { 
                    subscription.active = false; 
                    subscriptions.remove(i); 
                    i--; 
                    size--; 
                } 
            } 
        } 
    }

所以在unregister()方法中，释放了typesBySubscriber、subscriptionsByEventType中缓存的资源。

4、事件通知

发送一个事件的时候，我们可以通过如下方式

EventBus.getDefault().post("Hello World!")

通过post()方法完成的：

public void post(Object event) { 
        // currentPostingThreadState是一个PostingThreadState类型的ThreadLocal 
        // PostingThreadState类保存了事件队列和线程模式等信息 
        PostingThreadState postingState = currentPostingThreadState.get(); 
        List<Object> eventQueue = postingState.eventQueue; 
        // 将要发送的事件添加到事件队列 
        eventQueue.add(event); 
        // isPosting默认为false 
        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()) { 
                    // 发送单个事件 
                    // eventQueue.remove(0)，从事件队列移除事件 
                    postSingleEvent(eventQueue.remove(0), postingState); 
                } 
            } finally { 
                postingState.isPosting = false; 
                postingState.isMainThread = false; 
            } 
        } 
    }

所以post()方法先将发送的事件保存的事件队列，然后通过循环出队列，将事件交给postSingleEvent()方法处理

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error { 
        Class<?> eventClass = event.getClass(); 
        boolean subscriptionFound = false; 
        // eventInheritance默认为true，表示是否向上查找事件的父类 
        if (eventInheritance) { 
            // 查找当前事件类型的Class，连同当前事件类型的Class保存到集合 
            List<Class<?>> eventTypes = lookupAllEventTypes(eventClass); 
            int countTypes = eventTypes.size(); 
            // 遍历Class集合，继续处理事件 
            for (int h = 0; h < countTypes; h++) { 
                Class<?> clazz = eventTypes.get(h); 
                subscriptionFound |= postSingleEventForEventType(event, postingState, clazz); 
            } 
        } else { 
            subscriptionFound = postSingleEventForEventType(event, postingState, eventClass); 
        } 
        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)); 
            } 
        } 
    }

postSingleEvent()方法中，根据eventInheritance属性，决定是否向上遍历事件的父类型，然后用postSingleEventForEventType()方法进一步处理事件

private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) { 
        CopyOnWriteArrayList<Subscription> subscriptions; 
        synchronized (this) { 
            // 获取事件类型对应的Subscription集合 
            subscriptions = subscriptionsByEventType.get(eventClass); 
        } 
        // 如果已订阅了对应类型的事件 
        if (subscriptions != null && !subscriptions.isEmpty()) { 
            for (Subscription subscription : subscriptions) { 
                // 记录事件 
                postingState.event = event; 
                // 记录对应的subscription 
                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; 
    }

postSingleEventForEventType()方法核心就是遍历发送的事件类型对应的Subscription集合，然后调用postToSubscription()方法处理事件

5、事件处理

postToSubscription()内部会根据订阅事件方法的线程模式，间接或直接的以发送的事件为参数，通过反射执行订阅事件的方法

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 { 
                     // 如果是在子线程发送事件，则将事件入队列，通过Handler切换到主线程执行处理事件 
                    // mainThreadPoster 不为空 
                    mainThreadPoster.enqueue(subscription, event); 
                } 
                break; 
            // 无论在那个线程发送事件，都先将事件入队列，然后通过 Handler 切换到主线程，依次处理事件。 
            // mainThreadPoster 不为空 
            case MAIN_ORDERED: 
                if (mainThreadPoster != null) { 
                    mainThreadPoster.enqueue(subscription, event); 
                } else { 
                    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); 
        } 
    }

可以看到，postToSubscription()方法就是根据订阅事件方法的线程模式、以及发送事件的线程来判断如何处理事件，至于处理方式主要有两种：

一种是在相应线程直接通过invokeSubscriber()方法，用反射来执行订阅事件的方法，这样发送出去的事件就被订阅者接收并做相应处理了，

void invokeSubscriber(Subscription subscription, Object event) { 
        try { 
            subscription.subscriberMethod.method.invoke(subscription.subscriber, event); 
        } catch (InvocationTargetException e) { 
            handleSubscriberException(subscription, event, e.getCause()); 
        } catch (IllegalAccessException e) { 
            throw new IllegalStateException("Unexpected exception", e); 
        } 
    }

另外一种是先将事件入队列(其实底层是一个List)，然后做进一步处理，我们以mainThreadPoster.enqueue(subscription, event)为例简单的分析下，其中mainThreadPoster是HandlerPoster类的一个实例，来看该类的主要实现，

public class HandlerPoster extends Handler implements Poster { 
    private final PendingPostQueue queue; 
    private boolean handlerActive; 
    ...... 
    public void enqueue(Subscription subscription, Object event) { 
        // 用subscription和event封装一个PendingPost对象 
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event); 
        synchronized (this) { 
            // 入队列 
            queue.enqueue(pendingPost); 
            if (!handlerActive) { 
                handlerActive = true; 
                // 发送开始处理事件的消息，handleMessage()方法将被执行，完成从子线程到主线程的切换 
                if (!sendMessage(obtainMessage())) { 
                    throw new EventBusException("Could not send handler message"); 
                } 
            } 
        } 
    } 
    @Override 
    public void handleMessage(Message msg) { 
        boolean rescheduled = false; 
        try { 
            long started = SystemClock.uptimeMillis(); 
            // 死循环遍历队列 
            while (true) { 
                // 出队列 
                PendingPost pendingPost = queue.poll(); 
                ...... 
                // 进一步处理pendingPost 
                eventBus.invokeSubscriber(pendingPost); 
                ...... 
            } 
        } finally { 
            handlerActive = rescheduled; 
        } 
    } 
}

所以HandlerPoster的enqueue()方法主要就是将subscription、event对象封装成一个PendingPost对象，然后保存到队列里，之后通过Handler切换到主线程，在handleMessage()方法将中将PendingPost对象循环出队列，交给invokeSubscriber()方法进一步处理：

void invokeSubscriber(PendingPost pendingPost) { 
        Object event = pendingPost.event; 
        Subscription subscription = pendingPost.subscription; 
        // 释放pendingPost引用的资源 
        PendingPost.releasePendingPost(pendingPost); 
        if (subscription.active) { 
            // 用反射来执行订阅事件的方法 
            invokeSubscriber(subscription, event); 
        } 
    }

这个方法很简单，主要就是从pendingPost中取出之前保存的event、subscription，然后用反射来执行订阅事件的方法，又回到了第一种处理方式。所以mainThreadPoster.enqueue(subscription, event)的核心就是先将将事件入队列，然后通过Handler从子线程切换到主线程中去处理事件;

backgroundPoster.enqueue()和asyncPoster.enqueue也类似，内部都是先将事件入队列，然后再出队列，但是会通过线程池去进一步处理事件。

EventBus底层采用的是注解和反射的方式来获取订阅方法信息;

整个EventBus可以看出，事件是被观察者，订阅者类是观察者，当事件出现或者发送变更的时候，会通过EventBus通知观察者，使得观察者的订阅方法能够被自动调用;

本文转载自微信公众号「 Android开发编程」，可以通过以下二维码关注。转载本文请联系 Android开发编程公众号。

一文彻底搞懂EventBus3.0事件总线框架原理