EventBus 3.X 的源码解析及简单封装

前言

EventBus使用很简单，遵循着注册--发送--接收的一个步骤。EventBus 在3.0版本以后完全摒弃了以前固定接收方法，采用注解的形式来接收消息，注解的方法名可自定义，这样也更能明确的表现出方法的作用，不用再跟以前一样，所有的接收方法都一样的惨剧。当然官方给出了注解解析器，便于提高效率，做到编译时注解。Android Studio上有一个插件，eventbus3-intellij-plugin，可以为3.0及以后的版本提供快速跳转，不封装也可以愉快的使用。当然封装了就破坏了原有的结构，这个插件也没有效果了。一个是快速方便跳转，查找容易，一个是为了代码的统一性牺牲便利性，如何抉择，自己决定吧！

使用

使用方式及其简单，完全傻瓜教程只需三步：

注册：在需要接收EventBus传递消息的类注册EventBus。

EventBus.getDefault().register(object);

regist的参数是Object，也就说明在任何类中都可以注册EventBus。

发送：在任意类中，发送EventBus消息。

//发送即时事件
EventBus.getDefault().post(bean);
//发送粘性事件
EventBus.getDefault().postSticky(bean);

简单说下即时事件和粘性事件的区别：
即时事件：先注册接收，再发送事件。事件发出后即时传递下去，不考虑是否有注册这个事件的方法。
粘性事件：先发送，后注册接收事件。事件先发出，再检测是否有注册此事件的方法，若有就传递下去，若没有就停止传递，直到有此事件的方法注册了，才会传递。此事件EventBus会一直缓存，直到移除为止。
后续解析源码的时候再细说使用场景。

接收：在当前注册的类中，使用注解标记接收EventBus的发送来的数据

EventBus 3.0及后续的方法不再局限方法名，可使用任意方法的方面，只需要在方法前加注解@Subscribe即可

@Subscribe(threadMode = ThreadMode.MAIN)
    public void Demo(Demo3Bean bean) {
        //处理事件
    }

threadMode标记此方法的线程：

• POSTING：与发送事件的线程保持一致，减少内存开销。如果不需要切换线程，可以直接使用此值。
• MAIN：切换线程到主线程。由于是主线程操作，避免耗时操作。
• MAIN_ORDERED：同MAIN线程切换到主线程，与MAIN不同的是，如果MAIN线程发送事件的线程也是主线程，那么不进入队列，直接调用该接受方法；而MAIN_ORDERED是先进入队列后再发送给接受方法。因为也是主线程，所以避免耗时操作。
• BACKGROUND：后台线程。注意此线程是EventBus的唯一的后台线程，并保证所有事件按顺序交付，如果是比较耗时的后台操作，为了保证其他后台事件的正常运行，请使用ASYNC。
• ASYNC：后台线程，并且是一个单独的后台线程。若有网络请求等一类的耗时操作，请使用此线程。

如果发送的是粘性事件的话，需要再加一个参数：

@Subscribe(threadMode = ThreadMode.MAIN, sticky = true)
    public void Demo(Demo3Bean bean) {
         //接收到粘性事件
    }

sticky = true表示这是一个粘性事件，如果不移除此事件，EventBus会一直缓存此粘性事件，但凡注册了此事件的粘性接收事件都会接收到这个事件，所以使用完要及时移除。

// 移除指定的粘性事件
EventBus.getDefault().removeStickyEvent(Object event);

// 移除指定类型的粘性事件
EventBus.getDefault().removeStickyEvent(Class eventType);

// 移除所有的粘性事件
EventBus.getDefault().removeAllStickyEvents();

当然也可以指定事件的优先级：

@Subscribe(threadMode = ThreadMode.POSTING, priority = 0)
    public void Demo(Demo3Bean bean) {
         //TODO
    }

priority = 0是默认优先级，不设置的话priority的值就是0，可以在高优先级的订阅者方法接收到事件之后取消事件的传递。此时，低优先级的订阅者方法将不会接收到该事件。注意： 订阅者方法只有在线程模式为ThreadMode.POSTING时，才可以取消一个事件的传递。或者也可以理解为相同的线程模式下，才能取消下一事件的传递。能保证相同线程的模式也只有ThreadMode.POSTING。

掌握以上这些，你就可以愉快的使用了。

源码也要

源码解析

先看注册：

EventBus.getDefault().register(object);

 /** Convenience singleton for apps using a process-wide EventBus instance. */
    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);//注解@Subscriber的方法寻找器
        logSubscriberExceptions = builder.logSubscriberExceptions;//是否通过log输出异常日志，默认输出
        logNoSubscriberMessages = builder.logNoSubscriberMessages;//是否通过log输出没有订阅者的消息，默认输出
        sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;//是否发生异常到SubscriberExceptionEvent，默认发生
        sendNoSubscriberEvent = builder.sendNoSubscriberEvent;//是否将没有订阅的消息通过NoSubscriberEvent发送出去
        throwSubscriberException = builder.throwSubscriberException;//是否抛出SubscriberException，默认抛出
        eventInheritance = builder.eventInheritance;
        executorService = builder.executorService;
    }

创建过程也是大家常见的建造者模式，如果想定义其中某些属性也可以自己创建build，来修改内部属性；

EventBus.builder()
                .throwSubscriberException(false)
                .eventInheritance(false)
                ...
                .installDefaultEventBus();

最后执行installDefaultEventBus()，将修改后的EventBus对象赋值给默认的对象，使用方法依然是EventBus.getDefault().post(bean);而EventBus.getDefault()获取的默认对象就是已经自定义过的EventBus对象。
继续看register：

public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);//检索当前注册EventBus类使用@Subscriber的方法
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

简单看下findSubscriberMethods方法：

List findSubscriberMethods(Class 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;
        }
    }

到这可以看到，如果当前类注册了EventBus而没有任何方法使用@Subscribe接收方法，就会抛出异常。所以EventBus要按需使用，当需要使用的时候再去注册，不能再在基类中无脑注册反注册了。

再看下subscribe方法：

// Must be called in synchronized block
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        ···
        //多次注册也会抛异常
        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);
        //粘性事件处理
        if (subscriberMethod.sticky) {
            if (eventInheritance) {
                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);
            }
        }
    }

注册的逻辑大致如此，喜欢钻研的小伙伴们可以深入代码去了解。

接下来发送事件：

EventBus.getDefault().post(bean);

即时事件post()：

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