Android Router 从 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的一个映射，建立的过程要解决几个问题：

url的定义和解析
一个合理的url结构，不仅要方便理解，而且要方便快速解析查找。
路由表的建立
路由表是路由中非常重要的一环，路由表一方面要可以快速查找，一方面要方便建立和维护。
数据传递
启动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<? extends Activity> 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<? extends TypeElement> 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<? extends Element> 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<? extends Element> 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，在编译时生成路由映射表。

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

private boolean handleRouter(String genClassName, RoundEnvironment roundEnv) {
        Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Router.class);
    }

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

public final class RouterMapping_app {
  public static final void map() {
    java.util.Map<String,String> 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<String, String>();
    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<String> 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，了解更多移动开发前沿技术：