EventBus3.0源码学习(3) SubscriberMethodFinder

订阅函数查找

当一个对象调用register向EventBus注册时，查找对象中所有接收订阅事件的函数被封装在SubscriberMethodFinder类中。findSubscriberMethods的实现如下：

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    List<SubscriberMethod> 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为true，则调用findUsingReflection进行查找，否则调用findUsingInfo进行查找。EvenBus提供了额外的注解处理器，能在编译期完成订阅函数查找以提升性能。但此处我们只关注反射查找。findUsingReflection的实现如下：

private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
    FindState findState = prepareFindState();
    findState.initForSubscriber(subscriberClass);
    while (findState.clazz != null) {
        findUsingReflectionInSingleClass(findState);
        findState.moveToSuperclass();
    }
    return getMethodsAndRelease(findState);
}

第4-5行，遍历subscriberClass的超类体系，调用findUsingReflectionInSingleClass查找当前clazz的所有订阅函数。findUsingReflectionInSingleClass的代码如下：

private void findUsingReflectionInSingleClass(FindState findState) {
    Method[] methods;
    try {
        // This is faster than getMethods, especially when subscribers are fat classes like Activities
        methods = findState.clazz.getDeclaredMethods();
    } catch (Throwable th) {
        // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
        methods = findState.clazz.getMethods();
        findState.skipSuperClasses = true;
    }
    for (Method method : methods) {
        int modifiers = method.getModifiers();
        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];
                    if (findState.checkAdd(method, eventType)) {
                        ThreadMode threadMode = subscribeAnnotation.threadMode();
                        findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                    }
                }
            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                throw new EventBusException("@Subscribe method " + methodName +
                        "must have exactly 1 parameter but has " + parameterTypes.length);
            }
        } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
            String methodName = method.getDeclaringClass().getName() + "." + method.getName();
            throw new EventBusException(methodName +
                    " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
        }
    }
}

第3-10行，clazz.getDeclaredMethods()只返回当前clazz中声明的函数，而clazz.getMethods()将返回clazz的所有函数(包括继承自父类和接口的函数)，因此，此时skipSuperClasses被置为true，阻止递归查找父类。

第13行，只考虑public且非static、abstract、synthetic、bridge的方法(bridge方法主要是范型实现中用到(参见[1]))。第15行，函数有且只有一个参数。第16行，函数被@Subscribe注解修饰。第18-23行，将函数加入subscriberMethods集合。findState.checkAdd用于判断是否需要将当前method加入，其实现如下：

static class FindState {
    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) {
            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;
        }
    }
}

第5行，anyMethodByEventType存储<eventType, method>映射关系，若existing为空，则表示eventType第一次出现。一般情况下，一个对象只会有一个订阅函数处理特定eventType。

第9-17行，处理一个对象有多个订阅函数处理eventType的情况，此时，anyMethodByEventType中eventType被映射到一个非Method对象(即this)。

第22-24行，由于存在多个订阅函数处理eventType，此时，单纯使用eventType作为key已经无法满足要求了，因此，使用method.getName() + ">" + eventType.getName()作为methodKey，并使用subscriberClassByMethodKey存储<methodKey, methodClass>的映射关系。

第28-36行，如果methodClassOld或者methodClass是methodClassOld的子类，则将<methodKey, methodClass>放入，否则不放入。满足函数名相同、参数类型相同且被@Subscribe修饰的函数，在一个类中不可能存在两个；考虑类继承体系，若这样的两个函数分别来自父类和子类，则最终被加入的是子类的函数。

函数再过头来看，第10行，调用checkAddWithMethodSigature加入<existing, eventTpye>，第12行的throw理论上是不可能执行到的，第17行，调用checkAddWithMethodSigature加入<method, eventTpye>。

[参考文献]

[1] https://stackoverflow.com/questions/5007357/java-generics-bridge-method