概念

注解处理器(Annotation Processor)是javac内置的一个用于编译时扫描和处理注解(Annotation)的工具。简单的说，在源代码编译阶段，通过注解处理器，我们可以获取源文件内注解(Annotation)相关内容。

用途

由于注解处理器可以在程序编译阶段工作，所以我们可以在编译期间通过注解处理器进行我们需要的操作。比较常用的用法就是在编译期间获取相关注解数据，然后动态生成.java源文件(让机器帮我们写代码)，通常是自动产生一些有规律性的重复代码，解决了手工编写重复代码的问题，大大提升编码效率。

例子

Annotation Processor实质原理

** 编译期间根据注解(Annotation)获取相关数据 **

既然Annotation Processor是为了在编译期间获取注解(Annotation)相关内容，那么，具体的操作步骤要如何做呢：

Android Studio创建一个java library

自定义一个注解(Annotation),用于存储元数据

@Retention(RetentionPolicy.SOURCE)

@Target(ElementType.FIELD)

public @interface BindView {

int value() default -1;

}

创建一个自定义Annotation Processor继承于AbstractProcessor

package com.example;

@AutoService(Processor.class)

public class MyProcessor extends AbstractProcessor {

@Override

public synchronized void init(ProcessingEnvironment env){

}

@Override

public boolean process(Set extends TypeElement> annoations, RoundEnvironment roundEnv) { }

@Override

public Set getSupportedAnnotationTypes() {

}

@Override

public SourceVersion getSupportedSourceVersion() {

}

}

@AutoService(Processor.class) :向javac注册我们这个自定义的注解处理器，这样，在javac编译时，才会调用到我们这个自定义的注解处理器方法。

AutoService这里主要是用来生成

META-INF/services/javax.annotation.processing.Processor文件的。如果不加上这个注解，那么，你需要自己进行手动配置进行注册，具体手动注册方法如下：

1.创建一个

META-INF/services/javax.annotation.processing.Processor文件，

其内容是一系列的自定义注解处理器完整有效类名集合，以换行切割：

com.example.MyProcessor

com.foo.OtherProcessor

net.blabla.SpecialProcessor

2.将自定义注解处理器和

META-INF/services/javax.annotation.processing.Processor打包成一个.jar文件。所以其目录结构大概如下所示：

MyProcessor.jar

- com

- example

- MyProcessor.class

- META-INF

- services

- javax.annotation.processing.Processor

*** 建议直接采用@AutoService(Processor.class)进行自定义注解处理器注册，简洁方便 ***

init(ProcessingEnvironment env):每个Annotation Processor必须***

有一个空的构造函数 *。编译期间，init()会自动被注解处理工具调用，并传入ProcessingEnviroment参数，通过该参数可以获取到很多有用的工具类: Elements , Types , Filer **等等

process(Set extends TypeElement> annoations, RoundEnvironment roundEnv):Annotation Processor扫描出的结果会存储进roundEnv中，可以在这里获取到注解内容，编写你的操作逻辑。注意,process()函数中不能直接进行异常抛出,否则的话,运行Annotation Processor的进程会异常崩溃,然后弹出一大堆让人捉摸不清的堆栈调用日志显示.

getSupportedAnnotationTypes(): 该函数用于指定该自定义注解处理器(Annotation Processor)是注册给哪些注解的(Annotation),注解(Annotation)指定必须是完整的包名+类名(eg:com.example.MyAnnotation)

getSupportedSourceVersion():用于指定你的java版本，一般返回：SourceVersion.latestSupported()。当然，你也可以指定具体java版本：

return SourceVersion.RELEASE_7;

经过前面3个步骤后，其实就已经算完成了自定义Annotation Processor。后面要做的就是在源码里面，在需要的地方写上我们自定义的注解就行了。

Demo

牢记Annotation Process的实质用处就是在编译时通过注解获取相关数据，

那么，在这个Demo里面，我们就直接在编译时打印出我们注解的数据的成员变量名，成员变量类，包装类类名，包名和注解元数据进行显示，然后将这些信息写入到一个.java文件中，这里我就简单的直接输出这些信息进行显示。

按照上面自定义注解处理的方法，我们操作如下:

创建一个java library,其gradle配置如下:

apply plugin: 'java'

targetCompatibility = '1.7'

sourceCompatibility = '1.7'

dependencies {

compile fileTree(include: ['*.jar'], dir: 'libs')

compile 'com.google.auto.service:auto-service:1.0-rc3'

}

自定义一个注解(Annotation),用于存储元数据

@Retention(RetentionPolicy.SOURCE)

@Target(ElementType.FIELD)

public @interface BindView {

int value() default -1;

}

创建一个自定义Annotation Processor继承于AbstractProcessor

@AutoService(Processor.class)

public class MyAnnotationProcessor extends AbstractProcessor {

private Filer mFiler;

private Messager mMessager;

private Elements mElementUtils;

@Override

public synchronized void init(ProcessingEnvironment processingEnvironment) {

super.init(processingEnvironment);

mFiler = processingEnvironment.getFiler();

mMessager = processingEnvironment.getMessager();

mElementUtils = processingEnvironment.getElementUtils();

}

@Override

public Set getSupportedAnnotationTypes() {

Set annotations = new LinkedHashSet<>();

annotations.add(BindView.class.getCanonicalName());

return annotations;

}

@Override

public SourceVersion getSupportedSourceVersion() {

return SourceVersion.latestSupported();

}

@Override

public boolean process(Set extends TypeElement> set, RoundEnvironment roundEnvironment) {

Set extends Element> bindViewElements = roundEnvironment.getElementsAnnotatedWith(BindView.class);

for (Element element : bindViewElements) {

//1.获取包名

PackageElement packageElement = mElementUtils.getPackageOf(element);

String pkName = packageElement.getQualifiedName().toString();

note(String.format("package = %s", pkName));

//2.获取包装类类型

TypeElement enclosingElement = (TypeElement) element.getEnclosingElement();

String enclosingName = enclosingElement.getQualifiedName().toString();

note(String.format("enclosindClass = %s", enclosingElement));

//因为BindView只作用于filed，所以这里可直接进行强转

VariableElement bindViewElement = (VariableElement) element;

//3.获取注解的成员变量名

String bindViewFiledName = bindViewElement.getSimpleName().toString();

//3.获取注解的成员变量类型

String bindViewFiledClassType = bindViewElement.asType().toString();

//4.获取注解元数据

BindView bindView = element.getAnnotation(BindView.class);

int id = bindView.value();

note(String.format("%s %s = %d", bindViewFiledClassType, bindViewFiledName, id));

//4.生成文件

createFile(enclosingElement, bindViewFiledClassType, bindViewFiledName, id);

return true;

}

return false;

}

private void createFile(TypeElement enclosingElement, String bindViewFiledClassType, String bindViewFiledName, int id) {

String pkName = mElementUtils.getPackageOf(enclosingElement).getQualifiedName().toString();

try {

JavaFileObject jfo = mFiler.createSourceFile(pkName + ".ViewBinding", new Element[]{});

Writer writer = jfo.openWriter();

writer.write(brewCode(pkName, bindViewFiledClassType, bindViewFiledName, id));

writer.flush();

writer.close();

} catch (IOException e) {

e.printStackTrace();

}

}

private String brewCode(String pkName, String bindViewFiledClassType, String bindViewFiledName, int id) {

StringBuilder builder = new StringBuilder();

builder.append("package " + pkName + ";\n\n");

builder.append("//Auto generated by apt,do not modify!!\n\n");

builder.append("public class ViewBinding { \n\n");

builder.append("public static void main(String[] args){ \n");

String info = String.format("%s %s = %d", bindViewFiledClassType, bindViewFiledName, id);

builder.append("System.out.println(\"" + info + "\");\n");

builder.append("}\n");

builder.append("}");

return builder.toString();

}

private void note(String msg) {

mMessager.printMessage(Diagnostic.Kind.NOTE, msg);

}

private void note(String format, Object... args) {

mMessager.printMessage(Diagnostic.Kind.NOTE, String.format(format, args));

}

}

** 借助Messager，我们可以在编译时输出日志. **

使用注解，我们在Android工程中创建几个测试类，然后进行注解，如下所示：

public class MainActivity extends AppCompatActivity {

@BindView(R.id.tv)

TextView tv;

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

}

}

rebuild一下，可以在Gradle Console窗口中看到打印结果：

result

可以看到，我们成功的在编译期间获取了我们注解的相关数据。只要拿到了数据，那么你自己想干嘛就自己去弄吧 _

最后，我们根据注解获取到的数据还生成了一个java文件，其生成路径：app\build\generated\source\apt\debug\com\yn\annotationprocessdemo\ViewBinding.java

具体内容如下：

package com.yn.annotationprocessdemo;

//Auto generated by apt,do not modify!!

public class ViewBinding {

public static void main(String[] args) {

System.out.println("android.widget.TextView tv = 2131427422");

}

}

附录：

@AutoService引入:

compile 'com.google.auto.service:auto-service:1.0-rc3'

app的gralde配置：

apply plugin: 'com.android.application'

android {

compileSdkVersion 24

buildToolsVersion "24.0.0"

defaultConfig {

applicationId "com.example.annotationprocessor"

minSdkVersion 15

targetSdkVersion 24

versionCode 1

versionName "1.0"

}

buildTypes {

release {

minifyEnabled false

proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

}

}

compileOptions {

sourceCompatibility JavaVersion.VERSION_1_7

targetCompatibility JavaVersion.VERSION_1_7

}

//解决duplicate问题

packagingOptions {

exclude 'META-INF/services/javax.annotation.processing.Processor'

}

}

dependencies {

compile fileTree(dir: 'libs', include: ['*.jar'])

testCompile 'junit:junit:4.12'

compile 'com.android.support:appcompat-v7:24.0.0'

compile project(path: ':annotationprocessor')

}