介绍
APT就是（Annotation Processing Tool ）的简称，就是可以在代码编译期间对注解进行处理，并且生成Java文件，减少手动的代码输入。
代表框架：
Dagger2
ButterKnife
EventBus
ARouter
作用
使用APT的优点就是方便、简单，可以少些很多重复的代码。
APT处理要素
注册处理器（AutoService) + 注解处理器（AbstractProcessor） + 代码生成（javapoet）
1、 注册处理器
注册处理器有2种方式
一种是AutoService
首先引入
implementation 'com.google.auto.service:auto-service:1.0-rc2'
annotationProcessor 'com.google.auto.service:auto-service:1.0-rc2'
然后再AbstractProcessor类中加上注解@AutoService(Processor.class)
这样就注册完成了
第二种是添加文件。
image.png
2、 注解处理器（AbstractProcessor）
创建一个继承AbstractProcessor 类就可以了，在process方法里，获取我们需要的哪些注解。
public class BindViewProcessor extends AbstractProcessor {
public class BindViewProcessor extends AbstractProcessor {
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
super.init(processingEnv);
}
/**
* 指定注解
*/
@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();
}
/**
* 扫描注解处理
*/
@Override
public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
return true;
}
3、 代码生成
代码生成也有2种方式来实现
1.StringBuilder来实现，大概例子是这样的，所有的代码都是用字符串拼接起来，生成的代码格式也很乱，而且很容易写错。
2.另外一种是使用javapoet生成代码，生成的代码会自动排版，javapoet详细用法
可以看下两者的比较。
/**
* 使用StringBuilder创建类、而且还需要自己手写导入包，这边没写
*/
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();
}
/**
* 使用javapoet创建类
*/
public TypeSpec generateJavaCode2() {
TypeSpec bindingClass = TypeSpec.classBuilder(mBindingClassName)
.addModifiers(Modifier.PUBLIC)
.addMethod(generateMethods2())//创建方法
.build();
return bindingClass;
}
/**
* 使用StringBuilder创建方法
*/
private void generateMethods(StringBuilder builder) {
builder.append("public void bind(" + mTypeElement.getQualifiedName() + " target ) {\n");
for (int id : mapId.keySet()) {
VariableElement element = mapId.get(id);
String name = element.getSimpleName().toString();
builder.append("target." + name).append(" = ");
builder.append("target.findViewById( " + id + ");\n");
}
builder.append(" }\n");
}
/**
* 使用javapoet创建方法
*/
private MethodSpec generateMethods2() {
ClassName target = ClassName.bestGuess(mTypeElement.getQualifiedName().toString());
MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("bind")
.addModifiers(Modifier.PUBLIC)
.returns(void.class)
.addParameter(target, "target");
for (int id : mapId.keySet()) {
VariableElement element = mapId.get(id);
String name = element.getSimpleName().toString();
methodBuilder.addCode("target." + name + " = " + "target.findViewById( " + id + ");");
}
return methodBuilder.build();
}
这三步完成我们就可以生成我们要的代码了。
javapoet详细用法
获取注解对象
1、运行时注解： 通过 反射 机制获取注解对象，会损耗性能，常用的框架有retrofit
2、编译期注解： 通过 APT 方式获取注解对象，不会造成性能损耗。常用的框架Dagger2, ButterKnife、EventBus、ARouter
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface BindView {
}
@Retention(RetentionPolicy.CLASS)：表示编译时注解
@Target(ElementType.FIELD)：表示注解范围为类成员（构造方法、方法、成员变量）
注解 @Target代表意思
@Target(ElementType.TYPE) 接口、类、枚举、注解
@Target(ElementType.FIELD) 字段、枚举的常量
@Target(ElementType.METHOD) 方法
@Target(ElementType.PARAMETER) 方法参数
@Target(ElementType.CONSTRUCTOR) 构造函数
@Target(ElementType.LOCAL_VARIABLE) 局部变量
@Target(ElementType.ANNOTATION_TYPE) 注解
@Target(ElementType.PACKAGE) 包
element 的概念
表示一个程序元素，比如包、类或者方法。
element 包含有
PackageElement 表示一个包程序元素
TypeElement 表示一个类或接口程序元素
VariableElement 表示一个字段、enum 常量、方法或构造方法参数、局部变量或异常参数
ExecutableElement 表示某个类或接口的方法、构造方法或初始化程序（静态或实例），包括注解类型元素
TypeParameterElement 表示一般类、接口、方法或构造方法元素的泛型参数
如下图
public class Foo { // TypeElement 类型元素
private int a; // VariableElement 变量元素
private Foo other; // VariableElement 变量元素
public Foo() { // ExecutableElement 可执行元素
}
public void setA(int newA ) { // newA 代表是一个 VariableElement)
}
}
Element 的源码，源码解析。
public interface Element extends javax.lang.model.AnnotatedConstruct {
/**
* 返回该元素定义的类型。
* 泛型元素定义了一系列类型，而不仅仅是一个类型。如果这是一个泛型元素，则返回一个原型
* 类型。这是元素在对应于它自己的正式类型参数的类型变量上的调用。例如，对于泛型类元素
* C<N extends Number>，返回参数化类型C<N>。类型实用程序接口有更一般的方法来获取元
* 素定义的所有类型的范围。
*/
TypeMirror asType();
/**
* 返回该元素的类型
*/
ElementKind getKind();
/**
* 返回该元素的修饰符,包括注解.
* 隐式修饰符也包含,比如接口方法中的public和static
*/
Set<Modifier> getModifiers();
/**
* 返回该元素的简单名称.泛型类型的名称不包括对其正式类型参数的任何引用。
* 举例,java.util.Set<E>的简单名称是Set.
* 如果该元素代表的是未命名包,则返回一个空 Name.
* 如果代表的是构造器,则返回<init>所对应的Name.如果代表的是静态代码块,则返回的是<clinit>
* 如果代表的是匿名类或者是初始代码块,则返回一个空 Name.
*/
Name getSimpleName();
/**
* 返回包围该元素的最内层的元素.
* 如果这个元素的声明紧接在另一个元素的声明中，则返回另一个元素。
* 如果这是顶级类型，则返回其包。
* 如果这是一个包，则返回null。
* 如果这是类型参数，则返回类型参数的泛型元素。
* 如果这是一个方法或构造函数参数，则返回声明该参数的可执行元素。
*/
Element getEnclosingElement();
/**
* 返回该元素所包含的元素.
* 类或接口被认为包含了它直接声明的字段、方法、构造函数和成员类型.包直接包含了顶级类和接
* 口，但不包含其子包。其他类型的元素目前不被认为包含任何元素；然而，随着这个API或编程语
* 言的发展，这些元素可能会改变
*/
List<? extends Element> getEnclosedElements();
/**
* 当给定的参数和当前类代表同一个元素时返回true,否则,返回false.
* 注意，元素的标识涉及不能直接从元素的方法中访问的隐式状态，包括关于不相关类型的存在的
* 状态。即使“同一个”元素正在被建模，由这些接口的不同实现创建的元素对象也不应该期望相
* 等；这类似于通过不同的类加载器加载的同一个类文件的Class对象是不同的
*
*/
@Override
boolean equals(Object obj);
/**
* 基于Object.hashCode
*/
@Override
int hashCode();
/**
* 获得直接声明在该元素上的注解
* 如果要获得继承的注解,使用Elements#getAllAnnotationMirrors(Element)方法.
*/
@Override
List<? extends AnnotationMirror> getAnnotationMirrors();
@Override
<A extends Annotation> A getAnnotation(Class<A> annotationType);
<R, P> R accept(ElementVisitor<R, P> v, P p);
}
