ARouter实现原理解析

最新推荐文章于 2024-07-22 20:59:56 发布
最新推荐文章于 2024-07-22 20:59:56 发布
阅读量2.5k 收藏 1
点赞数 1
分类专栏： android 文章标签： Android ARouter 模块化 注解解析 组件隔离
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011101777/article/details/90735277
版权

相关角色：

ARouter:负责提供客户端使用的Api接口，采用了门面模式，实际上内部委托给了_ARouter去处理
_ARouter:路由中心控制器，负责控制整个路由的流程，通过Postcard中的信息导航客户端到目标地址（启动某个Activity或者获取某个服务的实现等）
LogisticsCenter:后勤中心，负责注册路由信息到Warehouse和根据path或者Postcard到数据仓库中获取数据，再生成相关对象
Warehouse:数据仓库，负责存储路由配置信息和具体生成的IProvider对象等。该类基本上都是一些数据集合，没有任何逻辑处理
Postcard:明信片，RouteMeta类的子类，用于描述一个路由的具体信息，比如，目标组件类型（Activity||IProvider等）、目标组件需要的参数，
RouteMeta:路由信息描述类，存储目标地址的类型，路径，参数等信息，LogisticsCenter根据RouteMeta对象描述的信息创建明信片。
IRouteGroup:多个RouteMeta数据的容器，类似ViewGroup与View的关系
IProvider:服务提供者，每一个实现该接口的类视为一个独立的服务，外部客户端可以根据path获取到该服务。
IInterceptor:拦截器，客户端可以通过注册IInterceptor的实现类来实现路由的拦截，其拦截流程控制是在子线程中按照注册顺序依次调用拦截器的process方法将拦截权释放给客户端。其拦截控制器的实现在InterceptorServiceImpl类中。
PathReplaceService:路径替换服务接口，实现者需要将path转换为另一个path

初始化流程：

ARouter框架能将多个服务提供者隔离，减少相互之间的依赖。其实现的流程和我们平常的快递物流管理很类似，每一个具体的快递包裹就是一个独立的服务提供者（IProvider），每一个快递信息单就是一个RouteMeta对象，客户端就是快递的接收方，而使用@Route注解中的path就是快递单号。在初始化流程中，主要完成的工作就是将所有注册的快递信息表都在物流中心（LogisticsCenter）注册，并将数据存储到数据仓库中（Warehouse）。
初始化的入口是ARouter的init方法，其主要是控制初始化的流程，自身不处理具体实现，而是都委托给_ARouter去处理。

public static void init(Application application) {
        if (!hasInit) {
            //委托给_ARouter去初始化
            hasInit = _ARouter.init(application);
            if (hasInit) {
               //初始化之后调用afterInit
                _ARouter.afterInit();
            }
        }
    }

_ARouter方法的init方法实际是调用LogisticsCenter的init方法，下面是其核心代码：

                Set<String> routerMap;
                if (ARouter.debuggable() || PackageUtils.isNewVersion(context)) {
                    //扫描apk中所有类，找到ROUTE_ROOT_PAKCAGE包下的类，实在子线程中完成的
                    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);    // Save new version name when router map update finish.
                } else {
                    logger.info(TAG, "Load router map from cache.");
                    routerMap = new HashSet<>(context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).getStringSet(AROUTER_SP_KEY_MAP, new HashSet<String>()));
                }
                for (String className : routerMap) {
                    if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) {
                        ((IRouteRoot) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex);
                    } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_INTERCEPTORS)) {
                        // Load interceptorMeta
                        ((IInterceptorGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.interceptorsIndex);
                    } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_PROVIDERS)) {
                        // Load providerIndex
                        ((IProviderGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.providersIndex);
                    }
                }

LogisticsCenter的init方法主要完成了下面几件事：

  • 找到com.alibaba.android.arouter.routes包下的所有class文件类名，如果本地缓存的数据有效就从本地获取，如果有更新或者是debug模式，则通过扫描安装包的dex文件获取
  • 根据找到的类名去加载相关的实例到Warehouse中（类似与快递信息表入库）
    实际上com.alibaba.android.arouter.routes包下的class是由注解解析器自动生成的，主要IRouteRoot，IRouteGroup和IProviderGroup的实现类，比如当我们使用@Route注解某个类时，会自动将这个类的信息注入的到自动生成的上述实现类中。
    完成初始化之后会调用afterInit方法，其主要就是注入拦截控制服务（InterceptorServiceImpl）
static void afterInit() {
        interceptorService = (InterceptorService) ARouter.getInstance().build("/arouter/service/interceptor").navigation();
    }

//build方法主要是将path和group封装到Postcard中，可以理解成根据快递号生成一个快递信息表
protected Postcard build(String path, String group) {
        if (TextUtils.isEmpty(path) || TextUtils.isEmpty(group)) {
            throw new HandlerException(Consts.TAG + "Parameter is invalid!");
        } else {
            PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
            if (null != pService) {
                path = pService.forString(path);
            }
            return new Postcard(path, group);
        }
    }

而navigation方法是根据快递信息表来生成具体的实例，这里的拦截服务控制器实际是InterceptorServiceImpl对象，后面分析具体路由的实现时再看其具体的代码实现。整个初始化流程到注入InterceptorServiceImpl后就基本完成了

如何实现路由功能：

这里以一个具体的使用场景来看下路由的具体实现，我们实现了一个微博分享的服务，并使用@Route标注该服务。如下：

@Route(path = "/service/WBShareService")
public class WBShareServiceImp implements IShareService extends IProvider{
      @Override
    public void doShareImage(String text, String title, String path, boolean onlyClient) {
    }
}

然后客户端需要分享图片到微博时的使用代码如下：

Object obj = ARouter.getInstance().build("/service/WBShareService").navigation();
if (obj instanceof IShareService) {
   ((IShareService)obj).doShareImage("", "", "", false);
}

前面我们分析过ARouter的build方法了，其就是根据path生成一个Postcard对象，这里我们接着分析navigation方法，postcard对象的navigation方法最终都是委托给_ARouter的navigation方法来处理。

protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
        //到物流中心完成postcard的信息填充，因为最初生成的postcard对象只包含path信息，不包含其他有效信息，比如路由类型，携带的参数等
        LogisticsCenter.completion(postcard);
        //如果不是绿色通道，则通过拦截控制器依次调用不同的拦截器处理信息（类似与一个包裹在检查通道了经过多个扫描检查）
        if (!postcard.isGreenChannel()) {  
            //每个拦截器的拦截方法调用都是在子线程中执行的
            interceptorService.doInterceptions(postcard, new InterceptorCallback() {
                @Override
                public void onContinue(Postcard postcard) {
                    _navigation(context, postcard, requestCode, callback);
                }
                @Override
                public void onInterrupt(Throwable exception) {
                    if (null != callback) {
                        //只要有一个拦截器拦截该包裹，则回调onInterrupt方法宣告本次路由被终止
                        callback.onInterrupt(postcard);
                    }
                }
            });
        } else {
            //绿色通道则直接调用_navigation方法进行具体的导航
            return _navigation(context, postcard, requestCode, callback);
        }
        return null;
    }

可以看出navigation方法主要做了如下事情：

  1. 根据只包含path（理解成只有快递单号的快递信息表）的postcard去物流中心查找具体的路由信息（由编译时生成，在init时注入），完成后续步骤需要的数据填充。
  2. 如果不是绿色通道，则将postcard交予拦截控制器，委托各个拦截器在子线程执行检查是否拦截。
  3. 如果未拦截，则执行具体的导航功能
    这里先看下LogisticsCenter是怎么去填充信息到postcard中：
public synchronized static void completion(Postcard postcard) {
        //去数据仓库获取路由信息，该信息在初始化ARouter时已经注入
        RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath());
        if (null == routeMeta) { 
           //如果没有路由信息，则尝试去数据仓库查找
        } else {
            //找到路由信息后，则将配置的路由信息填充到Postcard对象中
            postcard.setDestination(routeMeta.getDestination());
            postcard.setType(routeMeta.getType());
            postcard.setPriority(routeMeta.getPriority());
            postcard.setExtra(routeMeta.getExtra());

            Uri rawUri = postcard.getUri();
            if (null != rawUri) {   // Try to set params into bundle.
                //这里主要是完成参数的填充
            }
            //针对不同的路由类型进行处理
            switch (routeMeta.getType()) {
                case PROVIDER:  
                    //如果是服务提供者，则尝试获取其具体实例，如果没有，则根据路由信息构造一个实例，初始化并存储到数据仓库，
                    Class<? extends IProvider> providerMeta = (Class<? extends IProvider>) routeMeta.getDestination();
                    IProvider instance = Warehouse.providers.get(providerMeta);
                    if (null == instance) { // There's no instance of this provider
                        IProvider provider;
                        provider = providerMeta.getConstructor().newInstance();
                            provider.init(mContext);
                            Warehouse.providers.put(providerMeta, provider);
                            instance = provider;
                    }
                    postcard.setProvider(instance);
                    //服务提供者被设置成绿色渠道，不用接受拦截检查
                    postcard.greenChannel();   
                    break;
                case FRAGMENT:
                   //fragment也不用拦截检查
                    postcard.greenChannel();  
                default:
                    break;
            }
        }
    }

信息填充完之后，看一下具体的路由实现：

private Object _navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
        final Context currentContext = null == context ? mContext : context;

        switch (postcard.getType()) {
            case ACTIVITY:
                // Build intent
                final Intent intent = new Intent(currentContext, postcard.getDestination());
                intent.putExtras(postcard.getExtras());

                // Set flags.
                int flags = postcard.getFlags();
                if (-1 != flags) {
                    intent.setFlags(flags);
                } else if (!(currentContext instanceof Activity)) {    // Non activity, need less one flag.
                    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                }

                // Navigation in main looper.
                new Handler(Looper.getMainLooper()).post(new Runnable() {
                    @Override
                    public void run() {
                        if (requestCode > 0) {  // Need start for result
                            ActivityCompat.startActivityForResult((Activity) currentContext, intent, requestCode, postcard.getOptionsBundle());
                        } else {
                            ActivityCompat.startActivity(currentContext, intent, postcard.getOptionsBundle());
                        }

                        if ((0 != postcard.getEnterAnim() || 0 != postcard.getExitAnim()) && currentContext instanceof Activity) {    // Old version.
                            ((Activity) currentContext).overridePendingTransition(postcard.getEnterAnim(), postcard.getExitAnim());
                        }

                        if (null != callback) { // Navigation over.
                            callback.onArrival(postcard);
                        }
                    }
                });

                break;
            case PROVIDER:
                return postcard.getProvider();
            case BOARDCAST:
            case CONTENT_PROVIDER:
            case FRAGMENT:
                Class fragmentMeta = postcard.getDestination();
                try {
                    Object instance = fragmentMeta.getConstructor().newInstance();
                    if (instance instanceof Fragment) {
                        ((Fragment) instance).setArguments(postcard.getExtras());
                    } else if (instance instanceof android.support.v4.app.Fragment) {
                        ((android.support.v4.app.Fragment) instance).setArguments(postcard.getExtras());
                    }

                    return instance;
                } catch (Exception ex) {
                    logger.error(Consts.TAG, "Fetch fragment instance error, " + TextUtils.formatStackTrace(ex.getStackTrace()));
                }
            case METHOD:
            case SERVICE:
            default:
                return null;
        }

        return null;
    }

从上述代码我们可以看出，不同类型的路由其导航的方式也不一样

  • 如果是Activity类型，则将数据填充到intent中之后，调用ActivityCompat的startActivity或者startActivityForResult方法启动activity。
  • 如果是PROVIDER类型，则直接返回其服务提供者
  • 如果是BOARDCAST || CONTENT_PROVIDER || FRAGMENT，则创建其需要的实体，并填充数据，再返回该实体对象
三村阿明
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
阿里ARouter简单实现原理
年轻的博客
07-20 343
##1.前言 组件化或者模块化开发模式，已逐渐成为热浪的形式，使用这些模式可以让我们程序更容易的扩展、更方便的维护 更快捷的同步开发与更简单的单独调试，而ARouter的出现就是让组件间、模块间是实现完全的独立。 ARouter是：阿里巴巴自研路由框架，主要解决组件间、模块间的 界面跳转 问题。 今天用最简单的方式讲解Arouter的实现原理。 以下是我在学习网易公开课做的笔记,想学习可以百度搜索...
ARouter原理解析
王温暖的博客
08-09 6560
一、ARouter概述 用简单一两句话总结出来：ARouter通过Apt技术，生成保存路径(路由path)和被注解(@Router)的组件类的映射关系的类，利用这些保存了映射关系的类，Arouter根据用户的请求postcard（明信片）寻找到要跳转的目标地址(class),使用Intent跳转。原理很简单，可以看出来，该框架的核心是利用apt生成的映射关系。 使用时，在每个需要对其他module提供调用的Activity中，都要声明类似下面@Route注解，我们称之为路由地址。 @Route(pa
【鸿蒙南向开发】三方库Arouter：一款轻量、高效的页面路由工具
最新发布
HarmonyOS_666的博客
07-22 795
这份鸿蒙（HarmonyOS NEXT）文档包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、OpenHarmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。
ARouter原理
Icarus_的学习笔记
08-09 425
一、编译过程 1、注解 我们在要跳转的Activity上面添加了@Route注解，ARouter 的自动注册是利用了编译期自定义注解的处理来完成的，我们看一下这个注解的定义： @Target({ElementType.TYPE}) @Retention(RetentionPolicy.CLASS) public @interface Route{ String path(); String group() default ""; String name() default "";
Arouter路由原理-简述
nahfang的博客
03-28 1058
很想写一篇关于路由的文章，但是由于一些原因一直没有去完成，直接使用了Arouter作为路由方案，进行了我的组件化改造之路。最近经过一些鞭打，我发现我并不能完整的表达出来，所以我还是决定再去了解了解它的原理，博文内容仅代表个人意见，并且由于本人知识有限，如有错误，敬请指正！谢谢！
Arouter原理详解
tangedegushi的博客
12-11 778
对于组件化这个东西这里就不进行讲解了，组件化本身的目的是为了解耦，各个组件负责各自的功能，然后把各个组件组合起来就是一个完整的项目了，组合起来的时候，就会涉及到组件间的通讯问题，比如这个module的Activity调用另外一个module的activity，如果是直接调用，那显然他们之间就有了耦合了，为了组件间的解耦，这个时候就可以用到Arouter了，关于Arouter的使用这里可以去Git上...
移动开发+Android组件化+APT原理解析+ARouter基础技术之APT原理解析，源码分析
09-02
APT原理解析，一句化描述APT原理 在javac编译期间，先加载APT实现类（即 AbstractProcessor实现类），并查找解析java源文件注解信息，并于APT声明支持处理的注解信息做匹配，如果java源文件存在APT声明的注解，则调...
My_Arouter.zip
11-14
Arouter的工作原理主要包括路径注册、编译解析、路由匹配和分发四大部分。路径注册是在初始化阶段完成，开发者定义好各个模块的路径；编译解析阶段，Arouter会生成对应的Java代码，便于运行时快速查找；路由匹配则是...
ArouterDemo.zip
07-05
本文将通过解析ARouterDemo.zip中的示例，深入探讨ARouter框架在Android模块化开发中的运用。 ARouter是由Alibaba开发的一款强大的路由框架，它解决了大型项目中模块间的通信问题，实现了页面跳转、服务注入和数据...
ARouter组件demo
08-28
4. **编译时注解处理**：在编译阶段，ARouter会通过APT（Annotation Processing Tool）机制生成相应的Java代码，将路由信息解析并存入内存，从而在运行时快速查找目标组件。 5. **跳转与传递参数**：在需要跳转的...
MRouter:Android Route Library，如ARouter
05-10
本文将深入探讨MRouter的设计原理、核心功能以及如何在项目中实现和使用。\n\n1. 路由框架的作用\n路由框架的主要目的是解决大型Android应用中模块化、组件化的需求，它提供了一种高效、灵活的组件间通信方式，避免...
组件化ARouter开发完整代码
08-01
组件化ARouter开发完整代码，模块之间完全解耦，支持参数注解，类注解
使用 ARoute 实现组件化 ( 完整组件化项目示例 )
05-29
【Android 组件化】使用 ARoute 实现组件化 ( 完整组件化项目示例 ) https://hanshuliang.blog.csdn.net/article/details/117294139 博客源码
面试：ARouter原理
王温暖的博客
12-17 2355
ARouter原理概述： 一、路由表生成：编译时注解加上注解处理器生成路由表 二、路由表加载：LogisticsCenter通过反射加载这些路由信息表。 ARouter 是阿里开源的一款帮助 Android APP 进行组件化改造的路由框架，可以实现在同一个项目中互不依赖的的模块的 Activity 之间跳转。 ARouter 的路由、参数和拦截器都是用注解来标注的。注解在 Retrofit、Dagger 和 EventBus 中都有使用。 ARouter 的跳转是基于路由表 RouterMap
ARouter详解
m0_49508485的博客
11-11 6198
ARouter跳转到其他moudle时，需要注意的是，moudle中的目标Activity或者service服务类上使用@Route(path = “xx/xxx”) 与 app moudle中使用的@Route里的path路径不能相同，否则会报错，找不到索引。即会拦截跳转时的Path 和 Url (app内部跳转，以及页面跳转到app页面) ,拦截之后可以重新定义跳转路径，改变跳转的目标页面。通俗的讲，降级就是，在使用ARouter实现跳转的时候，如果发生错误，而进行相应的逻辑处理，
Android学习之路(24) ARouter原理解析
qq_32907491的博客
01-21 2393
本文先介绍了ARouter使用过程中 的一些基本概念，理解了这些概念后，我们再从使用步骤触发，对每个使用节点进行了介绍。最后使用一张图总结了整个使用原理过程1.ARouter帮助类是如何生成的，这里使用到了APT注解处理器的技术 关于APT我们会在下一章：Android开源系列-组件化框架Arouter-(三)APT技术详解这里还有个有趣的现象，我们在调用路由表加载的时候： 使用了加载，但是查看里面代码：java复制代码居然是空的。。java复制代码可以看到这里使用了。
【Android】阿里路由框架ARouter原理分析总结
now_android
01-23 5803
1、单向依赖的module之间 组件化中两个单向依赖的module之间需要互相启动对方的Activity时，因为没有相互引用，startActivity()是实现不了的，必须需要一个协定的通信方式，此时类似ARouter的路由框架就派上用场了。 2、互不依赖的module之间 两个module之间没有依赖，便不能通过startActivity()的显示启动进行通信，那么如何进行通信呢？ （...
ARouter 原理浅析
xzwhappycj的专栏
02-18 5395
ARouter是阿里巴巴开源的路由框架：https://github.com/alibaba/ARouter ARouter ARouter 是通过注解的方式结合android提供的启动Activity的API实现页面的跳转及参数的传递的。 ARouter 提供三种注解类型： @Route：注解跳转页面或是需要实例化的的类 @Interceptor：注解自定义拦截器 @AutoWire...
路由框架ARouter的使用与原理分析
老蒋也疯狂
04-21 1140
Arouter简介  ARouter是阿里开源的一款路由框架，为组件化提供解决方案，它支持解析标准URL进行跳转，并自动注入参数到目标页面中；支持添加多个拦截器，自定义拦截顺序。 所谓组件化就是将APP按照一定的功能和业务拆分成多个小组件，不同的组件由不同的开发小组来负责，这样就可以解决大型APP开发过程中的开发与协作的问题，将这些问题分散到小的APP中。 （1）原生路由方案：使用显示Intent和隐式Intent跳转 显示Intent存在直接依赖，耦合度过高； 隐式Intent存在规则集中式管理Path
"ARouter源码解析之Compiler：解决组件化数据传输问题
通过对ARouter的Compiler部分进行深入的源码解析，可以更好地理解ARouter框架的原理和实现方式，为使用和定制ARouter框架提供了重要的参考和帮助。 综上所述，本文主要讨论了阿里路由框架ARouter的Compiler部分的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值