Android中注解处理器APT用法示例，
投稿于 被查看 31412 次 评论：254
Android中注解处理器APT用法示例，
目录
- APT作用
- Android基本编译流程
- APT基本使用
- 1、 自定义注解
- 2、注解处理器
- 注解处理器
- 注解处理器注册
- java代码生成
- 3. 对外调用
- 4. 调用
- 总结
APT，Annotation Processing Tool，即注解处理器，是一种用来处理注解的工具，常用在编译时扫描和处理注解，最终生成处理注解逻辑的Java文件。APT技术在目前的很多框架上都有着使用，如ButterKnife，ARouter，GreenDAO等框架上都有着APT技术的影子。
APT作用
使用APT可以在编译时来处理编译时注解，生成额外的Java文件，有如下效果：
可以达到减少重复代码手工编写的效果。
如ButterKnife，我们可以直接使用注解来减少findviewbyid这些代码，只需要通过注解表示是哪个id就够了。
功能封装。将主要的功能逻辑封装起来，只保留注解调用。
相对于使用Java反射来处理运行时注解，使用APT有着更加良好的性能。
Android基本编译流程
Android中的代码编译时需要经过：Java——>class ——> dex 流程，代码最终生成dex文件打入到APK包里面。
APT是在编译开始时就介入的，用来处理编译时注解。
AOP（Aspect Oridnted Programming）是在编译完成后生成dex文件之前，通过直接修改.class文件的方式，来对代码进行修改或添加逻辑。常用在在代码监控，代码修改，代码分析这些场景。
APT基本使用
基本使用流程主要包括如下几个步骤：
- 创建自定义注解
- 创建注解处理器，处理Java文件生成逻辑
- 封装一个供外部调用的API
- 项目中调用
本次以仿写ButterKnife绑定View为例，省略findviewbyId的代码，调用代码如下：
public class AnnotationTestActivity extends AppCompatActivity {
@BindView(R.id.tv_annotation_test1)
TextView tvAnnotationTest1;
@BindView(R.id.tv_annotation_test2)
TextView tvAnnotationTest2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_annotation_test);
BindViewTools.bind(this);
tvAnnotationTest1.setText("测试文本");
tvAnnotationTest1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Logger.toast(WorkDemoApplication.context,"控件1:"+R.id.tv_annotation_test1);
}
});
tvAnnotationTest2.setText("另一个文本");
tvAnnotationTest2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Logger.toast(WorkDemoApplication.context,"控件2:"+R.id.tv_annotation_test2);
}
});
}
}
1、 自定义注解
我们新建立一个Java lib，命名为annotationTest，用来承载自定义注解，代码如下所示：
@Retention(RetentionPolicy.CLASS)
@Target(ElementType.FIELD)
public @interface BindView {
int value();
}
2、注解处理器
额外新建立一个Java lib，命名为processorTest，用来承载注解处理及Java文件生成逻辑。
主要包括如下几个步骤：
- 添加注解处理器
- 注解处理器注册
- 添加java代码生成逻辑
需要注意的是，当前的注解处理器lib需要引入注解lib——annotationTest,在当前Module的build.gradle文件中配置：
implementation project(':annotationTest')//依赖刚刚创建的annotation模块
注解处理器
注解处理器代码如下：
public class BindViewProcessor extends AbstractProcessor {
private Messager mMessager;
private Elements mElementUtils;
private Map<String, ClassCreatorProxy> mProxyMap = new HashMap<>();
@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;
}
@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latestSupported();
}
@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);
JavaFile javaFile = JavaFile.builder(proxyInfo.getPackageName(),proxyInfo.generateJavaCode2()).build();
try {
//生成Java文件
javaFile.writeTo(processingEnv.getFiler());
} catch (IOException e) {
mMessager.printMessage(Diagnostic.Kind.NOTE, " --> create " + proxyInfo.getProxyClassFullName() + "error");
}
}
mMessager.printMessage(Diagnostic.Kind.NOTE, "process finish ...");
return true;
}
}
此处为了代码演示简单起见，并没有加入格式校验（如对注解修饰的类型等信息进行校验），如果你实际运用APT技术，请务必要对注解的使用规则进行详细的校验。
注解处理器注册
自定义的注解处理器必须经过注册才能够使用，即需要对注解处理器添加自动主动的注解。
我们可以使用Google autoService来进行注解处理器的自动注册，首先需要在注解处理器所在的module的build.gradle文件添加autoService的包引入：
//google autoService
implementation "com.google.auto.service:auto-service:1.0-rc4"
annotationProcessor "com.google.auto.service:auto-service:1.0-rc4"
然后将自动注册的注解添加到注解处理器上以实现自动注册效果：
@AutoService(Processor.class)
public class BindViewProcessor extends AbstractProcessor {
...
}
java代码生成
对于java代码的生成存在有多种方式，如字符串拼接，JavaPoet等。
如果要使用JavaPoet，则需要在当前的Module的build.gradle文件中引入：
//javaPoet
implementation "com.squareup:javapoet:1.13.0"
详细代码如下：
package com.example.shapetest.bindview;
import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.TypeSpec;
import java.util.HashMap;
import java.util.Map;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.PackageElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.element.VariableElement;
import javax.lang.model.util.Elements;
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("import com.example..*;\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;
}
/**
* 创建Java代码 javapoet
* @return
*/
public TypeSpec generateJavaCode2() {
TypeSpec bindingClass = TypeSpec
//class名称设置
.classBuilder(mBindingClassName)
//类为public
.addModifiers(Modifier.PUBLIC)
.addMethod(generateMethods2())
.build();
return bindingClass;
}
/**
* 加入Method javapoet
*/
private MethodSpec generateMethods2() {
ClassName host = ClassName.bestGuess(mTypeElement.getQualifiedName().toString());
MethodSpec.Builder methodBuilder = MethodSpec
//方法名称
.methodBuilder("bind")
//方法为public
.addModifiers(Modifier.PUBLIC)
//返回值
.returns(void.class)
//方法参数
.addParameter(host, "host");
for (int id : mVariableElementMap.keySet()) {
VariableElement element = mVariableElementMap.get(id);
String name = element.getSimpleName().toString();
String type = element.asType().toString();
methodBuilder.addCode("host." + name + " = " + "(" + type + ")(((android.app.Activity)host).findViewById( " + id + "));\n");
}
return methodBuilder.build();
}
public String getPackageName() {
return mPackageName;
}
}
3. 对外调用
在完成了上述两步之后，APT的实际工作已经能够正常运行了，下面我们实现以下调用方法，以达到模仿butterknife的调用效果。
首先我们需要新建立一个Android lib的Module，命名为apt_lib。
当前的对外lib需要引用注解处理器lib——processorTest,在当前Module的build.gradle文件中进行如下配置：
implementation project(path: ':processorTest')
新建对外的调用方法，代码如下：、
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 (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
其主要功能是为被注解绑定的Activity生成对应的辅助类以实现apt被调用的效果。
4. 调用
在进行了如下几步之后，我们实际上已经能够正常的调用@BindView这个注解了.
我们在我们的主Module——app中调用APT，当然此时的APT需要引入之前的lib工程，可以在app的build.gradle文件中进行如下配置：
implementation project(':annotationTest') // 添加依赖模块
implementation project(':apt_lib') // 添加依赖模块
implementation project(':processorTest') // 添加依赖模块
annotationProcessor project(':processorTest')
需要注意的是annotationProcessor这一注解处理工具是Java语言使用的，如果你使用的是kotlin语言，则需要使用kapt.
此时直接调用我们在开头的调用代码，在编译执行后能够正常运行。
当我们查看工程内的build文件夹时能够在如下路径发现我们之前生成的文件：
看到里面的代码如下：
package com.example.workdemo.activity;
public class AnnotationTestActivity_ViewBinding {
public void bind(AnnotationTestActivity host) {
host.tvAnnotationTest1 = (android.widget.TextView)(((android.app.Activity)host).findViewById( 2131231102));
host.tvAnnotationTest2 = (android.widget.TextView)(((android.app.Activity)host).findViewById( 2131231103));
}
}
这样的话我们就完成了APT的一个简单示例。
总结
本文主要对Android中的APT技术进行了简单说明。APT技术能够利用编译的技术直接生成Java逻辑代码，在代码重复度较高的场景中比较适用。
到此这篇关于Android中注解处理器APT用法示例的文章就介绍到这了,更多相关Android中注解处理器APT内容请搜索3672js教程以前的文章或继续浏览下面的相关文章希望大家以后多多支持3672js教程！
您可能感兴趣的文章:- Android 利用 APT 技术在编译期生成代码
用户评论