概述
EventBus一般使用在调用register注册时，会通过反射去解析记录订阅方法，运行期反射比较耗费性能。3.0提供了高级用法即索引，通过注解处理器在编译期就提前解析记录订阅方法。EventBus在索引生成过程中有使用到Type、Element、JavaFileObject等接口，需要先对这些接口有一定了解。
实例解析
使用索引详细的配置方法可以按照官方文档http://greenrobot.org/eventbus/documentation/subscriber-index/。
这里继续用上篇的例子：
public class MyEventSubscriber {
private WeakReference<Activity> mActivity;
public EventSubscriber(Activity activity) {
this.mActivity = new WeakReference<>(activity);
}
public void register() {
EventBus.getDefault().register(this);
}
public void unregister() {
EventBus.getDefault().unregister(this);
}
@Subscribe(threadMode = ThreadMode.MAIN)
public void onMyEvent(MyEvent event) {
//todo 处理事件
···
}
}
在build.gradle中添加配置：
javaCompileOptions {
annotationProcessorOptions {
arguments = [ eventBusIndex : 'com.example.myapp.MyEventBusIndex' ]
}
}
当编译完成后，会在build->generated->source->apt->debug/release下生成对应的索引类。本例中生成com.example.myapp包，包下有一个MyEventBusIndex类。
源码解析
EventBus注解处理依赖库就一个类EventBusAnnotationProcessor，打开源码看看它是如何生成索引类。
一.继承自AbstractProcessor
1.先来看该类注册的两个注解：
@SupportedAnnotationTypes("org.greenrobot.eventbus.Subscribe")
@SupportedOptions(value = {"eventBusIndex", "verbose"})
public class EventBusAnnotationProcessor extends AbstractProcessor {
···
}
- SupportedAnnotationTypes用于注册该注解处理器支持的注解，这里仅处理EventBus定义的Subscribe注解；
- SupportedOptions用于注册支持的编译选项，即在本例中在build.gradle中配置的arguments = [ eventBusIndex : ‘com.example.myapp.MyEventBusIndex’ ]，eventBusIndex的值对应’com.example.myapp.MyEventBusIndex’ ，verbose默认false。
2.重写部分方法：
@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latest();
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
···
}
- getSupportedSourceVersion返回支持的Java版本，这里返回最新；
- process核心方法，编译过程中会回调该方法，在这里实现相应的方法。如果我们成功处理，返回true。否则返回false，会有后续的Processor去处理。
ps：根据观察日志发现，注解处理器会执行多轮，它还会处理生成的源文件中的注解或上一个Processor未处理的注解。
二.重要成员变量
先介绍下该类中的一些重要的成员变量的作用：
public class EventBusAnnotationProcessor extends AbstractProcessor {
/** 记录订阅方法（即注册了@Subscribe的method），订阅者类（即method所在的类）为key。 */
private final ListMap<TypeElement, ExecutableElement> methodsByClass = new ListMap<>();
/** 记录不处理的订阅者类。 */
private final Set<TypeElement> classesToSkip = new HashSet<>();
/** 标记索引类是否生成完成。 */
private boolean writerRoundDone;
/** 标记第几轮执行process */
private int round;
}
ps：ListMap是greenrobot对Map扩展的集合，对HashMap<K, List<V>>的封装。
三.核心方法process
直接看代码：
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment env) {
// annotations为注册的注解的类型元素的集合，在本例中该集合仅有Subscribe。env用于获取注解处理环境信息
// Messager用于打印日志
Messager messager = processingEnv.getMessager();
try {
// 获取在build.gradle中配置的eventBusIndex参数的值，本例即为com.example.myapp.MyEventBusIndex
String index = processingEnv.getOptions().get(OPTION_EVENT_BUS_INDEX);
if (index == null) {
messager.printMessage(Diagnostic.Kind.ERROR, "No option " + OPTION_EVENT_BUS_INDEX +
" passed to annotation processor");
return false;
}
// 获取verbose参数值
verbose = Boolean.parseBoolean(processingEnv.getOptions().get(OPTION_VERBOSE));
int lastPeriod = index.lastIndexOf('.');
// 截取生成索引类的目标包名，即com.example.myapp
String indexPackage = lastPeriod != -1 ? index.substring(0, lastPeriod) : null;
// 标记轮次增加
round++;
// verbose仅用于判断是否打印这段日志
if (verbose) {
messager.printMessage(Diagnostic.Kind.NOTE, "Processing round " + round + ", new annotations: " +
!annotations.isEmpty() + ", processingOver: " + env.processingOver());
}
// 判断注解处理最后一轮是否结束
if (env.processingOver()) {
// 判断是否有该处理器支持的注解或代码中是否有使用注解
if (!annotations.isEmpty()) {
// 若注解处理过程已经结束，但是仍然有注解集合传入，则打印错误日志
messager.printMessage(Diagnostic.Kind.ERROR,
"Unexpected processing state: annotations still available after processing over");
return false;
}
}
// 再对注解集合做一次非空检查
if (annotations.isEmpty()) {
return false;
}
// 若已经生成完成，也打印错误日志
if (writerRoundDone) {
messager.printMessage(Diagnostic.Kind.ERROR,
"Unexpected processing state: annotations still available after writing.");
}
// 以上是检查完毕，下面开始进行解析记录
// 记录合法的订阅方法，保存进methodsByClass集合---①
collectSubscribers(annotations, env, messager);
// 记录不处理的订阅方法---②
checkForSubscribersToSkip(messager, indexPackage);
if (!methodsByClass.isEmpty()) {
// 若存在合法的订阅方法，则开始生成索引类---③
createInfoIndexFile(index);
} else {
messager.printMessage(Diagnostic.Kind.WARNING, "No @Subscribe annotations found");
}
// 完成后标记writerRoundDone为true
writerRoundDone = true;
} catch (RuntimeException e) {
// IntelliJ does not handle exceptions nicely, so log and print a message
e.printStackTrace();
messager.printMessage(Diagnostic.Kind.ERROR, "Unexpected error in EventBusAnnotationProcessor: " + e);
}
// 最终返回true，表示已经正确处理
return true;
}
process方法中先进行初步的合法性检查，之后分三步开始处理：1.解析出所有订阅方法；2.记录不处理的订阅方法；3.生成索引类。接下来逐步分析。
1.初步收集订阅方法
关键在collectSubscribers方法中：
private void collectSubscribers(Set<? extends TypeElement> annotations, RoundEnvironment env, Messager messager) {
// 遍历该处理器注册的注解元素的集合
for (TypeElement annotation : annotations) {
// 获取所有使用了该注解的元素集合，在这里即所有添加了@Subscribe的方法的元素
Set<? extends Element> elements = env.getElementsAnnotatedWith(annotation);
for (Element element : elements) {
if (element instanceof ExecutableElement) {
// ExecutableElement表示可执行方法的元素，因为@Subscribe只能用在method上
ExecutableElement method = (ExecutableElement) element;
// 合法性校验
if (checkHasNoErrors(method, messager)) {
// 获取ExecutableElement所在类的元素，即订阅方法所在的订阅者类
TypeElement classElement = (TypeElement) method.getEnclosingElement();
// 根据class作key、method作value缓存到集合中
methodsByClass.putElement(classElement, method);
}
} else {
messager.printMessage(Diagnostic.Kind.ERROR, "@Subscribe is only valid for methods", element);
}
}
}
}
上面方法很简单，就是取得所有添加@Subscribe的method，将符合要求的method根据它所在的class归类缓存到methodsByClass中。
接着看下checkHasNoErrors方法，这里面如何对method进行校验：
private boolean checkHasNoErrors(ExecutableElement element, Messager messager) {
// 判断方法修饰符，不能是静态方法
if (element.getModifiers().contains(Modifier.STATIC)) {
messager.printMessage(Diagnostic.Kind.ERROR, "Subscriber method must not be static", element);
return false;
}
// 方法必须是public的
if (!element.getModifiers().contains(Modifier.PUBLIC)) {
messager.printMessage(Diagnostic.Kind.ERROR, "Subscriber method must be public", element);
return false;
}
// 获取该方法的参数集合
List<? extends VariableElement> parameters = ((ExecutableElement) element).getParameters();
// 参数个数必须是一个
if (parameters.size() != 1) {
messager.printMessage(Diagnostic.Kind.ERROR, "Subscriber method must have exactly 1 parameter", element);
return false;
}
return true;
}
可以看出，我们创建的订阅方法必须符合public、非static、仅有一个参数，否则即使添加@Subscribe也是无效的。
2.筛选订阅方法
进入checkForSubscribersToSkip方法：
private void checkForSubscribersToSkip(Messager messager, String myPackage) {
// 遍历集合key，依次检查订阅者类
for (TypeElement skipCandidate : methodsByClass.keySet()) {
TypeElement subscriberClass = skipCandidate;
while (subscriberClass != null) {
// 判断订阅者类是否可访问
if (!isVisible(myPackage, subscriberClass)) {
// 若该订阅者类对于即将生成的目标索引类不可访问，则添加进筛除集合，结束while循环，检查下一个订阅者类
boolean added = classesToSkip.add(skipCandidate);
if (added) {
String msg;
if (subscriberClass.equals(skipCandidate)) {
msg = "Falling back to reflection because class is not public";
} else {
msg = "Falling back to reflection because " + skipCandidate +
" has a non-public super class";
}
messager.printMessage(Diagnostic.Kind.NOTE, msg, subscriberClass);
}
break;
}
// 从集合中取出该订阅者类中的订阅方法
List<ExecutableElement> methods = methodsByClass.get(subscriberClass);
if (methods != null) {
for (ExecutableElement method : methods) {
String skipReason = null;
// 获取方法的第一个也是唯一一个参数
VariableElement param = method.getParameters().get(0);
// 获取参数对象的类型
TypeMirror typeMirror = getParamTypeMirror(param, messager);
// 参数必须是一个类的声明类型和类元素，即如本例定义的MyEvent实体类
if (!(typeMirror instanceof DeclaredType) ||
!(((DeclaredType) typeMirror).asElement() instanceof TypeElement)) {
skipReason = "event type cannot be processed";
}
// 参数类型校验通过，则检查参数对象类的可访问性
if (skipReason == null) {
TypeElement eventTypeElement = (TypeElement) ((DeclaredType) typeMirror).asElement();
if (!isVisible(myPackage, eventTypeElement)) {
skipReason = "event type is not public";
}
}
// 如果有一项校验不通过，则将该类加入筛除集合
if (skipReason != null) {
boolean added = classesToSkip.add(skipCandidate);
if (added) {
String msg = "Falling back to reflection because " + skipReason;
if (!subscriberClass.equals(skipCandidate)) {
msg += " (found in super class for " + skipCandidate + ")";
}
messager.printMessage(Diagnostic.Kind.NOTE, msg, param);
}
break;
}
}
}
// subscriberClass切换到父类，若父类是系统的类，则返回null，结束while循环
subscriberClass = getSuperclass(subscriberClass);
}
}
}
该方法中依次遍历订阅者类及父类，校验订阅者类的可访问性和订阅方法参数的类型及访问性，若有不符合要求的就添加进筛除集合。
接着再详细看下校验访问性的方法isVisible：
private boolean isVisible(String myPackage, TypeElement typeElement) {
Set<Modifier> modifiers = typeElement.getModifiers();
boolean visible;
// 也是通过判断修饰符
if (modifiers.contains(Modifier.PUBLIC)) {
visible = true;
} else if (modifiers.contains(Modifier.PRIVATE) || modifiers.contains(Modifier.PROTECTED)) {
visible = false;
} else {
// 若是默认则判断订阅者类所在包名和索引类所在包名是否一致
// getPackageElement方法中不断获取typeElement的顶层元素直至取到包元素，然后获取包名
String subscriberPackage = getPackageElement(typeElement).getQualifiedName().toString();
if (myPackage == null) {
visible = subscriberPackage.length() == 0;
} else {
visible = myPackage.equals(subscriberPackage);
}
}
return visible;
}
接着看获取参数类型的方法getParamTypeMirror：
private TypeMirror getParamTypeMirror(VariableElement param, Messager messager) {
TypeMirror typeMirror = param.asType();
// Check for generic type
if (typeMirror instanceof TypeVariable) {
// 获取该类型变量的上边界，如果该对象有通过extends继承其他对象，则upperBound为DeclaredType类型
TypeMirror upperBound = ((TypeVariable) typeMirror).getUpperBound();
if (upperBound instanceof DeclaredType) {
if (messager != null) {
messager.printMessage(Diagnostic.Kind.NOTE, "Using upper bound type " + upperBound +
" for generic parameter", param);
}
// 替换参数类型为上边界的类型
typeMirror = upperBound;
}
}
return typeMirror;
}
经过筛选将不需要写入索引类的订阅者类存进classesToSkip集合中，后续生成的时候会比较这个集合中的类，判断是跳过还是处理。
3.生成索引类
如果methodsByClass中不为空，则调用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);
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
}
}
}
}
writeIndexLines方法：
private void writeIndexLines(BufferedWriter writer, String myPackage) throws IOException {
// 遍历集合
for (TypeElement subscriberTypeElement : methodsByClass.keySet()) {
// 如果和筛除集合中匹配则跳过
if (classesToSkip.contains(subscriberTypeElement)) {
continue;
}
// 获取订阅者类名称字符串
String subscriberClass = getClassString(subscriberTypeElement, myPackage);
// 再次检查是否可访问
if (isVisible(myPackage, subscriberTypeElement)) {
// 写入第三个参数字符串数据，writeLine方法中封装了缩进换行操作
writeLine(writer, 2,
"putIndex(new SimpleSubscriberInfo(" + subscriberClass + ".class,",
"true,", "new SubscriberMethodInfo[] {");
List<ExecutableElement> methods = methodsByClass.get(subscriberTypeElement);
// 写入订阅方法相关信息
writeCreateSubscriberMethods(writer, methods, "new SubscriberMethodInfo", myPackage);
writer.write(" }));\n\n");
} else {
writer.write(" // Subscriber not visible to index: " + subscriberClass + "\n");
}
}
}
writeIndexLines方法中遍历methodsByClass，然后依次写入订阅方法相关信息。
先看里面的getClassString方法，该方法获取订阅者类的类名字符串：
private String getClassString(TypeElement typeElement, String myPackage) {
PackageElement packageElement = getPackageElement(typeElement);
// 获取订阅者类的包元素全限定名称
String packageString = packageElement.getQualifiedName().toString();
// 订阅者类全限定名称
String className = typeElement.getQualifiedName().toString();
if (packageString != null && !packageString.isEmpty()) {
// 比较包名
if (packageString.equals(myPackage)) {
// 若包名一致，则只取订阅者类的simple名称
// cutPackage通过截取字符串方式，而不是调用getSimpleName，避免内部类的时候取到$
className = cutPackage(myPackage, className);
} else if (packageString.equals("java.lang")) {
// 若是java.lang包，则直接取SimpleName
className = typeElement.getSimpleName().toString();
}
}
return className;
}
再看写订阅方法相关信息writeCreateSubscriberMethods：
private void writeCreateSubscriberMethods(BufferedWriter writer, List<ExecutableElement> methods,
String callPrefix, String myPackage) throws IOException {
// 遍历订阅方法
for (ExecutableElement method : methods) {
List<? extends VariableElement> parameters = method.getParameters();
TypeMirror paramType = getParamTypeMirror(parameters.get(0), null);
TypeElement paramElement = (TypeElement) processingEnv.getTypeUtils().asElement(paramType);
// 获取方法名称字符串
String methodName = method.getSimpleName().toString();
// 获取参数类名字符串
String eventClass = getClassString(paramElement, myPackage) + ".class";
Subscribe subscribe = method.getAnnotation(Subscribe.class);
List<String> parts = new ArrayList<>();
parts.add(callPrefix + "(\"" + methodName + "\",");
String lineEnd = "),";
// 获取注解中的值
if (subscribe.priority() == 0 && !subscribe.sticky()) {
if (subscribe.threadMode() == ThreadMode.POSTING) {
parts.add(eventClass + lineEnd);
} else {
parts.add(eventClass + ",");
parts.add("ThreadMode." + subscribe.threadMode().name() + lineEnd);
}
} else {
parts.add(eventClass + ",");
parts.add("ThreadMode." + subscribe.threadMode().name() + ",");
parts.add(subscribe.priority() + ",");
parts.add(subscribe.sticky() + lineEnd);
}
// 写入
writeLine(writer, 3, parts.toArray(new String[parts.size()]));
if (verbose) {
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Indexed @Subscribe at " +
method.getEnclosingElement().getSimpleName() + "." + methodName +
"(" + paramElement.getSimpleName() + ")");
}
}
}
以上就是生成索引类源文件，整个过程大致是从methodsByClass中获取订阅者类、方法相关信息，跳过不合法的订阅者类，然后获取类名、方法名、参数对象类字符串以及注解中的值，写入生成。
四.分析最终生成的源文件
以下是最终生成的源文件代码：
package com.example.myapp;
import org.greenrobot.eventbus.meta.SimpleSubscriberInfo;
import org.greenrobot.eventbus.meta.SubscriberMethodInfo;
import org.greenrobot.eventbus.meta.SubscriberInfo;
import org.greenrobot.eventbus.meta.SubscriberInfoIndex;
import org.greenrobot.eventbus.ThreadMode;
import java.util.HashMap;
import java.util.Map;
/** This class is generated by EventBus, do not edit. */
public class MyEventBusIndex implements SubscriberInfoIndex {
private static final Map<Class<?>, SubscriberInfo> SUBSCRIBER_INDEX;
static {
SUBSCRIBER_INDEX = new HashMap<Class<?>, SubscriberInfo>();
putIndex(new SimpleSubscriberInfo(com.example.myapp.subscribe.MyEventSubscriber.class, true,
new SubscriberMethodInfo[] {
new SubscriberMethodInfo("onMyEvent", com.example.myapp.model.event.MyEvent.class,
ThreadMode.MAIN),
}));
}
private static void putIndex(SubscriberInfo info) {
SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);
}
@Override
public SubscriberInfo getSubscriberInfo(Class<?> subscriberClass) {
SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass);
if (info != null) {
return info;
} else {
return null;
}
}
}
在静态代码块中，构造了SimpleSubscriberInfo对象，然后存进HashMap集合中。
回到EventBus3实例源码浅析（上），结合里面的源码来分析：
1）在初始化时通过EventBusBuilder的addIndex方法添加索引
/** Adds an index generated by EventBus' annotation preprocessor. */
public EventBusBuilder addIndex(SubscriberInfoIndex index) {
if(subscriberInfoIndexes == null) {
subscriberInfoIndexes = new ArrayList<>();
}
// 可添加多个索引，存入ArrayList集合中
subscriberInfoIndexes.add(index);
return this;
}
只需实例化索引类然后传入即可。
2）注册时会优先使用索引
在SubscriberMethodFinder的findUsingInfo方法中，会查找可用索引类，最终调用索引类的getSubscriberInfo方法获取SubscriberInfo对象。SubscriberInfo中包含订阅方法、参数、注解值等相关信息，因此省去了反射查找、校验的操作。
总结
索引将注册时的繁琐操作放在编译期完成，大大节省了事件，不过发送事件时仍需要反射。
扫一扫
299
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
