前言

类似于 ButterKnife 、 Dagger 、 ARouter，它们可以通过几个注解，就可以实现以往需要很大功夫写的代码，还可以非常好的解除依赖，来提高解耦度，提升代码的扩展空间。
其实它们也是通过一些注解在编译时生成一部分代码，来提高开发效率或者实现一些特别的功能。

这几天在准备春招的过程中对这一块的内容产生了较大的兴趣，于是也自己动手写了一个超级简易版的 Router，功能暂且就只实现跳转 Activity。

代码demo

需要知道的是

编译时注解

需要对 @Retention 有一个了解。

元注解 @Retention

类型	作用
SOURCE	只在 java 源文件中存在，编译器编译后就被丢弃
CLASS	在 Java 源文件和编译后生成的字节码中存在，在虚拟机运行时被丢弃
RUNTIME	运行时也存在，可以通过反射读取注解

这里的 CLASS 就是编译时注解，我们可以通过这样的注解在编译时获取到自己想要的一些信息，并依据它们做一些操作，来达到自己的目的。

注解其它相关这里就不提了。

APT

APT(annotation processing tool) 是一种处理编译时注解，在编译阶段解析注解并且生成 java 代码的技术，以此来减少开发时需要写的代码，我们这里用的就是 APT 技术。

AbstractProcessor

AbstractProcessor 是一个抽象类，是 Java 中专门用来处理注解的类。

AbstractProcessor 中有两个需要重写的方法

    //初始化方法，提供处理时的环境
    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
    }
    
    //处理注解过程
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        return false;
    }

SPI

如果对虚拟机的有了解朋友可能会对它有印象，因为可以追溯到第二次双亲委派模型破坏。

它是一种动态替换机制，可以动态加载一些继承某个接口的实体类。

AutoService

Android build 不会生成 META-INF，而 SPI 需要根据声明在 META-INF 中的类名来执行类文件。

这里可以使用 Google 的 AutoService 来创建 META-INF，并将被注解的文件声明到 META-INF 中。

JavaPoet

大名鼎鼎的 square 公司的 JavaPoet, 可以有效的帮忙生成代码。

开始动手

自定义注解

创建一个写自定义注解的library，注意，一定要选择 Java Library

image.png

创建一个自定义注解

//指定被标注类型为类或者接口
@Target(ElementType.TYPE)
//指定为编译时注解
@Retention(RetentionPolicy.CLASS)
public @interface RouterUrl {
    //用来做为跳转路径
    String url();
}

使用注解

先在 app 的 gradle 中引入此包

    implementation project(':lib_annotation')

接下来为 Activity 标注，因为需要跳转，这里我们写两个 Activty。

//当前类
@RouterUrl(url = "main")
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

//跳转目标
@RouterUrl(url = "second")
public class SecondActivity extends AppCompatActivity {
    private TextView textView;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = findViewById(R.id.tv_text);
        textView.setText("跳转成功～");
    }
}

自定义注解非常简答，接下来看 APT 技术的核心，如何在编译时解析一个注解。

解析注解

创建一个用来解析注解的 library，同样也需要 Java 的 library，不然将无法使用 AbstractProcessor。

image.png

在它的 gradle 中引用注解包和需要的第三方库

    implementation 'com.squareup:javapoet:1.8.0'
    implementation 'com.google.auto.service:auto-service:1.0-rc2'
    implementation project(':lib_annotation')

创建一个 RouterCompiler 类

//通过 AutoService 将 Processor 声明到 META-INF 中
@AutoService(Processor.class)
//指定解析的注解
@SupportedAnnotationTypes({"com.example.jzycc.lib_annotation.RouterUrl"})
public class RouterCompiler extends AbstractProcessor {
    private Filer filer;
    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        filer = processingEnvironment.getFiler();
    }

    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        //获取 RouterUrl 的集合
        Set< ? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(RouterUrl.class);
        
        //这里是 JavaPoet 的使用，作用是构建一个类，类名为 WhatRouterTable
        TypeSpec.Builder typeSpec = TypeSpec.classBuilder("WhatRouterTable")
                .addModifiers(Modifier.PUBLIC);

        for (Element element : elements){
            //获取注解中的 url 信息
            String url = element.getAnnotation(RouterUrl.class).url();
            //将其专成存有类信息的 TypeElement
            TypeElement typeElement = (TypeElement)element;
            //获取目标类的全名
            String className = typeElement.getQualifiedName().toString();
            
            //构造一个字段，以 url 为名，类名为值，如 public final static url = "classname";
            FieldSpec fieldSpec = FieldSpec.builder(String.class,url)
                    .addModifiers(Modifier.PUBLIC,Modifier.FINAL,Modifier.STATIC)
                    .initializer("$S",className)
                    .build();
            //将字段添加到 typeSpec 中
            typeSpec.addField(fieldSpec);
        }
        try{
            //指定生成 Java 文件的 包名 （这个包现在还没建立，接下来它做为提供给开发者使用的 api）
            String packageFullName = "com.example.jzycc.lib_whatrouter";
            //构造 Java 文件
            JavaFile javaFile = JavaFile.builder(packageFullName, typeSpec.build()).build();
            //写入到 filer，生成对应的 class 文件
            javaFile.writeTo(filer);

        }catch (IOException e){
            e.printStackTrace();
        }

        return true;
    }
}

以上就是处理注解的逻辑，我们通过解析注解获取它的url值以及被此注解表明的类名，并将这些值做为字段添加到我们解析时生成的 Java 文件中。

如何调试 APT

直接调试是无法调试 APT 代码的，首先找到项目中的 gradle.properties 文件，也可以在 .gradle 文件中全局配置。

加入如下代码

org.gradle.daemon=true
org.gradle.jvmargs=-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005

如图位置我们选择 Edit Configurations

image.png

点击下面图中的 + 号，并选择 Remote

image.png

随便起个名字，点击调试按钮，如果调试成功则会提示如下信息

image.png

Connected to the target VM, address: 'localhost:5005', transport: 'socket'

为 APT 代码加入断点，我们这时候 rebuild 程序就可以开始开始调试了。

接下来去看下如何使用解析注解得到的信息。

Router 的 API

同样，我们为它建立一个 module ，但是这次我们建立的是 Android Library，因为我们在这里需要使用 Android 的一些类。

image.png

在这里，我们先运行一下代码，看一下注解是否会生成我们想要的 Java 文件。

按两下 shift，搜索我们创建的类名 'WhatRouterTable'

可以发现我们很成功的生成了我们想要的信息，最重要的一步已经完成了，接下来我们来完成如何利用这个文件。

package com.example.jzycc.lib_whatrouter;

import java.lang.String;

public class WhatRouterTable {
  public static final String main = "com.example.jzycc.whatrouter.MainActivity";

  public static final String second = "com.example.jzycc.whatrouter.SecondActivity";
}

创建 WhatRouter，做为 Api 的提供类。

package com.example.jzycc.lib_whatrouter;

import android.app.Activity;
import android.app.IntentService;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

import java.lang.reflect.Method;

public class WhatRouter {

    private Class clazz;
    private Context context;
    private Class goalClazz;

    private static WhatRouter instance;
    //这里用单例模式来创建此类
    public static WhatRouter getInstance(){
        if (instance == null){
            synchronized (WhatRouter.class){
                if (instance == null){
                    instance = new WhatRouter();
                }
            }
        }

        return instance;
    }

    private WhatRouter(){
        try{
            clazz = Class.forName("com.example.jzycc.lib_whatrouter.WhatRouterTable");
        }catch (Exception e){
            Log.e("WhatRouterError", "WhatRouter: ",e );
        }
    }
    //传入 context
    public WhatRouter with(Context context){
        this.context = context;
        return this;
    }
    
    //传入 url
    public WhatRouter url(String url){
        try{
            goalClazz = Class.forName(clazz.getField(url).get("").toString());

        }catch (Exception e){
            Log.e("WhatRouterError", "url: ", e);
        }
        return this;
    }
    
    //启动 Activity
    public void startActiviity(){
        try{
            Intent intent = new Intent(context, goalClazz);
            context.startActivity(intent);
        }catch (Exception e){
            Log.e("WhatRouterError", "startActiviity: ",e );
        }
    }
}

非常的简单，我们通过反射去获取我们在解析注解时生成的类，再根据类中的url字段获取目标类的类名，依据此类名获取目标类用来启动 Activity。

使用一下看看是否成功

修改 MainActivity

@RouterUrl(url = "main")
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //这里我们启动 SecondActivity
        WhatRouter.getInstance().with(this).url("second").startActiviity();
    }
}

运行APP

image.png

成功的跳转到了 SecondActivity。

总结

看完之后发现实现一个简易 Router 是非常简单的了。

当然这只是一个学习 APT 技术的 demo, 如果要投入到实际场景当中去那是完全不行的，使用技术并不难，难的是如何更好的满足业务场景，以及更加深入到其中去学习它的原理。

学习 APT 相关的知识，我这仅仅是一个开始。