Android Router从0到1

96
wutongke
7.1 2017.02.01 00:16* 字数 1876

在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<? 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,在编译时生成路由映射表。

    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<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Router.class);

        MethodSpec.Builder mapMethod = MethodSpec.methodBuilder("map")
                .addModifiers(Modifier.PUBLIC, Modifier.FINAL, Modifier.STATIC)
                .addStatement("java.util.Map<String,String> 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<String, String>()");
                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<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,每天推送移动开发前沿技术文章:

wutongke

推荐阅读:

寻找卓越的(Android)软件工程师

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

你不知道一些神奇Android Api

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

Android
Web note ad 1