EventBus3.0源码分析

简述：

    在项目中，我们大多数开发者可能都使用过EventBus,即使没有使用过但我可以确定Android开发者也听说过这个牛X的库，从诞生到目前EventBus已经更新到3.X版本，可见生命力极强呀。那么这篇博文就从EventBus3.0源码的角度分析一下其内部处理流程。

使用流程：

    注册：

EventBus.getDefault().register(obj)

    订阅(消息接收)：

@Subscribe
public void receive(Object event){
}

    发布消息：

EventBus.getDefault().post(event)

    注销：

EventBus.getDefault().unregister(obj)

源码分析：

注册：

EventBus.getDefault().register(obj) 

   这段代码做了两件事情：① EventBus.getDefault() 创建EventBus对象；② register(obj) 方法为obj该类对象注册EventBus。 那这两个方法究竟在EventBus中究竟做了哪些工作呢？我们打开EventBus的源码看一下:

   1、EventBus.getDefault()

    源码如下：

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

    看到了吧，EventBus采用单例模式创建EventBus对象，接下来它在构造方法中又做了什么事情呢？

public EventBus() {
    this(DEFAULT_BUILDER);
}

    在构造方法中其调用了有参构造方法：EventBus(EventBusBuilder 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;

    //默认情况下参数为（null，false，false）
    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;
}

    这段代码对一些变量进行了初始化，现在就挑重要的变量解释一下。首先，初始化了3个Map，这3个Map有什么用呢？我们再来一一详细说一下：

    ① Map, CopyOnWriteArrayList> subscriptionsByEventType：key:事件类型（如：String类型或者自定义的事件类型），value:该事件的订阅者的list集合。当发送event消息的时候，都是去这里找对应的订阅者。

    ② Map>> typesBySubscriber：key:事件的订阅者（如XXXActivity），value：事件类型的运行时类的list集合。当register()和unregister()的时候都是操作这个Map。

    ③ Map, Object> stickyEvents：维护的是粘性事件的集合，粘性事件也就是当event发送出去之后再注册粘性事件的话，该粘性事件也能接收到之前发送出去的event消息。

    其次，初始化3个消息发送器如下：

    mainThreadPoster ：该类继承自Handler，而且在EventBus中mainThreadPoster属于主线程Handler，这是因为mainThreadPoster就是为处理“消息接收方法在主线程而消息发送在子线程 ”这个问题而设计的，所以子线程向主线程发送消息必须使用主线程的Handler。mainThreadPoster继承Handler也是为了效率考虑的。

    backgroundPoster：该类继承自Runnable，重写了run()方法。在run（）方法中将子线程中的消息通过EventBus发送到主线程。所以这个消息发送器作用就是处理“消息接收方法在子线程接而消息的发布在主线程”这样的问题。

    asyncPoster：该类继承自Runnable，也重写了run()方法，不过就像名字一样“异步”，也就是说不管订阅者是不是在主线程，消息接收方法都会另外开启一个线程处理消息。

    然后，一个重要的初始化对象为subscriberMethodFinder，这个对象利用反射的方法查找每一个接收消息者的方法（也即是添加了“@Subscribe ”注解的方法）。

    最后就是一些对EventBusBuilder的一些配置信息。其中eventInheritance和executorService在接下来分析源码时会经常碰到：① eventInheritance表示我们自定义的待发布消息事件是否允许继承,，默认情况下eventInheritance==true。它的作用就是处理业务时后来新增加业务后不必再修改代码，只需要继承就OK啦（这也符合程序的“开闭原则”）如下：

public class MessageEvent {
    public final String message;

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

public class SubMessageEvent extends MessageEvent {
    public SubMessageEvent(String message) {
        super(message);
    }
}

    ② executorService：这个线程池是给backgroundPoster和 asyncPoster用来处理消息发送的。这样做也能够提高消息发送的效率。

2、注册register(Object subscriber )

    EventBus的初始化工作已经完毕，我们继续看一下EventBus是怎么进行注册的，在注册过程中又搞了哪些事情？

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

     在该方法中首先取得注册者的运行时类对象，拿到运行时类对象后通过注册者注册方法查找器SubscriberMethodFinder利用反射的方法找到注册者类中所有的接收消息的方法，也即是所有添加了注解“Subscribe ”的方法。最后进行通过方法subscribe(subscriber, subscriberMethod)为每一个接收消息的方法进行注册。流程大致就是这样的，首先 我们先看一下findSubscriberMethods这个方法：

 /**
     * 方法描述：获取该运行时类的所有@Subscribe注解的所有方法
     *
     * @param subscriberClass @Subscribe注解所属类的运行时类对象
     * @return 注册EventBus类中@Subscribe注解的所有方法的List集合
     */
    List findSubscriberMethods(Class subscriberClass) {
        //先从缓存中查找是否存在消息接收的方法
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        if (ignoreGeneratedIndex) {
            //使用反射方法拿到订阅者中的订阅方法
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            //使用apt处理器拿到订阅者中的订阅方法
            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;
        }
    }

    这个方法很重要，在初次使用EventBus3.0的时候也容易出错的一个点（3.0新增注解）：就是在订阅事件的方法上没有添加 @Subscribe 注解，所以会碰到下面这个异常：

Caused by: org.greenrobot.eventbus.EventBusException: Subscriber class XXX and its super classes 
have no public methods with the @Subscribe annotation

    说到这我们还是没有最终看到EventBus是怎么进行注册的， OK，回过头来我们继续看注册：

private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    Class eventType = subscriberMethod.eventType;
    Log.e(TAG, eventType.getSimpleName());
    //将订阅类Object对象subscriber封装为EventBus的订阅类Subscription
    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);
        }
    }

    /**
    * 方法描述：对CopyOnWriteArrayList中的Subscription根据优先级的高低重新进行排序
    */
    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;
        }
    }
    /**
    * 方法描述：将开发者注册EventBus的类的运行时类添加到subscribedEvents中，并且把该运行时类添加到
    * typesBySubscriber中
    */
    List> subscribedEvents = typesBySubscriber.get(subscriber);
    Log.e(TAG, "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).
            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);
        }
    }
}

    上面的这段代码虽然很多，但主要做了几件事情：① 将注册的订阅者封装为新的Subscription类 ②将订阅者存储到Map集合 subscriptionsByEventType当中 ③对消息事件接收者根据优先级进行重排序 ④添加粘性消息事件

发布消息：

    我们已经分析完了EventBus的注册过程，接下来我们再来分析一下EventBus的事件发送过程。

EventBus.getDefault().post(event);

    那么这段代码是如何实现消息的发送呢？继续源码看一下：

public void post(Object event) {
    PostingThreadState postingState = currentPostingThreadState.get();
    List