“终于懂了” 系列：组件化框架 ARouter 完全解析（一） 原理详解
前言
在我之前的组件化文章《“终于懂了” 系列：Android组件化，全面掌握!》中，提到为了实现组件化要解决的几个问题点，其中 页面跳转、组件间通信 的问题是使用了 ARouter 这个框架来解决的。ARouter确实是专门用于做组件化改造，官方是这么介绍的：
一个用于帮助 Android App 进行组件化改造的框架 —— 支持模块间的路由、通信、解耦
关于组件化的知识已在上面文章中全面介绍了。那么是时候对 ARouter 这个强大的框架做一个解析了：它是如何做到 页面跳转、组件间通信 的？我们能从ARrouter中学到哪些东西？
而当时也确实承诺了有机会要写一篇ARouter的文章：
ARouter还有很多进阶用法，有机会我也针对ARouter写一篇全面分析
由于内容预计较多，分为三篇，分别介绍 ARouter的实现原理、框架使用到的相关通用技术：
“终于懂了” 系列：组件化框架 ARouter 完全解析（一）原理全解
“终于懂了” 系列：组件化框架 ARouter 完全解析（二）APT—帮助类生成
“终于懂了” 系列：组件化框架 ARouter 完全解析（二）AGP/Transform—动态代码注入
本篇就先梳理ARouter的实现原理，看看它是如何做到跨组件跳转页面、获取服务。
感谢继续关注和支持~
一、路由认知
ARouter从命名即可知，这是一个路由框架。那么路由是个啥呢？
路由（routing）就是通过互联的网络把信息从源地址传输到目的地址的活动。-- 百科
可见 路由 是个动词，这是网络传输中的概念，完成路由这个操作的实体设备就是 路由器（Router）。
另外，生活中的 信件邮寄 也可以理解为一个 路由过程：邮局把信件从邮寄方 传输到接收人的手上。首先 邮寄方 和 接收人 是无法接触的（无耦合依赖），只能通过 邮局这个第三方 完成邮寄；邮局根据信封上的地址，例如 “深圳市 深圳大学粤海校区”，决定分发到 开往深圳的车上，然后深圳的邮递员找到 深圳大学粤海校区 对应的 "南山区南海大道3688号”，最终找到接收人。
对应的， ARouter 也是个“路由器”，也是个“邮政系统”。通行根据组件化介绍的，ARouter 帮助 无相互依赖的组件间 进行跳转和通信。
抽象一下，邮局、ARouter 都是 路由系统 ——— 给 无依赖的双方 提供 通信和路由的能力。
官方文档（https://github.com/alibaba/ARouter） 有详细的引入和各种功能使用介绍，包括基础使用步骤、参数解析、拦截器、服务获取等进阶用法。这里不再搬运。
二、原理解析
使用ARouter在进行Activity跳转非常简单：初始化ARouter、添加注解@Route、发起路由。
1// 在module app中
2//1.初始化SDK
3ARouter.init(mApplication); // 尽可能早，推荐在Application中初始化
1// moduleA
2// 2.在支持路由的页面上添加注解(必选)
3// 路径注意至少需有两级，/xx/xx
4@Route(path = "/test/activity")
5public class YourActivity extend Activity {
6 ...
7}
1// moduleB（没有依赖 moduleA）
2// 3.发起路由跳转
3ARouter.getInstance().build("/test/activity").navigation();
这样就使得 没有依赖moduleA的moduleB能跳转到moduleA的Activity了。服务获取也是类似简单的代码就可实现。
那么 ARouter 是如何做到只通过简单2步 就完成 解耦组件间的路由操作呢？我们通过源码一步步理解。
2.1 构建PostCard
我们知道 想要跳转Activity最终必定是走到了 startActivity(intent)方法，而intent是一般需要目标Activity的Class。所以我们猜想 navigation()中应该是有寻找目标Activity的Class这一过程的。
下面就来跟踪源码分析这一过程。先看ARouter.getInstance()：
1public static ARouter getInstance() {
2 if (!hasInit) { // 未初始化则报异常
3 throw new InitException("ARouter::Init::Invoke init(context) first!");
4 } else {
5 if (instance == null) {
6 synchronized (ARouter.class) {
7 if (instance == null) {
8 instance = new ARouter();
9 }
10 }
11 }
12 return instance;
13 }
14}
获取ARouter单实例，没有初始化则报异常。再看它的build(string)方法：
1public Postcard build(String path) {
2 return _ARouter.getInstance().build(path);
3}
这里是调用了 _ARouter 的同名方法，返回了 Postcard（意为明信片）。ARouter实际是使用了外观模式（设计模式的一种），其所有方法都是调用了_ARouter的同名方法。进入_ARouter:
1protected Postcard build(String path) {
2 if (TextUtils.isEmpty(path)) { //path不能为空
3 throw new HandlerException(Consts.TAG + "Parameter is invalid!");
4 } else {
5 //path替换，这是预处理
6 PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
7 if (null != pService) {
8 path = pService.forString(path);
9 }
10 return build(path, extractGroup(path), true);
11 }
12}
这里对path做了空校验和预处理替换。如果想重写path，可以写一个PathReplaceService实现类。接着又走到重载方法：
1protected Postcard build(String path, String group, Boolean afterReplace) {
2 if (TextUtils.isEmpty(path) || TextUtils.isEmpty(group)) {
3 throw new HandlerException(Consts.TAG + "Parameter is invalid!");
4 } else {
5 ...
6 return new Postcard(path, group);
7 }
8}
其中参数group是通过extractGroup(path)获取，也就是path的第一级，即"/test/activity"中的"test"。group的作用是作为路由的默认分组。
路由中的分组概念:
SDK中针对所有的路径(/test/1、/test/2)进行分组，分组只有在分组中的某一个路径第一次被访问的时候，该分组才会被初始化
可以通过 @Route 注解主动指定分组，否则使用路径中第一段字符串(/*/)作为分组
注意：一旦主动指定分组之后，应用内路由需要使用 ARouter.getInstance().build(path, group) 进行跳转，手动指定分组，否则无法找到
@Route(path = "/test/1", group = "app")
最后返回创建的Postcard实例。Postcard是明信片的意思，承载了一次跳转/路由 需要的所有信息，它继承自路由元信息 RouteMeta：
1public final class Postcard extends RouteMeta {
2
3 // Base
4 private Uri uri; //使用Uri方式发起的路由
5 private Object tag; // A tag prepare for some thing wrong. inner params, DO NOT USE!
6 private Bundle mBundle; //启动activity的传入的Bundle
7 private int flags = 0; // 启动activity的Flags
8 private int timeout = 300; // 路由超时时间
9 private IProvider provider; // 如果是获取provider，就有值
10 private boolean greenChannel; //是绿色通道
11 private SerializationService serializationService;
12 private Context context; //context
13 private String action; //启动activity的action
14
15 // activity转场动画相关
16 private Bundle optionsCompat;
17 private int enterAnim = -1;
18 private int exitAnim = -1;
19
20 public Postcard(String path, String group) {
21 this(path, group, null, null);
22 }
23
24 public Postcard(String path, String group, Uri uri, Bundle bundle) {
25 setPath(path);
26 setGroup(group);
27 setUri(uri);
28 this.mBundle = (null == bundle ? new Bundle() : bundle);
29 }
30 ...
31}
1public class RouteMeta {
2 private RouteType type; // 路由类型；activity、service、fragment、IProvider等，编译时会根据被@Route注解的类的类型来设置
3 private Element rawType; // 路由原始类型，在编译时用来判断
4 private Class<?> destination; // 目的地：具体的 XxxActivity.class等
5 private String path; // Path
6 private String group; // Group
7 private int priority = -1; // 优先级，越小优先级越高
8 private int extra; // Extra
9 private Map<String, Integer> paramsType; // 参数类型，例如activity中使用@Autowired的参数类型
10 private String name; //路由名字，用于生成javadoc
11 private Map<String, Autowired> injectConfig; // 参数配置（对应paramsType）.
12}
Postcard：路由的信息。理解为是生活中的明信片。继承自RouteMeta。例如Postcard中的mBundle等则是 明信片上寄件人写的 “你好，xxx 节日快乐！” 这种文字内容。
RouteMeta：路由元信息，即基础信息。理解就是 明信片上的 收件人地址 这种必备的基础信息。明信片上可以没有文字内容，但想要被邮寄就必须有收件人地址。
2.2 路由过程
2.2.1 整体步骤
通过path构建了PostCard后调用了其navigation()方法，也就是开始了路由过程：
1public Object navigation() {
2 return navigation(null);
3}
4public Object navigation(Context context) {
5 return navigation(context, null);
6}
7public Object navigation(Context context, NavigationCallback callback) {
8 return ARouter.getInstance().navigation(context, this, -1, callback);
9}
看到连续走了两个重载方法，最后走到ARouter的navigation方法，并且把自己传了进去。ARouter的navigation方法同样会走到_ARouter的同名方法：
1 // @param context Activity or null.
2 // @param postcard Route metas
3 // @param requestCode RequestCode，startActivity的requestCode
4 // @param callback cb，路由回调：找到目的地、未找到、中断、到达
5protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
6 //若有PretreatmentService的实现，就进行预处理。可以在真正路由前进行一些判断然后中断路由。
7 PretreatmentService pretreatmentService = ARouter.getInstance().navigation(PretreatmentService.class);
8 if (null != pretreatmentService && !pretreatmentService.onPretreatment(context, postcard)) {
9 // 预处理返回false，路由取消.
10 return null;
11 }
12
13 // 给路由设置context，例如启动activity需要。如果没有传就使用mContext，即初始化ARouter时传入的Application
14 postcard.setContext(null == context ? mContext : context);
15
16 try {
17 // 1. 完善postcard信息（目前只有path、group，还需要知道具体目的地，例如要跳转到的activity信息）
18 LogisticsCenter.completion(postcard);
19 } catch (NoRouteFoundException ex) {
20 //这里就是debug包中，没找到路由目的地时 经常出现的提示
21 if (debuggable()) {
22 runInMainThread(new Runnable() {
23 public void run() {
24 Toast.makeText(mContext, "There's no route matched!\n" +" Path = [" + postcard.getPath() + "]\n" +
25 " Group = [" + postcard.getGroup() + "]", Toast.LENGTH_LONG).show();
26 }
27 });
28 }
29 //没找到的回调
30 if (null != callback) {
31 callback.onLost(postcard);
32 } else {
33 // 没有callback的话, （如果有）就回调到降低服务
34 DegradeService degradeService = ARouter.getInstance().navigation(DegradeService.class);
35 if (null != degradeService) {
36 degradeService.onLost(context, postcard);
37 }
38 }
39 return null;
40 }
41 //找到的回调
42 if (null != callback) {
43 callback.onFound(postcard);
44 }
45 // 2. 不是绿色通道的话，要先走拦截器
46 if (!postcard.isGreenChannel()) {
47 interceptorService.doInterceptions(postcard, new InterceptorCallback() {
48
49 //拦截器处理结果：继续路由
50 @Override
51 public void onContinue(Postcard postcard) {
52 // 3. 获取路由结果
53 _navigation(postcard, requestCode, callback);
54 }
55
56 //拦截器处理结果：中断路由，回调中断
57 @Override
58 public void onInterrupt(Throwable exception) {
59 if (null != callback) {
60 callback.onInterrupt(postcard);
61 }
62 }
63 });
64 } else {
65 //绿色通道，不走拦截器，就获取路由结果
66 return _navigation(postcard, requestCode, callback);
67 }
68
69 return null;
70}
`
使用前面构建好的PastCard经过整体3个步骤，就完成了路由：
完善postcard信息：只有path、group还不行，还需要知道具体目的地，例如要跳转到的Activity信息。
拦截器处理：不是绿色通道的话，要先经过路由器的处理，结果是中断或者继续。
获取路由结果：例如进行目标Activity的跳转、获取IProvider实现对象、获取Fragment等。
2.2.2 获取路由结果
先来看比较简单的最后一个步骤——路由结果获取过程，也就是_navigation()方法：
1private Object _navigation(final Postcard postcard, final int requestCode, final NavigationCallback callback) {
2 final Context currentContext = postcard.getContext();
3 //根据路由类型来走对应逻辑
4 switch (postcard.getType()) {
5 case ACTIVITY:
6 // Activity， 使用postcard.getDestination()来构建intent、传入Extras、设置 flags、action
7 final Intent intent = new Intent(currentContext, postcard.getDestination());
8 intent.putExtras(postcard.getExtras());
9 int flags = postcard.getFlags();
10 if (0 != flags) {
11 intent.setFlags(flags);
12 }
13 // 当前的context不是activity,需要添加flag:FLAG_ACTIVITY_NEW_TASK
14 //（启动startActivity需有任务栈的，application/service启动activity没有任务栈，所以必须要new_task_flag新建一个任务栈）
15 if (!(currentContext instanceof Activity)) {
16 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
17 }
18
19 String action = postcard.getAction();
20 if (!TextUtils.isEmpty(action)) {
21 intent.setAction(action);
22 }
23
24 // 最后在主线程执行 熟悉的startActivity，
25 runInMainThread(new Runnable() {
26 @Override
27 public void run() {
28 startActivity(requestCode, currentContext, intent, postcard, callback);
29 }
30 });
31 break;
32 case PROVIDER:
33 //provider，指的是想要获取的服务，即IProvider的实现类。直接从postCard中获取。
34 return postcard.getProvider();
35 case BOARDCAST:
36 case CONTENT_PROVIDER:
37 case FRAGMENT:
38 //Broadcast、ContentProvider、Fragment，都是使用postcard.getDestination()反射创建实例
39 Class<?> fragmentMeta = postcard.getDestination();
40 try {
41 Object instance = fragmentMeta.getConstructor().newInstance();
42 if (instance instanceof Fragment) {
43 ((Fragment) instance).setArguments(postcard.getExtras());
44 } else if (instance instanceof android.support.v4.app.Fragment) {
45 ((android.support.v4.app.Fragment) instance).setArguments(postcard.getExtras());
46 }
47 return instance;
48 } ...
49 }
50 return null;
51}
从上面可见，postcard 经过完善后，路由类型type、目的地destination等都已经被赋了值。destination就是目标类的class对象。
方法内容就是根据路由类型来走对应逻辑：
Activity， 使用postcard.getDestination()来构建intent、传入Extras、设置 flags、action，最后在主线程执行 熟悉的startActivity
provider，指的是想要获取的服务，即IProvider的实现类。是直接从postCard中获取的，因为服务类是单例，只会在首次获取时创建（）。
Broadcast、ContentProvider、Fragment，都是使用postcard.getDestination()反射创建实例
整体逻辑还是比较简单的。这里你可能好奇 destination的值是如何获取的，因为无论哪种类型的路由，都是要使用目标class，这个就是ARouter最为核心的内容——如何获取 无直接依赖的模块的 class对象，也就是完善postcard信息的过程。不过我们先来把拦截器逻辑分析完，最后再来看这个核心点。
2.2.3 拦截器
拦截器模式是开发中常用设计模式之一，路由中也可以设置拦截器，对路径进行判断决定是否需要中断。
未设置绿色通道的路由需要经过拦截器处理，也就是interceptorService的doInterceptions()方法。interceptorService是啥呢？
1final class ARouter {
2 ...
3 private static InterceptorService interceptorService;
4 ...
5 //ARouter的初始化方法
6 public static void init(Application application) {
7 if (!hasInit) {
8 logger = _ARouter.logger;
9 hasInit = _ARouter.init(application);
10 if (hasInit) {
11 _ARouter.afterInit();
12 }
13 }
14 }
15 ...
16}
1 //_ARouter.java
2 static void afterInit() {
3 interceptorService = (InterceptorService) ARouter.getInstance().build("/arouter/service/interceptor").navigation();
4 }
InterceptorService继承IProvider，可见interceptorService也是一个服务，在ARouter初始化后 获取，用于处理拦截器的逻辑。具体的实现类是InterceptorServiceImpl：
1@Route(path = "/arouter/service/interceptor")
2public class InterceptorServiceImpl implements InterceptorService {
3...
4 @Override
5 public void doInterceptions(final Postcard postcard, final InterceptorCallback callback) {
6 //有拦截器
7 if (MapUtils.isNotEmpty(Warehouse.interceptorsIndex)) {
8 ...
9 LogisticsCenter.executor.execute(new Runnable() { //放入线程池异步执行
10 @Override
11 public void run() { //interceptorCounter 用于保证所有拦截器都走完，并且设置了超时
12 CancelableCountDownLatch interceptorCounter = new CancelableCountDownLatch(Warehouse.interceptors.size());
13 try {//执行第一个拦截器，如果没有中断 则递归调用继续后面的拦截器
14 _execute(0, interceptorCounter, postcard);
15 interceptorCounter.await(postcard.getTimeout(), TimeUnit.SECONDS);
16 if (interceptorCounter.getCount() > 0) { // count>0说明超时了，拦截器还没处理完.
17 callback.onInterrupt(new HandlerException("The interceptor processing timed out."));
18 } else if (null != postcard.getTag()) { //Tag!=null说明被某个拦截器回调中断了
19 callback.onInterrupt((Throwable) postcard.getTag());
20 } else {
21 callback.onContinue(postcard); // 所有拦截器处理完、没超时、也没异常，则继续路由
22 }
23 }...
24 }
25 });
26 } else {
27 //没有拦截器则继续路由
28 callback.onContinue(postcard);
29 }
30 }
31
32 private static void _execute(final int index, final CancelableCountDownLatch counter, final Postcard postcard) {
33 if (index < Warehouse.interceptors.size()) {
34 //从Warehouse.interceptors中获取第index个拦截器，走process方法，如果回调到onContinue就继续下一个；
35 IInterceptor iInterceptor = Warehouse.interceptors.get(index);
36 iInterceptor.process(postcard, new InterceptorCallback() {
37 @Override
38 public void onContinue(Postcard postcard) {
39 counter.countDown();
40 _execute(index + 1, counter, postcard); // 继续下一个
41 }
42 @Override
43 public void onInterrupt(Throwable exception) {
44 postcard.setTag(null == exception ? new HandlerException("No message.") : exception); // save the exception message for backup.
45 counter.cancel();
46 ...
47 }
48 });
49 }
50 }
51
52 @Override //此init方法会在服务被创建后调用。这里就是反射创建所有的拦截器实例
53 public void init(final Context context) {
54 LogisticsCenter.executor.execute(new Runnable() {
55 @Override
56 public void run() {
57 if (MapUtils.isNotEmpty(Warehouse.interceptorsIndex)) {
58 //遍历Warehouse.interceptorsIndex ，使用存储与其中的拦截器class对象反射创建拦截器实例
59 for (Map.Entry<Integer, Class<? extends IInterceptor>> entry : Warehouse.interceptorsIndex.entrySet()) {
60 Class<? extends IInterceptor> interceptorClass = entry.getValue();
61 try {
62 IInterceptor iInterceptor = interceptorClass.getConstructor().newInstance();
63 iInterceptor.init(context);
64 //存入 Warehouse.interceptors
65 Warehouse.interceptors.add(iInterceptor);
66 }...
67 }
68 interceptorHasInit = true;
69 ...
70 }
71 }
72 });
73 }...
74}
doInterceptions()方法中判断如果有拦截器，就放入线程池异步执行第一个拦截器，且使用interceptorCounter 保证所有拦截器都走完，同时也设置了超时。如果第一个拦截器没有回调中断 则递归调用继续后面的拦截器。
拦截器的执行，是从Warehouse.interceptors中获取第index个拦截器，走process方法，如果回调到onContinue就继续下一个；若回调onInterrupt就中断路由。
拦截器的执行逻辑还是比较清晰的。那么拦截器是怎么获取的呢？我们来看下InterceptorServiceImpl的init方法：init()方法会在服务被创建后立即调用，如上所示就是遍历Warehouse.interceptorsIndex ，使用存储在其中的拦截器class对象 反射创建拦截器实例，然后存在存入 Warehouse.interceptors。也即是说，ARouter初始化完成后就获取到了所有拦截器实例。
那么Warehouse又是啥呢？interceptorsIndex是如何存储的所有拦截器的class的？
2.2.4 路由元信息的收集
Warehouse意为仓库，用于存放被 @Route、@Interceptor注释的 路由相关的信息，也就是我们关注的destination等信息。既然是仓库，那么就是有存有取
前面举的例子：moduleB发起路由跳转到moduleA的activity，moduleB没有依赖moduleA，只是在moduleA的activity上增加了@Route注解。由于进行activity跳转需要目标Activity的class对象来构建intent，所以必须有一个中间人，把路径"/test/activity"翻译成Activity的class对象，然后moduleB才能实现跳转。（因此在ARouter的使用中 moduleA、moduleB 都是需要依赖 arouter-api的）
这个中间人那就是ARouter了，而这个翻译工作用到的词典就是 Warehouse，它存着所有路由信息
1class Warehouse {
2 //所有IRouteGroup实现类的class对象，是在ARouter初始化中赋值，key是path第一级
3 //（IRouteGroup实现类是编译时生成，代表一个组，即path第一级相同的所有路由，包括Activity和Provider服务）
4 static Map<String, Class<? extends IRouteGroup>> groupsIndex = new HashMap<>();
5 //所有路由元信息，是在completion中赋值，key是path
6 //首次进行某个路由时就会加载整个group的路由，即IRouteGroup实现类中所有路由信息。包括Activity和Provider服务
7 static Map<String, RouteMeta> routes = new HashMap<>();
8
9 //所有服务provider实例，在completion中赋值，key是IProvider实现类的class
10 static Map<Class, IProvider> providers = new HashMap<>();
11 //所有provider服务的元信息(实现类的class对象)，是在ARouter初始化中赋值，key是IProvider实现类的全类名。
12 //主要用于使用IProvider实现类的class发起的获取服务的路由，例如ARouter.getInstance().navigation(HelloService.class)
13 static Map<String, RouteMeta> providersIndex = new HashMap<>();
14
15 //所有拦截器实现类的class对象，是在ARouter初始化时收集到，key是优先级
16 static Map<Integer, Class<? extends IInterceptor>> interceptorsIndex = new UniqueKeyTreeMap<>("...");
17 //所有拦截器实例，是在ARouter初始化完成后立即创建
18 static List<IInterceptor> interceptors = new ArrayList<>();
19...
20}
Warehouse存了哪些信息呢？
groupsIndex，所有路由组元信息。是所有IRouteGroup实现类的class对象，是在ARouter初始化中赋值，key是path第一级。IRouteGroup实现类是编译时生成，代表一个组，即path第一级相同的所有路由，包括Activity和Provider服务）。
routes，所有路由元信息。是在LogisticsCenter.completion中赋值，key是path。首次进行某个路由时就会加载整个group的路由，即IRouteGroup实现类中所有路由信息。包括Activity和Provider服务
providers，所有服务provider实例。在LogisticsCenter.completion中赋值，key是IProvider实现类的class
providersIndex，所有provider服务元信息(实现类的class对象)。是在ARouter初始化中赋值，key是IProvider实现类的全类名。用于使用IProvider实现类class发起的获取服务的路由，例如ARouter.getInstance().navigation(HelloService.class)
interceptorsIndex，所有拦截器实现类class对象。是在ARouter初始化时收集到，key是优先级
interceptors，所有拦截器实例。是在ARouter初始化完成后立即创建
其中groupsIndex、providersIndex、interceptorsIndex是ARouter初始化时就准备好的基础信息，为业务中随时发起路由操作（Activity跳转、服务获取、拦截器处理）做好准备。
那么Warehouse的信息是如何收集到的呢？ 下面就先来看下ARouter初始化具体做了哪些事情：
1final class _ARouter {
2 ...
3 protected static synchronized boolean init(Application application) {
4 mContext = application;
5 LogisticsCenter.init(mContext, executor);
6 ...
7 return true;
8 }
_ARouter的init方法中 调用了LogisticsCenter的init方法。LogisticsCenter意为物流中心，上面提到的完善postcard的completion操作也是此类提供。
1//LogisticsCenter.java
2//LogisticsCenter初始化，加载所有的路由元信息
3public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {...
4 try {
5 long startInit = System.currentTimeMillis();
6 //先尝试使用AGP transform 收集 根帮助类 后 写好的注入代码（要先引入插件才行 apply plugin: 'com.alibaba.arouter'）
7 loadRouterMap();
8 if (registerByPlugin) {
9 //registerByPlugin为true说明使用AGP加载ok了（通常都会用AGP，即registerByPlugin为true）
10 logger.info(TAG, "Load router map by arouter-auto-register plugin.");
11 } else {
12 //若没有使用 AGP transform，就用ClassUtils.getFileNameByPackageName来搜集dex中ROUTE_ROOT_PAKCAGE包下的所有类，即编译时生成的所有帮助类
13 //这样的话，就是运行时 遍历搜集 会比较耗时，也就是init会较为耗时；而AGP transform 是在编译时完成收集的。
14 //当前app是新安装时才会走（收集到的帮助类会缓存到SP文件）
15 Set<String> routerMap;
16 if (ARouter.debuggable() || PackageUtils.isNewVersion(context)) {
17 logger.info(TAG, "Run with debug mode or new install, rebuild router map.");
18 // 这写帮助类是在编译时由arouter-compiler生成
19 routerMap = ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE);
20 if (!routerMap.isEmpty()) {
21 context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).edit().putStringSet(AROUTER_SP_KEY_MAP, routerMap).apply();
22 }
23 PackageUtils.updateVersion(context);
24 } else {
25 //不是新安装的版本，就从SP文件中读取
26 routerMap = new HashSet<>(context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).getStringSet(AROUTER_SP_KEY_MAP, new HashSet<String>()));
27 }...
28 //遍历帮助类，区分是哪种帮助类，然后反射创建帮助类实例后，调用其loadInto方法来填充Warehouse相应的Map
29 for (String className : routerMap) {
30 if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) {
31 //类名开头：com.alibaba.android.arouter.routes.ARouter$$Root
32 //填充Warehouse.groupsIndex，即所有IRouteGroup实现类的class对象
33 ((IRouteRoot) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex);
34 } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_INTERCEPTORS)) {
35 //类名开头：com.alibaba.android.arouter.routes.ARouter$$Interceptors
36 //填充Warehouse.interceptorsIndex，即所有IInterceptor实现类的class对象
37 ((IInterceptorGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.interceptorsIndex);
38 } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_PROVIDERS)) {
39 //类名开头：com.alibaba.android.arouter.routes.ARouter$$Providers
40 //填充Warehouse.providersIndex，即所有provider的RouteMeta
41 ((IProviderGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.providersIndex);
42 }
43 }
44 }...
45 }
46}
LogisticsCenter初始化 就是加载所有的路由元信息的过程，有两种方式：
走loadRouterMap()方法：直接使用在编译时收集好的帮助类信息，然后反射创建帮助类实例后，调用其loadInto方法来填充Warehouse相应的Map。这需要开发者要先引入插件才行 apply plugin: 'com.alibaba.arouter'。如果加载成功，registerByPlugin这个值就为true，否则false。
若第一步没有加载成功，即registerByPlugin为false：就会使用ClassUtils.getFileNameByPackageName在运行时搜集dex中"com.alibaba.android.arouter.routes"包下的所有类(即帮助类)，然后遍历，区分是哪种帮助类。接着反射创建帮助类实例后，调用其loadInto方法来填充Warehouse相应的Map。
两种方式对比：
相同点：都是使用帮助类信息反射创建帮助类实例后，调用其loadInto方法来填充Warehouse相应的Map。
不同点：在于帮助类信息的收集方式。前者是在编译时搜集就完毕了，后者是运行时。
一般都是使用第一种，因为运行时遍历dex搜集会比较耗时，而第一种在编译时已经收集好了。第一种方式的loadRouterMap()方法的实现逻辑 我们稍后再看。
先看两个问题：
上面提到的帮助类是个啥？ 如何使用帮助类填充Warehouse的？
为啥帮助类还要收集？还分 编译时收集、运行时收集？
2.2.4.1 拦截器元信息
我们先来看拦截器元信息(拦截器class信息)是如何通过帮助类填充的：
上图是ARouter工程编译后module-java的build目录，ARouter$$ 开头的这些类都是在ARouter在编译过程中生成，它们就是所谓的帮助类：
ARouter$$Interceptors$$modulejava 这个类就是一个帮助类，帮助WareHouse填充WareHouse.interceptorsIndex。它实现接口IInterceptorGroup，loadInfo方法接受一个Map<Integer, Class<? extends IInterceptor>>，也就是WareHouse.interceptorsIndex的类型。loadInfo方法体内，是用接收的map来put当前module所有拦截器的class，即使用 @Interceptor 注解并实现 IInterceptor 接口的类。
在上面LogisticsCenter的init方法中第二种加载方式中看到，确实是遍历收集到的帮助类，然后使用类名判断是 ARouter$$Interceptors$$modulejava，接着就调用loadInfo方法，这就实现了对WareHouse.interceptorsIndex的赋值。也就是说，有了ARouter$$Interceptors$$modulejava ，我们就能在ARouter初始化时对WareHouse.interceptorsIndex进行赋值，就为创建所有拦截器实例做好了准备。
那么到这里，关于拦截器还有一个问题，ARouter$$Interceptors$$modulejava的loadInfo方法中 拦截器实现类class是如何获取的呢？—— 当然是编译时对注解 @Interceptor 的解析，解析过程将在下篇中介绍。
拦截器帮助类我们看完了，再来看看其他三种帮助类。
2.2.4.2 路由组元信息
路由组元信息的收集是通过 —— ARouter$$Root$$xxx —— 根帮助类：即用来帮助对 WareHouse.groupsIndex 赋值。这样就会把path第一级相同的所以路由分到同一个组中。一个module对应一个根帮助类。xxx是module名，就是在build.gradle中配置的 AROUTER_MODULE_NAME 。
如上图，ARouter$$Root$$modulejava 就是根帮助类，帮助WareHouse填充Warehouse.groupsIndex。实现自IRouteRoot接口，loadInfo方法接受一个Map<String, Class<? extends IRouteGroup>>，也就是WareHouse.groupsIndex 的类型。loadInfo方法体内，是用接收的map来put当前module所有路由组帮助类的class 。
在上面LogisticsCenter的init方法中同样 对遍历收集到的帮助类判断类名，接着就调用loadInfo方法，这就实现了对WareHouse.groupsIndex 的赋值。
根帮助类，目的就是对路由进行分组，分组的好处是避免一次性加载所有路由，减少反射耗时和内存占用的性能问题。
根帮助类也是在编译时生成，具体生成过程将在下篇中介绍。
2.2.4.3 路由元信息
路由元信息的收集是通过 —— ARouter$$Group$$xxx —— 组帮助类：即用来帮助对 WareHouse.routes 赋值。也就是把同组的路由put到WareHouse.routes。一个module可能有多个组，即对应有多个根帮助类，xxx是组名，即path第一级。
如上图，ARouter$$Group$$test 就是组帮助类，帮助WareHouse填充Warehouse.routes。实现自IRouteGroup接口，loadInfo方法接受一个Map<String, RouteMeta>，也就是WareHouse.routes 的类型。loadInfo方法体内，是用接收的map来put 当前组 的所有路由元信息 。其中最重要的就是 每个路由的目标类class。
在上面LogisticsCenter的init方法中 没有看到对组帮助类的处理。ARouter的设计是：在使用时才进行加载，即首次使用某个组的路由时，才会使用组帮助类对 WareHouse.routes 进行填充。
组帮助类，目的就是 首次使用时 一次性加载本组所有路由元信息。这比较符合实际使用场景：一般同组的路由都是同业务的内容，当前用户进入此业务时，就把本组路由元信息准备好，是比较合理的。
组帮助类也是在编译时生成。
2.2.4.4 provider元信息
provider元信息 其实在上面 路由元信息 中已经包含了，为啥还要单独拎出来呢？我们回头看下 _ARouter的navigation方法：
1protected <T> T navigation(Class<? extends T> service) {
2 Postcard postcard = LogisticsCenter.buildProvider(service.getName());
3 if (null == postcard) {
4 postcard = LogisticsCenter.buildProvider(service.getSimpleName());
5 }
6 if (null == postcard) {
7 return null;
8 }
9 postcard.setContext(mContext);
10 LogisticsCenter.completion(postcard);
11 return (T) postcard.getProvider();
12 ...
13}
14
15protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
16 ...
17}
前面介绍了4个参数的方法，而上面这个传服务class的重载方法 就是单独给获取provider服务使用的。看到通过LogisticsCenter使用服务类name获取到了PostCard，然后经过完善PostCard，直接获取provider服务。
1//LogisticsCenter.java
2public static Postcard buildProvider(String serviceName) {
3 RouteMeta meta = Warehouse.providersIndex.get(serviceName);
4 if (null == meta) {
5 return null;
6 } else {
7 return new Postcard(meta.getPath(), meta.getGroup());
8 }
9}
其中Postcard其实就是从 Warehouse.providersIndex 中获取到的RouteMeta后构建的。而Warehouse.providersIndex的赋值就是通过 ——ARouter$$Providers$$xxx —— Provider帮助类：
帮助类可能在其他文章中叫路由表，之前想叫做代理类，但觉得帮助类更合适，它们就是用来帮助填充WareHouse中的元数据的。
2.2.5 AGP方式加载路由
我们来看下路由信息收集的第一种方式，这是一般都会使用到的方式，也就是loadRouterMap()方法：
1public class LogisticsCenter {
2 private static boolean registerByPlugin;
3
4 private static void loadRouterMap() {
5 registerByPlugin = false;
6 //主动注册插件 会在此处插入代码。调用此方法就注册了全部的 Routers、Interceptors、Provider
7
8 }
9 ...
你会惊奇地发现，loadRouterMap()竟然只有一行代码？！
反编译 ARouter demo APK后，查看LogisticsCenter：
看到编译后的loadRouterMap()方法，多了几行register()方法的调用，而参数就是 所有的根帮助类、拦截器帮助类、provider帮助类。
1//LogisticsCenter.java
2...
3 private static void register(String className) {
4 if (!TextUtils.isEmpty(className)) {
5 try {
6 Class<?> clazz = Class.forName(className);
7 Object obj = clazz.getConstructor().newInstance();
8 if (obj instanceof IRouteRoot) {
9 registerRouteRoot((IRouteRoot) obj);
10 } else if (obj instanceof IProviderGroup) {
11 registerProvider((IProviderGroup) obj);
12 } else if (obj instanceof IInterceptorGroup) {
13 registerInterceptor((IInterceptorGroup) obj);
14 } ...
15 } ...
16 }
17 }
18 private static void registerRouteRoot(IRouteRoot routeRoot) {
19 markRegisteredByPlugin();
20 if (routeRoot != null) {
21 routeRoot.loadInto(Warehouse.groupsIndex);
22 }
23 }
24 private static void registerInterceptor(IInterceptorGroup interceptorGroup) {
25 markRegisteredByPlugin();
26 if (interceptorGroup != null) {
27 interceptorGroup.loadInto(Warehouse.interceptorsIndex);
28 }
29 }
30 private static void registerProvider(IProviderGroup providerGroup) {
31 markRegisteredByPlugin();
32 if (providerGroup != null) {
33 providerGroup.loadInto(Warehouse.providersIndex);
34 }
35 }
36 private static void markRegisteredByPlugin() {
37 if (!registerByPlugin) {
38 registerByPlugin = true; //标记通过AGP加载成功了
39 }
40 }
register()方法很简单，就是反射创建帮助类实例，调用loadInto方法对Warehouse进行填充，和第二种路由信息收集方式的是一致的。而第二种是在运行时遍历dex才找到的帮助类，在第一种方式就神奇的直接出现了？
这个神奇的操作，我们将在第三篇文章做详细介绍，目前只需知道是在编译时进行扫描并动态在loadRouterMap()中插入代码就可以了。
2.2.3 路由信息的完善
上面兜了一大圈，从路由整体过程、获取路由结果、拦截器、路由信息记载，到各个帮助类的介绍，也即是说 我们了解了 路由的发起、路由整体过程、路由结果获取，以及路由元信息的加载，那么现在就来看看路由元信息是如何使用的。
1//LogisticsCenter.java
2public synchronized static void completion(Postcard postcard) {
3 //完善postcard信息（目前只有path、group，还需要知道具体目的地，例如要跳转到的activity信息）
4 RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath());
5 if (null == routeMeta) {
6 //没有从Warehouse.routes获取到：要么不存在、要么还没有加载本组路由
7 //先看路由仓库中是否有这个组帮助类，没就异常。（仓库里的已有 组帮助类 是谁放进仓库的呢？就是 在 ARouter.init中调用 LogisticsCenter.init的时候。它里面的 loadRouterMap() 中执行代码是 transform时收集到的 APT 生成 根帮助类 的load方法。）
8 if (!Warehouse.groupsIndex.containsKey(postcard.getGroup())) {
9 throw new NoRouteFoundException(TAG + "There is no route match the path [" + postcard.getPath() + "], in group [" + postcard.getGroup() + "]");
10 } else {
11 try {
12 //这里，仓库中有这个组的帮助类，那么就可以 加载 这个组的所有路由 到内存
13 addRouteGroupDynamic(postcard.getGroup(), null);
14 } catch (Exception e) {
15 throw new HandlerException(TAG + "Fatal exception when loading group meta. [" + e.getMessage() + "]");
16 }
17 //仓库有了这个组的路由信息，再重新完善
18 completion(postcard);
19 }
20 } else {
21 //有路由信息，就完善postcard
22 postcard.setDestination(routeMeta.getDestination());
23 postcard.setType(routeMeta.getType());
24 postcard.setPriority(routeMeta.getPriority());
25 postcard.setExtra(routeMeta.getExtra());
26 ...
27 switch (routeMeta.getType()) {
28 case PROVIDER: //provider, 获取实例
29 // 要实现自IProvider
30 Class<? extends IProvider> providerMeta = (Class<? extends IProvider>) routeMeta.getDestination();
31 IProvider instance = Warehouse.providers.get(providerMeta);
32 if (null == instance) { // 没有，就反射创建
33 IProvider provider;
34 try {
35 provider = providerMeta.getConstructor().newInstance();
36 provider.init(mContext);
37 Warehouse.providers.put(providerMeta, provider); //实例存入仓库
38 instance = provider;
39 } catch (Exception e) {...
40 }
41 }
42 postcard.setProvider(instance); //实例通过PostCard带出去
43 postcard.greenChannel(); // Provider 不用经过拦截器
44 break;
45 case FRAGMENT:
46 postcard.greenChannel(); // Fragment 不用经过拦截器
47 }
48 }
49}
50
51
52public synchronized static void addRouteGroupDynamic(String groupName, IRouteGroup group) {
53 if (Warehouse.groupsIndex.containsKey(groupName)){//这里，仓库中 有这个组的帮助类
54 //拿到这个 组帮助类，实例化，调loadInfo 把 这个组所有的路由信息加载 到 仓库中的routes。
55 Warehouse.groupsIndex.get(groupName).getConstructor().newInstance().loadInto(Warehouse.routes);
56 Warehouse.groupsIndex.remove(groupName);
57 }...
58}
尝试通过path从仓库中获取对应的路由元信息，如果没有获取到：要么不存在、要么还没有加载本组路由。
先看路由仓库中是否有这个组帮助类，没就抛出异常；有就通过addRouteGroupDynamic()加载这个组的所有路由，然后再调completion
有了path对应的路由元信息，就同步到postCard中，其中最重要的就是 目标类class——routeMeta.getDestination()。并且判断如是provider就创建服务实例并存入仓库。
好了，到这里，我们终于可以解答最开始提出的问题了：ARouter最为核心的内容——如何获取 无直接依赖的模块的 class对象 ：
编译时ARouter根据注解 @Route 生成了各个帮助类，帮助类的loadInfo方法中包含了路由目标信息，最重要的是注解的类class，然后在ARouter初始化时根据 根帮助类、provider帮助类、拦截器帮助类 对仓库WareHouse的groupsIndex进行赋值（以及providersIndex、interceptorsIndex），然后在路由发起后，根据path通过WareHouse的groupsIndex 加载 同组的所有路由元信息，也就是拿到了目标class。
抽象一下就是：moduleA先把目标class存入第三方仓库——ARouter的WareHouse，然后muduleB发起路由时从仓库中根据path获取目标class，ARouter就是这个仓库的管理者。就好比 邮政是信件的管理者，它是两方通信者的中间人。
2.3 流程图
以上分析内容梳理成流程图：
三、总结
我们从路由发起开始，介绍了整个路由详细过程：moduelA通过中间人ARouter把路由信息存到仓库WareHouse；moduleB发起路由时，再通过中间人ARouter从仓库WareHouse取出路由信息，这就实现了没有依赖的两者之间的跳转与通信。其中涉及Activity的跳转、服务provider的获取、拦截器的处理等。
需要重点理解的是：路由框架的整体思路，通过中间人ARouter使用WareHouse加载和获取路由信息；路由信息加载实现原理，各帮助类作用和路由完善过程。
其中ARouter在编译时生成的帮助类，是用于对所有使用@Route、@Interceptor注解的类信息的分组和收集，编译运行时对路由信息仓库Warehouse的填充和使用。这里涉及到的是Annotation Process Tool（APT）技术，即注解处理工具。
如何使用编译时生成的帮助类呢？除了运行时查找dex，还可以在编译时扫描帮助类信息，并且直接在物流中心LogisticsCenter loadRouterMap()方法中直接插入使用帮助类的代码，这里涉及 Android Gradle Plugin（AGP）技术，即Android的gradle插件相关技术。
ARouter如何在编译时解析注解、如何生成帮助类以及对APT技术的介绍将在本系列第二篇中详细介绍。
ARouter如何在编译时扫描目标帮助类、如何注入代码以及对AGP技术的介绍将在本系列第三篇中详细介绍。
好了本篇就到这里，欢迎继续关注~
你的 点赞、分享，是对我的巨大鼓励！
欢迎关注我的公众号 ，文章更新可第一时间收到；
如果有问题或者想进群，号内有加我微信的入口，我拉你进技术讨论群。在技术学习、个人成长的道路上，我们一起前进
推荐阅读:
网络请求框架OkHttp3全解系列 - （二）OkHttp的工作流程分析
“终于懂了” 系列：Android屏幕刷新机制—VSync、Choreographer 全面理解！