Android事件传递三部曲：事件总线EventBus(下)

	SubscriberMethodFinder(List<SubscriberInfoIndex> subscriberInfoIndexes, boolean strictMethodVerification,
                           boolean ignoreGeneratedIndex) {
        // 这个我们在这里暂时不解释太多，后面用到的时候，我们在展开
        this.subscriberInfoIndexes = subscriberInfoIndexes;
        // 是否开启方法严格检查，如果开启，后面在检查订阅方法找到不符规则的方法会直接抛出异常，否则不做任何处理。默认是false
        this.strictMethodVerification = strictMethodVerification;
        // 是否忽略EventBus AnnotationProcessor 生成的代码，后面用到的时候再提，同样默认是false
        this.ignoreGeneratedIndex = ignoreGeneratedIndex;
    }
    
    // 找到subscriber中所有的订阅方法
    List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
        // 首先试图从缓存中读取，如果命中将直接返回
        List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }
        
        // 根据配置的不同，选择不同的获取方法
        if (ignoreGeneratedIndex) {
            // 忽略AnnotationProcessor生成的文件，直接通过反射获取
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            // 通过AnnotationProcessor生成的文件获取所有的订阅方法，效率更高
            subscriberMethods = findUsingInfo(subscriberClass);
        }
        
        // 如果在subscriber中没有找到任何订阅方法，则抛出异常
        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;
        }
    }

private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            // 获取findState当前指向的Class中包含的所有订阅方法
            findUsingReflectionInSingleClass(findState);
            // 如果支持订阅继承，findState将指向当前Class的父类，否则指向null, 退出循环。实现EventBus宣称的Subscriber inheritance特性
            findState.moveToSuperclass();
        }
        // 将findState中的subscriberMethods取出返回，并将findSate回收掉
        return getMethodsAndRelease(findState);
    }

    // 获取单个Class中的所有订阅方法并将其保存到findState的subscriberMethods中
    private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // 相比getMethods，getDeclaredMethods只会获取当前类声明的方法，不包括其继承的方法，效率更高
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            // 尝试用简单的方法失败之后，直接用gatMethods，
            // 这时候返回的方法中已经包含其父类的所有方法，所有就将skipSuperClasses置为true，提高效率
            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            // 这里就解释了为什么我们的订阅方法不是public时，不生效，但是具体为什么EventBus要求方法为public，我们会再做解释
            // 当然，除了public，还有一些其他的要求，包括不能包括abstract以及static
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                Class<?>[] parameterTypes = method.getParameterTypes();
                // 订阅方法要求只能有一个参数
                if (parameterTypes.length == 1) {
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                        Class<?> eventType = parameterTypes[0];
                        // 通过eventType判断是否已经添加过，如果已经添加过，这次将直接跳过
                        // 具体判断的逻辑，有兴趣的同学可以看下，还有有些条条道道的，分成了两步来判断：先检查eventType，在检查方法名
                        if (findState.checkAdd(method, eventType)) {
                            // 将注解中的信息取出：theadMode，priority以及sticky，并将其添加到方法列表中
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
                }
                // 省略了部分代码，用于处理方法不合规
            }
        }
    }
    
    private List<SubscriberMethod> getMethodsAndRelease(FindState findState) {
        List<SubscriberMethod> subscriberMethods = new ArrayList<>(findState.subscriberMethods);
        findState.recycle();
        // 省略部分代码
        return subscriberMethods;
    }

    private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
        // 获取一个FindState并初始化，具体获取是通过对象池实现的，避免了重复创建对象
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            // 获取AnnotationProcessor生成的subscriberInfo，如果获取失败，将使用反射获取
            // 后续的操作就和通过反射获取的方式类似
            findState.subscriberInfo = getSubscriberInfo(findState);
            if (findState.subscriberInfo != null) {
                SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
                for (SubscriberMethod subscriberMethod : array) {
                    if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                        findState.subscriberMethods.add(subscriberMethod);
                    }
                }
            } else {
                findUsingReflectionInSingleClass(findState);
            }
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }

android {
    defaultConfig {
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = [ eventBusIndex : 'com.example.myapp.MyEventBusIndex' ]
            }
        }
    }
}

dependencies {
    compile 'org.greenrobot:eventbus:3.0.0'
    annotationProcessor 'org.greenrobot:eventbus-annotation-processor:3.0.1'
}

EventBus eventBus = EventBus.builder().addIndex(new MyEventBusIndex()).build();

    private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
        switch (subscription.subscriberMethod.threadMode) {
            // 如果没有定义threadMode，默认就是这种，直接通过invoke执行subscriber中的订阅方法
            case POSTING:
                invokeSubscriber(subscription, event);
                break;
            // 如果已经在主线程了，效果和POSTING一样，否则将通过mainThreadPoster进行调度
            case MAIN:
                if (isMainThread) {
                    invokeSubscriber(subscription, event);
                } else {
                    mainThreadPoster.enqueue(subscription, event);
                }
                break;
            // 和MAIN恰好相反，如果不在主线程则直接调用，如果在主线程则将通过backgroundPoster调度
            case BACKGROUND:
                if (isMainThread) {
                    backgroundPoster.enqueue(subscription, event);
                } else {
                    invokeSubscriber(subscription, event);
                }
                break;
            // 不管在什么线程post事件，都会新开线程进行调度
            case ASYNC:
                asyncPoster.enqueue(subscription, event);
                break;
            default:
                throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
        }
    }

    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        ...
        // 如果这个订阅方法的sticky属性为true的话，将在订阅的同时收到之前缓存的StickyEvent
        if (subscriberMethod.sticky) {
            if (eventInheritance) {
                Set<Map.Entry<Class<?>, Object>> entries = stickyEvents.entrySet();
                for (Map.Entry<Class<?>, 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);
            }
        }
    }
    
    private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
        if (stickyEvent != null) {
            postToSubscription(newSubscription, stickyEvent, Looper.getMainLooper() == Looper.myLooper());
        }
    }

    public void postSticky(Object event) {
        synchronized (stickyEvents) {
            stickyEvents.put(event.getClass(), event);
        }
        post(event);
    }

        try {
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }