介绍
APT（Annotation Processor Tool）即 注解处理器，是一种处理注解的工具，确切的说它是javac的一个工具，它用在 编译时 扫描和处理注解。在JDK1.5之后，java语言提供了对注解的支持，在JDK1.6中实现了JSR-269规范，提供了一组插入式注解处理器的标准API，在编译期间对注解进行处理，我们可以把它看做是一组编译器的插件，在这些插件里面，可以读取、修改、添加抽象语法数中的任意元素。如果这些插件在处理注解期间对语法树进行了修改，编译器将回到解析及填充符号表的的过程重新处理，直到所有插入式注解处理器都没有再对语法树进行修改为止，每一次循环称为一个Round。 当然我们也可以只需要了解抽象语法树的信息，辅助我们生成一些其他的类。（本例中就是如此）。
作用
使用APT的优点就是方便、简单，可以少些很多重复的代码。（是AOP面向切面编程思想的实践）
用过 ButterKnife、Dagger、EventBus 等注解框架的同学就能感受到，利用这些框架可以少写很多代码，只要写一些注解就可以了。
实现
目标
通过APT实现一个功能，通过对 View 变量的注解，实现 View 的绑定（类似于 ButterKnife 中的 @BindView）
创建项目
创建 Android Module 命名为 app
创建 Java library Module 命名为 apt-annotation
创建 Java library Module 命名为 apt-processor 依赖 apt-annotation、auto-service
创建 Android library Module 命名为 apt-library 依赖 apt-annotation
结构如下：
功能主要分三个部分
- apt-annotation ： 自定义注解，存放 @BindView
- apt-processor ： 自定义注解处理器，根据 apt-annotation 中的注解，在编译期生成 xxxActivity_ViewBinding.java 代码
- apt-library ：工具类，调用 xxxActivity_ViewBinding.java 中的方法，实现 View 的绑定。
关系如下：
1、apt-annotation
创建注解类 BindView
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.CLASS)
public @interface BindView {
int value();
}
2、apt-processor
在此 Module 中添加依赖
implementation project(path: ':apt-annotation')
//https://blog.csdn.net/cpcpcp123/article/details/103871815
//由于Gradle 5.0将忽略compile classpath中的 annotationProcessor，因此需要手动添加
// annotationProcessor 'com.google.auto.service:auto-service:1.0-rc6'
implementation 'com.google.auto.service:auto-service:1.0-rc6'
annotationProcessor 'com.google.auto.service:auto-service:1.0-rc6'
自定义Processor，创建 BindViewProcessor
@AutoService(Processor.class)
public class BindViewProcessor extends AbstractProcessor {
private Messager mMessager;
private Elements mElementUtils;
private Map<String, ClassCreatorProxy> mProxyMap = new HashMap<>();
//初始化。可以得到ProcessingEnviroment，ProcessingEnviroment提供很多有用的工具类Elements, Types 和 Filer
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
super.init(processingEnv);
mMessager = processingEnv.getMessager();
mElementUtils = processingEnv.getElementUtils();
}
//指定这个注解处理器是注册给哪个注解的，这里说明是注解
@Override
public Set<String> getSupportedAnnotationTypes() {
HashSet<String> supportTypes = new LinkedHashSet<>();
supportTypes.add(BindView.class.getCanonicalName());
return supportTypes;
}
//指定使用的Java版本，通常这里返回
@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latestSupported();
}
//可以在这里写扫描、评估和处理注解的代码，生成Java文件
@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
mMessager.printMessage(Diagnostic.Kind.NOTE, "processing...");
mProxyMap.clear();
//得到所有的注解
Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(BindView.class);
for (Element element : elements) {
VariableElement variableElement = (VariableElement) element;
TypeElement classElement = (TypeElement) variableElement.getEnclosingElement();
String fullClassName = classElement.getQualifiedName().toString();
ClassCreatorProxy proxy = mProxyMap.get(fullClassName);
if (proxy == null) {
proxy = new ClassCreatorProxy(mElementUtils, classElement);
mProxyMap.put(fullClassName, proxy);
}
BindView bindAnnotation = variableElement.getAnnotation(BindView.class);
int id = bindAnnotation.value();
proxy.putElement(id, variableElement);
}
//通过遍历mProxyMap，创建java文件
for (String key : mProxyMap.keySet()) {
ClassCreatorProxy proxyInfo = mProxyMap.get(key);
try {
mMessager.printMessage(Diagnostic.Kind.NOTE, " --> create " + proxyInfo.getProxyClassFullName());
JavaFileObject jfo = processingEnv.getFiler().createSourceFile(proxyInfo.getProxyClassFullName(), proxyInfo.getTypeElement());
Writer writer = jfo.openWriter();
writer.write(proxyInfo.generateJavaCode());
writer.flush();
writer.close();
} catch (IOException e) {
mMessager.printMessage(Diagnostic.Kind.NOTE, " --> create " + proxyInfo.getProxyClassFullName() + "error");
}
}
mMessager.printMessage(Diagnostic.Kind.NOTE, "process finish ...");
return true;
}
}
创建生成 Java 文件的工具类 ClassCreatorProxy
public class ClassCreatorProxy {
private String mBindingClassName;
private String mPackageName;
private TypeElement mTypeElement;
private Map<Integer, VariableElement> mVariableElementMap = new HashMap<>();
public ClassCreatorProxy(Elements elementUtils, TypeElement classElement) {
this.mTypeElement = classElement;
PackageElement packageElement = elementUtils.getPackageOf(mTypeElement);
String packageName = packageElement.getQualifiedName().toString();
String className = mTypeElement.getSimpleName().toString();
this.mPackageName = packageName;
this.mBindingClassName = className + "_ViewBinding";
}
public void putElement(int id, VariableElement element) {
mVariableElementMap.put(id, element);
}
/**
* 创建Java代码
* @return
*/
public String generateJavaCode() {
StringBuilder builder = new StringBuilder();
builder.append("package ").append(mPackageName).append(";\n\n");
builder.append('\n');
builder.append("public class ").append(mBindingClassName);
builder.append(" {\n");
generateMethods(builder);
builder.append('\n');
builder.append("}\n");
return builder.toString();
}
/**
* 加入Method
* @param builder
*/
private void generateMethods(StringBuilder builder) {
builder.append("public void bind(" + mTypeElement.getQualifiedName() + " host ) {\n");
for (int id : mVariableElementMap.keySet()) {
VariableElement element = mVariableElementMap.get(id);
String name = element.getSimpleName().toString();
String type = element.asType().toString();
builder.append("host." + name).append(" = ");
builder.append("(" + type + ")(((android.app.Activity)host).findViewById(" + id + "));\n");
}
builder.append(" }\n");
}
public String getProxyClassFullName()
{
return mPackageName + "." + mBindingClassName;
}
public TypeElement getTypeElement()
{
return mTypeElement;
}
}
上面的代码主要就是从 Elements、TypeElement 得到想要的一些信息，如package name、Activity名、变量类型、id等，通过 StringBuilder 一点点拼出 Java 代码，每个对象分别代表一个对应的 .java 文件
提前看一下生成的代码 MainActivity_VewBinding.java，路径在 app/build/generated/ap_generated_sources/debug/out/ 下，最终是要打包到Apk中的。
package com.jxf.android_apt_demo;
public class MainActivity_ViewBinding {
public void bind(com.jxf.android_apt_demo.MainActivity host) {
host.textView = (android.widget.TextView) (((android.app.Activity) host).findViewById(2131165359));
}
}
使用 StringBuilder 的方式生成 java 代码，不但繁琐还容易写错。更好的方案是通过 javapoet 可以更加简单生成这样的java 代码。
介绍下依赖库 auto-service
使用自定义的注解处理器的常规步骤，还需要做一些其他工作：
1、需要在processorModule 所在的 main 目录下新建 META-INF/services 目录文件；
2、在 META-INF/services 目录下创建javax.annotation.processing.Processor文件；
3、在javax.annotation.processing.Processor文件中写入 定义的注解处理器全称，包括包路径 （例如：com.jxf.apt_processor.BindViewProcessor）；
=====================
这个流程声明相对繁琐且单调，auto-service这个库的作用就是 通过使用注解@AutoService 编译时可以自动生成META-INF/services/javax.annotation.processing.Processor文件
生成的文件可以查看，以我们项目为例，在apt-processor 的 build/classes/java/main/META-INF/services 下生成了 javax.annotation.processing.Processor 如下图：
其实 auto-service 实现也很简单，也是利用了APT的方法，在编译时通过扫描 @AutoService 动态生成文件的过程。还记得我们刚才引入的 auto-service的方式如下：
// 包含了 AutoService 注解类的定义
implementation 'com.google.auto.service:auto-service:1.0-rc6'
// 自定义注解处理器，动态帮助我们生成 META-INF/services 下的文件
annotationProcessor 'com.google.auto.service:auto-service:1.0-rc6'
3、apt-library
完成了 Processor的部分，基本快大功告成了。
在 BindViewProcessor中创建了对应的 xxxActivity_ViewBinding.java，我们通过反射调用。
在 此 Module 的 build.gradle 中添加依赖：
dependencies {
implementation project(path: ':apt-annotation')
}
创建注解工具类 BindViewTools
public class BindViewTools {
public static void bind(Activity activity){
Class clazz = activity.getClass();
try {
Class bindViewClass = Class.forName(clazz.getName() + "_ViewBinding");
Method method = bindViewClass.getMethod("bind", activity.getClass());
method.invoke(bindViewClass.newInstance(), activity);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
apt-library的部分比较简单了，通过反射找到对应的 ViewBinding 类，然后 调用其中的 bind 方法 完成View的绑定。
4、app 测试
依赖
在 Module 的build.gradle中添加
dependencies {
implementation project(path: ':apt-library') //工具
implementation project(path: ':apt-annotation') //注解
annotationProcessor project(path: ':apt-processor') //注解处理器
}
使用
在MainActivity中，在View的前面加上 BindView注解，把 id传入即可
public class MainActivity extends AppCompatActivity {
@BindView(R.id.txt)
TextView textView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
BindViewTools.bind(this);
textView.setText("Hello APT(Annotation Processor Tool)");
}
}
运行结果：
参考：
https://www.jianshu.com/p/7af58e8e3e18
《深入理解java虚拟机》
java注解处理器：
https://blog.csdn.net/qq_26814945/article/details/88863404
