摘要：第二種是通過方法來檢查，源碼如下通過以及來生成一個，來存儲方法所在的類。先看下的方法繼承了，調用方法后會向事件隊列中插入一個事件，然后將標記位設置為表示正在處理事件，然后調用發送消息通知處理事件。

首先從訂閱開始

EventBus.getDefault().register(this);

register方法會獲取傳入的object對象的class，通過findSubscriberMethods方法來查找這個class中訂閱的方法，如下

    public void register(Object subscriber) {
        Class<");synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

findSubscriberMethods方法實現如下，其中有一個ConcurrentHashMap類型的靜態對象METHOD_CACHE，是用來緩存對應類的訂閱方法的，以便后續再次訂閱時不用重新去findMethods，可以直接從緩存中讀取。

    List findSubscriberMethods(Class<"); {
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        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;
        }
    }

查找訂閱方法通過ignoreGeneratedIndex字段分為兩種方式

第一種findUsingReflection是通過反射來查找，找到被@Subscribe注解修飾的方法，并且根據具體的注解以及方法參數生成一個SubscriberMethod對象：

findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));

第二種findUsingInfo是通過apt的方式，提前找到訂閱的方法，可以避免通過反射查找方法帶來的耗時。

具體使用方法：在gradle配置apt，rebuild項目，會生成一個注解方法索引類，在EventBusBuilder中通過addIndex方法新建一個該類的對象傳入即可。

這邊還有一個問題，對于子類重寫父類的訂閱方法如何處理。在上面的兩種方式中在查找完子類的訂閱方法后都會繼續去查找父類的訂閱方法，都通過一個叫做checkAdd的方法進行支撐，該方法返回true表示可以添加到訂閱方法的集合中去。

boolean checkAdd(Method method, Class<"); {
    // 2 level check: 1st level with event type only (fast), 2ndlevelwith complete signature when required.
    // Usually a subscriber doesn"t have methods listening to thesameevent type.
    Object existing = anyMethodByEventType.put(eventType, method);
    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" theexistingMethod
            anyMethodByEventType.put(eventType, this);
        }
        return checkAddWithMethodSignature(method, eventType);
    }
}

checkAdd中設置了兩種檢查方式，第一種是通過eventType也就是訂閱方法的入參來檢查，這種方式比較快，只需要看下之前有沒有這種入參的方法就可以了。注釋中也指出了通常一個類不會有多個入參相同的訂閱方法。

第二種是通過checkAddWithMethodSignature方法來檢查，源碼如下：

private boolean checkAddWithMethodSignature(Method method,Class<"); {
    methodKeyBuilder.setLength(0);
    methodKeyBuilder.append(method.getName());
    methodKeyBuilder.append(">").append(eventType.getName());
    String methodKey = methodKeyBuilder.toString();
    Class<");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 theclasshierarchy
        subscriberClassByMethodKey.put(methodKey, methodClassOld);
        return false;
    }
}

通過method以及eventType來生成一個key，來存儲方法所在的類。其中methodClassOld == null ||methodClassOld.isAssignableFrom(methodClass)這個判斷條件對應著兩種情況，methodClassOld == null說明是入參相同但是方法名不同的方法正在被添加，直接返回true就可以了methodClassOld.isAssignableFrom(methodClass)這個條件是為了過濾掉父類被子類重寫的方法，前面說過了查找訂閱方法是從子類開始遍歷的，此時如果子類重寫了父類的訂閱方法，那么methodClassOld對應的是子類，methodClass對應的是父類，顯然這個判斷就會為false，之后進入下面的else分支return false，也就是忽略掉父類被子類重寫的方法。

查找訂閱方法基本就這么點，查找完畢之后需要執行訂閱操作，也就是register方法中的subscribe(subscriber, subscriberMethod);操作，直接看下該方法的實現：

private void subscribe(Object subscriber, SubscriberMethodsubscriberMethod) {
    Class<");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);
        }
    }
    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;
        }
    }
    Listif (subscribedEvents == null) {
        subscribedEvents = new ArrayList<>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
    subscribedEvents.add(eventType);
    if (subscriberMethod.sticky) {
        if (eventInheritance) {
            // Existing sticky events of all subclasses of eventTypehave to be considered.
            // Note: Iterating over all events may be inefficientwith lots of sticky events,
            // thus data structure should be changed to allow a moreefficient lookup
            // (e.g. an additional map storing sub classes of superclasses: Class -> List).
            Setfor (Map.Entryif (eventType.isAssignableFrom(candidateEventType)) {
                    Object stickyEvent = entry.getValue();
                checkPostStickyEventToSubscription(newSubscriptin, stickyEvent);
                }
            }
        } else {
            Object stickyEvent = stickyEvents.get(eventType);
            checkPostStickyEventToSubscription(newSubscription,stickyEvent);
        }
    }
}

subscriptionsByEventType這個Map是將eventType作為key保存其所對應的訂閱方法的集合。該方法將剛查找到的方法添加到對應的集合中去，添加時有這樣一層判斷i == size || subscriberMethod.priority >subscriptions.get(i).subscriberMethod.priority這表示這個集合里的方法會按照所設定的優先級進行排序。緊接著又出現了個MaptypesBySubscriber將訂閱者作為key保存一個Class的集合，暫時看不出有啥用，就先不管，最后再檢查下是不是粘性事件，如果是粘性事件就根據所保存的粘性事件來執行該方法。eventInheritance也是在bulider中設置的，如果為true則會考慮事件的繼承性，如果現在有eventType為正在訂閱的方法的eventType的子類的粘性事件存在，那么這個粘性事件也會被正在訂閱的方法接收到，直接說可能比較繞，舉個栗子，現在我有兩個事件，其中一個是另一個的子類，并且有兩個粘性訂閱方法，如下：

    class EventMessage {
  
    }

    class SubEventMessage extends EventMessage {

    }
    
    @Subscribe(sticky =  true)
    public void onEvent(EventMessage message) {
        // do something
    }

    @Subscribe(sticky =  true)
    public void onSubEvent(SubEventMessage message) {
        // do something
    }

當執行register時，如果內存中存在著一個類型為SubEventMessage的事件，那么訂閱的時候onEvent方法會被執行，入參是內存中類型為SubEventMessage的事件。

現在register大致就分析完了，再來看下unregister方法：

    public synchronized void unregister(Object subscriber) {
        Listif (subscribedTypes != null) {
            for (Class<");else {
            logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }

unregister方法十分簡單，typesBySubscriber是剛才在進行訂閱的時候不知道用來干什么的Map，現在知道是在取消訂閱時用到的，這個Map將訂閱者作為key，將其所有的訂閱方法的eventType存入到對應的List中去，取消訂閱時將這個List取出來，遍歷去移除對應的訂閱方法，具體實現在unsubscribeByEventType中，也十分簡單，就不贅述了。

訂閱和取消訂閱都看過了，還差個發送事件，發送事件分為post和postSticky兩種，先看post：

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