APT介绍与使用

APT：Annotation Processing Tool
是一个处理注解的工具，根据注解自动生成代码。

java是一种结构体语言，由各个有层级的Element组成。
kotlin也是。下面都用kotlin代码做例子：

package com.hujun.modulize              //PackageElement 包节点
    
class Main {                            //TypeElement 类节点
    private var x = 0                   //VariableElement 元素节点         
    
    init {
        print("hello world")
    }
    
    private fun print(msg:String){}     //ExecutableElement 方法节点
}

首先写自定义注解，用来注解需要自动生成代码的类上面。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface ARouter {
    //详细路由路径，比如"/app/MainActivity"
    String path();

    //也可以不填，可以从path中拿
    String group() default "";
}

然后写自己的注解处理器：
需要引入Google的auto-service，是Google提供的生成注解的服务。

    compileOnly'com.google.auto.service:auto-service:1.0-rc6'
    annotationProcessor'com.google.auto.service:auto-service:1.0-rc6'

自己的注解处理器如下：

@AutoService(Processor.class)
//处理什么class
@SupportedAnnotationTypes({"com.hujun.modulize.annotation.ARouter"})
@SupportedSourceVersion(SourceVersion.RELEASE_7) //根据什么JDK的版本来生成class文件
@SupportedOptions("content")  //接收外面给的信息类型
public class ARouterProcessor extends AbstractProcessor {
    //操作Element工具类
    private Elements elementUtils;

    //type（类信息）工具类
    private Types typeUtils;

    //用来输出警告、错误等日志
    private Messager messager;

    //文件生成器
    private Filer filer;

    //初始化工作，
    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        elementUtils = processingEnvironment.getElementUtils();
        typeUtils = processingEnvironment.getTypeUtils();
        messager = processingEnvironment.getMessager();
        filer = processingEnvironment.getFiler();
        if (messager==null){
            return;
        }
        if (processingEnvironment.getOptions()==null){
            return;
        }
        String content = processingEnvironment.getOptions().get("content");
        print(content);
    }



    /**
     * 相当于main函数，开始处理注解
     * 注解处理器的核心方法，处理具体的注解，生成java文件
     * @param set               使用了支持处理注解的节点集合
     * @param roundEnvironment  当前或之前的运行环境，可以通过该对象查找找到的注解
     * @return true 表示后续处理器不会再处理，已经处理完成
     */
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        print("process");
        if (set.isEmpty()) {
            return false;
        }

        //获取项目中所有使用了ARouter注解的节点
        Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(ARouter.class);
        //遍历所有的类节点
        for (Element element : elements) {
           generateJavaClassFile(element);
        }


        return true;
    }

    private void generateJavaClassFile(Element element){
        String pkgName = elementUtils.getPackageOf(element).getQualifiedName().toString();
        String className = element.getSimpleName().toString();
        print("被注解的类有："+className);

        String finalClassName = className + "$$ARouter";
        try {
            JavaFileObject sourceFile = filer.createSourceFile(pkgName+"."+finalClassName);
            Writer writer = sourceFile.openWriter();
            StringBuilder builder = new StringBuilder();
            builder.append("package "+pkgName+";\n");
            builder.append("public class "+finalClassName+"{\n");
            builder.append("public static Class<?> findTargetClass(String path){\n");
            ARouter router = element.getAnnotation(ARouter.class);
            builder.append("if (path.equalsIgnoreCase(\""+router.path()+"\")){\n");
            builder.append("return "+className+".class;\n");
            builder.append("}\n");
            builder.append("return null;\n");
            builder.append("}\n}");
            print(builder.toString());
            writer.write(builder.toString());
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void print(String msg){
        if (messager==null){
            return;
        }
        messager.printMessage(Diagnostic.Kind.NOTE,msg);
    }
}

需要掌握的API

需要掌握的API

最后，在需要自动生成代码的地方，加上注解ARouter.

@ARouter(path = "/app/MainActivity")
class MainActivity : AppCompatActivity() {}

需要将自己的注解处理器Module引入工程中。
java的代码用 annotationProcessor project(":compiler")
kotlin的代码用 kapt project(":compiler")，还需要加入apply plugin: 'kotlin-kapt'

然后build工程，自定义的注解生成器ARouterProcessor就会被调用，自动生成java代码。
kotlin工程自动生成的代码位置在：app/build/generated/source/kapt/debug/包名下面。

如果想给注解处理器传值，可以在build.gradle里加入：

        //在gradle文件中配置选项参数值，用于APT传参数值
        //必须写在defaultConfig节点中
        javaCompileOptions{
            annotationProcessorOptions{
                includeCompileClasspath false
                arguments = [content:"hello apt"]
            }
        }

结合JavaPoet使用

上面的生成代码方式很粗暴，很可能生成错误的，而且很难找到问题。
JavaPoet是square推出的开源java代码生成框架。
项目源码 ： https://github.com/square/javapoet

JavaPoet常用的8个类

    //帮助以类调用的形式来生成java代码
    implementation 'com.squareup:javapoet:1.10.0'

具体生成代码方式：

    private String generateJavaByJavaPoet(String pkgName,String className,String finalClassName,Element element){
        ARouter router = element.getAnnotation(ARouter.class);
        MethodSpec methodSpec = MethodSpec.methodBuilder("findTargetClass")
                .addModifiers(Modifier.PUBLIC,Modifier.STATIC)
                .returns(Class.class)
                .addParameter(String.class,"path")
                .beginControlFlow("if(path.equalsIgnoreCase($S))",router.path())
                .addStatement("return $T.class", ClassName.get((TypeElement) element))
                .endControlFlow()
                .addStatement("return null")
                .build();

        TypeSpec typeSpec = TypeSpec.classBuilder(finalClassName)
                .addModifiers(Modifier.PUBLIC)
                .addMethod(methodSpec)
                .build();

        JavaFile javaFile = JavaFile.builder(pkgName,typeSpec).build();
        return javaFile.toString();
    }