前言
类似于 ButterKnife 、 Dagger 、 ARouter，它们可以通过几个注解，就可以实现以往需要很大功夫写的代码，还可以非常好的解除依赖，来提高解耦度，提升代码的扩展空间。
其实它们也是通过一些注解在编译时生成一部分代码，来提高开发效率或者实现一些特别的功能。
这几天在准备春招的过程中对这一块的内容产生了较大的兴趣，于是也自己动手写了一个超级简易版的 Router，功能暂且就只实现跳转 Activity。
需要知道的是
编译时注解
需要对 @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 相关的知识，我这仅仅是一个开始。
网友评论