前言
在 [Android] ButterKnife 浅析 中，我们了解了 ButterKnife 的用法，比较简单。
本次文章我们来学习一下 ButterKnife 的 ButterKnifeProcessor 注解处理器，注解处理器能够解析代码中的注解信息，生成相应的 Java 类，这也是 ButterKnife 的关键实现原理。
建议在阅读前先了解下 Java 中『注解』的概念。
准备内容
APT
APT（Annotation processing tool）是在编译时，扫描和处理注解的一个构建工具，可以在编译源代码时额外生成 Java 源代码。
AbstractProcessor
AbstractProcessor 是扫描和处理注解的关键类，ButterKnife 自定义的 Processor 就需要继承自该类。
代码示例如下：
public class MyProcessor extends AbstractProcessor {
// 在 Processor 创建时调用并执行的初始化操作
@Override
public synchronized void init(ProcessingEnvironment env){ }
// 关键方法，进行扫描和处理注解，并生成新的源代码
@Override
public boolean process(Set<? extends TypeElement> annoations, RoundEnvironment env) { }
// 指定需要注册的注解
@Override
public Set<String> getSupportedAnnotationTypes() { }
// 指定支持的 Java 版本
@Override
public SourceVersion getSupportedSourceVersion() { }
}添加依赖
还记得我们使用 ButterKnife 前所做的添加吗？
dependencies {
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
}
dependencies {
compile 'com.jakewharton:butterknife:8.0.1'
apt 'com.jakewharton:butterknife-compiler:8.0.1'
}这里 com.jakewharton:butterknife-compiler 就是自定义的注解处理器，我们在 Gradle 中注册使用它。
然而我在项目结构中找了很久也没有找到这个库的文件，有可能是在编译时才去访问的，如果需要可以在 GitHub 中找到：
ButterKnifeProcessor 工作流程
上面注册完自定义的注解处理器后，我们就知道，在编译源代码时，APT 会调用 Processor 来查找解析注解。
主要逻辑
这里主要看 process 处理方法的内容。
@Override public boolean process(Set<? extends TypeElement> elements, RoundEnvironment env) {
// 查找并解析注解
Map<TypeElement, BindingClass> targetClassMap = findAndParseTargets(env);
// 去除注解的键值
for (Map.Entry<TypeElement, BindingClass> entry : targetClassMap.entrySet()) {
TypeElement typeElement = entry.getKey();
BindingClass bindingClass = entry.getValue();
// 生成源代码
try {
bindingClass.brewJava().writeTo(filer);
} catch (IOException e) {
error(typeElement, "Unable to write view binder for type %s: %s", typeElement,
e.getMessage());
}
}
return true;
}可以看到 process 方法的逻辑还是比较容易理解的，就是获取到注解的键值并生成源代码。
查找和解析注解
首先看 findAndParseTargets(RoundEnvironment env) 方法，通过参数 RoundEnvironment env 可以找到我们想要的某一个被注解的元素。
该方法会查找所有 ButterKnife 的注解来进行解析，我们选择最简单的 @BindInt 来看一下：
private Map<TypeElement, BindingClass> findAndParseTargets(RoundEnvironment env) {
Map<TypeElement, BindingClass> targetClassMap = new LinkedHashMap<>();
Set<TypeElement> erasedTargetNames = new LinkedHashSet<>();
// Process each @BindInt element.
for (Element element : env.getElementsAnnotatedWith(BindInt.class)) {
if (!SuperficialValidation.validateElement(element)) continue;
try {
parseResourceInt(element, targetClassMap, erasedTargetNames);
} catch (Exception e) {
logParsingError(element, BindInt.class, e);
}
}
...这里调用了 parseResourceInt 方法传入了被注解的元素进行解析：
private void parseResourceInt(Element element, Map<TypeElement, BindingClass> targetClassMap,
Set<TypeElement> erasedTargetNames) {
boolean hasError = false;
TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();
// Verify that the target type is int.
if (element.asType().getKind() != TypeKind.INT) {
error(element, "@%s field type must be 'int'. (%s.%s)", BindInt.class.getSimpleName(),
enclosingElement.getQualifiedName(), element.getSimpleName());
hasError = true;
}
// Verify common generated code restrictions.
hasError |= isInaccessibleViaGeneratedCode(BindInt.class, "fields", element);
hasError |= isBindingInWrongPackage(BindInt.class, element);
if (hasError) {
return;
}
// Assemble information on the field.
String name = element.getSimpleName().toString();
int id = element.getAnnotation(BindInt.class).value();
BindingClass bindingClass = getOrCreateTargetClass(targetClassMap, enclosingElement);
FieldResourceBinding binding = new FieldResourceBinding(id, name, "getInteger", false);
bindingClass.addResource(binding);
erasedTargetNames.add(enclosingElement);
}方法分为前后两部分，先进行了一些检验，检验通过则调用 getOrCreateTargetClass 获取或生成一个类放入数组中。
isInaccessibleViaGeneratedCode 方法检验了：
- 方法修饰符不能为 private 和 static
- 包类型不能为非 Class
- 类的修饰符不能为 private
isBindingInWrongPackage 则检验了包名，不能以 android 或 java 开头。
生成类文件
解析完每个被注解的元素之后会得到一个 Map<TypeElement, BindingClass> targetClassMap，接着就会调用 Map 中每个 bindingClass 生成 Java 源代码：
bindingClass.brewJava().writeTo(filer);brewJava() 的内容如下所示，添加了方法，父类，接口等信息，最后生成了一个 JavaFile，简单了解即可：
JavaFile brewJava() {
TypeSpec.Builder result = TypeSpec.classBuilder(generatedClassName)
.addModifiers(PUBLIC);
if (isFinal) {
result.addModifiers(Modifier.FINAL);
} else {
result.addTypeVariable(TypeVariableName.get("T", targetTypeName));
}
TypeName targetType = isFinal ? targetTypeName : TypeVariableName.get("T");
if (hasParentBinding()) {
result.superclass(ParameterizedTypeName.get(parentBinding.generatedClassName, targetType));
} else {
result.addSuperinterface(ParameterizedTypeName.get(VIEW_BINDER, targetType));
}
result.addMethod(createBindMethod(targetType));
if (isGeneratingUnbinder()) {
result.addType(createUnbinderClass(targetType));
} else if (!isFinal) {
result.addMethod(createBindToTargetMethod());
}
return JavaFile.builder(generatedClassName.packageName(), result.build())
.addFileComment("Generated code from Butter Knife. Do not modify!")
.build();
}于是我们编译过后就能在项目中找到类似 MainActivity$$ViewBinder 这样的文件。
到这里 ButterKnifeProcessor 的工作就结束了，ButterKnife 就能够调用生成的类来进行绑定工作，我们将在下一篇文章中对余下的流程进行学习。
