EventBus源码分析

摘要：第二种是通过方法来检查，源码如下通过以及来生成一个，来存储方法所在的类。先看下的方法继承了，调用方法后会向事件队列中插入一个事件，然后将标记位设置为表示正在处理事件，然后调用发送消息通知处理事件。

首先从订阅开始

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