1、概述

我们知道，Java代码需经过编译才能够被正确执行，而Java程序的编译可以分为两个阶段：Javac编译器的编译和JIT编译器的编译，笼统的讲：Javac编译器将.java文件编译成.class文件，即字节码文件，JIT编译器将*.class文件编译器本地机器码，本地机器码再由操作系统直接执行。在JDK1.6中提供了一组插入式注解处理器的标准API在编译期间对注解进行处理，我们可以把注解处理器看作是编译器的插件，在这些插件里面，可以读取、修改、添加抽象语法树中的任意元素。利用这个特点我们可以干涉编译器的行为，可以使用插入式注解处理器来实现原本只能在编码中完成的事情。

2、注解处理器

根据编译的不同阶段，我们将注解分为编译时注解和运行时注解。这里暂时不讨论运行时注解，我们只讨论Javac编译器中的注解，Javac中的注解处理器是编译时用来扫描和处理注解的工具，通过上一节我们知道：可以自定义注解，当然我们也可以为我们自定义的注解注册自己的注解处理器。

3、实现自定义注解处理器

实现自定义注解处理器需要继承抽象类javax.annotation.processing.AbstractProcessor.此抽象类只有一个抽象方法：process(),它是Javac编译器在执行注解处理器代码时要调用的过程，AbstractProcessor类源码如下：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package javax.annotation.processing;

import java.util.Collections;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
import javax.annotation.processing.Completion;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedOptions;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic.Kind;

public abstract class AbstractProcessor implements Processor {
    protected ProcessingEnvironment processingEnv;
    private boolean initialized = false;

    protected AbstractProcessor() {
    }

    public Set<String> getSupportedOptions() {
        SupportedOptions var1 = (SupportedOptions)this.getClass().getAnnotation(SupportedOptions.class);
        return var1 == null?Collections.emptySet():arrayToSet(var1.value());
    }

    public Set<String> getSupportedAnnotationTypes() {
        SupportedAnnotationTypes var1 = (SupportedAnnotationTypes)this.getClass().getAnnotation(SupportedAnnotationTypes.class);
        if(var1 == null) {
            if(this.isInitialized()) {
                this.processingEnv.getMessager().printMessage(Kind.WARNING, "No SupportedAnnotationTypes annotation found on " + this.getClass().getName() + ", returning an empty set.");
            }

            return Collections.emptySet();
        } else {
            return arrayToSet(var1.value());
        }
    }

    public SourceVersion getSupportedSourceVersion() {
        SupportedSourceVersion var1 = (SupportedSourceVersion)this.getClass().getAnnotation(SupportedSourceVersion.class);
        SourceVersion var2 = null;
        if(var1 == null) {
            var2 = SourceVersion.RELEASE_6;
            if(this.isInitialized()) {
                this.processingEnv.getMessager().printMessage(Kind.WARNING, "No SupportedSourceVersion annotation found on " + this.getClass().getName() + ", returning " + var2 + ".");
            }
        } else {
            var2 = var1.value();
        }

        return var2;
    }

    public synchronized void init(ProcessingEnvironment var1) {
        if(this.initialized) {
            throw new IllegalStateException("Cannot call init more than once.");
        } else {
            Objects.requireNonNull(var1, "Tool provided null ProcessingEnvironment");
            this.processingEnv = var1;
            this.initialized = true;
        }
    }

    public abstract boolean process(Set<? extends TypeElement> var1, RoundEnvironment var2);

    public Iterable<? extends Completion> getCompletions(Element var1, AnnotationMirror var2, ExecutableElement var3, String var4) {
        return Collections.emptyList();
    }

    protected synchronized boolean isInitialized() {
        return this.initialized;
    }

    private static Set<String> arrayToSet(String[] var0) {
        assert var0 != null;

        HashSet var1 = new HashSet(var0.length);
        String[] var2 = var0;
        int var3 = var0.length;

        for(int var4 = 0; var4 < var3; ++var4) {
            String var5 = var2[var4];
            var1.add(var5);
        }

        return Collections.unmodifiableSet(var1);
    }
}

1. init(ProcessingEnvironment env): 每一个注解处理器类都必须有一个空的构造函数。然而，这里有一个特殊的init()方法，它会被注解处理工具调用，并输入ProcessingEnviroment参数。ProcessingEnviroment提供很多有用的工具类Elements,Types和Filer。
2. process(Set<? extends TypeElement> annotations, RoundEnvironment env): 这相当于每个处理器的主函数main()。 在这里写扫描、评估和处理注解的代码，以及生成Java文件。输入参数RoundEnviroment，可以让查询出包含特定注解的被注解元素。
3. getSupportedAnnotationTypes(): 这里必须指定，这个注解处理器是注册给哪个注解的。注意，它的返回值是一个字符串的集合，包含本处理器想要处理的注解类型的合法全称。换句话说，在这里定义你的注解处理器注册到哪些注解上。
4. getSupportedSourceVersion(): 用来指定你使用的Java版本。通常这里返回SourceVersion.latestSupported()。然而，如果有足够的理由只支持Java 6的话，也可以返回SourceVersion.RELEASE_6。推荐使用前者。
5. 关于抽象的process()方法：我们可以从这个方法的第一个参数“var1”中获取到此注解处理器所要处理的注解集合，从第二个参数“var2”中访问到当前这个Round中的语法树节点，每个语法树节点在这里表示为一个Element。
6. 除process（）方法传入的参数外，还有一个很常用的实例变量“processEnv”,它是AbstractProcessor中的一个protected变量，在注解处理器初始化的时候创建，继承了AbstractProcessor类的注解处理器可以访问它，它代表了注解处理器框架提供的一个上下文环境，要创建新的代码，向编译器输出信息，获取其他工具类等都需要用到这个实例变量。