“终于懂了” 系列：组件化框架 ARouter 完全解析（一）原理详解

Original 胡飞洋胡飞洋

收录于合集

欢迎关注公众号~

前言

在我之前的组件化文章《“终于懂了” 系列：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    }

这个神奇的操作，我们将在第三篇文章做详细介绍，目前只需知道是在编译时进行扫描并动态在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技术的介绍将在本系列第三篇中详细介绍。

好了本篇就到这里，欢迎继续关注~

你的点赞、分享，是对我的巨大鼓励！
欢迎关注我的公众号 ，文章更新可第一时间收到；
如果有问题或者想进群，号内有加我微信的入口，我拉你进技术讨论群。在技术学习、个人成长的道路上，我们一起前进

“终于懂了” 系列：组件化框架 ARouter 完全解析（一） 原理详解

前言