前言
类似于 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
创建一个自定义注解
//指定被标注类型为类或者接口
@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。
在它的 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
点击下面图中的 + 号,并选择 Remote
随便起个名字,点击调试按钮,如果调试成功则会提示如下信息
Connected to the target VM, address: 'localhost:5005', transport: 'socket'
为 APT 代码加入断点,我们这时候 rebuild 程序就可以开始开始调试了。
接下来去看下如何使用解析注解得到的信息。
Router 的 API
同样,我们为它建立一个 module ,但是这次我们建立的是 Android Library,因为我们在这里需要使用 Android 的一些类。
在这里,我们先运行一下代码,看一下注解是否会生成我们想要的 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
成功的跳转到了 SecondActivity。
总结
看完之后发现实现一个简易 Router 是非常简单的了。
当然这只是一个学习 APT 技术的 demo, 如果要投入到实际场景当中去那是完全不行的,使用技术并不难,难的是如何更好的满足业务场景,以及更加深入到其中去学习它的原理。
学习 APT 相关的知识,我这仅仅是一个开始。