共计 6087 个字符，预计需要花费 16 分钟才能阅读完成。

关于为什么要进行 Android 模块化开发，网上也已经讲烂了，不过归结起来，大体是可以总结为：在 App 开发的初期，代码量不大，业务量比较少，一个 App 作为一个单独的模块进行开发，往往问题不大。但随着业务的增多，代码变的越来越复杂，每个模块之间的代码耦合变得越来越严重，结构越来越臃肿，修改一处代码要编译整个工程，导致非常耗时，这时候最好的办法就是进行模块化拆分。

总结现在的模块化，大体有以下一些好处：

公用功能，不用重复开发、修改，代码复用性更强；
独立编译运行，提高编译速度，也就提高了开发效率；
更利于团队开发，不同的人可以独立负责不同的模块；
独立模块可以采用不同的技术架构，尝试新的技术方案，比如采用新的网络框架，甚至换成 Kotlin 来开发 App。

要将项目模块化拆分，需要解决以下几个问题：

模块间页面跳转；
模块间事件通信；
模块间服务调用；
模块的独立运行；
模块间页面跳转路由拦截（如登录）

对于上面的问题，都可以使用 ARouter 进行解决。

官方地址：ARouter 开源地址
官方对 ARouter 框架的定义是：一个用于帮助 Android App 进行组件化改造的框架 —— 支持模块间的路由、通信、解耦。

支持直接解析标准 URL 进行跳转，并自动注入参数到目标页面中
支持多模块工程使用
支持添加多个拦截器，自定义拦截顺序
支持依赖注入，可单独作为依赖注入框架使用
支持 InstantRun
支持 MultiDex(Google 方案)
映射关系按组分类、多级管理，按需初始化
支持用户指定全局降级与局部降级策略
页面、拦截器、服务等组件均自动注册到框架
支持多种方式配置转场动画
支持获取 Fragment
完全支持 Kotlin 以及混编(配置见文末其他 #5)
支持第三方 App 加固(使用 arouter-register 实现自动注册)
支持生成路由文档
提供 IDE 插件便捷的关联路径和目标类

使用 ARouter 之前，需要先添加相应的依赖，依赖的脚步如下：

android {
    defaultConfig {
        ...
        javaCompileOptions {
            annotationProcessorOptions {arguments = [AROUTER_MODULE_NAME: project.getName()]
            }
        }
    }
}

dependencies {
    // 替换成最新版本, 需要注意的是 api
    // 要与 compiler 匹配使用，均使用最新版可以保证兼容
    compile 'com.alibaba:arouter-api:x.x.x'
    annotationProcessor 'com.alibaba:arouter-compiler:x.x.x'
    ...
}
// 旧版本 gradle 插件(< 2.2)，可以使用 apt 插件，配置方法见文末 '其他 #4'
// Kotlin 配置参考文末 '其他 #5'

要想 ARouter 识别路由，需要使用 @Route 注解标示具体的路径。例如：

// 在支持路由的页面上添加注解(必选)
// 这里的路径需要注意的是至少需要有两级，/xx/xx
@Route(path = "/test/activity")
public class YourActivity extend Activity {...}

if (isDebug()) {           // 这两行必须写在 init 之前，否则这些配置在 init 过程中将无效
    ARouter.openLog();     // 打印日志
    ARouter.openDebug();   // 开启调试模式(如果在 InstantRun 模式下运行，必须开启调试模式！线上版本需要关闭, 否则有安全风险)
}
ARouter.init(mApplication); // 尽可能早，推荐在 Application 中初始化

所谓发起路由操作，就是指触发路由的操作，例如：

// 1. 应用内简单的跳转(通过 URL 跳转在 '进阶用法' 中)
ARouter.getInstance().build("/test/activity").navigation();

// 2. 跳转并携带参数
ARouter.getInstance().build("/test/1")
            .withLong("key1", 666L)
            .withString("key3", "888")
            .withObject("key4", new Test("Jack", "Rose"))
            .navigation();

如果要接受传递处理的数据，可以使用下面的方式：

@Route(path = MainRoutePath.MAIN_ACTIVITY)
public class MainActivity extends BaseActivity {

    /**
     * 接收参数
     */
    @Autowired(name = "name")
    public String name;
    @Autowired(name = "age")
    public int age;
    ...
}

// A more classic application is to handle login events during a jump so that there is no need to repeat the login check on the target page.
// Interceptors will be executed between jumps, multiple interceptors will be executed in order of priority
@Interceptor(priority = 8, name = "test interceptor")
public class TestInterceptor implements IInterceptor {
    @Override
    public void process(Postcard postcard, InterceptorCallback callback) {
        ...
        // No problem! hand over control to the framework
        callback.onContinue(postcard);  
        
        // Interrupt routing process
        // callback.onInterrupt(new RuntimeException("Something exception"));      

        // The above two types need to call at least one of them, otherwise it will not continue routing
    }

    @Override
    public void init(Context context) {// Interceptor initialization, this method will be called when sdk is initialized, it will only be called once}
}

ARouter 提供的降级策略主要有两种方式，一种是通过回调的方式；一种是提供服务接口的方式。
一、回调方式
这种方式在跳转失败的时候会回调 NavCallback 接口的 onLost 方法。ARouter 提供的回调方式的函数如下：

ARouter.getInstance().build(MainRoutePath.MAIN_ACTIVITY).navigation(this, new NavCallback() {
     @Override
     public void onFound(Postcard postcard) {Log.d("ARouter", "找到了");
     }

     @Override
     public void onLost(Postcard postcard) {Log.d("ARouter", "找不到了");
     }

     @Override
     public void onArrival(Postcard postcard) {Log.d("ARouter", "跳转完了");
     }

     @Override
      public void onInterrupt(Postcard postcard) {Log.d("ARouter", "被拦截了");
      }
});

二、服务接口
全局降级 - 服务接口的方式主要处理逻辑在内部，暴露的接口很友好。

ARouter.getInstance().build("/test/test").navigation();

此种降级策略需要实现服务接口 DegradeService，返回的就一个方法就是 onLost。例如：

@Route(path = RoutePath.DEGRADE)
public class DegradeServiceImpl implements DegradeService {
    @Override
    public void onLost(Context context, Postcard postcard) {ARouter.getInstance().build(RoutePath.DEGRADE_TIP).greenChannel().navigation();
    }

    @Override
    public void init(Context context) {}}

为了避免打包时出现错误，需要将下面的内容使用 keep 标示。

-keep public class com.alibaba.android.arouter.routes.**{*;}
-keep public class com.alibaba.android.arouter.facade.**{*;}
-keep class * implements com.alibaba.android.arouter.facade.template.ISyringe{*;}

# 如果使用了 byType 的方式获取 Service，需添加下面规则，保护接口
-keep interface * implements com.alibaba.android.arouter.facade.template.IProvider

# 如果使用了 单类注入，即不定义接口实现 IProvider，需添加下面规则，保护实现
# -keep class * implements com.alibaba.android.arouter.facade.template.IProvider

在 Android Studio 插件市场中搜索 ARouter Helper, 或者直接下载文档上方最新版本中列出的 arouter-idea-plugin zip 安装包手动安装，安装后插件无任何设置，可以在跳转代码的行首找到一个图标 (navigation) 点击该图标，即可跳转到标识了代码中路径的目标类。

接下来，将会用一个 demo 介绍如何用 ARouter 进行模块化开发，demo 模块化的整体架构如下图所示。

每个模块的作用如下：

app：项目的宿主模块，仅仅是一个空壳，依赖于其他模块，成为项目架构的入口；

baselibrary：项目的基类库，每个子模块都依赖共享公用的类和资源，防止公用的功能在不同的模块中有多个实现方式；
module_route：集中管理所有模块的 route 的库；
module_main：闪屏页，登录页，主页等；
module_home：首页模块；
module_video：视频模块；
module_mine：我的模块；

使用模块化开发的一个好处是，各个独立的模块可以同时开发，独立运行而不必依赖于宿主 app，也就是每个 module 是一个独立的 App，项目发布的时候依赖到宿主 App 中即可。各业务模块之间不允许存在相互依赖关系，但是需要依赖基类库。
并且，单一模块生成的 apk 体积也小，编译时间也快，开发效率会高很多，同时也可以独立测试，要实现这样的效果需要对项目做一些配置。

在主项目的 gradle.properties 中需要设置一个开关，用来控制 module 的编译模式，例如：

isModule=false

当 isModule 为 false 时作为依赖库，只能以宿主 app 启动项目，选择运行模块时其他 module 前都是红色的 X，表示无法运行。

当 isModule 为 true 时，作为单独的模块进行运行，选择其中一个具体的 module 就可以直接运行。

为了完成依赖模式与独立模式的切换，module 清单文件需要配置两个，一个作为独立项目的清单文件，一个作为库的清单文件，以 module_main 模块为例。

buildApp 作为依赖库的清单文件，和独立项目的清单文件 buildModule 区别是依赖库的清单文件 Application 中没有配置入口的 Activity，其他都一样。

为了完成切换，还需要对 module 的 build.gradle 文件进行配置，如下图：

接下来，在宿主 app 的 build.gradle 中添加模块依赖，如下所示：

dependencies {if (!isModule.toBoolean()) {implementation project(':module_home')
        implementation project(':module_video')
        implementation project(':module_main')
        implementation project(':module_mine')
        implementation project(':module_router')
    }
}

错误：ARouter::Compiler >>> No module name, for more information, look at gradle log.
检查项目依赖的全部 module，包括 module 依赖的 module，为了能够进行单独的编译，所以需要为每一个 module 添加名称，即在每个 module 的 build.gradle 中加上下面的代码：

defaultConfig {
    
        javaCompileOptions {
            annotationProcessorOptions {arguments = [ AROUTER_MODULE_NAME : project.getName() ]
            }
        }
}

ARouter.getInstance().inject(this);
问题描述：有一个 singletask 启动模式的 activity，在 onNewIntent 方法中调用 ARouter.getInstance().inject(this); 得不到参数，查看 ARouter 在 build 过程中生成的代码可以知道它是调用了 activity 的 getIntent 来获取参数的，但是 onNewIntent 中的 intent 和在 onCreate 方法中的 intent 并不相同，所以需要在 onNewIntent 方法中调用 setIntent 方法，然后就能得到参数了。

ARouter there’s no route matched

不同 module 的一级路径必须不同，否则会导致一个 moudle 中的一级路径失效。

附：示例下载地址

使用ARouter进行Android模块化开发

Android 模块化

模块化的好处

需要解决的问题

ARouter 框架

基本用法

添加依赖和配置

添加注解

初始化 SDK

发起路由操作

拦截器

降级策略

混淆

ARouter Helper,

ARouter 模块化示例

依赖模式与独立模式的切换

gradle.properties 配置

module 清单文件

gradle 配置

宿主 app 配置

ARouter Helper

常见问题

问题 1

问题 2

问题 3

站内搜索