事件总线-EventBus-源码学习过程

使用过程略过。

源码分析

register方法：
1、获取注册对象类型
2、获取对象的所有的订阅方法的集合
3、遍历集合，执行订阅subscribe方法。

/**
     * Registers the given subscriber to receive events. Subscribers must call {@link #unregister(Object)} once they
     * are no longer interested in receiving events.
     * 

     * Subscribers have event handling methods that must be annotated by {@link Subscribe}.
     * The {@link Subscribe} annotation also allows configuration like {@link
     * ThreadMode} and priority.
     */
    public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

SubscriberMethod类包含订阅方法的所有信息，Method对象，参数类型，执行的线程，优先级，是否粘性

public class SubscriberMethod {
    final Method method;//Method
    final ThreadMode threadMode;//执行的线程
    final Class eventType;//方法参数的EventType
    final int priority;//优先级
    final boolean sticky;//是否粘性
    /** Used for efficient comparison */
    String methodString;//用于比较的字段

    public SubscriberMethod(Method method, Class eventType, ThreadMode threadMode, int priority, boolean sticky) {
        this.method = method;
        this.threadMode = threadMode;
        this.eventType = eventType;
        this.priority = priority;
        this.sticky = sticky;
    }
......其他代码省略
}

SubscriberMethod集合的获取逻辑：

List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);

findSubscriberMethods实现

    List findSubscriberMethods(Class subscriberClass) {
        //从缓存中查找
        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;
        }
    }```
分为使用索引和忽略索引两个方法的内容，使用索引的后面单独了解。忽略索引的逻辑，FindState查找帮助类。里面的checkAll、checkAddWithMethodSignature、moveToSuperclass这三个方法很有趣，使用的map.put返回“前任”逻辑，巧妙的实现了对象是否被添加过的判断。

static class FindState {
//所有订阅方法的集合
final List subscriberMethods = new ArrayList<>();
//事件类型是已经存在的标识map
final Map anyMethodByEventType = new HashMap<>();
//方法key和方法所属的类组成的标识map
final Map subscriberClassByMethodKey = new HashMap<>();
//产生方法key的builder
final StringBuilder methodKeyBuilder = new StringBuilder(128);

    Class subscriberClass;
    Class clazz;
    boolean skipSuperClasses;
    SubscriberInfo subscriberInfo;

    void initForSubscriber(Class subscriberClass) {
        this.subscriberClass = clazz = subscriberClass;
        skipSuperClasses = false;
        subscriberInfo = null;
    }

    void recycle() {
        subscriberMethods.clear();
        anyMethodByEventType.clear();
        subscriberClassByMethodKey.clear();
        methodKeyBuilder.setLength(0);
        subscriberClass = null;
        clazz = null;
        skipSuperClasses = false;
        subscriberInfo = null;
    }

    boolean checkAdd(Method method, Class eventType) {
        // 2 level check: 1st level with event type only (fast), 2nd level with complete signature when required.
        // Usually a subscriber doesn't have methods listening to the same event type.
        //当前事件类型和方法是否已经添加了
        Object existing = anyMethodByEventType.put(eventType, method);
        if (existing == null) {
            //没有添加,返回true
            return true;
        } else {
            //已经添加了,判断前一个添加的标识对象是不是方法对象
            if (existing instanceof Method) {
                //是否已经添加了
                if (!checkAddWithMethodSignature((Method) existing, eventType)) {
                    // Paranoia check
                    throw new IllegalStateException();
                }
                // Put any non-Method object to "consume" the existing Method
                anyMethodByEventType.put(eventType, this);
            }
            return checkAddWithMethodSignature(method, eventType);
        }
    }

    private boolean checkAddWithMethodSignature(Method method, Class eventType) {
        methodKeyBuilder.setLength(0);
        methodKeyBuilder.append(method.getName());
        methodKeyBuilder.append('>').append(eventType.getName());

        String methodKey = methodKeyBuilder.toString();
        Class methodClass = method.getDeclaringClass();
        Class methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
        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 the class hierarchy
            subscriberClassByMethodKey.put(methodKey, methodClassOld);
            return false;
        }
    }

    void moveToSuperclass() {
        if (skipSuperClasses) {
            clazz = null;
        } else {
            clazz = clazz.getSuperclass();
            String clazzName = clazz.getName();
            /** Skip system classes, this just degrades performance. */
            if (clazzName.startsWith("java.") || clazzName.startsWith("javax.") || clazzName.startsWith("android.")) {
                clazz = null;
            }
        }
    }
}```

findUsingReflection：将订阅对象中所有打了标记的Subscribe的订阅方法，全部添加到findState的subscriberMethods中，然后通过getMethodsAndRelease，返回所有的订阅方法集合，并且将findState的对象放回对象池。
查找方法集合后，返回EventBus执行注册的逻辑。

synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }```
subscribe：

//添加到集合，并且按照优先级排序
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;
}
}```
这里用到有两个Cache：
1、subscriptionsByEventType＝EventType：Subscriptions（subscriber＋subscriberMethod）
2、typesBySubscriber＝obj：EventTypes
通过事件，快速定位到订阅者＋订阅方法对象；通过订阅者，获取它所订阅的所有事件类型集合。
粘性事件下一章再说。
注册到些为止。

unregister：通过typesBySubscriber获取所有注册的事件类型。然后通过subscriptionsByEventType获取每个事件类型对应该的订阅器集合，遍历每个订阅器，判断是否为当前对象，如果是，移除。

post：先看PostingThreadState类用来说明当前执行的线程事件的执行状态。

final static class PostingThreadState {
        final List