EventBus3.x源码解析-register流程分析(反射方式)

前文

由于EventBus的源码还是比较的复杂的，打算使用五篇文章从浅入深的分析它的源码。包括：

1. post流程的分析
2. register流程分析(反射方式)【本文】
3. register流程分析(注解方式)
4. stickey消息实现和处理
5. 最佳实践

register的流程

我们再使用过程中，都需要在页面调用register(obj)进行注册，这样我们的使用了@Subscribe注解的方法才能接受消息。本文就是主要去讲解这个注册的流程。

在EventBus3.x之后，它新增了一种注解的方式，让我们通过编译期就能知道那些方法是需要接受消息的(即@Subscribe注解的方法)，在之前，他是只有通过运行时通过反射+缓存的方式，这种方式会一定程度的降低代码执行速度，所以就新增了一种，我们这里就先分析通过反射的方式去查找被@Subscribe注解的方法。需要注意的时候，查找这些方法可以通过注解进行运行时效率的优化，但是post消息的时候还是通过反射去调用的，这个的效率是没有降低的。

属性定义

首先，我们先看一下对一个事件的定义的属性有那些，类名称是SubscriberMethod，需要与SubscriberMethodInfo区分开，后者是用于注解生成的，他会转化成SubscriberMethod，这些我们再注解篇中再说。

public class SubscriberMethod {
    final Method method; //接收消息的方法
    final ThreadMode threadMode; //处理消息线程模式
    final Class<?> eventType; //事件的类型
    final int priority; //优先级
    final boolean sticky; //是否为粘性消息
    String methodString; //用于判断是否为同一个方法，不使用method.equal()，因为后者开销大，他的规则是<声明方法所在类>#<methodName>(<eventType name>，比如一个在A中声明的test(String)方法，methodString是com.example.A#test(Java.lang.String

}

Subscription类

final class Subscription {
    final Object subscriber; //subscriberMethod所在的类的对象
    final SubscriberMethod subscriberMethod; //订阅时事件的对象
    //false的时候，subscriberMethod将不会收到事件
    //他在unRegister的时候回被设置为false，因为页面销毁需要时间，假如是在页面销毁期间，收到了消息，这时候我们是不应该去处理的，即调用了unRegister，那么该页面的所有的事件，不管是否由于异步或者是滞后等其他原因post了消息来到当前的subscriberMethod，他都是不分发的
    volatile boolean active;
}

register流程

通过EventBus的register方法发起，具体的查找被@Subscribe注解的方法是在findSubscriberMethods中

public void register(Object subscriber) {
        if (AndroidDependenciesDetector.isAndroidSDKAvailable() && !AndroidDependenciesDetector.areAndroidComponentsAvailable()) {
            // 假如是Android的话，必须要引入org.greenrobot:eventbus-java依赖，我们使用gradle引入eventbus的时候，假如不是使用@arr的方式，是会自动引入的，它里面包含了AndroidComponentsImpl，是用于日志打印的，当然还有其他的，后续再说
            throw new RuntimeException("xxx");
        }
        //拿到当前页面的class
        Class<?> subscriberClass = subscriber.getClass();
        //查询当前页面的被@Subscribe注解的方法，本篇文章的终点就是探讨findSubscriberMethods方法
        List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        //下面的就是对sticky消息进行分发，本文暂不细说
        synchronized (this) {
            //把得到的需要订阅的那些消息存入到subscriptionsByEventType中
            //同时假如subscriberMethods中有stick的消息，则查询并发分，具体的我们后续再说
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

我们开始看下findSubscriberMethods是如何查询得到我们页面使用了@Subscribe方法的，看下整个的查找流程。

List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
        List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }
        //是否是忽略注解类型的形式去查找，我们可以通过eventbusBuilder去设置
        //注解是3.x之后引入的代码，他可以帮助我们避免查找方法到时候使用反射去查找，
        //假如我们没有配置注解，可以把该参数设置为true，关注解相关的我们后续再说
        if (ignoreGeneratedIndex) {
            //通过反射查找，这是我们本文的文章的终点
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            //这是可以通过注解的方式，我们下一篇文章再说，通过查找通过Builder的addIndex方法添加进来自动生成的类的得到subscriberClass所有的接受消息的方法
            subscriberMethods = findUsingInfo(subscriberClass);
        }
        if (subscriberMethods.isEmpty()) {
            throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
        } else {
            //缓存起来，以页面class为key，他的所有订阅方法缓存，这样下次再进入就不用重新查找读取了
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

本文是讲解的反射的方式，我们就只关注关注findUsingReflection方法

private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
        //准备一个FindState，他的作用是临时存储所有的查找到subscriberClass中@Subscribe的方法的
        FindState findState = prepareFindState();
        //初始化
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            //通过反射的方式，查找到所有使用了@Subscribe的适配的方法
            findUsingReflectionInSingleClass(findState);
            //查询父类
            findState.moveToSuperclass();
        }
        //释放findState并且返回得到的SubscriberMethod
        return getMethodsAndRelease(findState);
    }

我们看下其中prepareFindState和getMethodsAndRelease方法，看下它为何是使用了长度为4的作为缓存？

//从FIND_STATE_POOL读取缓存的FindState对象，如果不存在，则新生成一个，他会在getMethodsAndRelease中存入FIND_STATE_POOL缓存
private FindState prepareFindState() {
        synchronized (FIND_STATE_POOL) {
            for (int i = 0; i < POOL_SIZE; i++) {
                FindState state = FIND_STATE_POOL[i];
                if (state != null) {
                    FIND_STATE_POOL[i] = null;
                    return state;
                }
            }
        }
        return new FindState();
    }

//读取findState中的subscriberMethods，而且假如FIND_STATE_POOL中有原生为空，则会把findState缓存起来
private List<SubscriberMethod> getMethodsAndRelease(FindState findState) {
        List<SubscriberMethod> subscriberMethods = new ArrayList<>(findState.subscriberMethods);
        findState.recycle();
        synchronized (FIND_STATE_POOL) {
            for (int i = 0; i < POOL_SIZE; i++) {
                if (FIND_STATE_POOL[i] == null) {
                    FIND_STATE_POOL[i] = findState;
                    break;
                }
            }
        }
        return subscriberMethods;
    }    
    
//FIND_STATE_POOL的主要作用就是避免老是需要生成FindState对象，那为何需要4呢？我们想象一下，假如多个页面同时在不同线程去发起了注册，那么就会多次调用了prepareFindState方法，他是不会直接存起缓存的，只有得到所有的SubscriberMethod结果只会才会缓存，那么设立了长度为4，就是我们可以对线程数<=4的多线程注册都可以使用缓存去避免多次生成FindState对象，假如是超出的就不会使用了，这可以基本避免了FindState多次生成，一般情况下FIND_STATE_POOL应该是只有一个FindState对象

然后我们看下findUsingReflection他的核心循环方法

private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // 查找声明方法
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            // 发送异常则查找所有的方法
            try {
                methods = findState.clazz.getMethods();
            } catch (LinkageError error) { 
                //没有则报错，
            }
            //通过这种方式则不需要查找父类的
            findState.skipSuperClasses = true;
        }
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            //需要方法是PUBLIC的，而且不是MODIFIERS_IGNORE中的，MODIFIERS_IGNORE是抽象或者是静态或者是桥接，合成(新版java)之类的方法
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                Class<?>[] parameterTypes = method.getParameterTypes();
                //参数长度需要=1的方法
                if (parameterTypes.length == 1) {
                    //查找使用了Subscribe注解的方法
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                        Class<?> eventType = parameterTypes[0];
                        //符合checkAdd则subscriberMethods新增一个SubscriberMethod
                        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)) {
                    //如果Builder配置了严格检测，则把使用了Subscribe注解的方法，并且他的参数长度!=1的爆出一次
                    throw new EventBusException("xxx");
                }
            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                //如果Builder配置了严格检测，则把使用了Subscribe注解的方法，并且他的修饰符不正确则爆出异常
                throw new EventBusException("xxx");
            }
        }
    }

我们看下checkAdd方法是

 boolean checkAdd(Method method, Class<?> eventType) {
            //取出上一次缓存起来的type对应的对象，首次存入为null，多次存入的话，existing可能是当前对象，或者是Method对象
            Object existing = anyMethodByEventType.put(eventType, method);
            if (existing == null) {
                return true;
            } else {
                //假如存在，而且是一个method
                if (existing instanceof Method) {
                    if (!checkAddWithMethodSignature((Method) existing, eventType)) {
                        // false则说明，
                        throw new IllegalStateException();
                    }
                    // 把eventType对应的存储的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());
            //以方法名称+参数的类型名称组合为key，比如方法为test(String a)，则得到的methodKeyBuilder->[test>Java.lang.String]
            String methodKey = methodKeyBuilder.toString();
            //获取声明自己的类，注意假如是子重写了父类，getDeclaringClass那么返回的还是子类而不是父类，只要获取method传入的class中有声明或者是覆盖了该方法，就返回当前Class,没有就查找最靠近的父类的
            Class<?> methodClass = method.getDeclaringClass();
            //存入缓存，并返回oldValue，如果之前没有是返回null
            Class<?> methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
            //如果之前没有缓存，或者是缓存的class是当前声明method的父类or本身，就返回true
            //则返回true
            if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
                // Only add if not already found in a sub class
                return true;
            } else {
                // 否则存入当前，并返回false
                subscriberClassByMethodKey.put(methodKey, methodClassOld);
                return false;
            }
}

当完成了一次findUsingReflectionInSingleClass()方法调用之后，会调用findState.moveToSuperclass()进行下一个clazz的查找，如果没有，则findUsingReflection结束，

void moveToSuperclass() {
            if (skipSuperClasses) {
                //如果是跳过父类的方法查找，clazz置空
                clazz = null;
            } else {
                //获取父类
                clazz = clazz.getSuperclass();
                String clazzName = clazz.getName();
                // Skip system classes, this degrades performance.
                // Also we might avoid some ClassNotFoundException (see FAQ for background).
                if (clazzName.startsWith("java.") || clazzName.startsWith("javax.") ||
                        clazzName.startsWith("android.") || clazzName.startsWith("androidx.")) {
                        //父类是以java. javax. android. androix.开头的父类，就查找了，因为我们一般不会改动到这里的源码，查找了没有@Subscribe注解的 方法也没有意义
                    clazz = null;
                }
            }
        }

所以findUsingReflection(Class<?> subscriberClass)的流程图大致如下

当流程整体清晰了之后，我们再探讨下checkAdd()的作用，它在findUsingReflectionInSingleClass中被调用，他返回了true才可以得到有效的【订阅方法】，返回了false就会丢掉。我们来列举下面的一些情况，这些情况的前提method都必须使用了@Subscribe注解并且是符合规则是(比如非抽象，参数只有一个等)。

class Foo {
    @Subscribe
    public void test(String msg) {
    }
}

class Foo2 extends Foo {
    @Subscribe
    @Overrider
    public void test(String msg) {
    }
}

class Test extends Foo2{
    @Subscribe
    @Overrider
    public void test(String msg) {
    }
    
    @Subscribe
    public void test2(String tag){

    }
}

Test是我们的页面，我们会在Test中去调用EventBus的register方法，然后看checkAdd()的走势

1. 首次的时候,查找的是Test的test，我们的anyMethodByEventType肯定是没有对应的method，这时候是返回了true。
2. 然后是查找到Test的test2方法，然后发现existing是有值的，类型是method，然后第一次执行checkAddWithMethodSignature，methodKeyBuilder值为test>Java.lang.String，methodClass是Test,methodClassOld为null，返回true，所以不会抛出IllegalStateException，然后把anyMethodByEventTypeeventType对应的值修改为当前FindState，第二次执行checkAddWithMethodSignature，methodKeyBuilder值为tes2t>Java.lang.String,methodClassOld为null，返回了true。
3. 然后循环到 Foo2类，existing值是FindState，并更新anyMethodByEventType的eventType对应值未对应的method，执行checkAddWithMethodSignature，methodKeyBuilder值为test>Java.lang.String，methodClass是Foo，methodClassOld是Test，返回了false，然后checkAdd返回了false，并且把subscriberClassByMethodKey的值设置为了Test，所以Foo2中的Test方法并不是有效的【订阅方法】
4. 再次循环到Foo，这时候existing是Foo2类的test方法，然后第一次走checkAddWithMethodSignature，methodKeyBuilder值为test>Java.lang.String，methodClass是Foo2，methodClassOld是Test，返回false，抛出异常。

通过上面的流程分析，我们知道上面的代码会抛出异常，而且就算只有两层继承(没有Foo类)，父类的方法也不会被统计为有效的【订阅方法】

通过这个流程，我们再回头看下FindState类的组成，它的每个成员的作用进行描述：

static class FindState {
        //存储查找到的subscriberClass页面中的订阅方法
        final List<SubscriberMethod> subscriberMethods = new ArrayList<>();
        //key为事件的类型，value值可以是方法或者是当前fineState对象，他会进行来回的变更
        final Map<Class, Object> anyMethodByEventType = new HashMap<>();
        //key值为方法+声明方法所在类组合得到的key，valye为方法所在类，如果某个类不是已存在的子类或者是本身，就不会覆盖
        //也就是说，它存储的是继承关系中的子类而非父类
        final Map<String, Class> subscriberClassByMethodKey = new HashMap<>();
        //用于生成subscriberClassByMethodKey中的key
        final StringBuilder methodKeyBuilder = new StringBuilder(128);
        //页面class
        Class<?> subscriberClass;
        //用于循环查找的class
        Class<?> clazz;
        //是否不需要查找父类的标记
        boolean skipSuperClasses;
        //存储注解生成的method
        SubscriberInfo subscriberInfo;
}

通过分析上面的流程，我们可以知道一些关于重载与继承订阅方法的特点

1. 子类Override了父类的方法，两个方法都是使用了@Subscribe注解的时候，父类的会失效，不会被统计到为有效方法中，但是分发的时候也可以分发给该方法(配置篇和post()流程篇有说)。
2. 一个方法Override>=2次，并且，假如还具有一个额外的Overload方法，那么调用register就会抛出异常。
3. 假如父类有@Subscribe注解方法， 子类没有去重写，则post消息的时候他也是能收到的，也是有效的订阅方法