@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface DemoAnnotation {
    // 示例：如何为注解添加参数
    // 如果参数名为 value，则使用注解时可以隐式赋值
    int value() default 0;
}

// @SupportedOptions 注解搭配 #getSupportedOptions() 回调使用
@SupportedOptions({"org.gradle.annotation.processing.aggregating"})
public class DemoProcessor extends AbstractProcessor {

    private Filer filer;
    private Messager messager;
    private Types typeUtils;
    private Elements elements;

    /**
     * 初始化 Processor 环境，通常用于初始化 Filer，Message，ElementUtil。
     */
    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);

        filer = processingEnvironment.getFiler();
        messager = processingEnvironment.getMessager();
        typeUtils = processingEnvironment.getTypeUtils();
        elements = processingEnvironment.getElementUtils();
    }

    /**
     * 支持的 JDK 版本，通常选择最新版。
     * 如果用到了某个版本 JDK 特性，则需要选择该版本或更新版本。
     */
    @Override
    public SourceVersion getSupportedSourceVersion() {
        // return SourceVersion.RELEASE_8;
        return SourceVersion.latestSupported();
    }

    /**
     * 指定 Processor 编译选项，需要 Processor 添加 @SupportedOptions 并指定同样的 Options。
     * <p/>
     * 通过该方法可以指定 Processor 的编译方式，包括全量、增量两种：
     * <ul>
     *     <li>默认为全量编译。</li>
     *     <li>在 META-INF 中注册 Processor 时指定为 isolating，则使用增量编译。</li>
     *     <li>在 META-INF 中注册 Processor 时指定为 dynamic，则可在该方法中选择增量编译。</li>
     * </ul>
     * Note: 如果一个 Module 应用了 Processor 但又没有任何一个类被 Process、
     * 或是在 Gradle 中设置了自定义 compileOptions 但未在 SupportedOptions 中定义，
     * 则会出现日志警告：
     * <pre>
     *     The following options were not recognized by any processor: '[xxxOptionName]'
     * </pre>
     * Note: Auto-Service 1.0-rc6 才支持增量编译。
     */
    @Override
    public Set<String> getSupportedOptions() {
        // return super.getSupportedOptions();
        // 支持增量模式：
        return Collections.singleton("org.gradle.annotation.processing.aggregating");
    }

    /**
     * 用于指定该 Processor 需要处理的注解的类。
     *
     * 一个 Processor 可以同时处理多个注解，所以返回值为 Set。
     */
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        return Colletions.singleton(DemoAnnotation.class.getCanonicalName());
    }

    /**
     * 编译时处理注解的入口。
     */
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        return false;
    }
}

// Processor 所在 Module 添加 AutoService 的依赖，并用 AutoService 的注解处理器代替完成注册：
implementation 'com.google.auto.service:auto-service:1.0'
annotationProcessor 'com.google.auto.service:auto-service:1.0'

// 给 Processor 添加 AutoService 的注解：
@AutoService(Processor.class)
public class DemoProcessor extends AbstractProcessor {
    ......
}

// incremental.annotation.processors 文件中声明为 dynamic 模式：
priv.demo.DemoProcessor,dynamic

// Processor#getSupportedOptions(...) 中指定编译类型：
public class DemoProcessor extends AbstractProcessor {
    @Override
    public Set<String> getSupportedOptions() {
        // Aggregating 增量编译
        return Collections.singleton("org.gradle.annotation.processing.aggregating");
    }
    ......
}

public class DemoProcessor extends AbstractProcessor {
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        Set<String> routerAnnotationTypeSet = new HashSet<>();
        // 添加需要处理的注解类的全限定类名。
        routerAnnotationTypeSet.add(DemoAnnotation.class.getCanonicalName());
        // 值得注意的是，方法返回的集合是注解类全限定类名的集合，
        // 这意味着 Processor 并不一定要真正具有注解类的依赖关系，
        // 手动指定一个类的全限定类名也是可行的，例如：
        routerAnnotationTypeSet.add("priv.demo.DemoAnnotation");
        return routerAnnotationTypeSet;
    }
}

public class DemoProcessor extends AbstractProcessor {
    private Elements elementUtils;

    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);

        elementUtils = processingEnvironment.getElementUtils();
    }

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        if (set == null || set.isEmpty() || roundEnvironment == null) {
            return false;
        }

        if (roundEnvironment != null && roundEnvironment.processingOver()) {
            // 示例：判断是否正在处理当前 Module 的最后一个
        }

        // 获取包含了某个注解的元素集合：
        Set<? extends Element> demoAnnotatedClassSet = roundEnvironment.getElementsAnnotatedWith(DemoAnnotation.class);

        // 同样也可以直接通过注解的全限定类名获取：
        TypeElement demoAnnotationClassElement = elementUtils.getTypeElement("priv.demo.DemoAnnotation");
        Set<? extends Element> demoAnnotatedClassSet = roundEnvironment.getElementsAnnotatedWith(demoAnnotationClassElement);

        // 处理包含了注解的元素：
        for (Element annotatedElement : demoAnnotatedClassSet) {
            processElement(annotatedElement);
        }
        return true;
    }

    private void processElement(RoundEnvironment roundEnvironment, Element annotatedElement) {
        if (annotatedElement == null) {
            return;
        }

        if ((annotatedElement instanceof TypeElement) && annotatedElement.getKind() == ElementKind.CLASS) {
            // 示例：判断注解是否声明在类上，同理也可判断是否在方法、属性等元素上，
            // 可根据注解定义的类型选择是否需要处理该元素。
        }

        if (annotatedElement.getModifiers().contains(Modifier.PUBLIC)) {
            // 示例：判断被注解的元素包含的标识符，同理也可判断 private、static 等。
        }

        // 示例：获取被注解的 Class（前提是被注解的元素是 Class 类型）实现的所有接口：
        TypeElement annotatedTypeElement = ((TypeElement) annotatedElement);
        for (TypeMirror eachTypeMirror : annotatedTypeElement.getInterfaces()) {
            // 示例：判断某个接口是否是另一个接口或是其子类：
            TypeMirror superInterfaceTypeMirror = elementUtils.getTypeElement("priv.demo.IDemoInterface").asType();
            boolean isSubInterface = typeUtils.isSubtype(eachTypeMirror, superInterfaceTypeMirror);
        }
    }
}

@Documented
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface DemoAnnotation {
    // 如果参数名为 value，则使用注解时可以隐式赋值
    int value() default 0;
}

public class DemoProcessor extends BaseRouterProcessor {

    private void processElement(Element annotatedElement) {
        // 示例 1：获取被添加了注解的类所在的包名以及类名
        if ((eachElement instanceof TypeElement) && annotatedElement.getKind() == ElementKind.CLASS) {
            String packageName = annotatedElement.getEnclosingElement().toString();
            String className = annotatedElement.getSimpleName().toString();
        }

        // 示例 2：获取元素上的注解实例（前提是有注解类的依赖，能直接访问注解类），返回值是泛型：
        DemoAnnotation demoAnnotation = annotatedElement.getAnnotation(DemoAnnotation.class);
        // 然后就能获取使用注解时的参数赋值（如果有参数的话）：
        int value = demoAnnotation.value();

        // 示例 3：如果 Processor 不能直接访问注解类，则只能获取注解包含的抽象参数 List：
        // 可以通过 List 是否为空判断元素上的注解是否设置了参数，
        // 如果参数是枚举或 String 类型，可以尝试是否能通过字符串匹配的方式判断取值。
        List<? extends AnnotationMirror> annotationMirrorList = element.getAnnotationMirrors();

        // 示例：使用 JavaPoet 生成类（伪代码）
        try {
            JavaFile.builder(packageName,
                    TypeSpec.classBuilder(className + "_" + value)
                            .addJavadoc("DO NOT edit this file !!!")
                            .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
                            .build())
                    .build()
                    .writeTo(filer);
            messager.printMessage(Kind.NOTE, "Generated: " + packageName + "." + className);
        } catch (Exception e) {
            messager.printMessage(Kind.ERROR, "Failed: " + packageName + "." + className);
            throw new RuntimeException(e);
        }
    }
}

File generatedFile = new File("/DemoProject/" + className + ".java");
JavaFile.builder(packageName,
        TypeSpec.classBuilder(className)
                .build())
        .build()
        .writeTo(generatedFile.toPath());