AndroidRouter从0到1

在Android中启动Activity一般使用startActivity或者startActivityForResult，通过这种方法启动Activity的缺点是写代码时Activity必须已经存在，这不利于多人协同工作，而且这样硬编码启动Activity也不够灵活， 如需要在H5界面中启动本地Activity，或者在server端配置客户端行为时，这样的启动方式显得比较笨重。

如果可以通过类似url的方式打开Activity，即通过解析一个url字符串就可以打开相应的界面，不仅非常酷，而且以上提到问题也可以得到解决。

思路

google Android router 可以发现其实已经有了不少可用的轮子：

其中最后一个
ActivityRouter在之前的文章
Android组件化开发实践中提到过，这里我们来分析一下如何来实现一个Android Router，并拆一下
ActivityRouter，分析它的思路。

路由的目的就是把不同的请求交给不同的控制器，路由作为一个中间层，把页面请求和请求处理进行了解耦，而且还可以增加一些自定义功能，在灵活性和扩展性上做一些事情。

Android中我们的目的是建立url到Activity的一个映射，建立的过程要解决几个问题：

1. url的定义和解析
   一个合理的url结构，不仅要方便理解，而且要方便快速解析查找。

2. 路由表的建立
   路由表是路由中非常重要的一环，路由表一方面要可以快速查找，一方面要方便建立和维护。

3. 数据传递
   启动Activity时，经常需要给新的Activity传递一些数据，使用路由后，需要设计一定的策略在Activiy之间传递数据。

下面就从以上几个方面来看一下ActivityRouter的实现。

url 的设计

url定义

url一般主要由Schema、Host、Path以及QueryParameter等构成。

我们在路由中使用自定义的Schema以和普通的http进行区分，Host可以在应用中使用同意的字符串或者可以省略，path用来设置Activity请求路径，QueryParameter可以做他用，完成数据传递的任务。

我们看一下ActivityRouter中url的使用：

mzule://main/0xff878798

上例中mzule是自定义的Schema，main是path，

0xff878798是自定义的Parameter 。

url 解析

url解析就是拿到字符串中的Schema、host、path、queryParameters。


public static Path create(Uri uri) {
Path path = new Path(uri.getScheme().concat("://"));
String urlPath = uri.getPath();
if (urlPath == null) {
urlPath = "";
}
if (urlPath.endsWith("/")) {
urlPath = urlPath.substring(0, urlPath.length() - 1);
}
parse(path, uri.getHost() + urlPath);
return path;
}
private static void parse(Path scheme, String s) {
String[] compOnents= s.split("/");
Path curPath = scheme;
for (String component : components) {
Path temp = new Path(component);
curPath.next = temp;
curPath = temp;
}
}


按照以上url的规范设计我们Android路由中的url，可以非常方便地使用Java的Api，以上代码是ActivityRouter对于url的解析，非常清晰易懂。

路由表的实现

在路由表中增加一条记录都需要那些东西呢？首先肯定需要一个url，其次需要知道跳转的Activity 的名字，最好再有可以传递的一些数据，我们来看一下ActivityRouter的实现：

//Mapping.java
private final String format;
private final Class activity;
private final MethodInvoker method;
private final ExtraTypes extraTypes;
private Path formatPath;


可以看到format其实就是我们需要的url，activity就是跳转的Activity，extraTypes是可以传递的数据，完全符合我们的需求。

如何根据url打开相应的Activity呢：

private static boolean doOpen(Context context, Uri uri, int requestCode) {
initIfNeed();
Path path = Path.create(uri);
for (Mapping mapping : mappings) {
if (mapping.match(path)) {
//activity router 不仅可以打开Activity，还可以执行一些方法
if (mapping.getActivity() == null) {
mapping.getMethod().invoke(context, mapping.parseExtras(uri));
return true;
}
Intent intent = new Intent(context, mapping.getActivity());
intent.putExtras(mapping.parseExtras(uri));
intent.putExtra(KEY_RAW_URL, uri.toString());
//如果context不是activity的实例（如是Application的实例），则需要添加Intent.FLAG_ACTIVITY_NEW_TASK，才可以正确打开Activity
if (!(context instanceof Activity)) {
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
}
if (requestCode >= 0) {
if (context instanceof Activity) {
((Activity) context).startActivityForResult(intent, requestCode);
} else {
throw new RuntimeException("can not startActivityForResult context " + context);
}
} else {
context.startActivity(intent);
}
return true;
}
}
return false;
}


可以参考注释理解代码，没有什么难度。

如何在路由表中插入这样一条条记录呢，如果每次增加一个功能就手动增加一条记录并不是非常明智的做法，扩展性和维护性都不好。ActivityRouter采用了Apt的方式，这是ActivityRouter相比于其他android router的一个亮点，这里重点介绍一下。

annotation

annotation其实在很多常用的第三方库中都会用到，如EventBus3、butterknife、dagger等。
annotation根据其作用可以分为三种：

• 标记
  仅仅在源码中起作用，用于标示，功能类似于注释，如@Override等

• 编译时annotation
  在编译时起作用，可以在代码进行编译时对注解部分进行处理，比如根据annotation的部分自动生成代码的等，butterknife其实就到了annotation的这个功能

• 运行时annotation
  可以在运行时根据annotation 通过反射实现一些功能

看一个ActivityRouter中的例子：

@Retention(RetentionPolicy.CLASS)
public @interface Module {
String value();
}


这里定义了一个annotation，在使用时可以@Module("sdk")这样使用。

可以看到定义annotation时也使用了annotation，它们是元注解：

元注解共有四种@Retention, @Target, @Inherited, @Documented

@Retention 保留的范围，默认值为CLASS. 可选值有三种

• SOURCE, 只在源码中可用
• CLASS, 在源码和字节码中可用
• RUNTIME, 在源码,字节码,运行时均可用

@Target 可以用来修饰哪些程序元素，如 TYPE, METHOD, CONSTRUCTOR, FIELD, PARAMETER等，未标注则表示可修饰所有

@Inherited 是否可以被继承，默认为false

@Documented 是否会保存到 Javadoc 文档中

Apt

Android-apt实际是一个插件，可以处理annotation processors，在编译阶段对annotation进行处理。这里ActivityRouter就是使用annotation通过Apt的方式自动生成我们的路由表的。
关于Apt的更多介绍和使用可以参考android-apt

使用apt之后通过继承AbstractProcessor来对annotation来进行处理：

@Override
public boolean process(Set annotations, RoundEnvironment roundEnv) {
debug("process apt with " + annotations.toString());
if (annotations.isEmpty()) {
return false;
}
boolean hasModule = false;
boolean hasModules = false;
// module
String moduleName = "RouterMapping";
Set moduleList = roundEnv.getElementsAnnotatedWith(Module.class);
if (moduleList != null && moduleList.size() > 0) {
Module annotation = moduleList.iterator().next().getAnnotation(Module.class);
moduleName = moduleName + "_" + annotation.value();
hasModule = true;
}
// modules
String[] moduleNames = null;
Set modulesList = roundEnv.getElementsAnnotatedWith(Modules.class);
if (modulesList != null && modulesList.size() > 0) {
Element modules = modulesList.iterator().next();
moduleNames = modules.getAnnotation(Modules.class).value();
hasModules = true;
}
// RouterInit
if (hasModules) {
debug("generate modules RouterInit");
generateModulesRouterInit(moduleNames);
} else if (!hasModule) {
debug("generate default RouterInit");
generateDefaultRouterInit();
}
// RouterMapping
return handleRouter(moduleName, roundEnv);
}


ActivityRouter对project中是否有多个module分别进行了处理。

javapoet是非常好用的一个java代码生成库，ActivityRouter使用javapoet处理annotation，在编译时生成路由映射表。

private void generateDefaultRouterInit() {
MethodSpec.Builder initMethod = MethodSpec.methodBuilder("init")
.addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC);
initMethod.addStatement("RouterMapping.map()");
TypeSpec routerInit = TypeSpec.classBuilder("RouterInit")
.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
.addMethod(initMethod.build())
.build();
try {
JavaFile.builder("com.github.mzule.activityrouter.router", routerInit)
.build()
.writeTo(filer);
} catch (Exception e) {
e.printStackTrace();
}
}


以上代码生成RouterInit.java，并生成init方法。

private boolean handleRouter(String genClassName, RoundEnvironment roundEnv) {
Set elements = roundEnv.getElementsAnnotatedWith(Router.class);
MethodSpec.Builder mapMethod = MethodSpec.methodBuilder("map")
.addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC)
.addStatement("java.util.Map transfer = null")
.addStatement("com.github.mzule.activityrouter.router.ExtraTypes extraTypes")
.addCode("\n");
for (Element element : elements) {
Router router = element.getAnnotation(Router.class);
String[] transfer = router.transfer();
if (transfer.length > 0 && !"".equals(transfer[0])) {
mapMethod.addStatement("transfer = new java.util.HashMap()");
for (String s : transfer) {
String[] compOnents= s.split("=>");
if (components.length != 2) {
error("transfer `" + s + "` not match a=>b format");
break;
}
mapMethod.addStatement("transfer.put($S, $S)", components[0], components[1]);
}
} else {
mapMethod.addStatement("transfer = null");
}
mapMethod.addStatement("extraTypes = new com.github.mzule.activityrouter.router.ExtraTypes()");
mapMethod.addStatement("extraTypes.setTransfer(transfer)");
addStatement(mapMethod, int.class, router.intParams());
addStatement(mapMethod, long.class, router.longParams());
addStatement(mapMethod, boolean.class, router.booleanParams());
addStatement(mapMethod, short.class, router.shortParams());
addStatement(mapMethod, float.class, router.floatParams());
addStatement(mapMethod, double.class, router.doubleParams());
addStatement(mapMethod, byte.class, router.byteParams());
addStatement(mapMethod, char.class, router.charParams());
for (String format : router.value()) {
ClassName className;
Name methodName = null;
if (element.getKind() == ElementKind.CLASS) {
className = ClassName.get((TypeElement) element);
} else if (element.getKind() == ElementKind.METHOD) {
className = ClassName.get((TypeElement) element.getEnclosingElement());
methodName = element.getSimpleName();
} else {
throw new IllegalArgumentException("unknow type");
}
if (format.startsWith("/")) {
error("Router#value can not start with '/'. at [" + className + "]@Router(\"" + format + "\")");
return false;
}
if (format.endsWith("/")) {
error("Router#value can not end with '/'. at [" + className + "]@Router(\"" + format + "\")");
return false;
}
if (element.getKind() == ElementKind.CLASS) {
mapMethod.addStatement("com.github.mzule.activityrouter.router.Routers.map($S, $T.class, null, extraTypes)", format, className);
} else {
mapMethod.addStatement("com.github.mzule.activityrouter.router.Routers.map($S, null, " +
"new MethodInvoker() {\n" +
" public void invoke(android.content.Context context, android.os.Bundle bundle) {\n" +
" $T.$N(context, bundle);\n" +
" }\n" +
"}, " +
"extraTypes)", format, className, methodName);
}
}
mapMethod.addCode("\n");
}
TypeSpec routerMapping = TypeSpec.classBuilder(genClassName)
.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
.addMethod(mapMethod.build())
.build();
try {
JavaFile.builder("com.github.mzule.activityrouter.router", routerMapping)
.build()
.writeTo(filer);
} catch (Throwable e) {
e.printStackTrace();
}
return true;
}


以上代码用于根据注解生成一条条路由映射。我们可以看一下最终生成的文件：

public final class RouterMapping_app {
public static final void map() {
java.util.Map transfer = null;
com.github.mzule.activityrouter.router.ExtraTypes extraTypes;
transfer = null;
extraTypes = new com.github.mzule.activityrouter.router.ExtraTypes();
extraTypes.setTransfer(transfer);
com.github.mzule.activityrouter.router.Routers.map("home/:homeName", HomeActivity.class, null, extraTypes);
transfer = null;
extraTypes = new com.github.mzule.activityrouter.router.ExtraTypes();
extraTypes.setTransfer(transfer);
com.github.mzule.activityrouter.router.Routers.map("with_host", HostActivity.class, null, extraTypes);
transfer = new java.util.HashMap();
transfer.put("web", "fromWeb");
extraTypes = new com.github.mzule.activityrouter.router.ExtraTypes();
extraTypes.setTransfer(transfer);
extraTypes.setLongExtra("id,updateTime".split(","));
extraTypes.setBooleanExtra("web".split(","));
com.github.mzule.activityrouter.router.Routers.map("http://mzule.com/main", MainActivity.class, null, extraTypes);
com.github.mzule.activityrouter.router.Routers.map("main", MainActivity.class, null, extraTypes);
com.github.mzule.activityrouter.router.Routers.map("home", MainActivity.class, null, extraTypes);
transfer = null;
extraTypes = new com.github.mzule.activityrouter.router.ExtraTypes();
extraTypes.setTransfer(transfer);
com.github.mzule.activityrouter.router.Routers.map("logout", null, new MethodInvoker() {
public void invoke(android.content.Context context, android.os.Bundle bundle) {
NonUIActions.logout(context, bundle);
}
}, extraTypes);
transfer = null;
extraTypes = new com.github.mzule.activityrouter.router.ExtraTypes();
extraTypes.setTransfer(transfer);
com.github.mzule.activityrouter.router.Routers.map("upload", null, new MethodInvoker() {
public void invoke(android.content.Context context, android.os.Bundle bundle) {
NonUIActions.uploadLog(context, bundle);
}
}, extraTypes);
transfer = null;
extraTypes = new com.github.mzule.activityrouter.router.ExtraTypes();
extraTypes.setTransfer(transfer);
com.github.mzule.activityrouter.router.Routers.map("user/:userId", UserActivity.class, null, extraTypes);
com.github.mzule.activityrouter.router.Routers.map("user/:nickname/city/:city/gender/:gender/age/:age", UserActivity.class, null, extraTypes);
transfer = null;
extraTypes = new com.github.mzule.activityrouter.router.ExtraTypes();
extraTypes.setTransfer(transfer);
com.github.mzule.activityrouter.router.Routers.map("user/collection", UserCollectionActivity.class, null, extraTypes);
}
}


这里有个小问题是，RouterInit 和 RouterMapping两个文件其实是在编译期生成的，而很明显我们在其他地方需要用到这两个文件，也就是在build之前就需要存在着两个文件，怎么处理呢？这里在gradle中的dependencies中使用provided，即我们可以提前写好空壳RouterInit 和 RouterMapping，然后通过provided的方式使得代码通过编译，但是在执行时实际使用的是之后生成的文件：

dependencies {
provided project(':stub')
compile 'com.github.mzule.activityrouter:annotation:1.1.5'
}


数据传递

在web中我们可以通过在url后添加参数访问提交数据，在Android router中我们同样可以把数据保存在url中，只有可以正确解析出数据即可。

我们看下ActivityRouter中实现：

public Bundle parseExtras(Uri uri) {
Bundle bundle = new Bundle();
// path segments // ignore scheme
Path p = formatPath.next();
Path y = Path.create(uri).next();
while (p != null) {
if (p.isArgument()) {
put(bundle, p.argument(), y.value());
}
p = p.next();
y = y.next();
}
// parameter
Set names = UriCompact.getQueryParameterNames(uri);
for (String name : names) {
String value = uri.getQueryParameter(name);
put(bundle, name, value);
}
return bundle;
}


合理解析url，可以把数据打包为bundle，在启动activity时传递过去。

ActivityRouter代码结构

• activityrouter 路由实现的主义逻辑
• annotation 定义用到的annotation
• app demo
• app_module demo
• compiler 处理annotation，实现apt
• stub 提供编译期的RouterInit Router Mapping文件

总结

其实ActivityRouter中还实现了在浏览器中启动应用的界面，主要思路是启动一个透明activity，然后在activity中解析url，再启动目标activity。ActivityRouter也支持直接解析http，打开web界面。本文中不再进行分析，感兴趣的同学可以去看看源码。

欢迎关注公众号wutongke，每天推送移动开发前沿技术文章：

wutongke

推荐阅读：

寻找卓越的（Android）软件工程师

想在Android中使用java8？你可能不再需要retrolambda了

你不知道一些神奇Android Api

Android增量编译3～5秒的背后