[关闭]
@zyl06 2019-03-29T11:26:15.000000Z 字数 31970 阅读 2610

严选 Android 组件化实践

组件化 路由

0 背景

早前严选 Android 工程，业务模块和功能模块不多，工程较为简单，全部的业务代码均在主 app 工程，全部的业务 Activity 均在 module/ 目录下，相关的网络请求封装在 http 目录下，使用 volley 封装支持 http 请求和 wzp 请求；业务请求协议实现，均放在 app/httptask/ 下，业务层使用请求不区分是 wzp 还是 http(s)；全部的工具方法，如 DeviceUtil、BitmapHelper 均在 commno/util/ 里面；全局事件 EventBus event model 放在 eventbus/。

  1. common/
  2.     util/
  3.         DeviceUtil
  4.         ...
  5. module/
  6.     PayCompleteActivity
  7.     ...
  8. http/
  9. httptask/
  10.     LoginWzpTask
  11.     ...
  12. eventbus/
  13. ...

其中页面之间的跳转，使用原声 Intent 方式。为规范参数传递，做了编码规范，使用静态方法的方式唤起 Activity

  1. public static void start(Context context, ComposedOrderModel model, String skuList) {
  2.     Intent intent = new Intent(context, OrderCommoditiesActivity.class);
  3.     ...
  4.     context.startActivity(intent);
  5. }
  7. public static void start(Context context, ComposedOrderModel model, int skuId, int count) {
  8.     Intent intent = new Intent(context, OrderCommoditiesActivity.class);
  9.     ...
  10.     context.startActivity(intent);
  11. }

OrderCommoditiesActivity

  1. public static void startForResult(Activity context, int requestCode, int selectedCouponId, int skuId, int count, String skuListStr) {
  2.     Intent intent = new Intent(context, CouponListActivity.class);
  3.     ...
  4.     context.startActivityForResult(intent, requestCode);
  5. }

CouponListActivity

针对推送和 H5 scheme 唤起和跳转 Activity，我们编写了统一 scheme 跳转派发逻辑：

  1. public class RouterUtil {
  2.     public static Intent getRouteIntent(Context context, Uri uri) {
  3.         if (uri == null || !TextUtils.equals(uri.getScheme(), "yanxuan")) {
  4.             return null;
  5.         }
  6.         String host = uri.getHost();
  7.         if (host == null) {
  8.             return null;
  9.         }
  11.         Class<?> clazz = null;
  12.         String param = null;
  13.         switch (host) {
  14.             case ConstantsRT.GOOD_DETAIL_ROUTER_PATH:
  15.                 clazz = GoodsDetailActivity.class;
  16.                 ...
  17.                 break;
  18.             ...
  19.         }
  20.         Intent intent = null;
  21.         if (clazz != null) {
  22.             intent = new Intent();
  23.             intent.setClass(context, clazz);
  24.         }
  25.         return intent;
  26.     }
  27. }

根据输入 scheme，返回跳转 Activity 的 intent

  1. view.setOnClickListener(new View.OnClickListener() {
  2.         @Override
  3.         public void onClick(View v) {
  4.             if (!TextUtils.isEmpty(schemeUrl)) {
  5.                 Intent intent = RouterUtil.getRouteIntent(Uri.parse(schemeUrl));
  6.                 if (intent != null) {
  7.                     view.getContext().startActivity(intent);
  8.                 }
  9.             }
  10.         }
  11.     });

RouterUtil.getRouteIntent 使用样例

因为是单一 app 工程（排除和业务无关的第三方组件），所以工程内全部的 Activity类、接口、EventBus model 都是可见的，且由于工程量较小，Activity 页面数量尚不多，早期使用上述做法并不会碰到问题。但很快随着版本迭代，业务量的增长，很快爆发出来的就是 scheme 跳转派发逻辑的维护问题

  1. public class RouterUtil {
  2.     public static Intent getRouteIntent(Context context, Uri uri) {
  3.         ...
  4.         switch (host) {
  5.             case ConstantsRT.GOOD_DETAIL_ROUTER_PATH:
  6.                 clazz = GoodsDetailActivity.class;
  7.                 ...
  8.                 break;
  9.             case ConstantsRT.ORDER_DETAIL_ROUTER_PATH:
  10.                 clazz = OrderDetailActivity.class;
  11.                 ...
  12.                 break;
  13.             ...
  14.             ... 省略 28 个 case! ☹️
  15.             ...
  16.             default:
  17.                 break;
  18.         }
  20.         ...
  21.     }
  22. }

当严选 2.x.x 版本的时候，我们的 switch-case 就达到 30 个，代码明显不好维护了。同时，我们的 scheme 协议完全是按照业务需求来增加，不支持 scheme 跳转的大量 Activity 很容易和 iOS 不统一，如页面实现和参数使用方面，导致后期开放成 scheme 协议的时候，需要大量的沟通和业务代码修改。

当严选 3.x.x 版本的时候，工程中就已经出现跨工程接口复用的问题（如跨工程需要支持埋点、本地异常日志记录模块等）；当严选 4.x.x 版本的时候，需要处理处理跨模块 wzp 请求复用、跨工程 EventBus 通信问题。上述的简单设计已经完全不满足场景，本文就介绍严选在多版本迭代过程中，如何逐步处理和优化页面组件化、基础功能组件化。

1 页面组件化 ht-router 接入

参考 DeepLink从认识到实践，接入杭研 ht-router，由此通过注解的方式统一了 H5 唤醒、推送唤醒、正常启动 APP 的逻辑，上面点击跳转的逻辑得到了简化：

  1. view.setOnClickListener(new View.OnClickListener() {
  2.     @Override
  3.     public void onClick(View v) {
  4.         HTRouterManager.startActivity(view.getContext(), schemeUrl, null, false);
  5.     }
  6. });

RouterUtil 中冗长的 switch-case 代码也得到得到了极大的改善，统一跳转可通过 scheme 参数直接触发跳转，近 30 个 switch-case 减少至 7 个

  1. HTRouterManager.init();
  2. ...
  3. // 设置跳转前的拦截，返回 true 拦截不再跳转，返回 false 继续跳转
  4. HTRouterManager.setHtRouterHandler(new HTRouterHandler() {
  5.     @Override
  6.     public boolean handleRoute(Context context, HTRouterHandlerParams routerParams) {
  7.         final Uri uri = !TextUtils.isEmpty(routerParams.url) ? Uri.parse(routerParams.url) : null;
  8.         if (uri == null) {
  9.             return true;
  10.         }
  12.         String host = uri.getHost();
  13.         if (TextUtils.isEmpty(host)) {
  14.             return true;
  15.         }
  17.         switch (host) {
  18.             case ConstantsRT.CATEGORY_ROUTER_PATH: //"category"
  19.                 ...
  20.                 break;
  21.             ...
  22.             ...省略 5 个
  23.             ...
  24.             case ConstantsRT.MINE_ROUTER_PATH:
  25.                 ...
  26.                 break;
  27.             default:
  28.                 break;
  29.         }
  30.         return false;
  31.     }
  32. });

至于为什么还有 7 个，大体分 2 类

  1. 历史原因

    严选工程中 CategoryL2Activity 有 yanxuan://category 和 yanxuan://categoryl2 2 个 scheme，而同一个参数 categoryid 在不同的 scheme 下有不同的含义，为此在拦截器中添加新的字段，CategoryL2Activity 中仅需处理 2 个新加的字段，不必知道自身的 scheme

  2. 跳转 Activity 的不同 fragment

    严选首页 MainPageActivity 拥有 5 个 tab fragment，不同的 tab 会有不同的 scheme，拦截器中直接根据不同的 scheme，添加参数来指定不同的 tab，首页仅需处理 tab 参数显示不同的 fragment

ht-router 的其他优点、用法、api 见文章 DeepLink从认识到实践，这里不再叙述

2 ht-router 的痛点

ht-router 对工程框架的作用是巨大的，然而随着多期业务迭代和工程复杂度的提升，逐渐发现路由框架的多个痛点：

下述痛点，在其他第三方框架上很多并不存在。当时集成的时候，router 框架刚兴起，ARouter、天猫统跳、ActivityRouter 等并没有像现在的功能强大；另外如 ARouter，通过 path 定义 group 和跳转目标，而严选工程以 host 标识跳转目标，也有些差异

2.1 apt 生成代码量过大，业务开发较难维护

ht-router 通过 apt 生成的类有 6 个，其中 HTRouterManager 有 600 行代码，去除 init 方法中初始化 router 映射表的 100 行左右代码，剩余还有 500 行左右

Alt pic

apt 生成的类目录

Alt pic

HTRouterManager.java

参考 apt 的用法，若要生成一个简单的类，对应的 apt 代码会复杂的多。当目标代码量比较多的情况下，apt 的生成代码就会比较难以维护，根据业务场景添加接口，或者修改字段都会相比更加困难。另外 apt 的调试也比较辛苦，需要编译后再查看目标代码是否是有错误。

这里给 ht-router 的开发同学献上膝盖，为业务团队贡献了很多！

  1. /**
  2.  * apt 测试代码
  3.  */
  4. public class TestClass {
  5.   public static final String STATIC_FIELD = "ht_url_params_map";
  7.   public void foo() {
  8.     System.out.println("hello world");
  9.   }
  10. }

目标代码

  1. TypeSpec.Builder testbuilder = classBuilder("TestClass")
  2.             .addModifiers(PUBLIC);
  3. testbuilder.addJavadoc("apt 测试代码\n");
  4. FieldSpec testFieldSpec = FieldSpec
  5.         .builder(String.class, "STATIC_FIELD",
  6.                 PUBLIC, STATIC, FINAL)
  7.         .initializer("\"ht_url_params_map\"").build();
  8. testbuilder.addField(testFieldSpec);
  10. MethodSpec.Builder testMethod = MethodSpec.methodBuilder("foo")
  11.         .addModifiers(Modifier.PUBLIC)
  12.         .returns(void.class);
  13. testMethod.addStatement("System.out.println(\"hello world\")");
  14. testbuilder.addMethod(testMethod.build());
  15. TypeSpec generatedClass = testbuilder.build();
  16. JavaFile javaFile = builder(packageName, generatedClass).build();
  17. try {
  18.     javaFile.writeTo(filer);
  19. } catch (IOException e) {
  20.     e.printStackTrace();
  21. }

生成目标代码的 apt 代码

2.2 路由表和业务直接关联

由于整个路由表在 HTRouterManager 中，偶现（常见合并分支后）由于业务代码编译不通过，导致 apt 代码未生成，大量提示报错 HTRouterManager 找不到，但无法定位到真正的业务代码错误逻辑。

Alt pic

由于 HTRouterManager 在业务代码中广泛被使用，暂未有很好的办法解决这个报错，临时的处理办法是从同事处拷贝 apt 文件夹，临时绕过错误报错，修改业务层代码错误后 rebuild

第一次碰到比较懵逼，花了不少时间处理定位和解决问题，(⊙﹏⊙)b

2.3 拦截功能不满足登录需求

针对未登录状态，跳转需要登录状态的 Activity 的场景，我们期望是先唤起登录页，登录成功后，关闭登录页重定向至目标 Activity；若用户退出登录页，则回到上一个页面。针对已登录状态，则直接唤起目标页面。对于这个需求，ht-router 并不满足，虽然提供了 HTRouterHandler，但仅能判断根据返回值判断是否继续跳转，无法在登录回调中决定是否继续跳转。

  1. public static void startActivity(Activity activity, String url, Intent sourceIntent, boolean isFinish, int entryAnim, int exitAnim) {
  2.     Intent intent = null;
  3.     HTRouterHandlerParams routerParams = new HTRouterHandlerParams(url, sourceIntent);
  4.     if (sHtRouterHandler != null && sHtRouterHandler.handleRoute(activity, routerParams)) {
  5.         return;
  6.     }
  7.     ...
  8. }

2.4 需要拦截处理特殊 scheme 的逻辑还在全局

前面 RouterUtil 中的 switch-case 从 30 个大幅降至 7 个（即便是 7 个，感觉代码也不优雅），但这里的特殊处理逻辑属于各个页面的业务逻辑，不应该在 RouterUtil 中。路由的一个很大作用，就是将各个页面解耦，能为后期模块化等需求打下坚实基础，而这里的全局拦截处理逻辑，显然是和模块解耦是背道而驰的。

当然这些特殊的处理逻辑完全可以挪到各个 Activity 中，但是不是有机制能很好的处理这种场景，同时 Activity 是否需要关心自身当前的 scheme 是什么？

2.5 sdk 页面，无法添加路由注解

我们发现接入的子工程如图片选择器等也有自己的页面，而 apt 的代码生成功能是对 app 工程生效，不支持其他子工程的路由注解，为此子工程的页面就无法享受路由带来的好处。

2.6 router 初始化为类引用，阻碍 main dex 优化

最初通过 multidex 方案解决了 65535 问题后，2年后的现在，又爆出了 Too many classes in –main-dex-list 错误。

原因：dex 分包之后，各 dex 还是遵循 65535 的限制，而打包流程中 dx --dex --main-dex-list=<maindexlist.txt> 中的 maindexlist.txt 决定了哪些类需要放置进 main-dex。默认 main-dex 包含 manifest 中注册的四大组件，Application、Annonation、multi-dex 相关的类。由于 app 中 四大组件 （特别是 Activity） 比较多和 Application 中的初始化代码，最终还是可能导致 main-dex 爆表。

查看 ${android-sdks}/build-tools/${build-tool-version}/mainDexClasses.rules

  1. -keep public class * extends android.app.Instrumentation {
  2.     <init>();
  3. }
  4. -keep public class * extends android.app.Application {
  5. <init>();
  6.     void attachBaseContext(android.content.Context);
  7. }
  8. -keep public class * extends android.app.Activity {
  9.     <init>();
  10. }
  11. -keep public class * extends android.app.Service {
  12.     <init>();
  13. }
  14. -keep public class * extends android.content.ContentProvider {
  15.     <init>();
  16. }
  17. -keep public class * extends android.content.BroadcastReceiver {
  18.     <init>();
  19. }
  20. -keep public class * extends android.app.backup.BackupAgent {
  21.     <init>();
  22. }
  23. # We need to keep all annotation classes because proguard does not trace annotation attribute
  24. # it just filter the annotation attributes according to annotation classes it already kept.
  25. -keep public class * extends java.lang.annotation.Annotation {
  26.     *;
  27. }

解决方法

  1. gradle 1.5.0 之前

    执行 dex 命令时添加 --main-dex-list 和 --minimal-main-dex 参数。而这里 maindexlist.txt 中的内容需要开发生成，参考 main-dex 分析工具

    1. afterEvaluate {
    2.     tasks.matching {
    3.         it.name.startsWith("dex")
    4.     }.each { dx ->
    5.         if (dx.additionalParameters == null) {
    6.             dx.additionalParameters = []
    7.         }
    8.     // optional
    9.     dx.additionalParameters += "--main-dex-list=$projectDir/maindexlist.txt".toString()
    10.     dx.additionalParameters += "--minimal-main-dex"
    11.     }
    12. }

    参考文章 MultiDex中出现的main dex capacity exceeded解决之道

  2. gradle 1.5.0 ~ 2.2.0

    现严选使用 gradle plugin 2.1.2，并不支持上面的方法，可使用如下方法。

    1. //处理main dex 的方法测试
    2. afterEvaluate {
    3.     def mainDexListActivity = ['SplashActivity', 'MainPageActivity']
    4.     project.tasks.each { task ->
    5.         if (task.name.startsWith('collect')
    6.                 && task.name.endsWith('MultiDexComponents')
    7.                 && task.name.contains("Debug")) {
    8.             println "main-dex-filter: found task $task.name"
    9. 	            task.filter { name, attrs ->
    10. 	                String componentName = attrs.get('android:name')
    11. 	                if ('activity'.equals(name)) {
    12. 	                    def result = mainDexListActivity.find {
    13. 	                        componentName.endsWith("${it}")
    14.                     }
    15.                     return result != null
    16.                 } else {
    17.                     return true
    18.                 }
    19.             }
    20.         }
    21.     }
    22. }

    这里过滤掉除 SplashActivity，MainPageActivity 之外的其他 activity，但 main-dex 中未满 65535 之前，其他 activity 或类也可能在 main-dex 中，并不能将 main-dex 优化为最小。

    可参考 DexKnifePlugin 优化 main-dex 为最小。（自己并未实际用过）
    参考文章 Android-Easy-MultiDex

  3. gradle 2.3.0

    gradle 中通过 multiDexKeepProguard 或 multiDexKeepFile 设置必须放置 main-dex 的类。

    其次设置 additionalParameters 优化 main-dex 为最小

    1. dexOptions {
    2.     additionalParameters '--multi-dex', '--minimal-main-dex', '--main-dex-list=' + file('multidex-config.txt').absolutePath'
    3. }

严选 gradle 版本为 2.1.2，然而按照上述的解决方法发现并没有效果，查看 Application 初始化代码，可以发现 HTRouterManager.init 中引用了全部的 Activity 类

  1. public static void init() {
  2.     ...
  3.     entries.put("yanxuan://newgoods", new HTRouterEntry(NewGoodsListActivity.class, "yanxuan://newgoods", 0, 0, false));
  4.     entries.put("yanxuan://popular", new HTRouterEntry(TopGoodsRcmdActivity.class, "yanxuan://popular", 0, 0, false));
  5.     ...
  6. }

2.7 业务扩张导致路由表过大，内存和性能受损

严选 4.1.7 版本，页面跳转路由表已经注册了 125 个 scheme 协议，其中对外公开使用的 39 个scheme，为此我们 app 工程的页面路由表巨大，而这个路由表在 app 启动的时候就必须初始化装载到内存，整个 app 运行过程中，必须一直持有这部分内存。而一次进程生命周期中，只有少部分 scheme 协议会被用到。

除了内存消耗，另一个比较严重和明显的是性能损失。原因是 ht-router 进行路由表匹配的时候，支持正则匹配。根据 scheme 在路由表中查找路由数据时，需要遍历查找。而现在路由表已经变得巨大，将会导致每次路由查找非常的耗时。

  1. http://m.you.163.com/product/{id}.html

支持匹配以下这种形式的 scheme：

  1. http://m.you.163.com/product/1.html
  2. http://m.you.163.com/product/101.html
  3. ...

2.8 路由跳转不支持自定义降级

ht-router 跳转路由表中没有的 url 时，支持自动将 scheme 替换成 http，然后降级成 H5 页面去加载。而推送业务场景中，因为 app 版本兼容性原因需要的降级方案复杂的多：

  1. 新版本支持商品详情页，老版本不支持详情页，当老版本 app 打开推送内容的时候，我们期望打开 H5 页面展示商品详情
  2. 新版本支持推送跳转红包雨界面，当老版本 app 打开推送内容的时候，我们期望打开 H5 页面引导用户下载更新 APP
  3. 新版本支持购物车独立页面，老版本仅有首页购物车 tab 页，我们期望相同的推送，老版本能打开首页购物车 tab 页

以上业务场景，要求我们路由跳转支持自定义的降级方案

2.9 路由表不支持跨工程

由于跨工程后，假设 2 个业务工程都集成了 ht-router，使用 apt 实现的路由表生成逻辑会被执行 2 次，由于生成的 class 类是相同包名和类名，为此后期编译会产生类冲突。此外，多个路由表如何整合使用，也是我们要考虑的地方。

3 router 框架优化

3.1 apt 生成代码量过大问题优化

思考框架本身，其实可以发现仅有 router 映射表是需要根据注解编译生成的，其他的全部代码都是固定代码，完全可以 sdk 中直接编码提供。反过来思考为何当初 sdk 开发需要编写繁重的 apt 生成代码，去生成这些固定的逻辑，可以发现 htrouterdispatch-process 工程是一个纯 java 工程，部分纯 java 类的提供在 htrouterdispatch。由于无法引用 Android 类，同时期望业务层接口能完美隐藏内部实现，为此和 Android 相关的类，索性全部由 apt 生成。

  1. apply plugin: 'java' // 使用 apply plugin: 'com.android.library' 编译报错
  3. sourceCompatibility = JavaVersion.VERSION_1_7
  4. targetCompatibility = JavaVersion.VERSION_1_7
  6. dependencies {
  7.     compile project (':htrouterdispatch')
  8.     compile 'com.google.auto.service:auto-service:1.0-rc2'
  9.     compile 'com.squareup:javapoet:1.0.0'
  10. }

为了解决这里的问题，可以修改 HTRouterManager 的初始化接口，使用 router 映射表显式的传入，其中几个参数均有 HTRouterTable 提供。修改后就能发现仅有 HTRouterTable 里面的映射表接口需要 apt 生成，而其余的代码均可通过直接编码。

  1. public class HTRouterManager {
  2.     public static void init() {
  3.         ...
  4.     }
  5. }
  6. →
  7. public class HTRouterManager {
  8.     public static void init(Map<String, IRouterGroup> pageGroups,
  9.                             List<HTMethodRouterEntry> methodEntries,
  10.                             List<HTInterceptorEntry> annoInterceptors) {
  11.         ...
  12.     }
  13. }
  15. public final class HTRouterTable {
  17.     ...
  18.     private final HashMap<String, IRouterGroup> mRouterGroups = new HashMap<String, IRouterGroup>();
  19.     private final List<HTInterceptorEntry> mInterceptors = new LinkedList<HTInterceptorEntry>();
  20.     private final List<HTMethodRouterEntry> mMethodRouters = new LinkedList<HTMethodRouterEntry>();
  22.     private Map<String, IRouterGroup> pageRouterGroup() {
  23.     if (mRouterGroups.isEmpty()) {
  24.       mRouterGroups.put("m", new HTRouterGroup$$m());
  25.       ...
  26.     }
  27.     return mRouterGroups;
  28.   }
  30.   private List<HTInterceptorEntry> interceptors() {
  31.     if (mInterceptors.isEmpty()) {
  32.       mInterceptors.add(new HTInterceptorEntry("http://www.you.163.com/activity/detail/{id}.shtml", new ProductDetailInterceptor()));
  33.       ...
  34.     }
  35.     return mInterceptors;
  36.   }
  38.   private List<HTMethodRouterEntry> methodRouters() {
  39.     if (mMethodRouters.isEmpty()) {
  40.        {
  41.         List<Class> paramTypes = new ArrayList<Class>();
  42.         paramTypes.add(Context.class);
  43.         paramTypes.add(String.class);
  44.         paramTypes.add(int.class);
  45.         mMethodRouters.add(new HTMethodRouterEntry("http://www.you.163.com/jumpA", "com.netease.hearttouch.example.JumpUtil", "jumpA", paramTypes));
  46.       }
  47.       ...
  48.     }
  49.     return mMethodRouters;
  50.   }
  51. }

HTRouterTable.pageRouterGroup()、HTRouterTable.methodRouters() 和 HTRouterTable.interceptors() 先忽略，后续解释

Alt pic

新建了一个 Android Library htrouter，引用工程 htrouterdispatch，app 工程修改引用 htrouter

经过优化，router 跳转的逻辑代码可通过直接编码方式实现，普通 Android 开发也能轻松修改其中的逻辑，同时 apt 生成的类从 6 个直接减少至 1 个 HTRouterTable 和几个 HTRouterGroup。而自动生成的路由表和业务逻辑已经没有直接联系，就不会出现因为路由表未生成导致的大量编译出错问题。

3.2 路由表过大问题优化

参考 ARouter 的路由表分组和延迟加载概念，我们也引入相关机制。ARouter 使用 path 的第一个 segment 作为 group，为此 group 概念由业务层定义。而严选工程中，前期协议并没有考虑到 group，为此 url 中并没有业务字段指定 group，且全部 Activity 绑定是根据 host 字段，基本不定义 path 等。我这里采用 host 的第一个字母作为 group，生成如下 RouterGroup 映射表。

  1. public final class HTRouterGroup$$m implements IRouterGroup {
  2.   private final List<HTRouterEntry> mPageRouters = new LinkedList<HTRouterEntry>();
  4.   public List<HTRouterEntry> pageRouters() {
  5.     if (mPageRouters.isEmpty()) {
  6.       mPageRouters.add(new HTRouterEntry("com.netease.hearttouch.example.MainActivity", "yanxuan://member", 2131034128, 2131034126, false));
  7.       ...
  8.     }
  9.     return mPageRouters;
  10.   }
  11. }

而 HTRouterTable 持有全部的 RouterGroup 对象，支持路由跳转时按需加载路由分组的内容，降低内存消耗。同时进行路由表匹配查找时，就可以仅查找对应路由分组的内容，查找量是原来的 1/26（26 个字母），极大的降低路由查找性能开销

  1. public final class HTRouterTable {
  3.   public static Map<String, IRouterGroup> pageRouterGroup() {
  4.     if (ROUTER_GROUPS.isEmpty()) {
  5.       ROUTER_GROUPS.put("m", new HTRouterGroup$$m());
  6.       ...
  7.     }
  8.     return ROUTER_GROUPS;
  9.   }
  10. }

3.3 拦截器优化

3.3.1 优化前临时方案

针对登录拦截需求，当时的临时解决方案如下：

  1. 路由注解添加 needLogin 字段
  2. 并修改 apt 生成代码，使 HTRouterEntry 记录 needLogin 信息
  3. 提供 RouterUtil.startActivity 将目标页面的跳转构建成一个 runnable 传入，在登录成功回调中执行 runnable
  1. @HTRouter(url = {PreemptionActivateActivity.ROUTER_URL}, needLogin = true)
  2. public class PreemptionActivateActivity extends Activity {
  3.     ...
  4. }
  1. public static boolean startActivity(final Context context, final String schemeUrl,
  2.                                     final Intent sourceIntent, final boolean isFinish) {
  4.     return doStartActivity(context, schemeUrl, new Runnable() {
  5.         @Override
  6.         public void run() {
  7.             HTRouterManager.startActivity(context, schemeUrl, sourceIntent, isFinish);
  8.         }
  9.     });
  10. }
  12. private static boolean doStartActivity(final Context context, final String schemeUrl,
  13.                                  final Runnable runnable) {
  15.     if (HTRouterManager.isUrlRegistered(schemeUrl)) {
  16.         HTRouterEntry entry = HTRouterManager.findRouterEntryByUrl(schemeUrl);
  17.         if (entry == null) {
  18.             return false;
  19.         }
  21.         if (entry.isNeedLogin() && !UserInfo.isLogin()) {
  22.             LoginActivity.addOnLoginResultListener(new OnLoginResultListener() {
  23.                 @Override
  24.                 public void onLoginSuccess() {
  25.                     runnable.run();
  26.                 }
  28.                 @Override
  29.                 public void onLoginFail() {
  30.                     // do nothing
  31.                 }
  32.             });
  33.             LoginActivity.start(context);
  34.         }
  36.         return true;
  37.     }
  39.     return false;
  40. }

可以发现这种处理方式并不通用，同时需要业务层代码全部修改调用方式，未修改的接口还是可能出现以未登录态进入需要登录的页面（这种情况也确实在后面发生过，后来我们要求前端跳转之前，先通过 jsbridge 唤起登录页面(⊙﹏⊙)b）。我们需要一种通用规范的方式处理拦截逻辑，同时能适用各种场景，也能规避业务层的错误。

3.3.2 拦截器优化和设计

为避免业务层绕过拦截器直接调用到 HTRouterManager，将 HTRouterManager.startActivity 等接口修改为 package 引用范围，此外新定义 HTRouterCall 作为对外接口类。

  1. public class HTRouterCall implements IRouterCall {
  2.     ...
  3. }
  1. public interface IRouterCall {
  2.     // 继续路由跳转
  3.     void proceed();
  4.     // 继续路由跳转
  5.     void cancel();
  6.     // 获取路由参数
  7.     HTRouterParams getParams();
  8. }

定义拦截器 interface 如下：

  1. public interface IRouterInterceptor {
  2.     void intercept(IRouterCall call);
  3. }

总结拦截的需求场景，归纳拦截场景为 3 种：

  1. 全局拦截 → 全局拦截器

    全局拦截器，通过静态接口设置添加

    1. public static void addGlobalInterceptors(IRouterInterceptor... interceptors) {
    2.     Collections.addAll(sGlobalInterceptors, interceptors);
    3. }

    登录拦截需求可以理解是一个全局的需求，全部的 Activity 跳转都需要判断是否需要唤起登录页面。

    1. public class LoginRouterInterceptor implements IRouterInterceptor {
    3.     @Override
    4.     public void intercept(final IRouterCall call) {
    5.         HTDroidRouterParams params = (HTDroidRouterParams) call.getParams();
    6.         HTRouterEntry entry = HTRouterManager.findRouterEntryByUrl(params.url);
    7.         if (entry == null) {
    8.             call.cancel();
    9.             return;
    10.         }
    12.         if (entry.isNeedLogin() && !UserInfo.isLogin()) {
    13.             LoginActivity.setOnLoginResultListener(new OnLoginResultListener() {
    14.                 @Override
    15.                 public void onLoginSuccess() {
    16.                     call.proceed();
    17.                 }
    19.                 @Override
    20.                 public void onLoginFail() {
    21.                     call.cancel();
    22.                 }
    23.             });
    24.             LoginActivity.start(params.getContext());
    25.         } else {
    26.             call.proceed();
    27.         }
    28.     }
    29. }

    Alt pic

    登录拦截效果

  2. 业务页面固定拦截 → 注解拦截器

    上面剩余的 7 个 switch-case 拦截，可以理解为特定业务页面唤起都必须进入的一个拦截处理，分别定义 7 个拦截器类，同样通过注解的方式标记。

    以 yanxuan://category 为例子

    1. @HTRouter(url = {"yanxuan://category", "yanxuan://categoryl2"})
    2. public class CategoryL2Activity extends Activity {
    3.     ...
    4. }

    对应的注解拦截器

    1. @HTRouter(url = {"yanxuan://category"})
    2. public class CategoryL2Intercept implements IRouterInterceptor {
    4.     @Override
    5.     public void intercept(IRouterCall call) {
    6.         HTRouterParams routerParams = call.getParams();
    7.         Uri uri = Uri.parse(routerParams.url);
    9.         // routerParams.url 添加额外参数
    10.         Uri.Builder builder = uri.buildUpon();
    11.         ...
    12.         routerParams.url = builder.build().toString();
    14.         call.proceed();
    15.     }
    16. }

    apt 生成拦截器初始化代码

    1. public static List<HTInterceptorEntry> interceptors() {
    2.     if (INTERCEPTORS.isEmpty()) {
    3.         ...
    4.         INTERCEPTORS.add(new HTInterceptorEntry("yanxuan://category", new CategoryL2Intercept()));
    5.         ...
    6.     }
    7.     return INTERCEPTORS;
    8. }

    HTRouterTable

  3. 业务页面动态拦截

    比如 onClick 方法内执行路由跳转时，需要弹窗提示用户是否继续跳转，其他场景跳转并不需要这个弹窗，这种场景的拦截器我们认为是动态拦截

    1. HTRouterCall.newBuilder(data.schemeUrl)
    2.     .context(mContext)
    3.     .interceptors(new IRouterInterceptor() {
    4.         @Override
    5.         public void intercept(final IRouterCall call) {
    6.             Log.i("TEST", call.toString());
    7.             AlertDialog dialog = new AlertDialog.Builder(mContext)
    8.                     .setTitle("alert")
    9.                     .setMessage("是否继续")
    10.                     .setPositiveButton("继续", new DialogInterface.OnClickListener() {
    11.                         @Override
    12.                         public void onClick(DialogInterface dialog, int which) {
    13.                             call.proceed();
    14.                         }
    15.                     })
    16.                     .setNegativeButton("取消", new DialogInterface.OnClickListener() {
    17.                         @Override
    18.                         public void onClick(DialogInterface dialog, int which) {
    19.                             call.cancel();
    20.                         }
    21.                     }).create();
    22.             dialog.show();
    23.         }
    24.     })
    25.     .build()
    26.     .start();

    Alt pic

优先级：动态拦截器 > 注解拦截器 > 全局拦截器

3.4 sdk 页面 router 支持

我们接入了七鱼、HTImagePick 等 sdk，这些 sdk 也有自己的页面，而这部分页面并不能通过前面的路由方式打开，其原因如下：

  1. 我们不能修改他们的代码
  2. apt 处理的注解仅能针对引入 apt 的 app 工程

  3. 对应的页面唤起需要通过 sdk 提供的特殊接口唤起

    1. public static void openYsf(Context context, String url, String title, String custom) {
    2.     ConsultSource source = new ConsultSource(url, title, custom);
    3.     Unicorn.openServiceActivity(context, // 上下文
    4.             title, // 聊天窗口的标题
    5.             source // 咨询的发起来源，包括发起咨询的url，title，描述信息等
    6.     );
    7. }

    七鱼客服页面唤起

    1. public void openImagePick(Context context, ArrayList<PhotoInfo> photoInfos, boolean multiSelectMode, int maxPhotoNum, String title) {
    2.     HTPickParamConfig paramConfig = new HTPickParamConfig(HTImageFrom.FROM_LOCAL, null,
    3.             photoInfos, multiSelectMode, maxPhotoNum, title);
    4.     HTImagePicker.INSTANCE.start(context, paramConfig, this);
    5. }

基于此，只需要提供对方法的 router 调用，就能支持 sdk 中的页面路由跳转。具体用法示例如下

  1. 通过 HTMethodRouter 注解标记跳转方法（非静态方法需实现 getInstance 单例）

    1. public class JumpUtil {
    3.     private static final String TAG = "JumpUtil";
    4.     private static JumpUtil sInstance = null;
    6.     public static JumpUtil getInstance() {
    7.         if (sInstance == null) {
    8.             synchronized (JumpUtil.class) {
    9.                 if (sInstance == null) {
    10.                     sInstance = new JumpUtil();
    11.                 }
    12.             }
    13.         }
    14.         return sInstance;
    15.     }
    17.     private JumpUtil() {
    18.     }
    20.     @HTMethodRouter(url = {"http://www.you.163.com/jumpA"}, needLogin = true)
    21.     public void jumpA(Context context, String str, int i) {
    22.         String msg = "jumpA called: str=" + str + "; i=" + i;
    23.         Log.i(TAG, msg);
    24.         if (context != null) {
    25.             Toast.makeText(context, msg, Toast.LENGTH_LONG).show();
    26.         }
    27.     }
    29.     @HTMethodRouter(url = {"http://www.you.163.com/jumpB"})
    30.     public static void jumpB(Context context, String str, int i) {
    31.         String msg = "jumpB called: str=" + str + "; i=" + i;
    32.         Log.i(TAG, msg);
    33.         if (context != null) {
    34.             Toast.makeText(context, msg, Toast.LENGTH_LONG).show();
    35.         }
    36.     }
    38.     @HTMethodRouter(url = {"http://www.you.163.com/jumpC"})
    39.     public void jumpC() {
    40.         Log.i(TAG, "jumpC called");
    41.     }
    42. }

  2. 方法路由表生成

    1. public final class HTRouterTable {
    3.   private final List<HTMethodRouterEntry> mMethodRouters = new LinkedList<HTMethodRouterEntry>();
    5.   ...
    7.   private List<HTMethodRouterEntry> methodRouters() {
    8.     if (mMethodRouters.isEmpty()) {
    9.        {
    10.         List<Class> paramTypes = new ArrayList<Class>();
    11.         paramTypes.add(Context.class);
    12.         paramTypes.add(String.class);
    13.         paramTypes.add(int.class);
    14.         mMethodRouters.add(new HTMethodRouterEntry("http://www.you.163.com/jumpA", "com.netease.hearttouch.example.JumpUtil", "jumpA", paramTypes));
    15.       }
    16.        {
    17.         List<Class> paramTypes = new ArrayList<Class>();
    18.         paramTypes.add(Context.class);
    19.         paramTypes.add(String.class);
    20.         paramTypes.add(int.class);
    21.         mMethodRouters.add(new HTMethodRouterEntry("http://www.you.163.com/jumpB", "com.netease.hearttouch.example.JumpUtil", "jumpB", paramTypes));
    22.       }
    23.        {
    24.         List<Class> paramTypes = new ArrayList<Class>();
    25.         mMethodRouters.add(new HTMethodRouterEntry("http://www.you.163.com/jumpC", "com.netease.hearttouch.example.JumpUtil", "jumpC", paramTypes));
    26.       }
    27.     }
    28.     return mMethodRouters;
    29.   }
    30. }

  3. 方法路由触发逻辑

    除了设置动画、是否关闭当前页面等参数，这里方法路由的调用方式和页面路由完全一致，同样支持 needLogin 字段，同样支持全局拦截器、注解拦截器、动态拦截器

    1. // JUMPA 按钮点击
    2. public void onMethodRouter0(View v) {
    3.     HTRouterCall.call(MainActivity.this, "http://www.you.163.com/jumpA?a=lilei&b=10");
    4. }
    6. // JUMPB 按钮点击
    7. public void onMethodRouter1(View v) {
    8.     HTRouterCall.call(MainActivity.this, "http://www.you.163.com/jumpB?a=hanmeimei&b=10");
    9. }
    11. // JUMPC 按钮点击
    12. public void onMethodRouter2(View v) {
    13.     HTRouterCall.call(MainActivity.this, "http://www.you.163.com/jumpC");
    14. }

  4. 结果示例

    Alt pic

3.5 main dex 优化处理

这里的处理逻辑较为简单，仅需修改类引用为类名字符串，后续跳转时通过反射获取类

  1. public final class HTRouterGroup$$m implements IRouterGroup {
  2.   private final List<HTRouterEntry> mPageRouters = new LinkedList<HTRouterEntry>();
  4.   public List<HTRouterEntry> pageRouters() {
  5.     if (mPageRouters.isEmpty()) {
  6.       mPageRouters.add(new HTRouterEntry("com.netease.hearttouch.example.MainActivity", "yanxuan://m.you.163.com", 2131034128, 2131034126, false));
  7.       ...
  8.     }
  9.     return mPageRouters;
  10.   }
  11. }

3.6 自定义降级优化

为推送等提供降级跳转方案，添加了 downgradeUrls 参数设置，若当前 urlA 并不识别，则会依次对 urlB，urlC 做判断并尝试跳转

  1. HTRouterCall.newBuilder(urlA)
  2.     .context(ProductDetailActivity.this)
  3.     .downgradeUrls(urlB, urlC)
  4.     .sourceIntent(sourceIntent)
  5.     .requestCode(1001)
  6.     .forResult(true)
  7.     .build()
  8.     .start();

3.7 跨工程路由表整合

ht-router 不支持多工程，是因为 apt 生成的代码包名都是固定的，而多工程就会多次执行 apt 代码生成逻辑，最终会生成多个相同包名和类名的类，最后产生类冲突。类冲突的解决办法较为简单，只需要将包名改成外部传入就可以了

  1. apt {
  2.     arguments {
  3.         routerPkg 'com.netease.demo.router'
  4.     }
  5. }

app 工程指定 routerPkg 参数为 'com.netease.demo.router'

app 工程生成的路由表为 com.netease.demo.router.HTRouterTable。

多个业务工程生成了多个 HTRouterTable 后，需要业务开发调用多次 HTRouterManager.init 将各个路由表注册进去。为了隐藏多个路由表的实现细节，同时避免业务开发调用初始化方法可能产生的错误，这里通过 AspectJ 进行自动收集并注册路由表。业务层仅需要在 Application 中执行 HTRouterCall.init() 即可。

  1. 漏调初始化方法
  2. HTRouterTable 引用错误，因为生成的全部路由表都是 HTRouterTable
  1. @Aspect
  2. public final class HTRouterTable {
  3.   ...
  4.   @After("execution(void com.netease.hearttouch.router.HTRouterCall.init())")
  5.   public void init(JoinPoint joinPoint) {
  6.     HTRouterManager.init(pageRouterGroup(), methodRouters(), interceptors());
  7.   }
  8.   ...
  9. }

4 接口组件化

除了严选最初集成的 HTHTTP 网络库、HTRecycleView、HTEventbus 等基础模块之外，可以保持独立，后面开发的很多业务模块，甚至基础模块都需要使用到原 app 工程里面的功能或者类型，于是我们碰到了 微信 Android 同样的问题，也同样开始了初步的接口下沉和类型下沉，具体下沉的实例和背景原因如下：

  1. 基础功能类下沉

    前面讲述过，我们在 app 工程的 common/util/ 下积累了一部分 util 类，如 FileUtil、BitmapHelper、CookieUtil、LogUtil 等，这里部分是业务无关，部分是业务相关。如 FileUtil、BitmapHelper 和业务逻辑无关，而CookieUtil 和 LogUtil 和业务相关。此外，基础功能代码和其他代码也存在少量耦合，在下沉的过程中，容易导致更多的代码下沉。

    • CookieUtil 提供了业务相关的 Set-Cookie 解析保存和提取组装到网络请求、WebView，WebView Cookie 需要添加相关的 domain、httpOnly 设置。
    • LogUtil 提供了不同情况的日志表示逻辑。测试包将 error 日志通过对话框的形式展现给测试，同时记录错误日志到本地文件，普通日志正常 adb 展示；线上包将 error 日志上报服务器，普通日志关闭。这里对话框复用了 SingleAlertBuilder，写本地文件复用了存储模块

  2. 数据类型下沉

    工程里面全局事件总线通过 event 发送，在构建多工程模块的情况下，需要涉及跨工程通信的时候，就需要将相关 event 下沉到底层。

以上基础功能下沉和数据类型下沉过程中，我们构建了 yxcommonbase、yxlogger、yxstorage 等基础工程，app 工程和其他工程依赖这几个基础工程，这里不仅有业务工程、还有部分基础工程，如网络诊断工程。由于下沉的频率较高，基本上每个版本都要下沉一点点，导致其他基础工程无法以 aar 包的形式集成 app，如 app 工程引用基础模块 A，A 引用 yxcommonbase，虽然 A 代码完全没变，由于 yxcommonbase 发生了一点变化，我们还是需要重新发布 A aar。由于这种多级引用关系的存在，而 yxcommonbase 又是最底层的模块，最终导致的是全部的基础工程都无法以 aar 包的形式集成 app。最严重的还是长期的下沉最终会导致模块边界破坏、基础工程中心化。

4.1 方案选择

为阻止下沉情况，我们需要重新整理通信方式、功能调用方式，考虑有以下选择：

4.1.1 方法路由

首先能想到的就是前面提到的方法路由，使用方法路由能很好的统一 sdk 的页面路由、并支持服务端命令推送，在这方面使用方法路由是非常合适的。而方法路由一个最大的问题就是，每个方法都需要定义协议，而工程间的通信、功能复用情况会非常多，很容易导致协议过多，维护成本过大，为此在工程间通信方面并不是好的选择。此外对于特殊参数，如 Context、Bitmap 等，方法路由就显得比较无力。

4.1.2 ServiceLoader

排除通过方法路由进行通信，更安全和开发更适应的方式是接口通信。使用接口通信的方式，Java 原生提供的方式有 ServiceLoader

Jdk6 提供的一种 SPI（Service Provider Interfaces）机制，流程如下：
在 META-INF/services 下放置配置文件，Caculator 在接口工程 A，CalulatorImpl 在实现工程 B

  1. 文件名：com.example.Caculator
  2. 文件内容：com.example.CalulatorImpl

接口使用工程 C 定义 Factory 类，通过 get(） 来得到需要的具体实例，工程 C 并不需要知道 Caculator 的实现类。

  1. public class CalculatorFactory {
  2.     public CalculatorFactory() {
  3.         ServiceLoader<Caculator> loader = ServiceLoader.load(Caculator.class);
  4.         mIterator = loader.iterator();
  5.     }
  7.     private Iterator<Caculator> mIterator;
  9.     Caculator get() {
  10.         return mIterator.next();
  11.     }
  13.     boolean hasNextDisplay() {
  14.         return mIterator.hasNext();
  15.     }
  16. }

查看源码可以发现，ServiceLoader 通过 c.newInstance() 接口创建实现对象，为此有以下缺点：

  1. 不支持单例和使用参数来创建对象
  2. 只能使用 LazyIterator 获取实现对象，当有多个实现类时，使用工程需要通过遍历的方式查找目标对象，将不需要的实现类创建对象，浪费性能
  3. 需要定义接口工程，和实现工程中的配置文件，实现过程编码较多
  1. public S next() {
  2.     ...
  3.         c = Class.forName(cn, false, loader);
  4.     ...
  5.     try {
  6.         S p = service.cast(c.newInstance());
  7.         providers.put(cn, p);
  8.         return p;
  9.     } catch (Throwable x) {
  10.         ...
  11.     }
  12.     throw new Error();          // This cannot happen
  13. }

代码片段来源 Android-25 ServiceLoader.java

4.1.3 ARouter Provider 路由

ARouter 提供了 Provider 路由，使用样例如下：

  1. @Route(path = "/yourservicegroupname/hello")
  2. public class HelloServiceImpl implements HelloService {
  3.     Context mContext;
  5.     @Override
  6.     public void sayHello(String name) {
  7.         Toast.makeText(mContext, "Hello " + name, Toast.LENGTH_SHORT).show();
  8.     }
  10.     @Override
  11.     public void init(Context context) {
  12.         mContext = context;
  13.         Log.e("testService", HelloService.class.getName() + " has init.");
  14.     }
  15. }

代码片段来源

  1. ((HelloService) ARouter.getInstance().build("/yourservicegroupname/hello").navigation()).sayHello("mike");

HelloServiceImpl 使用样例

使用页面路由相同的方式，通过注解 path 来定义 Provider 路由。HelloServiceImpl 必须实现 IProvider 接口，实现 void init(Context context) 方法。如果我们将 HelloService 接口定义在接口工程，HelloServiceImpl 定义在接口实现工程 A（或 app 主工程），那工程 B 就能使用 Provider 路由来调用到工程 A 中的方法。

但也有几点不便之处：

  1. navigation() 调用值需要做强制类型转换，业务开发需要查询协议文档，确定 path 和 接口 HelloService 之间的联系

    1. public Object navigation() {
    2.     return navigation(null);
    3. }

  2. 提供的接口实现类要有无参构造函数，和 init(Context context) 方法，不支持其他的构造函数，实用类为单例

    1. public class LogisticsCenter {
    2.     ...
    3.     public synchronized static void completion(Postcard postcard) {
    4.         ...
    5.         Class<? extends IProvider> providerMeta = (Class<? extends IProvider>) routeMeta.getDestination();
    6.         // 重点 1：单例
    7.         IProvider instance = Warehouse.providers.get(providerMeta);
    8.         if (null == instance) { // There's no instance of this provider
    9.             IProvider provider;
    10.             try {
    11.                 // 重点 2：无参构造函数
    12.                 provider = providerMeta.getConstructor().newInstance();
    13.                 // 重点 3：init(Context context) 初始化方法
    14.                 provider.init(mContext);
    15.                 Warehouse.providers.put(providerMeta, provider);
    16.                 instance = provider;
    17.             } catch (Exception e) {
    18.                 throw new HandlerException("Init provider failed! " + e.getMessage());
    19.             }
    20.         }
    21.         ...
    22.     }
    23.     ...
    24. }

  3. 接口类 HelloService 相关的参数类型，或者返回值类型，需下沉到接口工程

4.1.4 WMRouter RouterService 功能

美团参考 ServiceLoader 的原理，提供了自己的 RouterService 功能，使用如下：

  1. @RouterService(interfaces = ILocationService.class, key = DemoConstant.SINGLETON, singleton = true)
  2. public class FakeLocationService implements ILocationService {
  4.     private final Handler mHandler = new Handler();
  6.     @Override
  7.     public boolean hasLocation() {
  8.         return false;
  9.     }
  11.     @Override
  12.     public void startLocation(final LocationListener listener) {
  13.         ...
  14.     }
  15. }

代码片段来源

  1. ILocationService locationService = Router.getService(ILocationService.class, DemoConstant.SINGLETON);

接口实例获取

相比 ARouter，有以下优点：

  1. 接口服务实例获取不需要强制类型转换，业务开发不容易写错

    1. public static <I, T extends I> T getService(Class<I> clazz, String key) {
    2.     return ServiceLoader.load(clazz).get(key);
    3. }

  2. 支持单例管理，无参构造、Context 构造和自定义 Factory

    针对有多个构造函数的服务类，需要定义多个自定义 Factory 类

    1. public interface IFactory {
    2.     @NonNull
    3.     <T> T create(@NonNull Class<T> clazz) throws Exception;
    4. }

  3. 支持相同接口的多个实现类，业务工程通过 key 选择

此外，同 ServiceLoader，ARouter 方法，上述方案非常优秀，但尚有有相同不便之处：

  1. 接口参数类型和返回类型要下沉到接口工程，而参数类型和返回类型可能和原工程有耦合，触发更多的代码需要下沉到接口工程
  2. 接口实现类，不支持静态方法
  3. 需要修改原有代码逻辑
    • 添加基类或接口
    • 修改方法为接口方法

4.2 AutoApi 组件方案

总结以上方法，开发 AutoApi 组件，使用注解自动配置，自动生成接口类和实现类，支持跨工程共享接口。

4.2.1 支持多构造函数创建接口实例

  1. @AutoApiClassAnno
  2. public class AddUtil {
  4.     private int mData1 = 0;
  5.     private int mData2 = 0;
  7.     @AutoApiConstructAnno
  8.     public AddUtil(int data1, int data2) {
  9.         mData1 = data1;
  10.         mData2 = data2;
  11.     }
  13.     @AutoApiConstructAnno
  14.     public AddUtil(int data) {
  15.         mData1 = data;
  16.         mData2 = data;
  17.     }
  19.     @AutoApiMethodAnno
  20.     public int calu() {
  21.         return mData1 + mData2;
  22.     }
  23. }

服务类通过注解标记，提供对外构造函数和普通方法

自动生成接口类和工厂类如下：

  1. /**
  2.  * com.netease.demo.autoapi.AddUtil's api Interface
  3.  */
  4. public interface AddUtilApi extends ApiBase {
  5.   int calu();
  6. }
  1. /**
  2.  * com.netease.demo.autoapi.AddUtil api Class's factory Interface
  3.  */
  4. public interface AddUtilApiFactory {
  5.   AddUtilApi newInstance(int data1, int data2);
  6.   AddUtilApi newInstance(int data);
  7. }

接口使用样例：

  1. AddUtilApiFactory factory = AutoApi.getApiFactory("AddUtilApi");
  2. AddUtilApi api = factory.newInstance(11, 12);
  3. int result0 = api.calu(); // 23

4.2.2 支持静态方法

  1. @AutoApiClassAnno
  2. public class AddUtil {
  4.     ...
  5.     @AutoApiMethodAnno
  6.     public int calu() {
  7.         return mData1 + mData2;
  8.     }
  9.     @AutoApiMethodAnno
  10.     public static int add(int a, int b) {
  11.         return a + b;
  12.     }
  13. }

服务类

  1. /**
  2.  * com.netease.demo.autoapi.AddUtil's api Interface
  3.  */
  4. public interface AddUtilApi extends ApiBase {
  5.   int calu();
  6.   int add(int a, int b);
  7. }

自动生成接口类

  1. AddUtilApiFactory factory = AutoApi.getApiFactory("AddUtilApi");
  2. AddUtilApi api = factory.newInstance(11, 12);
  3. int result1 = api.calu(); // 23
  4. int result2 = api.add(11, 12); // = 23

接口使用

4.2.3 支持静态方法构造接口实例（支持单例）

  1. @AutoApiClassAnno(name = "AppSingleton")
  2. public class Singleton {
  4.     private static Singleton sInstance = null;
  6.     @AutoApiClassBuildMethodAnno()
  7.     public static Singleton getInstance() {
  8.         if (sInstance == null) {
  9.             synchronized (Singleton.class) {
  10.                 if (sInstance == null) {
  11.                     sInstance = new Singleton();
  12.                 }
  13.             }
  14.         }
  16.         return sInstance;
  17.     }
  19.     private Singleton() {
  20.     }
  22.     @AutoApiMethodAnno()
  23.     public String foo1(String str1, String str2) {
  24.         Log.i("Singleton", "foo1 called");
  25.         return str1 + "_" + str2;
  26.     }
  27. }

服务类

  1. /**
  2.  * com.netease.demo.autoapi.Singleton api Class's factory Interface
  3.  */
  4. public interface AppSingletonApiFactory {
  5.   AppSingleton getInstance();
  6. }

自动生成的接口工厂类

  1. AppSingletonApiFactory apiFactory = AutoApi.getApiFactory("AppSingleton");
  2. AppSingleton singleton = apiFactory.getInstance();
  3. String result = singleton.foo1("var1", "var2");

apiFactory.getInstance() 通过 Singleton.getInstance() 获取实例

4.2.4 避免服务类相关类型下沉至接口工程

严选 app 工程引入了 HTHttp 组件，其中 HTHttp 工程是基于 Volley 封装的一个网络库。此外，严选工程基于 HTHttp 封装了 WZP 请求（网易邮件私有协议）。WZP 的封装、配置、初始化等代码和严选 app 主工程耦合较大，而我们的业务子工程便需要 WZP 请求功能。若采用现有开源方案，我们基本需要将 WZP 模块下沉至底层，而这不是我们期望看到的。这里我提供的 AutoApi 组件通过自动生成参数接口类型，来避免类型下沉的问题。

  1. @AutoApiClassAnno(includeSuperApi = true)
  2. public class SharedWzpCommonRequestTask extends BaseWzpCommonRequestTask {
  4.     private String mUrl;
  5.     private String mApi;
  6.     private Class mModelClass;
  8.     @AutoApiClassBuildMethodAnno()
  9.     public static SharedWzpCommonRequestTask newInstance(String url, Class modelClass,
  10.                                                          Map<String, String> queryParams,
  11.                                                          Map<String, String> headerMap,
  12.                                                          Map<String, Object> bodyMap) {
  13.         Builder builder = new Builder();
  14.         return builder.setApi(url)
  15.                 .setModelClass(modelClass)
  16.                 .setQueryParams(queryParams)
  17.                 .setHeaders(headerMap)
  18.                 .setBodyMap(bodyMap)
  19.                 .build();
  20.     }
  22.     private SharedWzpCommonRequestTask(SharedWzpDataModel data) {
  23.         mUrl = data.mUrl;
  24.         mApi = data.mApi;
  25.         mModelClass = data.mModelClass;
  26.     }
  27.     ...
  28. }
  30. public class BaseWzpCommonRequestTask {
  31.     ...
  33.     @AutoApiMethodAnno()
  34.     public Request query(@AutoApiCallbackAnno HttpListener listener) {
  35.         ...
  36.     }
  37.     @AutoApiMethodAnno()
  38.     public Request queryArray(@AutoApiCallbackAnno HttpListener listener) {
  39.         ...
  40.     }
  41. }
  43. @AutoApiClassAnno(allPublicNormalApi = true, includeSuperApi = true)
  44. public interface HttpListener extends BaseHttpListener {
  45.     void onCancel();
  46. }
  48. public interface BaseHttpListener {
  49.     void onHttpSuccess(String httpName, Object result);
  50.     void onHttpError(String httpName, int errorCode, String errorMsg);
  51. }
  53. @AutoApiClassAnno(allPublicNormalApi = true)
  54. public class Request {
  55.     public void cancel() {
  56.         ...
  57.     }
  58. }

WZP HttpTask 服务类及相关类

  1. public interface SharedWzpCommonRequestTaskApi extends ApiBase {
  2.   RequestApi query(HttpListenerApi listener);
  3.   RequestApi queryArray(HttpListenerApi listener);
  4. }
  6. public interface HttpListenerApi extends ApiBase {
  7.   void onCancel();
  8.   void onHttpSuccess(String httpName, Object result);
  9.   void onHttpError(String httpName, int errorCode, String errorMsg);
  10. }
  12. public interface RequestApi extends ApiBase {
  13.   void cancel();
  14. }

编译自动生成接口类

  1. public interface SharedWzpCommonRequestTaskApiFactory {
  2.   SharedWzpCommonRequestTaskApi newInstance(String url, Class modelClass, Map<String, String> queryParams, Map<String, String> headerMap, Map<String, Object> bodyMap);
  3. }

编译自动生成工厂接口类

  1. SharedWzpCommonRequestTaskApiFactory apiFactory = AutoApi.getApiFactory("SharedWzpCommonRequestTaskApi");
  2.         SharedWzpCommonRequestTaskApi api = apiFactory.newInstance("/xhr/test/a", null, null, null, null);
  3.         RequestApi request = api.query(new HttpListenerApi() {
  4.             @Override
  5.             public void onCancel() {  }
  7.             @Override
  8.             public void onHttpSuccess(String httpName, Object result) {  }
  10.             @Override
  11.             public void onHttpError(String httpName, int errorCode, String errorMsg) {  }
  13.             @Override
  14.             public Object getApiServiceTarget() {
  15.                 return null;
  16.             }
  17.         });
  19.         // 取消请求
  20.         request.cancel();

业务子工程使用接口服务

以上避免了接口参数类型 HttpListener 和返回类型 Request 下沉至接口工程，业务子工程对于服务类相关的代码类型并无感知

4.2.5 实际对象获取

在跨工程中，我们也能使用 EventBus 进行通信，EventBus 通过 event 的 class 类型来区分事件类型，为了支持子工程能给 app 工程发送事件，但又不想 app 工程中的 event 类下沉到底层，也不想让子工程感知到 event 实际类型信息（如event classname），我们可以通过接口类的 getApiServiceTarget 方法获取实际对象

  1. @AutoApiClassAnno()
  2. public class EventA {
  3.     ...
  4. }

app 工程 Event 类型

  1. EventAApiFactory factory = AutoApi.getApiFactory("EventAApi");
  2. EventAApi api = factory.newInstance();
  3. EventBus.getDefault().post(api.getApiServiceTarget());

业务子工程发送 EventBus 事件

4.2.6 支持接口泛型

  1. @AutoApiClassAnno
  2. public class JsonUtil {
  3.     ...
  5.     @AutoApiMethodAnno
  6.     public static <T> T toJsonObj(String jsonStr, Class<T> clazz) {
  7.         try {
  8.             if (!TextUtils.isEmpty(jsonStr)) {
  9.                 return JSONObject.parseObject(jsonStr, clazz, Feature.IgnoreNotMatch);
  10.             }
  11.         } catch (Throwable e) {
  12.             LogUtil.yxLogE(e);
  13.         }
  14.         return null;
  15.     }
  16. }

app 工程服务类

  1. public interface JsonUtilApi extends ApiBase {
  2.   ...
  4.   <T> T toJsonObj(String jsonStr, Class<T> clazz);
  5. }

自动生成的接口类

5 总结

严选比起其他大厂，Android 组件化方面做得还比较初步，但也根据我们的业务场景做了适合我们自己的方案

在路由方案方面，我们做了如下优化：

  1. 通过区分路由表生成代码和其他跳转逻辑，优化 apt 代码生成逻辑的复杂性和和维护性；
  2. 通过优化拦截器，解决登录拦截问题，优化子模块和全局代码划分；
  3. 通过提供方法路由，解决 sdk 页面的路由跳转问题；
  4. 通过修改路由表对类的直接引用，解决 main-dex 问题；
  5. 路由表根据 host 自动分组，使用过程中懒加载路由表，优化路由表内存占用较大问题和路由查找性能开销问题
  6. 路由跳转支持自定义降级
  7. 支持跨工程的多路由表，使用 AspectJ 自动收集和初始路由表

在接口组件化方面，我们通过提供方法路由，支持方法推送，并开发了 AutoApi 组件方案

  1. 仅根据注解自动生成接口类和实现类，支持跨工程共享接口；
  2. 支持构造函数和静态方法创建接口实例；
  3. 支持单例；
  4. 支持对外提供服务类的普通方法和静态方法；
  5. 通过 includeSuperApi 支持不修改服务类基类，提供基类的服务方法；
  6. 避免服务类接口相关数据类型下沉至接口工程；
  7. 支持 EventBus；
  8. 支持接口参数泛型

htrouter 源码地址：https://github.com/bitterbee/htrouter
auto-api 源码地址：https://github.com/bitterbee/auto-api

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注