注解处理器使用

本文同步至：http://blog.edreamoon.com/

注解的生命周期

注解生命周期即表明注解在代码的什么阶段生效，通过@Retention来指定，其值可以为以下三种：

• SOURCE,源码注解， 注解只在源码中存在，javac在编译成class时会把Java源程序上的源码注解给去掉编译成.class文件就将相应的注解去掉。
• CLASS,编译时注解，注解在源码、.class文件里面存在。
• RUNTIME,运行时注解，在运行阶段还起作用

三个阶段简单表示为：java源文件–>class文件–>内存中的字节码

注解处理器(Annotation Processor)

注解处理器用来在编译时扫描和处理注解，是javac的一个工具。一般使用注解处理器在编译时生成新的java文件，新生成的java文件会在编译期同其它java文件一样被编译。
目前比较流行的一些库都用到了注解处理器，如dagger2、butterknife、Android提供的data binding，相对于使用反射极大的提高了效率。

案例

Talk is cheap, show me the code! 下面使用一个demo来说明如何使用注解处理器。这个Demo比较简单，只是在编译项目时，打印注解信息。

工程目录如下：

752773433.png

mj-annotate、mj-processor是java library，分别用于自定义注解、自定义注解处理器。

1. 首先定义注解，这个很简单

@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
public @interface BindTest {
    int value();
}

这里指定为源码注解，可以用到字段、方法、类上

2. 在项目的Activity中使用此注解，在类、方法、字段中均使用了下。

@BindTest(R.layout.activity_main)
public class MainActivity extends AppCompatActivity {
 
    @BindTest(R.id.bt_activity_main)
    private Button button;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
 
    @BindTest(R.id.bt_activity_main)
    public void onClickButton() {
    }
}

3.注解已经使用了，但这些注解并没有起到什么作用。如何让项目编译时处理这些注解并打印注解相关信息哪？接下来就是注解处理器显神威的时候了。
定义一个处理器需要继承AbstractProcessor，并覆盖其中的一些方法的实现。

public class MProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set set, RoundEnvironment roundEnvironment) {
        /**
         * 处理注解的地方，注解的上面说到的生成Java文件就是在此处理的，这里可以获取注解相关的内容
         */
 
        Messager messager = processingEnv.getMessager();
        //遍历用BindView注解的元素
        for (Element element : roundEnvironment.getElementsAnnotatedWith(BindTest.class)) {
            BindView annotation = element.getAnnotation(BindView.class);
 
            int value = annotation.value(); //注解的值
            ElementKind kind = element.getKind();//注解作用的位置
 
            if (kind == ElementKind.FIELD) {//如果这个元素是一个方法
                VariableElement variableElement = (VariableElement) element;//转换成方法对应的element
                messager.printMessage(Diagnostic.Kind.NOTE, "field");
            } else if (kind == ElementKind.METHOD) {//如果这个元素是一个方法
                ExecutableElement executableElement = (ExecutableElement) element;//转成方法对应的element
                messager.printMessage(Diagnostic.Kind.NOTE, "method return type : " + executableElement.getReturnType().toString());
                List params = executableElement.getParameters();//获取方法所有的参数
            } else if (kind == ElementKind.CLASS) {
                TypeElement typeElement = (TypeElement) element;
                messager.printMessage(Diagnostic.Kind.NOTE, "class " + typeElement.getQualifiedName());
            }
 
            //打印注解相关的信息
            messager.printMessage(Diagnostic.Kind.NOTE, value + " : " + kind.name());
        }
 
        /**
         * 返回true表示该注解已经被处理, 后续不会再有其他处理器处理； 返回false表示仍可被其他处理器处理.
         */
        return false;
    }
 
    @Override
    public Set getSupportedAnnotationTypes() {
        /**
         * 返回支持的注解类型，限定注解处理器用到哪些注解上
         */
        Set types = new LinkedHashSet<>();
        types.add(BindTest.class.getCanonicalName());
        return types;
    }
 
    @Override
    public SourceVersion getSupportedSourceVersion() {
        /**
         *指定使用的Java版本，为了更好的兼容使用SourceVersion.latestSupported()
         */
        return SourceVersion.latestSupported();
    }
}

主要实现就是getSupportedAnnotationTypes、getSupportedSourceVersion、process，代码中已经解释很清楚了。其中针对AbstractProcessor，也可以使用@SupportedAnnotationTypes、@SupportedSourceVersion注解来代替getSupportedAnnotationTypes() 、getSupportedSourceVersion()。也就是代码简化为如下：

@SupportedAnnotationTypes({"com.mj.annotate.BindView"})
@SupportedSourceVersion(SourceVersion.RELEASE_7)
public class MProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set set, RoundEnvironment roundEnvironment) {
        //..............省略..........
    }
}

但考虑到兼容性和可维护性，最好还是用覆盖对应方法的形式实现比较好。

处理器已经写好了，然后在 app module 中添加对 mj-processor 的依赖。

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    compile 'com.android.support:appcompat-v7:25.1.0'
    compile project(path: ':mj-annotate')
    compile project(path: ':mj-processor')
}

此时Rebuild下项目，并不会打印process中的log信息，还需要创建处理器说明文件： main->resources->META-INF/services->javax.annotation.processing.Processor，然后在文件中输入定义的处理器：com.mj.processor.MProcessor。如果有多个Processor，以换行切换。这个步骤要创建多级目录比较麻烦，我们可以使用AutoService注解简化，在mj-processor 中添加相应依赖即可使用：

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    compile project(path: ':mj-annotate')
    compile 'com.google.auto.service:auto-service:1.0-rc2'
}

在 MProcessor 类使用@AutoService(Processor.class)，编译成jar包时即会自动生成上述文件。

此时再回过头看文章开头的目录结构，就和各步骤对应了。
此时再Rebuild下项目就会打印log：

519130143.png

注意，此处是log是在gradle console中，为了能看到log，最好是Rebuild，或者是clean下项目。

Processor运行环境

既然Processor是编译时处理各种注解的，而Processor也是java文件，那它是如何运行工作的哪？
Processor也是运行在虚拟机JVM中的，只不过是一个独立的JVM，javac会启动一个完整Java虚拟机来保证Processor的工作，所以在这里保证了java的运行环境。

APT

Processor是在编译期工作的，而我们的apk运行时就不再需要了，但反编译上面生成的apk会发现mj-processor的代码。

APT(Annotation Processing Tool)就很好解决了这个问题，它能在编译时期去依赖注解处理器并进行工作，但在生成 APK 时不会包含任何遗留的东西
修改工程目录下的 build.gradle，添加maven仓库、apt依赖

 repositories {
    jcenter()
    mavenCentral() //for apt
}
dependencies {
    classpath 'com.android.tools.build:gradle:2.2.3'
    classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8' //for apt
}

然后在 app module 修改依赖：

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    compile 'com.android.support:appcompat-v7:25.1.0'
    compile project(':mj-annotate')
//    compile project(':mj-processor')
    apt project(':mj-processor') // 使用apt依赖
}

这样就可以去除apk中processor相关内容