ARouter使用及原理分析

最新推荐文章于 2023-08-17 15:25:00 发布

置顶 JALLV

最新推荐文章于 2023-08-17 15:25:00 发布

阅读量902

点赞数

分类专栏： Android Java 文章标签： android java

本文链接：https://blog.csdn.net/jallv/article/details/105256217

版权

Android 同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

Java

4 篇文章 0 订阅

订阅专栏

简介

ARouter是阿里开源的路由组件，是 Android 平台中对页面、服务提供路由功能的中间件，常被用来进行组件化通讯。

功能介绍

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

典型应用

从外部URL映射到内部页面，以及参数传递与解析
跨模块页面跳转，模块间解耦
拦截跳转过程，处理登陆、埋点等逻辑
跨模块API调用，通过控制反转来做组件解耦

基本使用

常用的使用方式，推荐直接参考官网文档，写的非常详细。
链接：https://github.com/alibaba/ARouter/blob/master/README_CN.md

源码分析

源码主要包含三个部分：

arouter-annotation：定义路由相关注解，Route（路由地址）、Autowired(属性装配)、Interceptor（路由拦截器）

arouter-compiler：注解处理器，用来生成路由表、属性装配器等java文件

arouter-api：路由api

大体思路是通过注解再编译期生成路由表，再ARouter.init()中将路由表加载到内存，然后调用api进行页面跳转等功能。

如果对自定义注解不了解的建议看下Java注解之编译时注解，另外arouter-compiler中使用JavaPoet Library来生成 Java 代码，JavaPoet 看这一篇就够了

arouter-annotation

arouter-annotation没什么说的，就是定义了路由需要的注解和数据结果

annotation

Route：路由定义注解，定义了path（路径）、group（分组，路由表是按组来继续管理的）、name（只在生成java文件的时候，添加注释用的）、priority（优先级）、extra（额外数据）等。主要是path和group其他的基本上没怎么用。
Autowired：属性自动装配注解，用于成员变量装配，比如Activity中经常使用getIntent().getExtra()，就可以通过Autowired注解来自定装配。
Interceptor：路由拦截器注解

enums

RouteType：路由类型，有用的就只有：ACTIVITY、PROVIDER、FRAGMENT另外SERVICE、BOARDCAST、CONTENT_PROVIDER有定义，但是没使用，并不能通过ARouter来发送广播或启动服务。
TypeKind：数据类型，用于成员变量自动装配

model

RouteMeta：路由的数据定义
TypeWrapper：获取class的type

arouter-compiler

定义了三个注解处理器：

RouteProcessor：处理Route注解，生成路由表
AutowiredProcessor：生成属性自动装配器
InterceptorProcessor：拦截器表，分不同优先级

RouteProcessor

/**
* 继承BaseProcessor，BaseProcessor中主要定义了类型、文件等工具类的引用、java版本进行初始化
**/
public class RouteProcessor extends BaseProcessor {
    //...省略代码
    //路由分组，前面也说了，路由是通过分组来进行管理的，每个路由分组对应一个java文件（ARouter$$Group$$组名），通过一个Root class(ARouter$$Root$$模块名称（Module）)统一管理，ARouter.init时只会先加载Root，然后根据分组，在加载分组表。key:路由分组名称，value:路由表
    private Map<String, Set<RouteMeta>> groupMap = new HashMap<>(); // ModuleName and             routeMeta.
    //模块路由分组入口。key:分组名称，value：路由分组java文件路径
    private Map<String, String> rootMap = new TreeMap<>();  // Map of root metas, used for generate class file in order.
    // IProvider类型
    private TypeMirror iProvider = null;
    // java文件生成器
    private Writer docWriter;       // Writer used for write doc
    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        //...省略代码
        //初始化工具和类型
    }
    
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (CollectionUtils.isNotEmpty(annotations)) {
            //获取Route注解
            Set<? extends Element> routeElements = roundEnv.getElementsAnnotatedWith(Route.class);
            try {
                logger.info(">>> Found routes, start... <<<");
                //处理Route注解，生成对应的路由java文件
                this.parseRoutes(routeElements);

            } catch (Exception e) {
                logger.error(e);
            }
            return true;
        }

        return false;
    } 
   //...省略代码
    private void parseRoutes(Set<? extends Element> routeElements) throws IOException {
        if (CollectionUtils.isNotEmpty(routeElements)) {
            //...省略代码
            //清空路由分组
            rootMap.clear();
            //获取activity类型
            TypeMirror type_Activity = elementUtils.getTypeElement(ACTIVITY).asType();
            //获取service类型
            TypeMirror type_Service = elementUtils.getTypeElement(SERVICE).asType();
            //获取fragment类型
            TypeMirror fragmentTm = elementUtils.getTypeElement(FRAGMENT).asType();
            //获取fragment V4类型 
            TypeMirror fragmentTmV4 = elementUtils.getTypeElement(Consts.FRAGMENT_V4).asType();

            //获取路由组接口
            TypeElement type_IRouteGroup = elementUtils.getTypeElement(IROUTE_GROUP);
            //获取iProvider组接口，提供通过class获取iProvider
            TypeElement type_IProviderGroup = elementUtils.getTypeElement(IPROVIDER_GROUP);
            ClassName routeMetaCn = ClassName.get(RouteMeta.class);
            ClassName routeTypeCn = ClassName.get(RouteType.class);

            /*
               定义方法参数类型：Map<String, Class<? extends IRouteGroup>>
             */
            ParameterizedTypeName inputMapTypeOfRoot = ParameterizedTypeName.get(
                    ClassName.get(Map.class),
                    ClassName.get(String.class),
                    ParameterizedTypeName.get(
                            ClassName.get(Class.class),
                            WildcardTypeName.subtypeOf(ClassName.get(type_IRouteGroup))
                    )
            );

            /*
             *定义方法参数类型：Map<String, RouteMeta>
             */
            ParameterizedTypeName inputMapTypeOfGroup = ParameterizedTypeName.get(
                    ClassName.get(Map.class),
                    ClassName.get(String.class),
                    ClassName.get(RouteMeta.class)
            );

            /*
             * 定义参数：(Map<String, Class<? extends IRouteGroup>> routes)
             */
            ParameterSpec rootParamSpec = ParameterSpec.builder(inputMapTypeOfRoot, "routes").build();
            /*
             *定义参数：(Map<String, RouteMeta> atlas)
             */
            ParameterSpec groupParamSpec = ParameterSpec.builder(inputMapTypeOfGroup, "atlas").build();
            /*
             *定义参数：(Map<String, RouteMeta> providers)
             */
            ParameterSpec providerParamSpec = ParameterSpec.builder(inputMapTypeOfGroup, "providers").build();  // Ps. its param type same as groupParamSpec!

            /*
             *创建加载路由分组的方法：
             *@Override
             *public void loadInto(Map<String, Class<? extends IRouteGroup>> routes)
             */
            MethodSpec.Builder loadIntoMethodOfRootBuilder = MethodSpec.methodBuilder(METHOD_LOAD_INTO)
                    .addAnnotation(Override.class)
                    .addModifiers(PUBLIC)
                    .addParameter(rootParamSpec);

            //  Follow a sequence, find out metas of group first, generate java file, then statistics them as root.
            //遍历所以Route注解原始
            for (Element element : routeElements) {
                //获取元素类型
                TypeMirror tm = element.asType();
                //获取注解
                Route route = element.getAnnotation(Route.class);
                RouteMeta routeMeta;

                if (types.isSubtype(tm, type_Activity)) {                 
                    // Activity
                    // 存放所有被Autowired注解的成员变量<名称,类型>
                    Map<String, Integer> paramsType = new HashMap<>();
                    //<名称,注解>
                    Map<String, Autowired> injectConfig = new HashMap<>();
                    //变量Activity所有子节点
                    for (Element field : element.getEnclosedElements()) {
                        //如果是成员变量并且不是iProvider的子类
                        if (field.getKind().isField() && field.getAnnotation(Autowired.class) != null && !types.isSubtype(field.asType(), iProvider)) {
                            // It must be field, then it has annotation, but it not be provider.                    
                            Autowired paramConfig = field.getAnnotation(Autowired.class);
                            //注入名称，如果Autowired注解不带name,就以变量名做name
                            String injectName = StringUtils.isEmpty(paramConfig.name()) ? field.getSimpleName().toString() : paramConfig.name();
                            //添加名称、类型，paramsType和injectConfig主要用来生成文档和Uri参数解析，并不用于变量注入，activity成员变量的注入，主要还是靠AutowiredProcessor生产的注入器来实现。
                            paramsType.put(injectName, typeUtils.typeExchange(field));
                            injectConfig.put(injectName, paramConfig);
                        }
                    }
                    //创建RouteMeta
                    routeMeta = new RouteMeta(route, element, RouteType.ACTIVITY, paramsType);
                    routeMeta.setInjectConfig(injectConfig);
                } else if (types.isSubtype(tm, iProvider)) {         
                    // IProvider
                    logger.info(">>> Found provider route: " + tm.toString() + " <<<");
                    routeMeta = new RouteMeta(route, element, RouteType.PROVIDER, null);
                } else if (types.isSubtype(tm, type_Service)) {           
                    // Service，这个基本上没用，ARouter目前并不支持启动服务
                    routeMeta = new RouteMeta(route, element, RouteType.parse(SERVICE), null);
                } else if (types.isSubtype(tm, fragmentTm) || types.isSubtype(tm, fragmentTmV4)) {
                    //fragment
                    logger.info(">>> Found fragment route: " + tm.toString() + " <<<");
                    routeMeta = new RouteMeta(route, element, RouteType.parse(FRAGMENT), null);
                } else {
                    throw new RuntimeException("ARouter::Compiler >>> Found unsupported class type, type = [" + types.toString() + "].");
                }
                //添加分组
                categories(routeMeta);
            }
            /*
             *创建加载iProvider表的方法：
             *@override 
             *public void loadInto((Map<String, RouteMeta> providers))
             *
             */
            MethodSpec.Builder loadIntoMethodOfProviderBuilder = MethodSpec.methodBuilder(METHOD_LOAD_INTO)
                    .addAnnotation(Override.class)
                    .addModifiers(PUBLIC)
                    .addParameter(providerParamSpec);

            Map<String, List<RouteDoc>> docSource = new HashMap<>();

            // Start generate java source, structure is divided into upper and lower levels, used for demand initialization.
            //变量所有路由分组
            for (Map.Entry<String, Set<RouteMeta>> entry : groupMap.entrySet()) {
                //获取路由分组名称
                String groupName = entry.getKey();
                /*
                 *创建加载路由列表方法：
                 *@Override
                 *public void loadInfo(Map<String, RouteMeta> atlas)
                 */
                MethodSpec.Builder loadIntoMethodOfGroupBuilder = MethodSpec.methodBuilder(METHOD_LOAD_INTO)
                        .addAnnotation(Override.class)
                        .addModifiers(PUBLIC)
                        .addParameter(groupParamSpec);

                List<RouteDoc> routeDocList = new ArrayList<>();

                // Build group method body
                Set<RouteMeta> groupData = entry.getValue();
                //遍历当前分组的所有节点
                for (RouteMeta routeMeta : groupData) {
                    RouteDoc routeDoc = extractDocInfo(routeMeta);
                    
                    ClassName className = ClassName.get((TypeElement) routeMeta.getRawType());
                    //根据不同的类型在不同的loadInfo方法中，添加语句，将当前节点加入对应的表中
                    switch (routeMeta.getType()) {
                        //当前节点是iProvider,在public void loadInto((Map<String, RouteMeta> providers))方法中加入providers.put(class,routeMeta)
                        case PROVIDER:  
                            //获取所有继承的接口
                            List<? extends TypeMirror> interfaces = ((TypeElement) routeMeta.getRawType()).getInterfaces();
                            for (TypeMirror tm : interfaces) {
                                routeDoc.addPrototype(tm.toString());
                                //如果直接继承iProvider，providers.put("com.alibaba.android.arouter.facade.template.IProvider",routeMeta)
                                if (types.isSameType(tm, iProvider)) {   
                                    loadIntoMethodOfProviderBuilder.addStatement(
                                            "providers.put($S, $T.build($T." + routeMeta.getType() + ", $T.class, $S, $S, null, " + routeMeta.getPriority() + ", " + routeMeta.getExtra() + "))",
                                            (routeMeta.getRawType()).toString(),
                                            routeMetaCn,
                                            routeTypeCn,
                                            className,
                                            routeMeta.getPath(),
                                            routeMeta.getGroup());
                                } else if (types.isSubtype(tm, iProvider)) {
                                //如果是iProvider的子类，providers.put(当前类型的全路径,routeMeta)
                                    loadIntoMethodOfProviderBuilder.addStatement(
                                            "providers.put($S, $T.build($T." + routeMeta.getType() + ", $T.class, $S, $S, null, " + routeMeta.getPriority() + ", " + routeMeta.getExtra() + "))",
                                            tm.toString(),    // So stupid, will duplicate only save class name.
                                            routeMetaCn,
                                            routeTypeCn,
                                            className,
                                            routeMeta.getPath(),
                                            routeMeta.getGroup());
                                }
                            }
                            break;
                        default:
                            break;
                    }

                    // 其他类型
                    StringBuilder mapBodyBuilder = new StringBuilder();
                    //后面这部分主要用于生成文档，不影响路由表的生成
                    Map<String, Integer> paramsType = routeMeta.getParamsType();
                    Map<String, Autowired> injectConfigs = routeMeta.getInjectConfig();
                    if (MapUtils.isNotEmpty(paramsType)) {
                        List<RouteDoc.Param> paramList = new ArrayList<>();

                        for (Map.Entry<String, Integer> types : paramsType.entrySet()) {
                            mapBodyBuilder.append("put(\"").append(types.getKey()).append("\", ").append(types.getValue()).append("); ");

                            RouteDoc.Param param = new RouteDoc.Param();
                            Autowired injectConfig = injectConfigs.get(types.getKey());
                            param.setKey(types.getKey());
                            param.setType(TypeKind.values()[types.getValue()].name().toLowerCase());
                            param.setDescription(injectConfig.desc());
                            param.setRequired(injectConfig.required());

                            paramList.add(param);
                        }

                        routeDoc.setParams(paramList);
                    }
                    String mapBody = mapBodyBuilder.toString();
                    /*
                     *路由表加载方法
                     * public void loadInfo(Map<String, RouteMeta> atlas)中添加语句
                     * atlas.put(路由路径,routeMeta)
                     */
                    loadIntoMethodOfGroupBuilder.addStatement(
                            "atlas.put($S, $T.build($T." + routeMeta.getType() + ", $T.class, $S, $S, " + (StringUtils.isEmpty(mapBody) ? null : ("new java.util.HashMap<String, Integer>(){{" + mapBodyBuilder.toString() + "}}")) + ", " + routeMeta.getPriority() + ", " + routeMeta.getExtra() + "))",
                            routeMeta.getPath(),
                            routeMetaCn,
                            routeTypeCn,
                            className,
                            routeMeta.getPath().toLowerCase(),
                            routeMeta.getGroup().toLowerCase());

                    routeDoc.setClassName(className.toString());
                    routeDocList.add(routeDoc);
                }

                /* 生成路由组java文件：
                public class ARouter$$Group&&组名 implements IRouteGroup{
                    @Override
                    void loadInto(Map<String, RouteMeta> atlas){
                        atlas.put(路由名，RouteMeta);
                        ...
                    }
                }
                */
                String groupFileName = NAME_OF_GROUP + groupName;
                JavaFile.builder(PACKAGE_OF_GENERATE_FILE,
                        TypeSpec.classBuilder(groupFileName)
                                .addJavadoc(WARNING_TIPS)
                                .addSuperinterface(ClassName.get(type_IRouteGroup))
                                .addModifiers(PUBLIC)
                                .addMethod(loadIntoMethodOfGroupBuilder.build())
                                .build()
                ).build().writeTo(mFiler);

                logger.info(">>> Generated group: " + groupName + "<<<");
                //将路由分组java文件路径添加到rootMap
                rootMap.put(groupName, groupFileName);
                docSource.put(groupName, routeDocList);
            }
            
            if (MapUtils.isNotEmpty(rootMap)) {
                // Generate root meta by group name, it must be generated before root, then I can find out the class of group.
                for (Map.Entry<String, String> entry : rootMap.entrySet()) {
                    /*
                      加载路由分组的方法添加语句
                      public void loadInto(Map<String, Class<? extends IRouteGroup>> routes){
                            routes.put(分组名，路由分组java文件路径)
                      }
                    */
                    loadIntoMethodOfRootBuilder.addStatement("routes.put($S, $T.class)", entry.getKey(), ClassName.get(PACKAGE_OF_GENERATE_FILE, entry.getValue()));
                }
            }

            // Output route doc
            if (generateDoc) {
                docWriter.append(JSON.toJSONString(docSource, SerializerFeature.PrettyFormat));
                docWriter.flush();
                docWriter.close();
            }

            // Write provider into disk
            /*
             创建IPovider路由表类java文件
             public class ARouter$$Providers$$模块名称 implements IProviderGroup{
                @Override
                public void loadInto(Map<String, RouteMeta> providers){
                    providers.put(IPovider或子类全路径，RouteMeta);
                    ...
                }
             }
             
            */
            String providerMapFileName = NAME_OF_PROVIDER + SEPARATOR + moduleName;
            JavaFile.builder(PACKAGE_OF_GENERATE_FILE,
                    TypeSpec.classBuilder(providerMapFileName)
                            .addJavadoc(WARNING_TIPS)
                            .addSuperinterface(ClassName.get(type_IProviderGroup))
                            .addModifiers(PUBLIC)
                            .addMethod(loadIntoMethodOfProviderBuilder.build())
                            .build()
            ).build().writeTo(mFiler);

            logger.info(">>> Generated provider map, name is " + providerMapFileName + " <<<");

            // Write root meta into disk.
            /*
             创建路由分组管理类
              public class ARouter$$Root$$模块名 implements IRouteRoot{
                @Override
                public void loadInto(Map<String, Class<? extends IRouteGroup>> routes){
                    routes.put(组名，路由分组类class);
                    ...
                }
              }
            */
            String rootFileName = NAME_OF_ROOT + SEPARATOR + moduleName;
            JavaFile.builder(PACKAGE_OF_GENERATE_FILE,
                    TypeSpec.classBuilder(rootFileName)
                            .addJavadoc(WARNING_TIPS)
                            .addSuperinterface(ClassName.get(elementUtils.getTypeElement(ITROUTE_ROOT)))
                            .addModifiers(PUBLIC)
                            .addMethod(loadIntoMethodOfRootBuilder.build())
                            .build()
            ).build().writeTo(mFiler);

            logger.info(">>> Generated root, name is " + rootFileName + " <<<");
        }
    }
    /**
     * 添加routeMete到对应分组
     *
     * @param routeMete metas.
     */
    private void categories(RouteMeta routeMete) {
        //校验routeMete分组信息，如果没有组名，以第一个"/"与第二个"/"之间的名字作为组名，如果都不存在则无效
        if (routeVerify(routeMete)) {
            //根据组名获取分组
            Set<RouteMeta> routeMetas = groupMap.get(routeMete.getGroup());
            //如果分组不存在
            if (CollectionUtils.isEmpty(routeMetas)) {
                //创建一个分组
                Set<RouteMeta> routeMetaSet = new TreeSet<>(new Comparator<RouteMeta>() {
                    @Override
                    public int compare(RouteMeta r1, RouteMeta r2) {
                        try {
                            return r1.getPath().compareTo(r2.getPath());
                        } catch (NullPointerException npe) {
                            logger.error(npe.getMessage());
                            return 0;
                        }
                    }
                });
                routeMetaSet.add(routeMete);
                groupMap.put(routeMete.getGroup(), routeMetaSet);
            } else {
                //已经存在分组，直接添加
                routeMetas.add(routeMete);
            }
        } else {
            logger.warning(">>> Route meta verify error, group is " + routeMete.getGroup() + " <<<");
        }
    }
}

RouteProcessor主要生成了三个java文件：路径在对应模块的build/generated/ap_generated_sources/debug/out/com.alibaba.android.arouter.routes下

public class ARouter$$Group&&组名 implements IRouteGroup{
    @Override
    public void loadInto(Map<String, RouteMeta> atlas){
        atlas.put(路由名，RouteMeta);
        ...
    }
}

public class ARouter$$Providers$$模块名称 implements IProviderGroup{
    @Override
    public void loadInto(Map<String, RouteMeta> providers){
        providers.put(IPovider或子类全路径，RouteMeta);
        ...
    }
}

public class ARouter$$Root$$模块名 implements IRouteRoot{
    @Override
        public void loadInto(Map<String, Class<? extends IRouteGroup>> routes){
            routes.put(组名，路由分组类class);
            ...
    }
}

例如：

public class ARouter$$Root$$app implements IRouteRoot {
  @Override
  public void loadInto(Map<String, Class<? extends IRouteGroup>> routes) {
    routes.put("baseUrl", ARouter$$Group$$baseUrl.class);
    routes.put("guide", ARouter$$Group$$guide.class);
    routes.put("main", ARouter$$Group$$main.class);
    routes.put("noteDb", ARouter$$Group$$noteDb.class);
    routes.put("share", ARouter$$Group$$share.class);
    routes.put("translateDb", ARouter$$Group$$translateDb.class);
    routes.put("vip", ARouter$$Group$$vip.class);
  }
}
public class ARouter$$Providers$$app implements IProviderGroup {
  @Override
  public void loadInto(Map<String, RouteMeta> providers) {
    providers.put("com.iflytek.tibet.core.http.IBaseUrlProvider", RouteMeta.build(RouteType.PROVIDER, TibetUrlProvider.class, "/baseUrl/provider", "baseUrl", null, -1, -2147483648));
    providers.put("com.iflytek.tibet.translate.db.provider.ITranslateDbProvider", RouteMeta.build(RouteType.PROVIDER, TibetTranslateDbProvider.class, "/translateDb/provider", "translateDb", null, -1, -2147483648));
    providers.put("com.iflytek.tibet.note.db.INoteDbProvider", RouteMeta.build(RouteType.PROVIDER, TibetNoteDbProvider.class, "/noteDb/provider", "noteDb", null, -1, -2147483648));
    providers.put("com.iflytek.tibet.core.share.IShareProvider", RouteMeta.build(RouteType.PROVIDER, TibetShareProvider.class, "/share/provider", "share", null, -1, -2147483648));
  }
}
public class ARouter$$Group$$main implements IRouteGroup {
  @Override
  public void loadInto(Map<String, RouteMeta> atlas) {
    atlas.put("/main/agreement", RouteMeta.build(RouteType.ACTIVITY, UserAgreementActivity.class, "/main/agreement", "main", null, -1, -2147483648));
  }
}

InterceptorProcessor

public class InterceptorProcessor extends BaseProcessor {
    /**
     * 拦截器列表，<优先级,拦截器节点>，优先级从0开始，依次递减
     */
    private Map<Integer, Element> interceptors = new TreeMap<>();
    //...省略代码
    /**
     * {@inheritDoc}
     *
     * @param annotations
     * @param roundEnv
     */
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (CollectionUtils.isNotEmpty(annotations)) {
            //获取说有Interceptor注解
            Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Interceptor.class);
            try {
                //处理注解
                parseInterceptors(elements);
            } catch (Exception e) {
                logger.error(e);
            }
            return true;
        }

        return false;
    }

    /**
     * Parse tollgate.
     *
     * @param elements elements of tollgate.
     */
    private void parseInterceptors(Set<? extends Element> elements) throws IOException {
        if (CollectionUtils.isNotEmpty(elements)) {
            //便利Interceptor注解原始
            for (Element element : elements) {
                //校验原始
                if (verify(element)) {
                    //获取Interceptor注解
                    Interceptor interceptor = element.getAnnotation(Interceptor.class);
                    //检查是否已经存在相同优先级的拦截器，有就抛出异常
                    Element lastInterceptor = interceptors.get(interceptor.priority());
                    if (null != lastInterceptor) {
                        throw new IllegalArgumentException(
                                String.format(Locale.getDefault(), "More than one interceptors use same priority [%d], They are [%s] and [%s].",
                                        interceptor.priority(),
                                        lastInterceptor.getSimpleName(),
                                        element.getSimpleName())
                        );
                    }
                    //不存在相同优先级的拦截器，加入列表
                    interceptors.put(interceptor.priority(), element);
                } else {
                    logger.error("A interceptor verify failed, its " + element.asType());
                }
            }

            //获取IInterceptor接口
            TypeElement type_ITollgate = elementUtils.getTypeElement(IINTERCEPTOR);
            //获取IInterceptorGroup接口
            TypeElement type_ITollgateGroup = elementUtils.getTypeElement(IINTERCEPTOR_GROUP);
            /**
             *创建参数类型Map<Integer, Class<? extends IInterceptor>>
             **/
            ParameterizedTypeName inputMapTypeOfTollgate = ParameterizedTypeName.get(
                    ClassName.get(Map.class),
                    ClassName.get(Integer.class),
                    ParameterizedTypeName.get(
                            ClassName.get(Class.class),
                            WildcardTypeName.subtypeOf(ClassName.get(type_ITollgate))
                    )
            );

            //创建参数Map<Integer, Class<? extends IInterceptor>> interceptors
            ParameterSpec tollgateParamSpec = ParameterSpec.builder(inputMapTypeOfTollgate, "interceptors").build();

            /**
             * 创建方法
             * @Override
             * public void loadInfo(Map<Integer, Class<? extends IInterceptor>> interceptor)
             *
             */
            MethodSpec.Builder loadIntoMethodOfTollgateBuilder = MethodSpec.methodBuilder(METHOD_LOAD_INTO)
                    .addAnnotation(Override.class)
                    .addModifiers(PUBLIC)
                    .addParameter(tollgateParamSpec);

            /**
             * 添加将各个拦截器加入列表的语句
             * @Override
             * public void loadInfo(Map<Integer, Class<? extends IInterceptor>> interceptor){
             *     interceptors.put(优先级,拦截器类信息)
             * }
             */
            if (null != interceptors && interceptors.size() > 0) {
                // Build method body
                for (Map.Entry<Integer, Element> entry : interceptors.entrySet()) {
                    loadIntoMethodOfTollgateBuilder.addStatement("interceptors.put(" + entry.getKey() + ", $T.class)", ClassName.get((TypeElement) entry.getValue()));
                }
            }

            /**
             * 创建添加Interceptor列表类
             * public class ARouter$$Interceptors$$模块名称 implements IInterceptorGroup{
             *     @Override
             *     public void loadInto(Map<Integer, Class<? extends IInterceptor>> interceptor){
             *         interceptors.put(优先级,拦截器类信息);
             *     }
             * }
             */
            JavaFile.builder(PACKAGE_OF_GENERATE_FILE,
                    TypeSpec.classBuilder(NAME_OF_INTERCEPTOR + SEPARATOR + moduleName)
                            .addModifiers(PUBLIC)
                            .addJavadoc(WARNING_TIPS)
                            .addMethod(loadIntoMethodOfTollgateBuilder.build())
                            .addSuperinterface(ClassName.get(type_ITollgateGroup))
                            .build()
            ).build().writeTo(mFiler);

        }
    }

    /**
     * 校验原始是不是被Interceptor注解，并且是IInterceptor子类
     *
     * @param element Interceptor taw type
     * @return verify result
     */
    private boolean verify(Element element) {
        Interceptor interceptor = element.getAnnotation(Interceptor.class);
        return null != interceptor && ((TypeElement) element).getInterfaces().contains(iInterceptor);
    }
}

主要生成一个按优先级添加IInterceptor列表的类，在ARouter.init()时通过此类将IInterceptor列表加载进内存。然后通过InterceptorService来进行拦截器管理。后续在详解InterceptorService

public class ARouter$$Interceptors$$模块名称 implements IInterceptorGroup{
    @Override
    public void loadInto(Map<Integer, Class<? extends IInterceptor>> interceptor){
        interceptors.put(优先级,拦截器类信息);
    }
}

AutowiredProcessor

public class AutowiredProcessor extends BaseProcessor {
    /**
     * 需要自动装配的成员变量和它的父节点类列表<父节点类,当前类需要自动装配的成员变量列表>
     */
    private Map<TypeElement, List<Element>> parentAndChild = new HashMap<>(); 
@Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        if (CollectionUtils.isNotEmpty(set)) {
            try {
                logger.info(">>> Found autowired field, start... <<<");
                //遍历所有Autowired注解，并按父节点类加入列表
                categories(roundEnvironment.getElementsAnnotatedWith(Autowired.class));
                //根据父节点类列表生成对应装配类
                generateHelper();

            } catch (Exception e) {
                logger.error(e);
            }
            return true;
        }

        return false;
    }
/**
     * @throws IOException
     * @throws IllegalAccessException
     */
    private void generateHelper() throws IOException, IllegalAccessException {
        //...省略代码

        //创建参数Object target
        ParameterSpec objectParamSpec = ParameterSpec.builder(TypeName.OBJECT, "target").build();

        if (MapUtils.isNotEmpty(parentAndChild)) {
            //遍历parentAndChild
            for (Map.Entry<TypeElement, List<Element>> entry : parentAndChild.entrySet()) {
                /**
                 * 创建inject方法
                 * @Override
                 * public void inject(Object target)
                 */
                MethodSpec.Builder injectMethodBuilder = MethodSpec.methodBuilder(METHOD_INJECT)
                        .addAnnotation(Override.class)
                        .addModifiers(PUBLIC)
                        .addParameter(objectParamSpec);

                TypeElement parent = entry.getKey();
                List<Element> childs = entry.getValue();
                //获取父节点类的限定名
                String qualifiedName = parent.getQualifiedName().toString();
                //获取父节点类包名
                String packageName = qualifiedName.substring(0, qualifiedName.lastIndexOf("."));
                //父节点类对应装配器类名
                String fileName = parent.getSimpleName() + NAME_OF_AUTOWIRED;

                logger.info(">>> Start process " + childs.size() + " field in " + parent.getSimpleName() + " ... <<<");
                /**
                 * 创建装配器类
                 * public class 父节点类包名$$ARouter$$Autowired implements ISyringe{
                 *      public void inject(Object target){
                 *
                 *      }
                 * }
                 */
                TypeSpec.Builder helper = TypeSpec.classBuilder(fileName)
                        .addJavadoc(WARNING_TIPS)
                        .addSuperinterface(ClassName.get(type_ISyringe))
                        .addModifiers(PUBLIC);
                //创建变量 SerializationService serializationService，用来对Object变量进行序列化和反序列化
                FieldSpec jsonServiceField = FieldSpec.builder(TypeName.get(type_JsonService.asType()), "serializationService", Modifier.PRIVATE).build();
                helper.addField(jsonServiceField);
                //inject方法中添加初始化serializationService语句
                injectMethodBuilder.addStatement("serializationService = $T.getInstance().navigation($T.class)", ARouterClass, ClassName.get(type_JsonService));
                //inject方法中添加对参数target进行强制类型转换语句
                injectMethodBuilder.addStatement("$T substitute = ($T)target", ClassName.get(parent), ClassName.get(parent));

                // 遍历待装配变量列表
                for (Element element : childs) {
                    Autowired fieldConfig = element.getAnnotation(Autowired.class);
                    //获取装配变量名
                    String fieldName = element.getSimpleName().toString();
                    //如果变量类型是iProvider，这通过ARouter.getInstance().navigation(类)，来进行装配
                    if (types.isSubtype(element.asType(), iProvider)) {  // It's provider
                        if ("".equals(fieldConfig.name())) {    // User has not set service path, then use byType.

                            // Getter
                            injectMethodBuilder.addStatement(
                                    "substitute." + fieldName + " = $T.getInstance().navigation($T.class)",
                                    ARouterClass,
                                    ClassName.get(element.asType())
                            );
                        } else {    // use byName
                            // Getter
                            injectMethodBuilder.addStatement(
                                    "substitute." + fieldName + " = ($T)$T.getInstance().build($S).navigation()",
                                    ClassName.get(element.asType()),
                                    ARouterClass,
                                    fieldConfig.name()
                            );
                        }

                        // Validater
                        if (fieldConfig.required()) {
                            injectMethodBuilder.beginControlFlow("if (substitute." + fieldName + " == null)");
                            injectMethodBuilder.addStatement(
                                    "throw new RuntimeException(\"The field '" + fieldName + "' is null, in class '\" + $T.class.getName() + \"!\")", ClassName.get(parent));
                            injectMethodBuilder.endControlFlow();
                        }
                    } else {    // It's normal intent value
                        String originalValue = "substitute." + fieldName;
                        String statement = "substitute." + fieldName + " = " + buildCastCode(element) + "substitute.";
                        boolean isActivity = false;
                        //如果是activity则通过getIntent()获取传递的数据
                        if (types.isSubtype(parent.asType(), activityTm)) {  // Activity, then use getIntent()
                            isActivity = true;
                            statement += "getIntent().";
                        } else if (types.isSubtype(parent.asType(), fragmentTm) || types.isSubtype(parent.asType(), fragmentTmV4)) {   // Fragment, then use getArguments()
                            //如果是fragment则通过getArguments()获取传递的数据
                            statement += "getArguments().";
                        } else {
                            throw new IllegalAccessException("The field [" + fieldName + "] need autowired from intent, its parent must be activity or fragment!");
                        }
                        //根据变量的不同类型，创建对应的获取语句
                        statement = buildStatement(originalValue, statement, typeUtils.typeExchange(element), isActivity);
                        if (statement.startsWith("serializationService.")) {   // Not mortals
                            injectMethodBuilder.beginControlFlow("if (null != serializationService)");
                            injectMethodBuilder.addStatement(
                                    "substitute." + fieldName + " = " + statement,
                                    (StringUtils.isEmpty(fieldConfig.name()) ? fieldName : fieldConfig.name()),
                                    ClassName.get(element.asType())
                            );
                            injectMethodBuilder.nextControlFlow("else");
                            injectMethodBuilder.addStatement(
                                    "$T.e(\"" + Consts.TAG + "\", \"You want automatic inject the field '" + fieldName + "' in class '$T' , then you should implement 'SerializationService' to support object auto inject!\")", AndroidLog, ClassName.get(parent));
                            injectMethodBuilder.endControlFlow();
                        } else {
                            injectMethodBuilder.addStatement(statement, StringUtils.isEmpty(fieldConfig.name()) ? fieldName : fieldConfig.name());
                        }

                        // Validator
                        if (fieldConfig.required() && !element.asType().getKind().isPrimitive()) {  // Primitive wont be check.
                            injectMethodBuilder.beginControlFlow("if (null == substitute." + fieldName + ")");
                            injectMethodBuilder.addStatement(
                                    "$T.e(\"" + Consts.TAG + "\", \"The field '" + fieldName + "' is null, in class '\" + $T.class.getName() + \"!\")", AndroidLog, ClassName.get(parent));
                            injectMethodBuilder.endControlFlow();
                        }
                    }
                }

                helper.addMethod(injectMethodBuilder.build());

                // 生成装配器类文件
                JavaFile.builder(packageName, helper.build()).build().writeTo(mFiler);
            }
        }
    }
}

主要是生成对应类的装配器，路径在\build\generated\ap_generated_sources\debug\out\对应包名\对应使用Autowired的类

public class 父节点类包名$$ARouter$$Autowired implements ISyringe{
    public void inject(Object target){
        //例如
        TestActivity substitute = (TestActivity )target;
        substitute.text =  substitute.getIntent().getIntExtra("text");
    }
}

然后在调用ARouter.getInstance().inject(this);时，通过AutowiredService管理类创建装配器类，然后进行变量装配。后面详解

初始化

ARouter初始化一般是在Application中调用ARouter.init(context);

public static void init(Application application) {
    if (!hasInit) {
        logger = _ARouter.logger;
        _ARouter.logger.info(Consts.TAG, "ARouter init start.");
        hasInit = _ARouter.init(application);
        if (hasInit) {
            _ARouter.afterInit();
        }
        _ARouter.logger.info(Consts.TAG, "ARouter init over.");
    }
}

最终会通过_ARouter.init(application)调用LogisticsCenter.init(mContext, executor)

public class LogisticsCenter {
    public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {
        try {
            //...省略代码
            if (registerByPlugin) {
                logger.info(TAG, "Load router map by arouter-auto-register plugin.");
            } else {
                Set<String> routerMap;
                //...省略代码
                // 如果是debug版本或者app版本更新，就重新加载所有com.alibaba.android.arouter.routes.*文件路径,不然就从sp中获取，这样只有第一次慢一点
                if (ARouter.debuggable() || PackageUtils.isNewVersion(context)) {
                    logger.info(TAG, "Run with debug mode or new install, rebuild router map.");
                    // These class was generated by arouter-compiler.
                    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 finishes.
                } 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>()));
                }

                logger.info(TAG, "Find router map finished, map size = " + routerMap.size() + ", cost " + (System.currentTimeMillis() - startInit) + " ms.");
                startInit = System.currentTimeMillis();
                //变量所有的路由文件
                for (String className : routerMap) {
                    if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) {
                        //如果是GroupRoot,通过反射创建对象，并加载到Warehouse.groupsIndex列表中
                        // This one of root elements, load 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
                        //如果是拦截器Group,通过反射创建对象，并加载到Warehouse.interceptorsIndex列表中
                        ((IInterceptorGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.interceptorsIndex);
                    } else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_PROVIDERS)) {
                        // Load providerIndex
                        //如果是ProviderGroup,通过反射创建对象，并加载到Warehouse.providersIndex列表中
                        ((IProviderGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.providersIndex);
                    }
                }
            }

            logger.info(TAG, "Load root element finished, cost " + (System.currentTimeMillis() - startInit) + " ms.");

            if (Warehouse.groupsIndex.size() == 0) {
                logger.error(TAG, "No mapping files were found, check your configuration please!");
            }

            if (ARouter.debuggable()) {
                logger.debug(TAG, String.format(Locale.getDefault(), "LogisticsCenter has already been loaded, GroupIndex[%d], InterceptorIndex[%d], ProviderIndex[%d]", Warehouse.groupsIndex.size(), Warehouse.interceptorsIndex.size(), Warehouse.providersIndex.size()));
            }
        } catch (Exception e) {
            throw new HandlerException(TAG + "ARouter init logistics center exception! [" + e.getMessage() + "]");
        }
    }
}

初始化主要完成了

扫描所有com.alibaba.android.arouter.routes.*文件路径，因为注解处理器生成的java文件都在这个路径下
通过反射创建对应对象
根据类型调用相应loadInfo方法加载到Warehouse中，Warehouse可以理解就是一个路由表。

_ARouter.init初始化完，注意调用了_ARouter.afterInit()

final class _ARouter {
    //...
    static void afterInit() {
        interceptorService = (InterceptorService) ARouter.getInstance().build("/arouter/service/interceptor").navigation();
    }
    //...
}

这里初始化了拦截器管理类，后面再详解如何创建及什么时候使用。

使用路由

路由的基本使用：ARouter.getInstance().build("app/main").withBoolean("state",true).navigation();

ARouter.build会直接调用_ARouter.getInstance().build(path)，build有多个重载方法，build(string)、build(url)，build(path、group)，最后调用都一样，我们以build(string)为例。

final class _ARouter {
//...省略代码
    protected Postcard build(String path) {
        //判空
        if (TextUtils.isEmpty(path)) {
            throw new HandlerException(Consts.TAG + "Parameter is invalid!");
        } else {
            //获取路由替换服务，PathReplaceService就是一个IProvider，提供forString、forUrl对路由地址进行替换。获取过程后面详解。
            PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
            if (null != pService) {
                //如果路由替换服务不为空，调用替换方法
                path = pService.forString(path);
            }
            //调用重载方法build(path,group)返回Postcard
            return build(path, extractGroup(path));
        }
    }
//...省略代码
}

在build(path)方法中首先会通过PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);获取我们自定义的PathReplaceService，例如：

@Route(path = "/app/replace")
public class MyPathReplaceService implements PathReplaceService {
    @Override
    public String forString(String path) {
        if(path.equals(ActivityConsts.ACTIVITY_URL_SECOND)){
            return ActivityConsts.ACTIVITY_URL_THIRD;
        }
        return path;
    }
    @Override
    public Uri forUri(Uri uri) {
        return null;
    }
    @Override
    public void init(Context context) {

    }
}

如果获取PathReplaceService不为空，则调用forString(path)对当前路由进行替换。我们先来看一下PathReplaceService的获取方式。PathReplaceService继承IProvider接口，所以它的获取方式IProvider的获取方式一样，所以后面所有获取IProvider都可以参考这个。一层层跟进，最后会调用

final class _ARouter {
    //...省略代码
    protected <T> T navigation(Class<? extends T> service) {
        try {
            //通过Warehouse.providersIndex表，根据class name获取Postcard
            Postcard postcard = LogisticsCenter.buildProvider(service.getName());

            // Compatible 1.0.5 compiler sdk.
            // Earlier versions did not use the fully qualified name to get the service
            if (null == postcard) {
                // No service, or this service in old version.
                postcard = LogisticsCenter.buildProvider(service.getSimpleName());
            }

            if (null == postcard) {
                return null;
            }
            //校验Postcard，添加相应属性，并通过反射创建相应IProvider对象
            LogisticsCenter.completion(postcard);
            return (T) postcard.getProvider();
        } catch (NoRouteFoundException ex) {
            logger.warning(Consts.TAG, ex.getMessage());
            return null;
        }
    }
    //...省略代码
}

根据class name从init时加载的Warehouse.providersIndex表中获取Postcard
使用LogisticsCenter.completion(postcard)方法校验Postcard，添加相应属性，并通过反射创建相应IProvider对象

跟进看一下LogisticsCenter.completion

public class LogisticsCenter {
    //...省略代码
    public synchronized static void completion(Postcard postcard) {
        if (null == postcard) {
            throw new NoRouteFoundException(TAG + "No postcard!");
        }
        //从Warehouse.routes路由表加载对应路由信息
        RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath());
        //如果还未加载过对应路由
        if (null == routeMeta) {
            //先获取对应group分组
            Class<? extends IRouteGroup> groupMeta = Warehouse.groupsIndex.get(postcard.getGroup());
            //如果不存在对应分组，直接报错
            if (null == groupMeta) {
                throw new NoRouteFoundException(TAG + "There is no route match the path [" + postcard.getPath() + "], in group [" + postcard.getGroup() + "]");
            } else {
                // Load route and cache it into memory, then delete from metas.
                try {
                    if (ARouter.debuggable()) {
                        logger.debug(TAG, String.format(Locale.getDefault(), "The group [%s] starts loading, trigger by [%s]", postcard.getGroup(), postcard.getPath()));
                    }
                    //通过反射创建对应分组对象
                    IRouteGroup iGroupInstance = groupMeta.getConstructor().newInstance();
                    //将该分组下所有路由信息加载到Warehouse.routes
                    iGroupInstance.loadInto(Warehouse.routes);
                    //从分组列表中删除对应分组，避免多次加载
                    Warehouse.groupsIndex.remove(postcard.getGroup());

                    if (ARouter.debuggable()) {
                        logger.debug(TAG, String.format(Locale.getDefault(), "The group [%s] has already been loaded, trigger by [%s]", postcard.getGroup(), postcard.getPath()));
                    }
                } catch (Exception e) {
                    throw new HandlerException(TAG + "Fatal exception when loading group meta. [" + e.getMessage() + "]");
                }
                //重新调用completion
                completion(postcard);
            }
        } else {
            //如果已加载过对应路由，添加相应属性
            postcard.setDestination(routeMeta.getDestination());
            postcard.setType(routeMeta.getType());
            postcard.setPriority(routeMeta.getPriority());
            postcard.setExtra(routeMeta.getExtra());
            //如果是通过Uri获取路由
            Uri rawUri = postcard.getUri();
            if (null != rawUri) {
                //获取Uri中的参数，并根据Autowired注解变量的类型，将参数设置到Bundle中，用于后面变量的自动装配
                Map<String, String> resultMap = TextUtils.splitQueryParameters(rawUri);
                Map<String, Integer> paramsType = routeMeta.getParamsType();

                if (MapUtils.isNotEmpty(paramsType)) {
                    for (Map.Entry<String, Integer> params : paramsType.entrySet()) {
                        setValue(postcard,
                                params.getValue(),
                                params.getKey(),
                                resultMap.get(params.getKey()));
                    }
                    postcard.getExtras().putStringArray(ARouter.AUTO_INJECT, paramsType.keySet().toArray(new String[]{}));
                }
                postcard.withString(ARouter.RAW_URI, rawUri.toString());
            }

            switch (routeMeta.getType()) {
                case PROVIDER:
                    //如果是注解是PROVIDER类型
                    Class<? extends IProvider> providerMeta = (Class<? extends IProvider>) routeMeta.getDestination();
                    //判断Warehouse.providers列表中是否已经创建了对应的IProvider
                    IProvider instance = Warehouse.providers.get(providerMeta);
                    if (null == instance) {
                        //如果没有创建，通过反射创建对应IProvider对象，并添加到Warehouse.providers列表中
                        IProvider provider;
                        try {
                            provider = providerMeta.getConstructor().newInstance();
                            provider.init(mContext);
                            Warehouse.providers.put(providerMeta, provider);
                            instance = provider;
                        } catch (Exception e) {
                            throw new HandlerException("Init provider failed! " + e.getMessage());
                        }
                    }
                    //对postcard中的IProvider进行赋值
                    postcard.setProvider(instance);
                    //设置IProvider不能被拦截
                    postcard.greenChannel();
                    break;
                case FRAGMENT:
                    postcard.greenChannel();
                default:
                    break;
            }
        }
    }
    //...省略代码
}

检查路由是否已经加载，如果加载了会放在Warehouse.routes表中
如果没有记载过此路由，先加载路由分组，通过反射创建分组对象，并将该分组下的所有路由加载到Warehouse.routes表，重新加载路由
根据路由信息更新postcard对应字段，Postcard下边详解
如果是通过Uri获取路由，需要根据参数类型将Uri中传递的参数加载到Postcard的Bundle中
如果是PROVIDER类型，则通过反射创建相应对象，调用IProvider.init方法进行初始化，并添加到Warehouse.providers表中
对Postcard的provider字段进行赋值，设置provider不能被拦截

Postcard可以理解为路由组装类，类似于builder模式

定义了activity跳转、fragment传递数据的Bundle，并提供设置参数的接口及Object序列化服务
支持设置activity跳转动画及启动模式
如果当前RouteMeta的类型是Iprovider，会提供provider实例
greenChannel标记当前路由是否可以被拦截

public final class Postcard extends RouteMeta {
    // Base
    private Uri uri;
    //传递数据
    private Bundle mBundle;        
    //activity启动模式
    private int flags = -1;        
    //拦截超时 
    private int timeout = 300;     
    //如果当前路由是IProvider,就会被设置
    private IProvider provider;     
    //表示是否会被拦截，true不能被拦截
    private boolean greenChannel;
    //mBundle设置Object是序列化服务
    private SerializationService serializationService;

    //activity跳转动画
    private Bundle optionsCompat;    // The transition animation of activity
    private int enterAnim;
    private int exitAnim;
    //...省略代码
    public void navigation(Activity mContext, int requestCode, NavigationCallback callback) {
        ARouter.getInstance().navigation(mContext, this, requestCode, callback);
    }
    //...省略代码
}

执行路由Postcard.navigation()，直接执行ARouter.getInstance().navigation(mContext, this, requestCode, callback);最终都会调用_ARouter.getInstance().navigation

final class _ARouter {
    /**
     * 执行路由
     *
     * @param context     Activity or null.
     * @param postcard    Route metas 路由
     * @param requestCode RequestCode activity请求码
     * @param callback    路由执行回调
     */
    protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
        //获取预处理服务，PretreatmentService就是一个IProvider,获取方式和PathReplaceService一样
        PretreatmentService pretreatmentService = ARouter.getInstance().navigation(PretreatmentService.class);
        if (null != pretreatmentService && !pretreatmentService.onPretreatment(context, postcard)) {
            //预处理服务不为空，并且预处理失败，则不执行路由
            return null;
        }

        try {
            /**
             * 补全路由数据，由于build返回的Postcard对象，是我们手动填写的路由地址，但路由并不一定存在,
             * 所有通过LogisticsCenter.completion来校验是否存在此路由，并补全Postcard相关成员变量
             */
            LogisticsCenter.completion(postcard);
        } catch (NoRouteFoundException ex) {
            //路由不存在
            if (debuggable()) {
                // debug模式就Toast提醒
                runInMainThread(new Runnable() {
                    @Override
                    public void run() {
                        Toast.makeText(mContext, "There's no route matched!\n" +
                                " Path = [" + postcard.getPath() + "]\n" +
                                " Group = [" + postcard.getGroup() + "]", Toast.LENGTH_LONG).show();
                    }
                });
            }
            /**
             * 如果回调不为空,执行回调onLost，如果回调为空，执行降级策略，所有要注意设置了回调是不会执行降级策略的
             */
            if (null != callback) {
                callback.onLost(postcard);
            } else {
                //获取降级策略服务，DegradeService就是一个IProvider
                DegradeService degradeService = ARouter.getInstance().navigation(DegradeService.class);
                if (null != degradeService) {
                    degradeService.onLost(context, postcard);
                }
            }

            return null;
        }
        //回调onFound
        if (null != callback) {
            callback.onFound(postcard);
        }
        //是否能被拦截
        if (!postcard.isGreenChannel()) {
            //通过InterceptorService服务，检查是否被拦截
            interceptorService.doInterceptions(postcard, new InterceptorCallback() {
                /**
                 * 继续执行
                 * @param postcard route meta
                 */
                @Override
                public void onContinue(Postcard postcard) {
                    _navigation(context, postcard, requestCode, callback);
                }

                /**
                 * 被拦截
                 * @param exception Reson of interrupt.
                 */
                @Override
                public void onInterrupt(Throwable exception) {
                    if (null != callback) {
                        callback.onInterrupt(postcard);
                    }
                }
            });
        } else {
            //继续执行路由
            return _navigation(context, postcard, requestCode, callback);
        }

        return null;
    }

    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()) {
            //如果是Activity路由
            case ACTIVITY:
                // 创建Intent并添加数据
                final Intent intent = new Intent(currentContext, postcard.getDestination());
                intent.putExtras(postcard.getExtras());

                // 设置启动模式
                int flags = postcard.getFlags();
                if (-1 != flags) {
                    intent.setFlags(flags);
                } else if (!(currentContext instanceof Activity)) {
                    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                }

                // 设置action
                String action = postcard.getAction();
                if (!TextUtils.isEmpty(action)) {
                    intent.setAction(action);
                }

                // 在主线程启动activity
                runInMainThread(new Runnable() {
                    @Override
                    public void run() {
                        startActivity(requestCode, currentContext, intent, postcard, callback);
                    }
                });

                break;
            case PROVIDER:
                //如果是IProvider路由,直接返回
                return postcard.getProvider();
            case BOARDCAST:
            case CONTENT_PROVIDER:
            case FRAGMENT:
                /**
                 * 如果是BoardCast、ContentProvider、Fragment路由，通过反射调用无参数构造函数继续创建，
                 * 所有BoardCast、ContentProvider类型基本上没什么用
                 */
                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;
    }
}

获取预处理服务PretreatmentService，如果预处理失败则结束路由执行。PretreatmentService获取方式和PathReplaceService一样
LogisticsCenter.completion(postcard)校验路由，由于build返回的Postcard对象，是我们手动填写的路由地址，但路由并不一定存在,所有通过LogisticsCenter.completion来校验是否存在此路由，并补全Postcard相关成员变量
路由不存在，如果有设置回调，则执行onLost，否则获取降级策略DegradeService，并执行。所以要注意如果设置了回调就不会调用降级策略
路由存在，则校验路由类型，并根据不同类型执行

路由的执行过程到这就结束了。

路由拦截

通过前面分析我们知道，路由拦截是通过InterceptorService实现的，InterceptorService的初始化后 _ARouter.afterInit()进行

static void afterInit() {
        // Trigger interceptor init, use byName.
        interceptorService = (InterceptorService) ARouter.getInstance().build("/arouter/service/interceptor").navigation();
}

通过路由"/arouter/service/interceptor"获取InterceptorService的实例InterceptorServiceImpl，定义在arouter-api。由于InterceptorServiceImpl继承IProvider接口，在初始化后会调用对应init()方法。

@Route(path = "/arouter/service/interceptor")
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() {
                //在ARouter.init中会将所有定义的interceptor加载到Warehouse.interceptorsIndex列表中
                //如果Warehouse.interceptorsIndex不为空
                if (MapUtils.isNotEmpty(Warehouse.interceptorsIndex)) {
                    //遍历所有拦截器，由于Warehouse.interceptorsIndex是TreeMap类型，默认按key的默认顺序进行排序，而key是Integer类型，所以key越小，优先级越高。
                    for (Map.Entry<Integer, Class<? extends IInterceptor>> entry : Warehouse.interceptorsIndex.entrySet()) {
                        Class<? extends IInterceptor> interceptorClass = entry.getValue();
                        try {
                            //通过反射创建IInterceptor对应实例
                            IInterceptor iInterceptor = interceptorClass.getConstructor().newInstance();
                            //调用init进行初始化
                            iInterceptor.init(context);
                            //添加到Warehouse.interceptors列表
                            Warehouse.interceptors.add(iInterceptor);
                        } catch (Exception ex) {
                            throw new HandlerException(TAG + "ARouter init interceptor error! name = [" + interceptorClass.getName() + "], reason = [" + ex.getMessage() + "]");
                        }
                    }
                    //设置加载完成标志位
                    interceptorHasInit = true;

                    logger.info(TAG, "ARouter interceptors init over.");
                    //释放同步锁
                    synchronized (interceptorInitLock) {
                        interceptorInitLock.notifyAll();
                    }
                }
            }
        });
    }
}

InterceptorServiceImpl.init(context)主要是通过异步方式，按优先级加载所有的 interceptor：

遍历Warehouse.interceptorsIndex列表，由于Warehouse.interceptorsIndex是TreeMap类型，默认按key的默认顺序进行排序，key的类型是Integer，所以key越小，优先级越高
通过反射创建IInterceptor对应实例
调用init进行初始化，添加到Warehouse.interceptors列表

执行拦截doInterceptions

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

    @Override
    public void doInterceptions(final Postcard postcard, final InterceptorCallback callback) {
        //如果拦截器列表不为空
        if (null != Warehouse.interceptors && Warehouse.interceptors.size() > 0) {
            //等待拦截器列表初始化完成，10秒超时
            checkInterceptorsInitStatus();
            //如果超时后还未初始化完成，直接回调拦截
            if (!interceptorHasInit) {
                callback.onInterrupt(new HandlerException("Interceptors initialization takes too much time."));
                return;
            }
            //异步执行拦截
            LogisticsCenter.executor.execute(new Runnable() {
                @Override
                public void run() {
                    CancelableCountDownLatch interceptorCounter = new CancelableCountDownLatch(Warehouse.interceptors.size());
                    try {
                        //通过interceptorCounter根据优先级串行调用拦截器，如果被拦截，取消interceptorCounter，继续执行interceptorCounter.await之后代码
                        _excute(0, interceptorCounter, postcard);
                        //等待遍历拦截器列表，如果interceptorCounter未减为0或者超时，则阻塞等待
                        interceptorCounter.await(postcard.getTimeout(), TimeUnit.SECONDS);
                        
                        if (interceptorCounter.getCount() > 0) {
                            //如果interceptorCounter.getCount() > 0,证明是超时唤醒
                            callback.onInterrupt(new HandlerException("The interceptor processing timed out."));
                        } else if (null != postcard.getTag()) {    
                            //在路由被拦截时，会设置tag，所以null != postcard.getTag证明被拦截
                            callback.onInterrupt(new HandlerException(postcard.getTag().toString()));
                        } else {
                            //不拦截，继续执行
                            callback.onContinue(postcard);
                        }
                    } catch (Exception e) {
                        callback.onInterrupt(e);
                    }
                }
            });
        } else {
            //不拦截，继续执行
            callback.onContinue(postcard);
        }
    }
}

等待拦截器列表初始化完成，10秒超时
异步执行拦截，通过interceptorCounter根据优先级串行调用拦截器，如果被拦截，取消interceptorCounter，继续执行interceptorCounter.await之后代码
根据interceptorCounter.getCount判断执行拦截或超时

自动装配

使用@Autowired注解后，需要在使用之前会调用ARouter.getInstance().inject(this)来完成自动装配。

static void inject(Object thiz) {
        AutowiredService autowiredService = ((AutowiredService) ARouter.getInstance().build("/arouter/service/autowired").navigation());
        if (null != autowiredService) {
            autowiredService.autowire(thiz);
        }
}

自动装配主要是通过AutowiredService来进行管理的，通过“/arouter/service/autowired”路由获取到的是AutowiredServiceImpl。定义在arouter-api中

@Route(path = "/arouter/service/autowired")
public class AutowiredServiceImpl implements AutowiredService {
    /**
     * ISyringe缓存
     */
    private LruCache<String, ISyringe> classCache;
    /**
     * 黑名单，不能autowire的类名
     */
    private List<String> blackList;

    @Override
    public void autowire(Object instance) {
        String className = instance.getClass().getName();
        try {
            //不存在黑名单
            if (!blackList.contains(className)) {
                //获取缓存
                ISyringe autowiredHelper = classCache.get(className);
                if (null == autowiredHelper) {
                    //不存在缓存，通过反射创建对应装配器实例。前面我们说过AutowiredProcessor会为每个包含Autowired注解的类生成一个装配器类
                    autowiredHelper = (ISyringe) Class.forName(instance.getClass().getName() + SUFFIX_AUTOWIRED).getConstructor().newInstance();
                }
                //进行装配
                autowiredHelper.inject(instance);
                //添加到缓存，避免多次创建
                classCache.put(className, autowiredHelper);
            }
        } catch (Exception ex) {
            //加入黑名单
            blackList.add(className);
        }
    }
}

主要通过反射创建对应AutowiredProcessor生成的装配器类，调用装配器类的inject进行注入。

JALLV

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ARouter使用及原理分析

简介ARouter是阿里开源的路由组件，是 Android 平台中对页面、服务提供路由功能的中间件，常被用来进行组件化通讯。功能介绍支持直接解析标准URL进行跳转，并自动注入参数到目标页面中支持多模块工程使用支持添加多个拦截器，自定义拦截顺序支持依赖注入，可单独作为依赖注入框架使用支持InstantRun 支持MultiDex(Google方案) 映射关系按组分类、...
复制链接

扫一扫