EventBus索引加速探究

EventBus在3.0后推出了索引加速（自己的AnnotationProcessor实现），来优化EventBus对 ​​@Subscribe​​方法的查找速度。

EventBus的官方说明中有这么一段：

译为：我们墙裂建议你使用 EventBus注解器和它的订阅者索引，这样会避免一些因为使用反射而导致的问题。

这说明EventBus本身不会自己使用注解器，需要我们添加才会使用。由于之前一直没有在项目中使用，突然发现有这么个说法，就写这篇来研究一下。（顺便回顾一下EventBus源码）

0. 为什么使用索引加速？

EventBus在源码上的实现目标是什么：“找到所有的订阅方法”
所以它的优化方向是什么：“以最快的速度找到所有的订阅方法”

这里先介绍一下3.0之前 EventBus寻找订阅方法的做法

• 3.0版本之前
  通过反射，拿到订阅者类的所有方法，找到​​​onEvent​​开头的订阅方法

就是通过 反射+遍历 的方式。这样的做法未免太过暴力，如果在方法特别多的类进行了注册，性能会不高。

GreenDao其实在很早就想过使用 反射+注解 的方式来进行方法搜寻，但是由于注解只是作为一个标识的方法，在没有别的帮助的情况下，还是得使用 遍历来拿到所有被注解的方法。 它就是变相版的“onEvent开头”的做法。
甚至性能更低（因为算上了注解时消耗的时间空间），这就导致 GreenDao团队迟迟不肯使用这个注解+反射的原因。

直到他们使用了 AnnotationProcessor

• 3.0版本
  提供了​​​EventBusAnnotationProcessor​​，它可以在编译时生成代码，避免了在运行时通过反射遍历所有方法的弊端。 在性能方面，超越之前任何版本

厉害归厉害，但是我之前一直认为这个 注解器是直接封装在 EventBus里面的，所以默认它会使用这种方法，直到我学习了AnnotationProcessor的用法…

1. findSubscriberMethods方法

在EventBus的​​register()​​​实现订阅者注册中，用到了 ​​findSubscriberMethods()​​​来获取订阅者声明的​​@Subscribe​​方法：

// EventBus.java
    List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
        List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }
        
        if (ignoreGeneratedIndex) {  // 1
            subscriberMethods = findUsingReflection(subscriberClass);  // 2
        } else {
            subscriberMethods = findUsingInfo(subscriberClass); // 3
        }
        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;
        }
    }

第一次注册的订阅者会走到注释1处进行判断。
​​​ignoreGeneratedIndex​​​ 这个字段的意思为 ：是否忽略索引生成
可以看出，这个字段用来判断订阅者是否使用索引加速。默认为false。

如果不使用索引加速，就会调用注释2： ​​findUsingRelfection()​​​，它通过反射得到订阅者类及其父类里所有方法，找到的被 ​​@Subscribe​​注解的方法。和第0节中所讲的方式是一样的。

如果使用索引加速，就会调用注释3： ​​findUsingInfo()​​，通过注解器方式获取。来看下这个方法：

// SubscriberMethodFinder.java
    private List<SubscriberMethod> findUsingInfo(Class<?> subscriberClass) {
        FindState findState = prepareFindState();  // 1
        findState.initForSubscriber(subscriberClass);  // 2
        while (findState.clazz != null) {
            findState.subscriberInfo = getSubscriberInfo(findState); // 3
            if (findState.subscriberInfo != null) { // 4
                SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods(); 
                for (SubscriberMethod subscriberMethod : array) {
                    if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                        findState.subscriberMethods.add(subscriberMethod);
                    }
                }
            } else {
                findUsingReflectionInSingleClass(findState); // 5
            }
            findState.moveToSuperclass(); // 6
        }
        return getMethodsAndRelease(findState);
    }

注释1：从 ​​FindState​​​池中获取一个 FindState对象，所以它的内容是空的。为什么使用 FindState池而不是 new一个出来，是因为EventBus是一个单例模式，一个进程只有一个EventBus，如果为了每个订阅者都要new一个FindState，那么其EventBus的内存空间就会有许许多多的FindState，为了优化性能，就创建 一个池子来循环利用。​​FindState​​的作用是用来描述 订阅者和订阅方法的关联信息。

注释2：将 订阅者对象 和注释1处获取到的FindState对象绑定，代码是这样的：

void initForSubscriber(Class<?> subscriberClass) {
            this.subscriberClass = clazz = subscriberClass;
            skipSuperClasses = false;
            subscriberInfo = null;  // 这里 subscriberInfo置null
        }

注释3：通过 ​​getSubscriberInfo(findState)​​来获取这个 订阅者的subscriberInfo

注释4： 如果subscriberInfo存在，就从 subscriberInfo中获取 @Subscribe方法

注释5：如果subscriberInfo不存在，就调用 ​​findUsingReflectionInSingleClass(findState)​​​ 反射+暴力的方法寻找，就是一开始的​​findUsingReflection()​​

显然，注释3的获取的东西，可以验证我们有没有开启 索引加速。我们来看看这个方法：

// SubscriberMethodFiner.java
    private SubscriberInfo getSubscriberInfo(FindState findState) {
        if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {  // 1
            SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
            if (findState.clazz == superclassInfo.getSubscriberClass()) {
                return superclassInfo;
            }
        }
        if (subscriberInfoIndexes != null) {  // 2
            for (SubscriberInfoIndex index : subscriberInfoIndexes) {
                SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
                if (info != null) {
                    return info;
                }
            }
        }
        return null;
    }

注释1： 如果 findState.subcriberInfo 不为null，且其内容也不为null，就把那些东西取出来。
在上面 FindState的初始化，我们看到了会把它的 subcriberInfo置为null，所以如果是第一次执行，注释1的条件是会判断会false。就会往注释2走。

注释2：判断 ​​subscriberInfoIndexes​​是否为空，如果不为空，则遍历所有，找到一个和 订阅者相匹配的 SubscriberInfo返回回去。

那​​subscriberInfoIndexes​​​是什么？怎么来的呢？
首先它是一个 ​​​List<SubscriberInfoIndex>​​​类型，它是一个列表，里面放的是 “订阅者索引”。
它在 EventBus的构造方法中被创建：

EventBus(EventBusBuilder builder) {
        ....
        subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
                builder.strictMethodVerification, builder.ignoreGeneratedIndex);
        ....
    }

可以看出它是来自于 ​​EventBusBuilder​​，而在EventBusBuilder中， 这个对象又是怎么产生的呢，我通过源码，发现它只有一处地方用来操作这个列表：

// EventBusBuidler.java
    /** Adds an index generated by EventBus' annotation preprocessor. */
    public EventBusBuilder addIndex(SubscriberInfoIndex index) {
        if (subscriberInfoIndexes == null) {
            subscriberInfoIndexes = new ArrayList<>();
        }
        subscriberInfoIndexes.add(index);
        return this;
    }

通过 ​​addIndex()​​​将 ​​SubscriberInfoIndex​​​ 往这个列表里面加。再往上找，没有了，addIndex()没有出现在任意一处被调用的地方。
也就是说，这个方法，是外部调用的。

它的英文注释我翻译一下：通过EventBus的注解处理器添加一个索引 。

这就说明了这个方法，是由注解器产生的Java文件调用。这也说明了，如果我们不使用注解处理器，EventBus寻找 ​​@Subcriber​​的做法，永远是 反射 + 遍历。

2. 通过EventBusAnnotationProcessor生成Java文件

​​EventBusAnnotationProcessor​​ 需要引入，示例代码如下：

// build.gradle
android {
    defaultConfig {
        javaCompileOptions {
            annotationProcessorOptions {
                arguments = [ eventBusIndex : 'com.example.myapp.MyEventBusIndex' ]
            }
        }
    }
}
 
dependencies {
    def eventbus_version = '3.2.0'
    implementation "org.greenrobot:eventbus:$eventbus_version"
    annotationProcessor "org.greenrobot:eventbus-annotation-processor:$eventbus_version"
}

然后在项目中，写入 ​​@Subscribe​​方法：

public class MainActivity extends AppCompatActivity {

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMainActivityEvent(MainActivityEvent event){

    }

    ...
}

点击编译，就会在下图目录中看到编译时生成的文件：

来看下文件内容：

public class MyEventBusIndex implements SubscriberInfoIndex {
    private static final Map<Class<?>, SubscriberInfo> SUBSCRIBER_INDEX; 

    static {
        SUBSCRIBER_INDEX = new HashMap<Class<?>, SubscriberInfo>(); // 1

        putIndex(new SimpleSubscriberInfo(MainActivity.class, true, new SubscriberMethodInfo[] {
            new SubscriberMethodInfo("onMainActivityEvent", MainActivityEvent.class, ThreadMode.MAIN),
        }));  // 2

    }

    private static void putIndex(SubscriberInfo info) {
        SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);
    }

    @Override
    public SubscriberInfo getSubscriberInfo(Class<?> subscriberClass) {  // 3
        SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass);
        if (info != null) {
            return info;
        } else {
            return null;
        }
    }
}

注释1： 在静态代码块中， 创建一个 Map，key是所有的订阅者， value 是该订阅者所有的订阅方法

注释2：对每个订阅者，将其内部所有的 @Subscribe方法添加其 ​​SubscriberMethodInfo[]​​ 这个数组中，并封装到 SubscriberInfo中，put到注释1的Map中。

注释3：​​getSubscriberInfo()​​​用来拿到对应订阅者的信息，在第一节中的 ​​SubscriberMethodFiner.getSubscriberInfo()​​​里面，我们看到的正是调用了这个方法。
但是如果我们默认情况下使用 ​​​EventBus.getDefault().register()​​​是不会调用到这个方法的，因为默认方法并不会 赋值给​​subscriberInfoIndexes​​，所以我们要手动加入：

EventBus.builder().addIndex(new MyEventBusIndex()).installDefaultEventBus(); // 1
EventBus.getDefault().register(this);

注释1：通过 ​​addIndex()​​​把生成出来的Java文件加入进去，它会给 ​​subscriberInfoIndexes​​赋值。这个方法只能使用一次，建议在Application的onCreate中使用。

到这里，索引的用法就结束了。通过使用索引，把搜索订阅方法的做法放在了编译时做，相比于运行时暴力搜索，性能相比可见一斑。官方给出了在Nexus5上性能图：

EventBus3.0在没有使用注解生成器的性能比2.x都低（我现在就是处在这个位置），但是使用索引之后，速度能快到究极独一档。所以没什么好说的，赶紧用了。

接下来我要分析一下EventBusAnnotationProcessor的源码，这部分不感兴趣的同学可以不看了。

3.EventBusAnnotationProcessor部分源码分析

3.1 process方法

AnnotationProcessor的关键地方都是在与 ​​process()​​​是怎么生成Java文件的，来看下它的 ​​process()​​：

// EventBusAnnotationProcessor.java
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
        Messager messager = processingEnv.getMessager();  // 1
        try {
            String index = processingEnv.getOptions().get(OPTION_EVENT_BUS_INDEX); // 2
            ...
            verbose = Boolean.parseBoolean(processingEnv.getOptions().get(OPTION_VERBOSE)); // 3
            int lastPeriod = index.lastIndexOf('.');
            String indexPackage = lastPeriod != -1 ? index.substring(0, lastPeriod) : null; // 4

            ...
            collectSubscribers(annotations, env, messager);  // 5
            checkForSubscribersToSkip(messager, indexPackage); // 6

            if (!methodsByClass.isEmpty()) {
                createInfoIndexFile(index);  // 7
            } ...
        } ...
    }

​​process()​​ 仅留下比较关键的代码，其他非关键代码更多是容错相关。

注释1： 获取信使，它用来打印log，因为AnnotationProcessor组件是Java的，所以不能使用Android的Log工具来打印，它就起到这么一个作用。

注释2：​​OPTION_EVENT_BUS_INDEX​​​就是我们在 gradle文件中写的 ： ​​[eventBusIndex : 'xxx']​​​的内容，通过注释2的方法，可以拿到当前项目EventBus的 ​​eventBusIndex​​。它的作用是用来创建索引文件。

注释3：拿到verbose值，它同样在 gralde中拿，但是我们导包时没有写出来，annotationProcessor的完整导包是：

{
            annotationProcessorOptions {
                arguments = [ eventBusIndex : 'com.example.myapp.MyEventBusIndex' 
                              verbose : 'true']
            }
        }

这个 verbose如果为true，那我们注释1的信使就会在 编译时打印编译这些代码的log，如果为false则不打印。所以这个字段并不重要，我们一般都会忽略。

注释4：根据注释2拿到的索引，生成一个包名，就是新生成的Java文件的所在包的包名。

注释5：粗略收集所有的订阅者信息，因为订阅者是带有 ​​@Subscribe​​注解的文件，所以 AnnotationProcessor能够扫描到。

注释6：检查注释5中的订阅者，如果他们不是public，或者说他们的内部包含的事件方法不是public，则去除掉这些订阅者。

注释7：创建索引文件

上面最终要的方法是注释5、注释7。

先来看下注释5。

3.2 collectSubscribers方法

// EventBusAnnotationProcessor.java
    private final ListMap<TypeElement, ExecutableElement> methodsByClass = new ListMap<>();
    
    private void collectSubscribers(Set<? extends TypeElement> annotations, RoundEnvironment env, Messager messager) {
        // 1
        for (TypeElement annotation : annotations) {
            Set<? extends Element> elements = env.getElementsAnnotatedWith(annotation); // 2
            for (Element element : elements) {   // 3
                if (element instanceof ExecutableElement) {
                    ExecutableElement method = (ExecutableElement) element; // 4
                    if (checkHasNoErrors(method, messager)) {  
                        TypeElement classElement = (TypeElement) method.getEnclosingElement(); // 5
                        methodsByClass.putElement(classElement, method);// 6
                    }
                } else {
                    messager.printMessage(Diagnostic.Kind.ERROR, "@Subscribe is only valid for methods", element);
                }
            }
        }
    }

注释1： 遍历所有的 annotations，annotations是被AnnotationProcessor扫描项目扫出来的，这个Set只有一个元素，那就是 Subscribe。

注释2：拿到所有被 @Subscribe 标记的 元素（也就是方法）

注释3：遍历所有的 注释2中获取的元素

注释4：把 元素(Element) 转换成 方法(ExecutableElement)

注释5：​​getEnclosingElement()​​​可以拿到方法的外部类，比如说我们例子的 ​​onMainActivityEvent​​，它的外部信息，就是 MainAcitivty

注释6：把 订阅方法和其所在的类（订阅者）放到ListMap中。

​​collectSubscribers()​​这个方法最终可以整理出一个 Map，key是所有的订阅者，value是这个订阅者里面的订阅方法。

接下来就是把上面的信息写成一个文件。就是 ​​createInfoIndexFile()​​

3.3 createInfoIndexFile方法

它就是生成文件的方法：

private void createInfoIndexFile(String index) {
        BufferedWriter writer = null;
        try {
            JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(index);
            int period = index.lastIndexOf('.');
            String myPackage = period > 0 ? index.substring(0, period) : null;
            String clazz = index.substring(period + 1);
            writer = new BufferedWriter(sourceFile.openWriter());
            if (myPackage != null) {
                writer.write("package " + myPackage + ";\n\n");
            }
            writer.write("import org.greenrobot.eventbus.meta.SimpleSubscriberInfo;\n");
            writer.write("import org.greenrobot.eventbus.meta.SubscriberMethodInfo;\n");
            writer.write("import org.greenrobot.eventbus.meta.SubscriberInfo;\n");
            writer.write("import org.greenrobot.eventbus.meta.SubscriberInfoIndex;\n\n");
            writer.write("import org.greenrobot.eventbus.ThreadMode;\n\n");
            writer.write("import java.util.HashMap;\n");
            writer.write("import java.util.Map;\n\n");
            writer.write("/** This class is generated by EventBus, do not edit. */\n");
            writer.write("public class " + clazz + " implements SubscriberInfoIndex {\n");
            writer.write("    private static final Map<Class<?>, SubscriberInfo> SUBSCRIBER_INDEX;\n\n");
            writer.write("    static {\n");
            writer.write("        SUBSCRIBER_INDEX = new HashMap<Class<?>, SubscriberInfo>();\n\n");
            writeIndexLines(writer, myPackage);  // 1
            writer.write("    }\n\n");
            writer.write("    private static void putIndex(SubscriberInfo info) {\n");
            writer.write("        SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);\n");
            writer.write("    }\n\n");
            writer.write("    @Override\n");
            writer.write("    public SubscriberInfo getSubscriberInfo(Class<?> subscriberClass) {\n");
            writer.write("        SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass);\n");
            writer.write("        if (info != null) {\n");
            writer.write("            return info;\n");
            writer.write("        } else {\n");
            writer.write("            return null;\n");
            writer.write("        }\n");
            writer.write("    }\n");
            writer.write("}\n");
        } catch (IOException e) {
            throw new RuntimeException("Could not write source for " + index, e);
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    //Silent
                }
            }
        }
    }

    private void writeIndexLines(BufferedWriter writer, String myPackage) throws IOException {
        for (TypeElement subscriberTypeElement : methodsByClass.keySet()) {  // 2
            if (classesToSkip.contains(subscriberTypeElement)) {
                continue;
            }

            String subscriberClass = getClassString(subscriberTypeElement, myPackage);
            if (isVisible(myPackage, subscriberTypeElement)) {
                writeLine(writer, 2,
                        "putIndex(new SimpleSubscriberInfo(" + subscriberClass + ".class,",
                        "true,", "new SubscriberMethodInfo[] {");   // 3
                List<ExecutableElement> methods = methodsByClass.get(subscriberTypeElement);
                writeCreateSubscriberMethods(writer, methods, "new SubscriberMethodInfo", myPackage);
                writer.write("        }));\n\n"); // 4
            } else {
                writer.write("        // Subscriber not visible to index: " + subscriberClass + "\n");
            }
        }
    }

上面这些没啥技术含量，​​createInfoIndexFile()​​首先写好了所有的格式，接着在static代码块中，调用了注释1的代码

注释1：调用​​writeIndexLines()​​写入 订阅者内容

注释2：遍历methodsByClass，这个是我们 3.2节中整理出来的订阅者Map，就是遍历所有的订阅者

注释3、4 将订阅者、订阅者信息写入到 BufferWriter中。

就这样，一个编译时产生的Java文件就被写出来了。它帮助了EventBus更好的提升了性能。关于AnnotationProcessor的用法我们也可以多借鉴使用，它更多是和 注解一起配合，提高程序效率。