手写APT

作者: 付十一v | 来源:发表于2021-08-03 21:21 被阅读0次

APT（Annotation Processing Tool）注解处理器，一种编译时技术。

在javac中的，用来编译时扫描和处理的注解的工具。可以依据业务制定注解以及注解处理器。在注解处理器中生成Java代码，这些生成的Java代码会组成.java文件。而这些.java文件，与其他普通Java代码一样，都会被javac编译。

在不少第三方框架中就可以看见APT的应用，如ARouter、ButterKnife、databinding等，如果想要了解这些框架的原理，必定需要先去了解APT，这篇文章也是作为先行者，为后面源码分析做好铺垫。

言归正传，接下来将仿照ARouter处理Activity之间跳转的方式，一步一步的说明这个编译时技术-APT。

手写APT

ARouter是一个路由，主要应用于各Module之间的通信，在使用它的时候，直接在各个Activity上添加@Route注解，即能够进行Activity之间的跳转。那直接就从该注解开始APT之旅。

注解处理器，顾名思义，一个注解，一个处理器，这俩便是APT的关键。

那我们就先来创建注解和处理器。

image.png

注解和处理器是属于Java Library，直接创建就好，在这里我将注解命名为"lib-annotation"，处理器命名为"lib-annotation-compiler"。

image.png

接下来就详细说明注解处理器的内部实现。

注解

ARouter使用中，在每个Activity上都加上了@Route注解，以代表当前Activity。

我们这里也新建一个注解Route.java

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Route {

    String path() default "";
}

可以看到在@interface Route上添加了两个元注解，@Target和@Retention：

@Target：用于描述注解的使用范围，并且内部声明了一个ElementerType[]数组，而值有多种ElementType，分别如下：

TYPE：用于类、接口（包括注解类型）或枚举声明；
FIELD：用于字段声明（包括枚举常量）；
METHOD：用于方法声明；
PARAMETER：用于方法参数声明；
CONSTRUCTOR：用于构造函数声明；
LOCAL_VARIABLE：用于局部变量声明；
ANNOTATION_TYPE：用于注解类型声明；
PACKAGE：用于包声明；
TYPE_PARAMETER：Java 1.8引入，用于类型参数声明；
TYPE_USE：Java 1.8引入，用于各种类型。

@Retention：用于描述注解的保留时间，内部存在一个枚举RetentionPolicy，分别如下：

SOURCE：注解只在源文件中存在，编译时即不存在；
CLASS：注解保留到 class文件中，运行时便不存在；
RUNTIME：注解将会一直保留到运行时。
注解保留时间SOURCE << CLASS << RUNTIME。

在新建Route注解时，设置@Target为ElementType.TYPE，主要用于各个Activity类，设置@Retention为CLASS，保留到编译时期。

在Route注解中，定义一个String返回值的path方法，设置Activity所对应的路径，用于后续处理器根据该path查找到所对应的Activity类。

实现完注解，接下来就来看处理器。

处理器

在开始处理器具体实现之前，需要先了解几个点。

AbstractProcessor

AbstractProcessor一个抽象注释处理器，作用主要在于在编译时期，根据相应的的注解生成我们需要的java文件。我们在创建处理器时，需要继承该类，重写init()、process()、getSupportedAnnotationTypes()等方法，生成源文件。

getSupportedSourceVersion（）：指定使用的Java版本；
getSupportedAnnotationTypes（）：主要声明该处理器所支持的注解类型，如该项目所要支持的是@Route注解。
process（）：处理器的核心，这个方法中可拿到注解、类名，并通过注解对代码进行拼装，以生成我们想要的java文件；

接下来就开始对注解进行轮询且拼接代码生成java文件。

@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    //获取使用Route注解的Activity类对象
    Set<? extends Element> elementsAnnotatedWith = roundEnv.getElementsAnnotatedWith(Route.class);
    Map<String, String> map = new HashMap<>();
    //遍历所有使用过Route注解的节点
    for (Element element :
            elementsAnnotatedWith) {
        TypeElement typeElement = (TypeElement) element;
        //获取每个Activity的Route注解
        Route annotation = typeElement.getAnnotation(Route.class);
        //通过注解获取内部参数path值，也就是我们在Activity上定义Activity的key
        String path = annotation.path();
        //获取包名加类名
        Name qualifiedName = typeElement.getQualifiedName();
        //以path为key,类名为value存入一个hashMap中
        map.put(path, qualifiedName + ".class");
    }

    if (map.size() > 0) {
        Writer writer = null;
        //开始拼装代码，生成一个java文件，
        String className = "ActivityUtil" + System.currentTimeMillis();
        try {
            JavaFileObject classFile = filer.createSourceFile("com.fuusy.arouterapi." + className);
            writer = classFile.openWriter();
            writer.write("package com.fuusy.arouterapi;\n" +
                    "\n" +
                    "import com.fuusy.arouterapi.ARouter;\n" +
                    "import com.fuusy.arouterapi.IRouter;\n" +
                    "\n" +
                    "public class " + className + " implements IRouter {\n" +
                    "    @Override\n" +
                    "    public void putActivity() {\n");

            Iterator<String> iterator = map.keySet().iterator();
            while (iterator.hasNext()) {
                String activityKey = iterator.next();
                String cls = map.get(activityKey);
                writer.write("        ARouter.getInstance().putActivity(");
                writer.write(""" + activityKey + ""," + cls + ");");
            }
            writer.write("\n}\n" +
                    "}");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
    return false;
}

接下来便开始验证一下是否生成java文件成功。
我们在app#gradle引入注解处理器的依赖。

image.png

在MainActivity中加上@Route注解以及相应的path值。

image.png

make一下。可以看到在app/build/generated/ap_generated_sources/debug/out 路径下生成了一个java文件，而这个文件的内容就是上面AbstractProcessor#process中拼接而成。

image.png

说到这里，其实注解处理器的使用也差不多了，但是你会发现process在生成代码时，是由开发者一行一行的进行拼接，

更优雅的生成代码

在上面AbstractProcessor#process中，为了生成java代码，我们使用了Writer进行一句一句拼接，

JavaFileObject classFile = filer.createSourceFile("com.fuusy.arouterapi." + className);
writer = classFile.openWriter();
writer.write("package com.fuusy.arouterapi;\n" +
        "\n" +
        "import com.fuusy.arouterapi.ARouter;\n" +
        "import com.fuusy.arouterapi.IRouter;\n" +
        "\n" +
        "public class " + className + " implements IRouter {\n" +
        "    @Override\n" +
        "    public void putActivity() {\n");

Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
    String activityKey = iterator.next();
    String cls = map.get(activityKey);
    writer.write("        ARouter.getInstance().putActivity(");
    writer.write(""" + activityKey + ""," + cls + ");");
}
writer.write("\n}\n" +
        "}");

这无疑是效率低下且容易犯错的写法。为了更好的进行代码编写， square出品了一个代码生成框架 square/javapoet。

以下是javapoet的写法：

//使用Javapoet
MethodSpec methodSpec = MethodSpec.methodBuilder("putActivity")//方法名
        .addModifiers(Modifier.PUBLIC)
        .returns(void.class)//方法返回类型
        .addStatement("ARouter.getInstance().putActivity("+"""+activityKey+"","+cls+")")//方法内的逻辑操作
        .build();
final ClassName InterfaceName = ClassName.get("com.fuusy.arouterapi","IRouter");//实现的接口
TypeSpec typeSpec = TypeSpec.classBuilder("ActivityUtil"+System.currentTimeMillis())//类名
        .addSuperinterface(InterfaceName)//实现接口
        .addModifiers(Modifier.PUBLIC)
        .addMethod(methodSpec)//添加上面创建的方法
        .build();

JavaFile javaFile = JavaFile.builder("com.fuusy.arouterapi", typeSpec).build();
javaFile.writeTo(filer);//生成文件

build之后两种写法最后都会生成java文件，如下：

public class ActivityUtil1627738894383 implements IRouter {
  public void putActivity() {
    ARouter.getInstance().putActivity("main/MainActivity",com.fuusy.aptex.MainActivity.class);
  }
}

验证

注解处理器创建已经完成，因为是仿ARouter的跳转功能进行编写，验证也很简单，新建一个Module-"module-one"，依赖lib-annotation-compiler、lib-annotation，在其主Activity上添加注解
@Route，并加上path。

@Route(path = "module_one/OneActivity")
public class OneActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_one);
    }
}

app module的activity中进行跳转操作，从主MainActivity跳转到OneActivity。

public void intentToOne(View view) {
    ARouter.getInstance().jumpActivity("module_one/OneActivity");
}

来看看结果：

20210731_225116.gif

最后

以上便是APT的基本使用，更多详细细节可直接访问该项目源码，已在文末提供。另外，注解和处理器还有一些其他知识点在这里就没有展示了，比如元注解 @Retention、@Inherited等。
市面上其实越来越多的框架使用了该技术，了解它的使用能帮助我们更好的理解第三方框架源码，以及开阔自己项目架构设计的视野。后续源码解析敬请期待。

感谢你的阅读。

APT源码地址

参考资料：

手把手教你实现 Android 编译期注解-vivo

腾讯课堂-ARouter

推荐阅读：

组件化+Jetpack实战

从问题到解析，读懂Retrofit2原理

欢迎关注公 z 号：9点大前端，每天9点推荐更多前端、Android、Flutter文章

手写APT

手写APT

注解

处理器

AbstractProcessor

更优雅的生成代码

验证

最后

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读