【ARouter】初始化过程分析

最新推荐文章于 2024-08-07 09:14:43 发布
最新推荐文章于 2024-08-07 09:14:43 发布
阅读量2.2k 收藏 1
点赞数 3
分类专栏： Android 源码学习 文章标签： ARouter ARputer初始化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011494285/article/details/84592885
版权

本篇主要介绍 ARouter 的初始化过程。
Arouter系列:
【ARouter】接入笔记
【ARouter】初始化过程分析
【ARouter】跳转 Activity 过程分析

文章目录

初始化

一般建议在应用打开时的初始化过程即在 application 中进行初始化工作。同时如果是在开发的情况下最好打开 log 和 debug 开关。

        if (BuildConfig.DEBUG) {
            ARouter.openLog()
            ARouter.openDebug()
        }
        ARouter.init(this)

ARouter.init(this) 是一个单例。它把初始化以及初始化后的工作都交给了 _ARouter 来做。

    // class ARouter
    public static void init(Application application) {
        if (!hasInit) {
            logger = _ARouter.logger;
            hasInit = _ARouter.init(application);
            if (hasInit) {
                _ARouter.afterInit();
            }
        }
    }
    // class _ARouter
    protected static synchronized boolean init(Application application) {
        mContext = application;
        LogisticsCenter.init(mContext, executor);
        hasInit = true;
        mHandler = new Handler(Looper.getMainLooper());
        return true;
    }

在 _ARouter.init 把初始化工作交给了 LogisticsCenter.init 来做，同时自己初始化了一个 handler。

LogisticsCenter.init

在 ARouter 中 LogisticsCenter 是一个很关键的类，几乎所有的工作最终都是由它来做。

其中 init 方法是扫描所有路由的映射关系，并将它们保存到内存中来。下面是它的部分关键代码：

    public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {
        try {
            ...
            if (registerByPlugin) { // 一般这里就是 false ，除非是使用 ARouter 提供的插件自动设置路由的。
                logger.info(TAG, "Load router map by arouter-auto-register plugin.");
            } else {
                Set<String> routerMap;

                // 如果是 debug 或者升级了新版本，则扫描路由
                // 这也是为什么我们要在开发状态下打开 debug 开关的原因
                if (ARouter.debuggable() || PackageUtils.isNewVersion(context)) {
                    // 1、扫描 dex 包，找出所有路由
                    routerMap = ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE);
                    if (!routerMap.isEmpty()) {
                        // 缓存路由
                        context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).edit().putStringSet(AROUTER_SP_KEY_MAP, routerMap).apply();
                    }
                    // 保存版本
                    PackageUtils.updateVersion(context);  
                } else {
                    // 从缓存中读取
                    routerMap = new HashSet<>(context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).getStringSet(AROUTER_SP_KEY_MAP, new HashSet<String>()));
                }

                    //2、循环遍历加载路由或者拦截器以及 provider 信息
                for (String className : routerMap) {
            
                    if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) {
                        //com.alibaba.android.arouter.routes.ARouter.$$Root
                        // 将路由信息保存到内存中，
                        ((IRouteRoot) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex);
                    } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_INTERCEPTORS)) {
                        //com.alibaba.android.arouter.routes.ARouter.$$Interceptors
                        // 将拦截器保存到内存中
                        ((IInterceptorGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.interceptorsIndex);
                    } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_PROVIDERS)) {
                        //com.alibaba.android.arouter.routes.ARouter.$$Providers
                        // 将 provider 保存到内存中
                        ((IProviderGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.providersIndex);
                    }
                }
            }
        } catch (Exception e) {
            throw new HandlerException(TAG + "ARouter init logistics center exception! [" + e.getMessage() + "]");
        }
    }

上面代码可以看到主要有两个关键步骤：

  • 扫描所有的路由
  • 通过循环遍历加载路由或者拦截器以及 provider 信息

扫描理由表

ARouter 通过 ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE); 方法来扫描路由信息，进入这个方法看一下：

//packageName ===> com.alibaba.android.arouter.routes
//通过指定包名，扫描包下面包含的所有的ClassName
public static Set<String> getFileNameByPackageName(Context context, final String packageName) throws PackageManager.NameNotFoundException, IOException, InterruptedException {
        final Set<String> classNames = new HashSet<>();
        // 扫描所有 dex 包，获取所有包的路径
        List<String> paths = getSourcePaths(context);
        // 通过 CountDownLatch 来完成线程同步工作。
        //CountDownLatch 类似于计数器，在它结束之前会一直等待所有程序执行完
        final CountDownLatch parserCtl = new CountDownLatch(paths.size());

        for (final String path : paths) {
            // 通过线程池把扫描的工作放在子线程中执行
            DefaultPoolExecutor.getInstance().execute(new Runnable() {
                @Override
                public void run() {
                    DexFile dexfile = null;
                    try {
                        // 获取 dex 文件
                        if (path.endsWith(EXTRACTED_SUFFIX)) {
                            dexfile = DexFile.loadDex(path, path + ".tmp", 0);
                        } else {
                            dexfile = new DexFile(path);
                        }

                        Enumeration<String> dexEntries = dexfile.entries();
                        while (dexEntries.hasMoreElements()) {
                            String className = dexEntries.nextElement();
                            // 取到所有符合包名的类，并存放到一个集合中
                            if (className.startsWith(packageName)) {
                                classNames.add(className);
                            }
                        }
                    }
                    ...
                }
            });
        }
        ...
        return classNames;
    }

根据以上代码可以知道，它做的工作就是找到所有 dex 包，并从 dex 包中扫描出符合 arouter 包名的类，添加到集合当中并返回。

将扫描出来的路由信息保存到内存中

根据上面把所有 ARouter 的类扫描出来以后，就遍历这些类，并将必要的信息保存到内存中：

    for (String className : routerMap) {     
        if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) {
            //com.alibaba.android.arouter.routes.ARouter.$$Root
            // 将路由信息保存到内存中，
            ((IRouteRoot) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex);
        } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_INTERCEPTORS)) {
            //com.alibaba.android.arouter.routes.ARouter.$$Interceptors
            // 将拦截器保存到内存中
            ((IInterceptorGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.interceptorsIndex);
        } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_PROVIDERS)) {
            //com.alibaba.android.arouter.routes.ARouter.$$Providers
            // 将 provider 保存到内存中
            ((IProviderGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.providersIndex);
        }
    }

根据上面的代码可以得知，通过循环便利找到了一些类，然后通过反射的方式调用了他们的 loadInto 方法，这些类分别是：

  • com.alibaba.android.arouter.routes.ARouter.$$Root.xxx
  • com.alibaba.android.arouter.routes.ARouter.$$Interceptors.xxx
  • com.alibaba.android.arouter.routes.ARouter.$$Providers.xxx

以上那些类都是通过注解在编译过程中自动生成的，其中 xxx 是在 gradle 中配置的 module 名。这些类在工程编译完以后能在 build/generated/source/apt 或 kapt/debug/包名/routes 下找到。而他们的信息都保存到了 Warehouse 中，这个类里面都是一些静态的map，用以全局的维持路由信息。以主工程为例：

ARouter.$$Root.xxx

ARouter.$$Root 的作用是将 组名—当前组路由表 保存到一个 map 中。

public class ARouter$$Root$$app implements IRouteRoot {
  @Override
  public void loadInto(Map<String, Class<? extends IRouteGroup>> routes) {
    routes.put("test", ARouter$$Group$$test.class);
    routes.put("yourservicegroupname", ARouter$$Group$$yourservicegroupname.class);
  }
}

其中 ARouter$$Group$$test 等类的结构如下，他们保存了一组(test组)的所有路由映射信息：

public class ARouter$$Group$$test implements IRouteGroup {
  @Override
  public void loadInto(Map<String, RouteMeta> atlas) {
    atlas.put("/test/activity1", RouteMeta.build(RouteType.ACTIVITY, Test1Activity.class, "/test/activity1", "test", new java.util.HashMap<String, Integer>(){{put("ser", 9); put("ch", 5); put("fl", 6); put("dou", 7); put("boy", 0); put("url", 8); put("pac", 10); put("obj", 11); put("name", 8); put("objList", 11); put("map", 11); put("age", 3); put("height", 3); }}, -1, -2147483648));
    atlas.put("/test/activity2", RouteMeta.build(RouteType.ACTIVITY, Test2Activity.class, "/test/activity2", "test", new java.util.HashMap<String, Integer>(){{put("key1", 8); }}, -1, -2147483648));
  }
}

其实在这里就能大概知道为什么说 ARouter 加载路由的时候是按组加载的。

ARouter.$$Interceptors.xxx

ARouter.$$Interceptors 是直接将具体的拦截器类按照优先级为 key 保存到了内存中。

public class ARouter$$Interceptors$$app implements IInterceptorGroup {
  @Override
  public void loadInto(Map<Integer, Class<? extends IInterceptor>> interceptors) {
    interceptors.put(7, Test1Interceptor.class);
  }
}

ARouter.$$Providers.xxx

ARouter.$$Providers 是将一些服务类按照 类名——路由信息 的形式保存到内存中。

public class ARouter$$Providers$$app implements IProviderGroup {
  @Override
  public void loadInto(Map<String, RouteMeta> providers) {
    providers.put("com.alibaba.android.arouter.facade.service.SerializationService", RouteMeta.build(RouteType.PROVIDER, JsonServiceImpl.class, "/yourservicegroupname/json", "yourservicegroupname", null, -1, -2147483648));
    providers.put("com.alibaba.android.arouter.demo.testservice.SingleService", RouteMeta.build(RouteType.PROVIDER, SingleService.class, "/yourservicegroupname/single", "yourservicegroupname", null, -1, -2147483648));
  }
}

至此，所有的必要的路由信息已经被加载到内存中了。

加载拦截器

而在 _ARouter.init 方法中，初始化以后它还调用了 afterInit方法，来完成初始化以后的工作。

    if (hasInit) {
        _ARouter.afterInit();
    }

    static void afterInit() {
        // 触发拦截器的初始化
        interceptorService = (InterceptorService) ARouter.getInstance().build("/arouter/service/interceptor").navigation();
    }

根据以上代码可以知道 ARouter 在初始化以后，紧跟着通过路由的方式初始化了一个路由为 /arouter/service/interceptor 的拦截器，其实这个拦截器是 ARouter 官方实现的 com.alibaba.android.arouter.core.InterceptorServiceImpl，它的结构和我们自己实现的拦截器并无不同，所以这里主要看一下它的 init 方法：

public class InterceptorServiceImpl implements InterceptorService {
    private static boolean interceptorHasInit;
    private static final Object interceptorInitLock = new Object();

    @Override
    public void init(final Context context) {
        // 初始化的过程放在了子线程中
        LogisticsCenter.executor.execute(new Runnable() {
            @Override
            public void run() {
                if (MapUtils.isNotEmpty(Warehouse.interceptorsIndex)) {
                    for (Map.Entry<Integer, Class<? extends IInterceptor>> entry : Warehouse.interceptorsIndex.entrySet()) {
                        Class<? extends IInterceptor> interceptorClass = entry.getValue();
                        try {
                            // 这里就是将上一步保存到 Warehouse.interceptorsIndex 中的拦截器拿出来并初始化
                            IInterceptor iInterceptor = interceptorClass.getConstructor().newInstance();
                            iInterceptor.init(context);
                            // 将初始化后的拦截器保存到  Warehouse.interceptors 中
                            Warehouse.interceptors.add(iInterceptor);
                        } catch (Exception ex) {
                        }
                    }
                    interceptorHasInit = true;
                    synchronized (interceptorInitLock) {
                        // 线程同步
                        interceptorInitLock.notifyAll();
                    }
                }
            }
        });
    }
}

可以看到 InterceptorServiceImpl 的工作也很简单，

  • 将在初始化时保存到 Warehouse.interceptorsIndex 中的拦截器一一初始化，并保存到 Warehouse.interceptors 中。
  • 同步线程（这里主要是因为它拦截器初始化过程是在子线程中，如果这时候拦截器被使用，则可能造成拦截器未被初始化的问题）

根据这里也可以知道，拦截器是在最开始的时候就被初始化了，而服务（provider）不是。

总结

至此，Arouter 的初始化成功全部结束，总结一下就是三步：

  • 扫描所有 Dex 包找到相关的类
  • 将路由相关的信息保存到内存当中
  • 初始化拦截器

以上就是本篇的全部内容，希望对你有帮助。

版权声明：本文为博主原创文章，转载请声明出处，请尊重别人的劳动成果，谢谢！

耳东_
关注
专栏目录
android底层提高开机速度,Android 启动速度优化之— 提高 ARouter 的初始化速度
weixin_35925956的博客
05-26 676
如何提高 ARouter 的初始化速度在 app module 的 build.gradle 中 加入：apply plugin: 'com.alibaba.arouter'在项目的 build.gradle中加入：buildscript {repositories {jcenter()}dependencies {classpath "com.alibaba:arouter-register:1...
ARouter组件化框架原理分析
lbcwnu的博客
01-11 3818
ARouter组件化框架原理分析欢迎使用Markdown编辑器编译阶段运行阶段新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出...
ARouter初始化及跳转原理
importSUC的专栏
04-02 637
Arouter初始化及跳转原理 编译后生成文件 仓库类 `` class Warehouse { // Cache route and metas static Map<String, Class<? extends IRouteGroup>> groupsIndex = new HashMap<>(); static Map<String, RouteMeta> routes = new HashMap<>();
ARouter源码解析（一）-- 初始化分析
xiaoguidan159的博客
09-04 624
文章目录初始化流程分析ARouter.init_ARouter.initLogisticsCenter.init_ARouter.afterInit总结 目前项目做了组件化，接下来的时间会把组件化过程中涉及到的技术点和遇到的坑通过博客的形式写出来，希望能对大家有所帮助。 在组件化的过程中肯定会涉及到组件间跳转通信的问题，这就要引入本章需要讲到的技术点–路由了。目前几种路由解决方案中，ARouter...
ARouter 使用教程
最新发布
gitblog_00242的博客
08-07 568
ARouter 使用教程 ARouter???? A framework for assisting in the renovation of Android componentization (帮助 Android App 进行组件化改造的路由框架)项目地址:https://gitcode.com/gh_mirrors/ar/ARouter 项目介绍 ARouter 是阿里巴巴开源的一个用于 And...
ARouter源码简析一：初始化流程
One_Month的博客
08-26 442
Arouter简单使用 @Route(path = "/image/imageActivity") class MainActivity : AppCompatActivity() { @Autowired(name = "tip") @JvmField var mTip: String? = "" override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInsta.
ARoute源码分析之初始化过程
YeYaLing123的博客
11-28 404
ARoute初始化源码解析
ARouter init 源码解析（自动注册的实现）
许佳佳的博客
04-05 1590
概要 使用ARouter，我们只需要在必要的地方加上注解，然后在application中init Arouter就可以直接通过代码进行路由跳转了。 为什么我们可以不用写任何注册的代码，就直接跳转到相关路由呢？答案肯定是——ARouter帮我们做了。 @Route(path = "/test/activity2") public class Test2Activity extends AppComp...
路由框架ARouter的使用与原理分析
老蒋也疯狂
04-21 1179
Arouter简介  ARouter是阿里开源的一款路由框架，为组件化提供解决方案，它支持解析标准URL进行跳转，并自动注入参数到目标页面中；支持添加多个拦截器，自定义拦截顺序。 所谓组件化就是将APP按照一定的功能和业务拆分成多个小组件，不同的组件由不同的开发小组来负责，这样就可以解决大型APP开发过程中的开发与协作的问题，将这些问题分散到小的APP中。 （1）原生路由方案：使用显示Intent和隐式Intent跳转 显示Intent存在直接依赖，耦合度过高； 隐式Intent存在规则集中式管理Path
Android路由框架ARouter分析
01-20
3. **初始化**：在应用程序启动时，需要初始化ARouter，加载编译时生成的映射文件。 4. **路由跳转**：在需要进行路由的地方，调用ARouter提供的API，指定目标路径和参数，进行页面或服务的跳转。 5. **拦截处理**...
“终于懂了” 系列：组件化框架 ARouter 完全解析（一） 原理详解
胡飞洋的技术积累
07-25 2934
我们从路由发起开始使，介绍了整个路由详细过程moduelA通过中间人ARouter把路由信息的存到仓库WareHouse；moduleB发起路由时，再通过中间人ARouter从仓库WareHouse取出路由信息，这要就实现了没有依赖的两者之间的跳转与通信。其中涉及Activity的跳转、服务provider的获取、拦截器的处理等。需要重点理解的是路由框架的整体思路，通过中间人ARouter使用WareHouse加载和获取路由信息；路由信息加载实现原理，各帮助类作用和路由完善过程。（APT（AGP。...
低端机Arouter初始化耗时分析与优化
古苏的博客
06-29 1472
Android 项目中用到了阿里开源路由框架 https://github.com/alibaba/ARouter 但是低端机首次安装启动发现耗时比较长，那么我们分析一下原因，read thd fuck source code 初始化逻辑：ARouter.init方法 /** * Init, it must be call before used router. */ public static void init(Application application)...
ARouter基本使用及原理分析
yuantian_shenhai的博客
08-15 427
ARouter是阿里开源的一款帮助Android App进行组件化改造的路由框架，是Android平台中对页面和服务提供路由功能的中间件，可以实现在不同模块的Activity之间跳转。ARouter的特点是灵活性强还能帮助项目解耦。ARouter使用@Route注解，在编译时期通过APT技术生成类文件用于存储path和activityClass的映射关系。在app进程启动的时候会拿到这些类文件，把里面存储的映射关系数据读到内存里，保存在路由表map中。
ARouter基本使用及原理分析_arouter跨模块调用 init provider failed!(3)
2401_84862306的博客
05-10 986
ARouter项目中包含了API、编译器Compiler、插件Gradle Plugin和注解Annotation4 个模块。
ARouter路由框架
Super 含 的博客
10-16 275
一个用于帮助 Android App 进行组件化改造的框架 —— 支持模块间的路由、通信、解耦
ARouter原理分析
int_65536的博客
08-01 395
简单使用 //1 初始化 if (BuildConfig.DEBUG) { ARouter.openLog(); ARouter.openDebug(); } ARouter.init(this); //2 配置需要路由的目标 @Route(path = Constant.MAIN2) public class Main2Activity extends AppCompatActivity {} /
阿里路由框架--ARouter 源码解析之初始化ARouter
crazy_jack
08-17 3409
转载请注明出处：http://blog.csdn.net/crazy1235/article/details/77337691上一篇介绍了ARouter的Compiler SDK ： 阿里路由框架–ARouter 源码解析之Compiler在编译阶段会根据注解生成相应的 java 类文件。接下来分析一下 arouter-api SDK先来看看目录结构：
阿里ARouter全面全面全面解析(使用介绍+源码分析+设计思路)
CallmeZhe的博客
02-06 6480
概述 arouter是android实现组件化的路由框架，涉及到的功能有activity、fragment的跳转、跳转带参数、自定义服务、自定义拦截器、拦截下沉、重定向url都是Arouter里面定义的功能，可能用过Arouter的小伙伴们只用过Arouter的跳转以及跳转功能带参数的功能，像它的自定义服务、拦截器、全局降级策略、重定向功能都是很不错的功能，下面我会一一介绍这些功能该怎么使用。 使用介绍 1.基础依赖 1.1.java版本的依赖 在需要使用Arouter的module中添加如下
【Android -- 开源库】ARouter 的基本使用
Kevin Learn Android
03-25 1687
一个用于帮助 Android App 进行组件化改造的框架 —— 支持模块间的路由、通信、解耦。
Java数组初始化完全解析
数组初始化是创建并设置数组元素初始值的过程。本篇将详细讲解Java中一维和二维数组的初始化方法及其规则。 一、一维数组初始化 1) 声明数组但不初始化： ```java int[] a; // 只声明了数组，没有分配内存，不能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值