ARouter源码分析上

• What is ARouter

  A framework for assisting in the renovation of Android app componentization
  

  官方介绍只有简短的一句话总结，一套协助Android app组件化革新的框架。

• Why to use it

  即便是组件化，我们其实也可以用startActivity的方式来进行跳转，那ARouter又有何特殊之处呢？

  1. 传统的方式，不管是url传参还是bundle传参都较为繁琐，需要把参数先设置到url或者bundle，然后在跳转页通过getIntent方法来获取传参，ARouter把这部分工作封装了起来。通过链式调用设置参数，通过Autowired注解获取参数。
  2. 支持组件化，ARouter的组件化在于不需要module间相互依赖就可以互相跳转。
  3. 支持interceptor，可以通过interceptor做一些跳转前的逻辑，比如需要登录状态才能访问的页面。
  4. 支持依赖注入，通过AOP思想把注解映射成路由类。
  5. 支持Instant Run方式编译的apk。
  6. 支持MultiDex。
  7. 支持业务类Service，通过Route和Autowired注解和Service类联系起来。

• How to use it & Why it work

  • 依赖

    每一个需要使用ARouter的module下的build.gradle中添加下面配置（可以把这块抽出来，通过apply from: '../xx.gradle'去引用）：

    //如果含有kotlin代码，需要添加一下kotlin plugin
    apply plugin: 'kotlin-kapt'
    
    //使用ARouter auto-register自动扫描路由信息，非必选，通过gradle注册，性能更优
    apply plugin: 'com.alibaba.arouter'
    
    android {
        defaultConfig {
            ...
            javaCompileOptions {
                annotationProcessorOptions {
                    arguments = [AROUTER_MODULE_NAME: project.getName()]
                }
            }
        }
    }
    
    //使用ARouter auto-register自动扫描路由信息，非必选，通过gradle注册，性能更优
    buildscript {
        repositories {
            jcenter()
        }
    
        dependencies {
            //ARouter auto-register，Replace with the latest versios
            classpath "com.alibaba:arouter-register:?"
        }
    }
    
    //如果是包含kotlin类的路由，需要添加下面代码
    kapt {
        arguments {
            arg("AROUTER_MODULE_NAME", project.getName())
        }
    }
    
    dependencies {
        // Replace with the latest version
        //使用api继承依赖，不需要每个module都添加
        api 'com.alibaba:arouter-api:?'
        //这个不能使用api依赖继承，所以每个module都要添加
        annotationProcessor 'com.alibaba:arouter-compiler:?'
        //如果是kotlin，需要添加kotlin编译jar包
        kapt 'com.alibaba:arouter-compiler:?'
        ...
    }
    

  • 两种加载方式

    通过Route、Autowired、Interceptor等ARouter注解修饰的类需要被加载到一些Map中，这些Map被放在Warehouse类中：

    class Warehouse {
        // Cache route and metas
        static Map> groupsIndex = new HashMap<>();
        static Map routes = new HashMap<>();
    
        // Cache provider
        static Map providers = new HashMap<>();
        static Map providersIndex = new HashMap<>();
    
        // Cache interceptor
        static Map> interceptorsIndex = new UniqueKeyTreeMap<>("More than one interceptors use same priority [%s]");
        static List interceptors = new ArrayList<>();
    
        static void clear() {
            routes.clear();
            groupsIndex.clear();
            providers.clear();
            providersIndex.clear();
            interceptors.clear();
            interceptorsIndex.clear();
        }
    }
    

    加载的方式有两种，一种是通过plugin来利用gradle的构建自动生成加载代码的方式加载，另一种是通过java代码手动扫描出含有这些注解的类，这也是初始化的两种方式，官方提倡使用register-plugin自动生成性能更好。

  • 初始化

    class MyApp : MultiDexApplication() {
    
        override fun onCreate() {
            super.onCreate()
            if(BuildConfig.DEBUG){
                ARouter.openLog()
                ARouter.openDebug()
            }
            ARouter.init(this)
        }
      
        override fun onTerminate() {
            super.onTerminate()
            ARouter.getInstance().destroy()
        }
    }
    

    为了app安全考虑，非debug版本下不要输出log和打开debug模式。

    看一下ARouter的init方法做了什么：

    /**
     * Init, it must be call before used router.
     */
    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的类去做的，Arouter只是它的包装类。__ARouter的init方法返回hasInit标志是否已成功初始化：

    protected static synchronized boolean init(Application application) {
        mContext = application;
        LogisticsCenter.init(mContext, executor);
        logger.info(Consts.TAG, "ARouter init success!");
        hasInit = true;
        mHandler = new Handler(Looper.getMainLooper());
    
        return true;
    }
    

    此处又调用了LogisticsCenter.init方法：

    /**
     * LogisticsCenter init, load all metas in memory. Demand initialization
     */
    public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {
        mContext = context;
        executor = tpe;
    
        try {
            long startInit = System.currentTimeMillis();
            //billy.qi modified at 2017-12-06
            //load by plugin first
            loadRouterMap();
            if (registerByPlugin) {
                logger.info(TAG, "Load router map by arouter-auto-register plugin.");
            } else {
                Set routerMap;
    
                // It will rebuild router map every times when debuggable.
                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()));
                }
    
                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)) {
                        // 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
                        ((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);
                    }
                }
            }
    
            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() + "]");
        }
    }
    

    首先调用了loadRouterMap()方法来试图通过arouter-auto-register plugin加载route信息：

    /**
     * arouter-auto-register plugin will generate code inside this method
     * call this method to register all Routers, Interceptors and Providers
     * @author billy.qi Contact me.
     * @since 2017-12-06
     */
    private static void loadRouterMap() {
        registerByPlugin = false;
        //auto generate register code by gradle plugin: arouter-auto-register
        // looks like below:
        // registerRouteRoot(new ARouter..Root..modulejava());
        // registerRouteRoot(new ARouter..Root..modulekotlin());
    }
    

    这个方法里什么也没有，因为这里要交给plugin去注册，默认设置为不通过plugin注册，通过注释可以得知，plugin会把加载逻辑代码动态的生成在这个方法里，至于怎样生成的另起篇文章总结。

    下载arouter-register的source包查看:

    class RouteMethodVisitor extends MethodVisitor {
    
        RouteMethodVisitor(int api, MethodVisitor mv) {
            super(api, mv)
        }
    
        @Override
        void visitInsn(int opcode) {
            //generate code before return
            if ((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN)) {
                extension.classList.each { name ->
                    name = name.replaceAll("/", ".")
                    mv.visitLdcInsn(name)//类名
                    // generate invoke register method into LogisticsCenter.loadRouterMap()
                    mv.visitMethodInsn(Opcodes.INVOKESTATIC
                            , ScanSetting.GENERATE_TO_CLASS_NAME
                            , ScanSetting.REGISTER_METHOD_NAME
                            , "(Ljava/lang/String;)V"
                            , false)
                }
            }
            super.visitInsn(opcode)
        }
        @Override
        void visitMaxs(int maxStack, int maxLocals) {
            super.visitMaxs(maxStack + 4, maxLocals)
        }
    }
    

    mv.visitMethodInsn方法就是注入加载代码的地方，采用循环的方式来加载每一个类。ScanSetting.GENERATE_TO_CLASS_NAME是：

    /**
     * The register code is generated into this class
     */
    static final String GENERATE_TO_CLASS_NAME = 'com/alibaba/android/arouter/core/LogisticsCenter'
    

    ScanSetting.REGISTER_METHOD_NAME是：

    /**
     * register method name in class: {@link #GENERATE_TO_CLASS_NAME}
     */
    static final String REGISTER_METHOD_NAME = 'register'
    

    在arouter-api的jar包中找到LogisticsCenter的register方法：

    /**
     * register by class name
     * Sacrificing a bit of efficiency to solve
     * the problem that the main dex file size is too large
     * @author billy.qi Contact me.
     * @param className class name
     */
    private static void register(String className) {
        if (!TextUtils.isEmpty(className)) {
            try {
                Class clazz = Class.forName(className);
                Object obj = clazz.getConstructor().newInstance();
                if (obj instanceof IRouteRoot) {
                    registerRouteRoot((IRouteRoot) obj);
                } else if (obj instanceof IProviderGroup) {
                    registerProvider((IProviderGroup) obj);
                } else if (obj instanceof IInterceptorGroup) {
                    registerInterceptor((IInterceptorGroup) obj);
                } else {
                    logger.info(TAG, "register failed, class name: " + className
                            + " should implements one of IRouteRoot/IProviderGroup/IInterceptorGroup.");
                }
            } catch (Exception e) {
                logger.error(TAG,"register class error:" + className);
            }
        }
    }
    

    三个方法分别是注册Root（页面）、Interceptor、IProvider（Service）的逻辑：

    /**
     * method for arouter-auto-register plugin to register Routers
     * @param routeRoot IRouteRoot implementation class in the package: com.alibaba.android.arouter.core.routers
     * @author billy.qi Contact me.
     * @since 2017-12-06
     */
    private static void registerRouteRoot(IRouteRoot routeRoot) {
        markRegisteredByPlugin();
        if (routeRoot != null) {
            routeRoot.loadInto(Warehouse.groupsIndex);
        }
    }
    
    /**
     * method for arouter-auto-register plugin to register Interceptors
     * @param interceptorGroup IInterceptorGroup implementation class in the package: com.alibaba.android.arouter.core.routers
     * @author billy.qi Contact me.
     * @since 2017-12-06
     */
    private static void registerInterceptor(IInterceptorGroup interceptorGroup) {
        markRegisteredByPlugin();
        if (interceptorGroup != null) {
            interceptorGroup.loadInto(Warehouse.interceptorsIndex);
        }
    }
    
    /**
     * method for arouter-auto-register plugin to register Providers
     * @param providerGroup IProviderGroup implementation class in the package: com.alibaba.android.arouter.core.routers
     * @author billy.qi Contact me.
     * @since 2017-12-06
     */
    private static void registerProvider(IProviderGroup providerGroup) {
        markRegisteredByPlugin();
        if (providerGroup != null) {
            providerGroup.loadInto(Warehouse.providersIndex);
        }
    }
    

    markRegisteredByPlugin是修改registerByPlugin标志位：

    /**
     * mark already registered by arouter-auto-register plugin
     * @author billy.qi Contact me.
     * @since 2017-12-06
     */
    private static void markRegisteredByPlugin() {
        if (!registerByPlugin) {
            registerByPlugin = true;
        }
    }
    

    可以看到，对于不同类型的route类分别保存到Warehouse中对应的Map中，注意这里添加的只是类，不是跳转的所有信息。

    回到init方法，判断registerByPlugin是否为true来决定是否手动加载，如果没有设置register-plugin，则会走到else分支，这里就是手动代码检索路由信息的地方：

    if (ARouter.debuggable() || PackageUtils.isNewVersion(context))判断如果是debug模式或者是新版本更新的话就重新检索路由信息，核心代码就是ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE)，ROUTE_ROOT_PACKAGE是：

    public static final String ROUTE_ROOT_PAKCAGE = "com.alibaba.android.arouter.routes";
    

    public static Set getFileNameByPackageName(Context context, final String packageName) throws PackageManager.NameNotFoundException, IOException, InterruptedException {
        final Set classNames = new HashSet<>();
    
        List paths = getSourcePaths(context);
        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 {
                        if (path.endsWith(EXTRACTED_SUFFIX)) {
                            //NOT use new DexFile(path), because it will throw "permission error in /data/dalvik-cache"
                            dexfile = DexFile.loadDex(path, path + ".tmp", 0);
                        } else {
                            dexfile = new DexFile(path);
                        }
    
                        Enumeration dexEntries = dexfile.entries();
                        while (dexEntries.hasMoreElements()) {
                            String className = dexEntries.nextElement();
                            if (className.startsWith(packageName)) {
                                classNames.add(className);
                            }
                        }
                    } catch (Throwable ignore) {
                        Log.e("ARouter", "Scan map file in dex files made error.", ignore);
                    } finally {
                        if (null != dexfile) {
                            try {
                                dexfile.close();
                            } catch (Throwable ignore) {
                            }
                        }
    
                        parserCtl.countDown();
                    }
                }
            });
        }
    
        parserCtl.await();
    
        Log.d(Consts.TAG, "Filter " + classNames.size() + " classes by packageName <" + packageName + ">");
        return classNames;
    }
    

    这里的工作就是多线程读取所有的dex文件，逐个判断里面的className，如果className是以com.alibaba.android.arouter.routes开头的则存入classNames集合，最终会返回所有com.alibaba.android.arouter.routes开头的类名。

    注意在最前面有一个getSourcePaths方法来获取apk的所有dex文件的位置，然后从这些位置读取dex文件：

     /**
         * get all the dex path
         *
         * @param context the application context
         * @return all the dex path
         * @throws PackageManager.NameNotFoundException
         * @throws IOException
         */
        public static List getSourcePaths(Context context) throws PackageManager.NameNotFoundException, IOException {
            ApplicationInfo applicationInfo = context.getPackageManager().getApplicationInfo(context.getPackageName(), 0);
            File sourceApk = new File(applicationInfo.sourceDir);
    
            List sourcePaths = new ArrayList<>();
            sourcePaths.add(applicationInfo.sourceDir); //add the default apk path
    
            //the prefix of extracted file, ie: test.classes
            String extractedFilePrefix = sourceApk.getName() + EXTRACTED_NAME_EXT;
    
    //        如果VM已经支持了MultiDex，就不要去Secondary Folder加载 Classesx.zip了，那里已经么有了
    //        通过是否存在sp中的multidex.version是不准确的，因为从低版本升级上来的用户，是包含这个sp配置的
            if (!isVMMultidexCapable()) {
                //the total dex numbers
                int totalDexNumber = getMultiDexPreferences(context).getInt(KEY_DEX_NUMBER, 1);
                File dexDir = new File(applicationInfo.dataDir, SECONDARY_FOLDER_NAME);
    
                for (int secondaryNumber = 2; secondaryNumber <= totalDexNumber; secondaryNumber++) {
                    //for each dex file, ie: test.classes2.zip, test.classes3.zip...
                    String fileName = extractedFilePrefix + secondaryNumber + EXTRACTED_SUFFIX;
                    File extractedFile = new File(dexDir, fileName);
                    if (extractedFile.isFile()) {
                        sourcePaths.add(extractedFile.getAbsolutePath());
                        //we ignore the verify zip part
                    } else {
                        throw new IOException("Missing extracted secondary dex file '" + extractedFile.getPath() + "'");
                    }
                }
            }
    
            if (ARouter.debuggable()) { // Search instant run support only debuggable
                sourcePaths.addAll(tryLoadInstantRunDexFile(applicationInfo));
            }
            return sourcePaths;
        }
    

    isVMMultidexCapable判断是否JVM支持MultiDex了，就是判断JVM的版本（2.1之后的支持）：

    /**
     * Identifies if the current VM has a native support for multidex, meaning there is no need for
     * additional installation by this library.
     *
     * @return true if the VM handles multidex
     */
    private static boolean isVMMultidexCapable() {
        boolean isMultidexCapable = false;
        String vmName = null;
    
        try {
            if (isYunOS()) {    // YunOS需要特殊判断
                vmName = "'YunOS'";
                isMultidexCapable = Integer.valueOf(System.getProperty("ro.build.version.sdk")) >= 21;
            } else {    // 非YunOS原生Android
                vmName = "'Android'";
                String versionString = System.getProperty("java.vm.version");
                if (versionString != null) {
                    Matcher matcher = Pattern.compile("(\\d+)\\.(\\d+)(\\.\\d+)?").matcher(versionString);
                    if (matcher.matches()) {
                        try {
                            int major = Integer.parseInt(matcher.group(1));
                            int minor = Integer.parseInt(matcher.group(2));
                            isMultidexCapable = (major > VM_WITH_MULTIDEX_VERSION_MAJOR)
                                    || ((major == VM_WITH_MULTIDEX_VERSION_MAJOR)
                                    && (minor >= VM_WITH_MULTIDEX_VERSION_MINOR));
                        } catch (NumberFormatException ignore) {
                            // let isMultidexCapable be false
                        }
                    }
                }
            }
        } catch (Exception ignore) {
    
        }
    
        Log.i(Consts.TAG, "VM with name " + vmName + (isMultidexCapable ? " has multidex support" : " does not have multidex support"));
        return isMultidexCapable;
    }
    

    取到routeMap之后会把它存到SP中，最后遍历routeMap，根据前缀Root、Interceptors、Providers的不同分别存入Warehouse中的对应xxxIndex的map中，这一步和自动加载是一样的。

    至此，初始化工作就完成了。

  • 路由名称注意

    Route注解指定的路由path中格式为/groupName/elseName...，至少含有两个‘/’且groupName不能为空。因为ARouter会自动生成以groupName为后缀的类，可以在build的generated包下找到。

    arouter-api:xxx的这个jar包下的routes包中有三个已经存在的类：

    ARouter$$Group$$arouter：

    public class ARouter$$Group$$arouter implements IRouteGroup {
        public ARouter$$Group$$arouter() {
        }
    
        public void loadInto(Map atlas) {
            atlas.put("/arouter/service/autowired", RouteMeta.build(RouteType.PROVIDER, AutowiredServiceImpl.class, "/arouter/service/autowired", "arouter", (Map)null, -1, -2147483648));
            atlas.put("/arouter/service/interceptor", RouteMeta.build(RouteType.PROVIDER, InterceptorServiceImpl.class, "/arouter/service/interceptor", "arouter", (Map)null, -1, -2147483648));
        }
    }
    

    ARouter$$Providers$$arouterapi:

    public class ARouter$$Providers$$arouterapi implements IProviderGroup {
        public ARouter$$Providers$$arouterapi() {
        }
    
        public void loadInto(Map providers) {
            providers.put("com.alibaba.android.arouter.facade.service.AutowiredService", RouteMeta.build(RouteType.PROVIDER, AutowiredServiceImpl.class, "/arouter/service/autowired", "arouter", (Map)null, -1, -2147483648));
            providers.put("com.alibaba.android.arouter.facade.service.InterceptorService", RouteMeta.build(RouteType.PROVIDER, InterceptorServiceImpl.class, "/arouter/service/interceptor", "arouter", (Map)null, -1, -2147483648));
        }
    }
    

    ARouter$$Root$$arouterapi：

    public class ARouter$$Root$$arouterapi implements IRouteRoot {
        public ARouter$$Root$$arouterapi() {
        }
    
        public void loadInto(Map> routes) {
            routes.put("arouter", arouter.class);
        }
    }
    

    在build中还会自动生成ARouter$$Providers$$moduleName、ARouter$$Root$$moduleName，moduleName是模块的名字。以module是app为例，ARouter$$Root$$app为：

    public class ARouter$$Root$$app implements IRouteRoot {
      @Override
      public void loadInto(Map> routes) {
        routes.put("john", ARouter$$Group$$john.class);
        routes.put("rxseriers", ARouter$$Group$$rxseriers.class);
      }
    }
    

    前面分析的初始化中会调用到loadInto方法，这里就会把ARouter$$Group$$john.class和ARouter$$Group$$rxseriers.class保存到Warehouse.groupsIndex中。

    而Route注解生成的类的类名格式为ARouter$$Group$$groupName，知道了这些之后，我们可以得出结论，路由中的groupName不能是“arouter”，倘若相同，自动生成的class名就会和routes包下的默认存在的class同名，那么routes.put("arouter", ARouter$$Group$$john.class)传入的class就会被routes中的同名class替代，从而导致找不到自定义的路由类的问题。

  • 跳转

    Example：

    ARouter.getInstance().build(Const.LOGIN_ACTIVITY_PATH).withString("name","John").navigation()
    

    通过单例模式获取ARouter实例：

    public static ARouter getInstance() {
        if (!hasInit) {
            throw new InitException("ARouter::Init::Invoke init(context) first!");
        } else {
            if (instance == null) {
                synchronized (ARouter.class) {
                    if (instance == null) {
                        instance = new ARouter();
                    }
                }
            }
            return instance;
        }
    }
    

    可以看到实例化之前必须先初始化。

    build有多个重载方法：

    /**
     * Build postcard by path and default group
     */
    protected Postcard build(String path) {
        if (TextUtils.isEmpty(path)) {
            throw new HandlerException(Consts.TAG + "Parameter is invalid!");
        } else {
            PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
            if (null != pService) {
                path = pService.forString(path);
            }
            return build(path, extractGroup(path), true);
        }
    }
    
    /**
     * Build postcard by uri
     */
    protected Postcard build(Uri uri) {
        if (null == uri || TextUtils.isEmpty(uri.toString())) {
            throw new HandlerException(Consts.TAG + "Parameter invalid!");
        } else {
            PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
            if (null != pService) {
                uri = pService.forUri(uri);
            }
            return new Postcard(uri.getPath(), extractGroup(uri.getPath()), uri, null);
        }
    }
    
    /**
     * Build postcard by path and group
     */
    protected Postcard build(String path, String group, Boolean afterReplace) {
        if (TextUtils.isEmpty(path) || TextUtils.isEmpty(group)) {
            throw new HandlerException(Consts.TAG + "Parameter is invalid!");
        } else {
            if (!afterReplace) {
                PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
                if (null != pService) {
                    path = pService.forString(path);
                }
            }
            return new Postcard(path, group);
        }
    }
    
    }
    

    其实就是两种方式，一个参数是String类型的path，这就是Route注解的path属性的值，另一个参数是Uri类型，这种形式最终使用的是Uri的path值，无论哪种形式，都必须是/groupName/???的格式，extractGroup方法决定了这样：

    /**
     * Extract the default group from path.
     */
    private String extractGroup(String path) {
        if (TextUtils.isEmpty(path) || !path.startsWith("/")) {
            throw new HandlerException(Consts.TAG + "Extract the default group failed, the path must be start with '/' and contain more than 2 '/'!");
        }
    
        try {
            String defaultGroup = path.substring(1, path.indexOf("/", 1));
            if (TextUtils.isEmpty(defaultGroup)) {
                throw new HandlerException(Consts.TAG + "Extract the default group failed! There's nothing between 2 '/'!");
            } else {
                return defaultGroup;
            }
        } catch (Exception e) {
            logger.warning(Consts.TAG, "Failed to extract default group! " + e.getMessage());
            return null;
    }
    

    所以build之后得到了一个Postcard(明信片)对象，接下来是调用它的navigation方法。

    navigation方法同样有多个重载方法，所有可传参数有：Activity mContext, int requestCode, NavigationCallback callback。mContext若不传就是构建时传入的application上下文，requestCode是用以forResult方式打开Activity的需求，可以传一个callback以自定义处理一些特殊情况。

    最终会调用到_ARouter的navigation方法中：

    protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
        PretreatmentService pretreatmentService = ARouter.getInstance().navigation(PretreatmentService.class);
        if (null != pretreatmentService && !pretreatmentService.onPretreatment(context, postcard)) {
            // Pretreatment failed, navigation canceled.
            return null;
        }
    
        try {
            LogisticsCenter.completion(postcard);
        } catch (NoRouteFoundException ex) {
            logger.warning(Consts.TAG, ex.getMessage());
    
            if (debuggable()) {
                // Show friendly tips for user.
                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();
                    }
                });
            }
    
            if (null != callback) {
                callback.onLost(postcard);
            } else {
                // No callback for this invoke, then we use the global degrade service.
                DegradeService degradeService = ARouter.getInstance().navigation(DegradeService.class);
                if (null != degradeService) {
                    degradeService.onLost(context, postcard);
                }
            }
    
            return null;
        }
    
        if (null != callback) {
            callback.onFound(postcard);
        }
    
        if (!postcard.isGreenChannel()) {   // It must be run in async thread, maybe interceptor cost too mush time made ANR.
            interceptorService.doInterceptions(postcard, new InterceptorCallback() {
                /**
                 * Continue process
                 *
                 * @param postcard route meta
                 */
                @Override
                public void onContinue(Postcard postcard) {
                    _navigation(context, postcard, requestCode, callback);
                }
    
                /**
                 * Interrupt process, pipeline will be destory when this method called.
                 *
                 * @param exception Reson of interrupt.
                 */
                @Override
                public void onInterrupt(Throwable exception) {
                    if (null != callback) {
                        callback.onInterrupt(postcard);
                    }
    
                    logger.info(Consts.TAG, "Navigation failed, termination by interceptor : " + exception.getMessage());
                }
            });
        } else {
            return _navigation(context, postcard, requestCode, callback);
        }
    
        return null;
    }
    

    这里只看核心代码，LogisticsCenter.completion(postcard)用于完善和检查Postcard的必要信息，暂时先不看，先看方法最终的逻辑：

    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);
                }
    
                // Set Actions
                String action = postcard.getAction();
                if (!TextUtils.isEmpty(action)) {
                    intent.setAction(action);
                }
    
                // Navigation in main looper.
                runInMainThread(new Runnable() {
                    @Override
                    public void run() {
                        startActivity(requestCode, currentContext, intent, postcard, callback);
                    }
                });
    
                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;
    }
    
    /**
     * Start activity
     *
     * @see ActivityCompat
     */
    private void startActivity(int requestCode, Context currentContext, Intent intent, Postcard postcard, NavigationCallback callback) {
        if (requestCode >= 0) {  // Need start for result
            if (currentContext instanceof Activity) {
                ActivityCompat.startActivityForResult((Activity) currentContext, intent, requestCode, postcard.getOptionsBundle());
            } else {
                logger.warning(Consts.TAG, "Must use [navigation(activity, ...)] to support [startActivityForResult]");
            }
        } else {
            ActivityCompat.startActivity(currentContext, intent, postcard.getOptionsBundle());
        }
    
        if ((-1 != postcard.getEnterAnim() && -1 != postcard.getExitAnim()) && currentContext instanceof Activity) {    // Old version.
            ((Activity) currentContext).overridePendingTransition(postcard.getEnterAnim(), postcard.getExitAnim());
        }
    
        if (null != callback) { // Navigation over.
            callback.onArrival(postcard);
        }
    }
    

    可以看到，最底层也是调用了startActvity或startActivityForResult（requestCode大于0且context是Activity）来处理回调，动画和NavigationCallback的处理也是在这里。

    回过头来我们看一下LogisticsCenter.completion(postcard)方法，它只在navigation方法里面最开始调用：

    public synchronized static void completion(Postcard postcard) {
        if (null == postcard) {
            throw new NoRouteFoundException(TAG + "No postcard!");
        }
    
        RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath());
        if (null == routeMeta) {    // Maybe its does't exist, or didn't load.
            Class groupMeta = Warehouse.groupsIndex.get(postcard.getGroup());  // Load route meta.
            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();
                    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(postcard);   // Reload
            }
        } else {
            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.
                Map resultMap = TextUtils.splitQueryParameters(rawUri);
                Map paramsType = routeMeta.getParamsType();
    
                if (MapUtils.isNotEmpty(paramsType)) {
                    // Set value by its type, just for params which annotation by @Param
                    for (Map.Entry params : paramsType.entrySet()) {
                        setValue(postcard,
                                params.getValue(),
                                params.getKey(),
                                resultMap.get(params.getKey()));
                    }
    
                    // Save params name which need auto inject.
                    postcard.getExtras().putStringArray(ARouter.AUTO_INJECT, paramsType.keySet().toArray(new String[]{}));
                }
    
                // Save raw uri
                postcard.withString(ARouter.RAW_URI, rawUri.toString());
            }
    
            switch (routeMeta.getType()) {
                case PROVIDER:  // if the route is provider, should find its instance
                    // Its provider, so it must implement IProvider
                    Class providerMeta = (Class) routeMeta.getDestination();
                    IProvider instance = Warehouse.providers.get(providerMeta);
                    if (null == instance) { // There's no instance of this provider
                        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.setProvider(instance);
                    postcard.greenChannel();    // Provider should skip all of interceptors
                    break;
                case FRAGMENT:
                    postcard.greenChannel();    // Fragment needn't interceptors
                default:
                    break;
            }
        }
    }
    

    还记得之前init的时候已经把自动生成的Root类保存进了Warehouse.groupsIndex了吧，这里首先会从Warehouse.groupsIndex中取RouteMeta，如果没取到说明之前没有跳转过，则从Warehouse.groupsIndex中取得之前存入的class，取到之后调用groupMeta.getConstructor().newInstance()反射生成实例，调用它的loadInto(Warehouse.routes)方法，这里我定义的是@Route(path="/john/")，所以生成的是ARouter$$Group$$john：

    /**
     * DO NOT EDIT THIS FILE!!! IT WAS GENERATED BY AROUTER. */
    public class ARouter$$Group$$john implements IRouteGroup {
      @Override
      public void loadInto(Map atlas) {
        atlas.put("/john/", RouteMeta.build(RouteType.ACTIVITY, LoginActivity.class, "/john/", "john", new java.util.HashMap(){{put("name", 8); put("age", 3); }}, -1, -2147483648));
      }
    }
    

    那么loadInto方法就是这里的，做的工作就是把生成的RouteMeta对象保存进Warehouse.routes，后面再次递归调用completion方法，再次进来，Warehouse.routes内就含有了RouteMeta对象。

    我们看一下自动生成的RouteMeta都含有什么关键信息。

    首先第一个参数RouteType，标志跳转目标的类型:

    public enum RouteType {
        ACTIVITY(0, "android.app.Activity"),
        SERVICE(1, "android.app.Service"),
        PROVIDER(2, "com.alibaba.android.arouter.facade.template.IProvider"),
        CONTENT_PROVIDER(-1, "android.app.ContentProvider"),
        BOARDCAST(-1, ""),
        METHOD(-1, ""),
        FRAGMENT(-1, "android.app.Fragment"),
        UNKNOWN(-1, "Unknown route type");
    
        int id;
        String className;
    
        public int getId() {
            return id;
        }
    
        public RouteType setId(int id) {
            this.id = id;
            return this;
        }
    
        public String getClassName() {
            return className;
        }
    
        public RouteType setClassName(String className) {
            this.className = className;
            return this;
        }
    
        RouteType(int id, String className) {
            this.id = id;
            this.className = className;
        }
    
        public static RouteType parse(String name) {
            for (RouteType routeType : RouteType.values()) {
                if (routeType.getClassName().equals(name)) {
                    return routeType;
                }
            }
    
            return UNKNOWN;
        }
    }
    

    第二个参数是Class类型，是跳转目标类。第三个参数是Route定义的path。第四个参数是group。第五个参数是Map，用于保存Autowired参数类型的，value是整型，表示enum.ordinal：

    public enum TypeKind {
        // Base type
        BOOLEAN,
        BYTE,
        SHORT,
        INT,
        LONG,
        CHAR,
        FLOAT,
        DOUBLE,
    
        // Other type
        STRING,
        SERIALIZABLE,
        PARCELABLE,
        OBJECT;
    }
    

    通过setValue方法赋值到postcard的mBundle：

    private static void setValue(Postcard postcard, Integer typeDef, String key, String value) {
        if (TextUtils.isEmpty(key) || TextUtils.isEmpty(value)) {
            return;
        }
    
        try {
            if (null != typeDef) {
                if (typeDef == TypeKind.BOOLEAN.ordinal()) {
                    postcard.withBoolean(key, Boolean.parseBoolean(value));
                } else if (typeDef == TypeKind.BYTE.ordinal()) {
                    postcard.withByte(key, Byte.parseByte(value));
                } else if (typeDef == TypeKind.SHORT.ordinal()) {
                    postcard.withShort(key, Short.parseShort(value));
                } else if (typeDef == TypeKind.INT.ordinal()) {
                    postcard.withInt(key, Integer.parseInt(value));
                } else if (typeDef == TypeKind.LONG.ordinal()) {
                    postcard.withLong(key, Long.parseLong(value));
                } else if (typeDef == TypeKind.FLOAT.ordinal()) {
                    postcard.withFloat(key, Float.parseFloat(value));
                } else if (typeDef == TypeKind.DOUBLE.ordinal()) {
                    postcard.withDouble(key, Double.parseDouble(value));
                } else if (typeDef == TypeKind.STRING.ordinal()) {
                    postcard.withString(key, value);
                } else if (typeDef == TypeKind.PARCELABLE.ordinal()) {
                    // TODO : How to description parcelable value with string?
                } else if (typeDef == TypeKind.OBJECT.ordinal()) {
                    postcard.withString(key, value);
                } else {    // Compatible compiler sdk 1.0.3, in that version, the string type = 18
                    postcard.withString(key, value);
                }
            } else {
                postcard.withString(key, value);
            }
        } catch (Throwable ex) {
            logger.warning(Consts.TAG, "LogisticsCenter setValue failed! " + ex.getMessage());
        }
    }
    

    注意这里setValue使用resultMap.get(params.getKey())来尝试获取Uri中的值，就是Uri中‘?’到‘#’(可以没有)之间的‘xx=xx&xx=xx&...’键值对。

    第六个参数是priority，设置优先级，通过Route注解的priority属性指定，最后一个参数通过Route注解的extras属性指定。

  • 参数传递

    对于基本的类型传递，Postcard中都有对应的方法withXxx()来设置，对于实例化类型，如果实现了Serializable或Parcelable的，可以调用withSerializable和withParcelable方法设置。

    而对于自定义的未实现上述接口的则需要调用withObject方法：

    public Postcard withObject(@Nullable String key, @Nullable Object value) {
        serializationService = ARouter.getInstance().navigation(SerializationService.class);
        mBundle.putString(key, serializationService.object2Json(value));
        return this;
    }
    

    可见需要定义实现自SerializationService的类，譬如：

    @Route(path = AppConstant.ARouteService.SERVICE_SERIALIZATION)
    public class ModuleSerializationRouteServiceImpl implements SerializationService {
    
        private Gson gson;
        private GsonBuilder gsonBuilder;
    
        @Override
        public  T json2Object(String input, Class clazz) {
            return null;
        }
    
        @Override
        public String object2Json(Object instance) {
            return gson.toJson(instance);
        }
    
        @Override
        public  T parseObject(String input, Type clazz) {
            return gson.fromJson(input, clazz);
        }
    
        @Override
        public void init(Context context) {
            gsonBuilder = new GsonBuilder();
            gsonBuilder.registerTypeAdapter(Class.class, new ClassTypeAdapter());
            gson = gsonBuilder.create();
        }
    }
    

    这里的navigation(Class service)是：

    protected  T navigation(Class service) {
        try {
            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;
            }
    
            LogisticsCenter.completion(postcard);
            return (T) postcard.getProvider();
        } catch (NoRouteFoundException ex) {
            logger.warning(Consts.TAG, ex.getMessage());
            return null;
        }
    }
    

    LogisticsCenter.buildProvider从Warehouse.providersIndex中取得provider：

    public static Postcard buildProvider(String serviceName) {
        RouteMeta meta = Warehouse.providersIndex.get(serviceName);
    
        if (null == meta) {
            return null;
        } else {
            return new Postcard(meta.getPath(), meta.getGroup());
        }
    }
    

    实例化SerializationService和调用它的init的代码就在completion中的：

    switch (routeMeta.getType()) {
        case PROVIDER:  // if the route is provider, should find its instance
            // Its provider, so it must implement IProvider
            Class providerMeta = (Class) routeMeta.getDestination();
            IProvider instance = Warehouse.providers.get(providerMeta);
            if (null == instance) { // There's no instance of this provider
                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.setProvider(instance);
            postcard.greenChannel();    // Provider should skip all of interceptors
            break;
                ...
              
    }
    

    所以实际上withObject存储的是对象的json字符串。

  • 传参自动注入

    传参自然需要获取参数，上面我们知道最终也是通过intent和bundle传递的参数，那么获取的时候当然也可是通过getIntent().getExtras()方法获取参数值。

    对于ARouter，这些工作我们还可以通过Autowiredz注解自动完成。

    要完成自动注入需要两点，一点是必须在每个需要自动注入的属性上面加Autowired注解，它有三个注解属性，必须要有的是name属性，这个属性的值必须和跳转时传递到bundle的key相同，如果指定了name属性，则字段的名字不必和bundle的key相同，反之则必须相同；第二个是required属性，如果设置为true则表示该Field的值不能为null，否则会crash；最后一个参数是desc，用于描述Field的作用。注意如果是kotlin类，则需要同时加上@JvmField属性，否则不能通过kapt编译。

    另一点是需要在使用自动注入的字段的值之前调用ARouter.getInstance().inject(this)方法，否则使用值为null的实例会抛出NullPointerException异常。

    下面我们看看，对于这些要求ARouter是怎么通过代码设置的。

    首先，含有Autowired注解的类会被自动生成一个名为“类名$$ARouter$$Autowired”的类，那么ARouter.getInstance().inject(this)方法调用了_ARouter的inject方法：

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

    可见，这里会找到path为/arouter/service/autowired的AutowiredService，那这个接口的实现类在哪里，还记得我们初始化的时候for循环loadInto操作吗，就在那个时候前缀为com.alibaba.android.arouter.routes.ARouter$$Providers的类被存到了Warehouse.providesIndex中，所以jar包arouter-api中的ARouter$$Providers$$arouterapi类自然也被加进去了，所以completion中找到这个类调用它的loadInto方法：

    public void loadInto(Map providers) {
        providers.put("com.alibaba.android.arouter.facade.service.AutowiredService", RouteMeta.build(RouteType.PROVIDER, AutowiredServiceImpl.class, "/arouter/service/autowired", "arouter", (Map)null, -1, -2147483648));
        providers.put("com.alibaba.android.arouter.facade.service.InterceptorService", RouteMeta.build(RouteType.PROVIDER, InterceptorServiceImpl.class, "/arouter/service/interceptor", "arouter", (Map)null, -1, -2147483648));
    }
    

    所以path为/arouter/service/autowired的就是AutowiredServiceImpl类，接下来调用它的autowire方法，传入的是被跳转页Activity的实例：

    @Override
    public void autowire(Object instance) {
        doInject(instance, null);
    }
    
    /**
     * Recursive injection
     *
     * @param instance who call me.
     * @param parent   parent of me.
     */
    private void doInject(Object instance, Class parent) {
        Class clazz = null == parent ? instance.getClass() : parent;
    
        ISyringe syringe = getSyringe(clazz);
        if (null != syringe) {
            syringe.inject(instance);
        }
    
        //这里可见会自动把其父类中的Autowired字段注入
        Class superClazz = clazz.getSuperclass();
        // has parent and its not the class of framework.
        if (null != superClazz && !superClazz.getName().startsWith("android")) {
            doInject(instance, superClazz);
        }
    }
    

    来看看getSyringe方法：

    private ISyringe getSyringe(Class clazz) {
        String className = clazz.getName();
    
        try {
            if (!blackList.contains(className)) {
                ISyringe syringeHelper = classCache.get(className);
                if (null == syringeHelper) {  // No cache.
                    syringeHelper = (ISyringe) Class.forName(clazz.getName() + SUFFIX_AUTOWIRED).getConstructor().newInstance();
                }
                classCache.put(className, syringeHelper);
                return syringeHelper;
            }
        } catch (Exception e) {
            blackList.add(className);    // This instance need not autowired.
        }
    
        return null;
    }
    

    (ISyringe) Class.forName(clazz.getName() + SUFFIX_AUTOWIRED).getConstructor().newInstance()这行代码就是获取自动生成的名为“类名$$ARouter$$Autowired”的类，这里比如说是LoginActivity类，那么这行代码就会找到LoginActivity$$ARouter$$Autowired：

    public class LoginActivity$$ARouter$$Autowired implements ISyringe {
      private SerializationService serializationService;
    
      @Override
      public void inject(Object target) {
        serializationService = ARouter.getInstance().navigation(SerializationService.class);
        LoginActivity substitute = (LoginActivity)target;
        substitute.name = substitute.getIntent().getExtras() == null ? substitute.name : substitute.getIntent().getExtras().getString("name", substitute.name);
        substitute.howOld = substitute.getIntent().getIntExtra("age", substitute.howOld);
      }
    }
    

    可见这个类实现自ISyringe接口，所以调用ISyringe的inject方法就是调用LoginActivity$$ARouter$$Autowired的inject方法，可以看到，这个方法里给这个Activity实例的相关字段赋值，取值来源也是通过getIntent()。

  • Service Management

    // Declaration interface, other components get the service instance through the interface
    public interface HelloService extends IProvider {
        String sayHello(String name);
    }
    
    @Route(path = "/yourservicegroupname/hello", name = "test service")
    public class HelloServiceImpl implements HelloService {
    
        @Override
        public String sayHello(String name) {
            return "hello, " + name;
        }
    
        @Override
        public void init(Context context) {
    
        }
    }
    

    结合Autowired就可以实现自动注入，原理同上。

  • NavigationCallback

    如果你需要在路由正常跳转或者没找到时做一些回调处理，那么可以在调用navigation方法时传入一个NavigationCallback对象用于处理：

    public interface NavigationCallback {
    
        /**
         * Callback when find the destination.
         *
         * @param postcard meta
         */
        void onFound(Postcard postcard);
    
        /**
         * Callback after lose your way.
         *
         * @param postcard meta
         */
        void onLost(Postcard postcard);
    
        /**
         * Callback after navigation.
         *
         * @param postcard meta
         */
        void onArrival(Postcard postcard);
    
        /**
         * Callback on interrupt.
         *
         * @param postcard meta
         */
        void onInterrupt(Postcard postcard);
    }
    

  • DegradeService

    对于NoRouteFoundException发生时，你可以通过NavigationCallback来处理，但需要每次navigation都需要指定，如果你需要指定一个全局通用的onLost处理，你可以定义一个类实现DegradeService接口，重写onLost方法，这样所有的navigation发生NoRouteFoundException时都会进入到此方法，因为navigation方法中：

    try {
        LogisticsCenter.completion(postcard);
    } catch (NoRouteFoundException ex) {
        logger.warning(Consts.TAG, ex.getMessage());
    
        if (debuggable()) {
            // Show friendly tips for user.
            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();
                }
            });
        }
    
        if (null != callback) {
            callback.onLost(postcard);
        } else {
            // No callback for this invoke, then we use the global degrade service.
            DegradeService degradeService = ARouter.getInstance().navigation(DegradeService.class);
            if (null != degradeService) {
                degradeService.onLost(context, postcard);
            }
        }
    
        return null;
    }
    

    可见，优先走NavigationCallback的onLost。

  • Interceptor

    navigation方法中，判断postcard.isGreenChannel()是否为false来决定是否需要拦截处理，如果是false，则进行拦截处理：

    interceptorService.doInterceptions(postcard, new InterceptorCallback() {
        /**
         * Continue process
         *
         * @param postcard route meta
         */
        @Override
        public void onContinue(Postcard postcard) {
            _navigation(context, postcard, requestCode, callback);
        }
    
        /**
         * Interrupt process, pipeline will be destory when this method called.
         *
         * @param exception Reson of interrupt.
         */
        @Override
        public void onInterrupt(Throwable exception) {
            if (null != callback) {
                callback.onInterrupt(postcard);
            }
    
            logger.info(Consts.TAG, "Navigation failed, termination by interceptor : " + exception.getMessage());
        }
    });
    

    interceptorService是什么时候实例化的呢？答案还是在初始化里面，init方法里，若成功执行完 _ARouter.init(application)方法则会返回true赋值给hasInit，hasInit为true会执行 _ARouter.afterInit()方法：

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

    同AutowiredService一样，初始化时在ARouter$$Providers$$arouterapi的loadInto中path为/arouter/service/interceptor的InterceptorServiceImpl.class被存进了Warehouse.interceptorsIndex，所以这里afterInit会取到InterceptorServiceImpl.class，它的doInterceptions方法如下：

    @Override
    public void doInterceptions(final Postcard postcard, final InterceptorCallback callback) {
        if (null != Warehouse.interceptors && Warehouse.interceptors.size() > 0) {
    
            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 {
                        _execute(0, interceptorCounter, postcard);
                        interceptorCounter.await(postcard.getTimeout(), TimeUnit.SECONDS);
                        if (interceptorCounter.getCount() > 0) {    // Cancel the navigation this time, if it hasn't return anythings.
                            callback.onInterrupt(new HandlerException("The interceptor processing timed out."));
                        } else if (null != postcard.getTag()) {    // Maybe some exception in the tag.
                            callback.onInterrupt(new HandlerException(postcard.getTag().toString()));
                        } else {
                            callback.onContinue(postcard);
                        }
                    } catch (Exception e) {
                        callback.onInterrupt(e);
                    }
                }
            });
        } else {
            callback.onContinue(postcard);
        }
    }
    

    checkInterceptorsInitStatus():

    private static void checkInterceptorsInitStatus() {
        synchronized (interceptorInitLock) {
            while (!interceptorHasInit) {
                try {
                    interceptorInitLock.wait(10 * 1000);
                } catch (InterruptedException e) {
                    throw new HandlerException(TAG + "Interceptor init cost too much time error! reason = [" + e.getMessage() + "]");
                }
            }
        }
    }
    

    只要interceptorHasInit不为true，则会一直阻塞当前线程等待，每10秒重新检查一次，那interceptorHasInit在哪里改变的？还记得在completion里：

    switch (routeMeta.getType()) {
        case PROVIDER:  // if the route is provider, should find its instance
            // Its provider, so it must implement IProvider
            Class providerMeta = (Class) routeMeta.getDestination();
            IProvider instance = Warehouse.providers.get(providerMeta);
            if (null == instance) { // There's no instance of this provider
                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.setProvider(instance);
            postcard.greenChannel();    // Provider should skip all of interceptors
            break;
        ...
    }
    

    此时是InterceptorServiceImpl，为什么InterceptorServiceImpl的Type是PROVIDER而不是INTERCEPTOR呢？因为ARouter$$Providers$$arouterapi的loadInto存入时设置的就是PROVIDER：

    providers.put("com.alibaba.android.arouter.facade.service.InterceptorService", RouteMeta.build(RouteType.PROVIDER, InterceptorServiceImpl.class, "/arouter/service/interceptor", "arouter", (Map)null, -1, -2147483648));
    

    所以provider.init()方法就是InterceptorServiceImpl的init方法：

    @Override
    public void init(final Context context) {
        LogisticsCenter.executor.execute(new Runnable() {
            @Override
            public void run() {
                if (MapUtils.isNotEmpty(Warehouse.interceptorsIndex)) {
                    for (Map.Entry> entry : Warehouse.interceptorsIndex.entrySet()) {
                        Class interceptorClass = entry.getValue();
                        try {
                            IInterceptor iInterceptor = interceptorClass.getConstructor().newInstance();
                            iInterceptor.init(context);
                            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();
                    }
                }
            }
        });
    }
    

    可以看到，这里会把Warehouse.interceptorsIndex里的所以interceptor都执行init方法，然后设置interceptorHasInit为true，因为这里的init方法是新建线程执行的，所以在执行的同时，completion后面的doInterceptions方法也在异步执行，所以现在可以理解checkInterceptorsInitStatus的意义了，它就是在等init完成，调用interceptorInitLock.notifyAll()结束wait，从而继续往下执行doInterceptions方法，如果因为等待时间太长被系统终止则会抛出InterruptedException异常。

    doInterceptions下面的代码就是开启子线程执行_execute方法，interceptorCounter.await同步等待 _executes执行完：

      private static void _execute(final int index, final CancelableCountDownLatch counter, final Postcard postcard) {
            if (index < Warehouse.interceptors.size()) {
                IInterceptor iInterceptor = Warehouse.interceptors.get(index);
                iInterceptor.process(postcard, new InterceptorCallback() {
                    @Override
                    public void onContinue(Postcard postcard) {
                        // Last interceptor excute over with no exception.
                        counter.countDown();
                        _execute(index + 1, counter, postcard);  // When counter is down, it will be execute continue ,but index bigger than interceptors size, then U know.
                    }
    
                    @Override
                    public void onInterrupt(Throwable exception) {
                        // Last interceptor excute over with fatal exception.
    
                        postcard.setTag(null == exception ? new HandlerException("No message.") : exception.getMessage());    // save the exception message for backup.
                        counter.cancel();
                        // Be attention, maybe the thread in callback has been changed,
                        // then the catch block(L207) will be invalid.
                        // The worst is the thread changed to main thread, then the app will be crash, if you throw this exception!
    //                    if (!Looper.getMainLooper().equals(Looper.myLooper())) {    // You shouldn't throw the exception if the thread is main thread.
    //                        throw new HandlerException(exception.getMessage());
    //                    }
                    }
                });
            }
        }
    

    这里就是对所有的Interceptor依次执行process方法，假如定义了一个Interceptor：

    @Interceptor(priority = 8, name = "test interceptor")
    public class TestInterceptor implements IInterceptor {
        @Override
        public void process(Postcard postcard, InterceptorCallback callback) {
            ...
            // No problem! hand over control to the framework
            if(LoginUtils.isLogin()){
                    callback.onContinue(postcard);
            }else{
              callback.onInterrupt(new Throwable("The Route needs login first!"));
            }
            
            // Interrupt routing process
            // callback.onInterrupt(new RuntimeException("Something exception"));      
    
            // The above two types need to call at least one of them, otherwise it will not continue routing
        }
    
        @Override
        public void init(Context context) {
            // Interceptor initialization, this method will be called when sdk is initialized, it will only be called once
        }
    }
    

    这里模拟了跳转需要登录的逻辑，如果已登录则执行跳转，如果未登录则intertupt。在process中调用callback.onContinue或者callback.onInterrupt方法就会回到_execute中处理。

    执行完后判断如果interceptorCounter的getCount大于0说明因Postcard超时时间到期中止，这个超时时间可以设置，默认300秒，如果postcard.getTag()不为null说明有异常产生，若顺利的话会走到callback.onContinue(postcard)，就会回调到_ARouter.navigation方法里doIntercaptions传入的匿名InterceptorCallback对象的onContinue方法，从而执行 _navigation方法执行跳转。

    至此，拦截工作就完成了。

  • Priority

    Interceptor的priority在哪设置的？@Interceptor注解修饰的类会被自动创建的ARouter$$Interceptors$$app存进Warehouse.interceptorsIndex中，原理同上：

    public class ARouter$$Interceptors$$app implements IInterceptorGroup {
      @Override
      public void loadInto(Map> interceptors) {
        interceptors.put(5, LoginInterceptor.class);
      }
    }
    

    因为我创建的Interceptor是：

    @Interceptor(name = "LoginInInterceptor" , priority = 5)
    class LoginInterceptor : IInterceptor {
    

    所以interceptors.put的参数分别是5和LoginInterceptor.class，5是设置的priority，为什么把priority作为key呢？因为Warehouse的interceptorsIndex是一个UniqueKeyTreeMap，它的put方法：

    @Override
    public V put(K key, V value) {
        if (containsKey(key)) {
            throw new RuntimeException(String.format(tipText, key));
        } else {
            return super.put(key, value);
        }
    }
    

    比其父类多的一个操作是首先判断不能添加重复key值的value。然后调用了父类TreeMap的put方法：

    public V put(K key, V value) {
        TreeMapEntry t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check
    
            root = new TreeMapEntry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        TreeMapEntry parent;
        // split comparator and comparable paths
        Comparator cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            @SuppressWarnings("unchecked")
                Comparable k = (Comparable) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        TreeMapEntry e = new TreeMapEntry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }
    

    可见会按照key值将新元素插入到合适的位置，顺序就是key值越小越靠前，而我们前面看到执行process的时候都是从Warehouse.interceptorsIndex的第0个元素开始，这也就是为什么它文档上写的priority越小优先级越高。

    Route注解里面也可以设置priority，但是我发现它好像没有用到，我唯一能想到的就是可以在NavigationCallback或者Interceptor中通过Postcard对象取到它然后根据它的值来做点什么逻辑，同样extra属性也是这样。

  • Pretreatment Service

    在navigation方法的最前面有这样几行代码：

    PretreatmentService pretreatmentService = ARouter.getInstance().navigation(PretreatmentService.class);
    if (null != pretreatmentService && !pretreatmentService.onPretreatment(context, postcard)) {
        // Pretreatment failed, navigation canceled.
        return null;
    }
    

    如果说Interceptor是在找到路由后、跳转之前的处理拦截，那PretreatmentService就是在查找路由之前的处理拦截：

    @Route(path = "/xxx/xxx")
    public class PretreatmentServiceImpl implements PretreatmentService {
        @Override
        public boolean onPretreatment(Context context, Postcard postcard) {
            // Do something before the navigation, if you need to handle the navigation yourself, the method returns false
        }
    
        @Override
        public void init(Context context) {
    
        }
    }
    

    官方注释告诉我们，如果你不希望通过ARouter自动跳转的话这里可以返回false，就不会执行查找路由等操作了。

    注意，PretreatmentService只能定义一个，因为：

    public class ARouter$$Providers$$app implements IProviderGroup {
      @Override
      public void loadInto(Map providers) {
        providers.put("com.alibaba.android.arouter.facade.service.PretreatmentService", RouteMeta.build(RouteType.PROVIDER, MyPreTreatmentService.class, "/lllSS/myPretreatmentService", "lllSS", null, 1, -2147483648));
        providers.put("com.alibaba.android.arouter.facade.service.PretreatmentService", RouteMeta.build(RouteType.PROVIDER, OtherPretreatmentService.class, "/lllSS/otherPretreatmentService", "lllSS", null, 2, -2147483648));
      }
    }
    

    定义多个，key值是一样的，因此只有最后一个会生效。

  • Rewrite URL

    在 _ARouter.build方法里有这样的处理：

    PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
    if (null != pService) {
        //path是String
        path = pService.forString(path);
        //path是Uri
        //path = pService.forUri(path);
    }
    

    也就是说出build传入的路由地址还可以通过PathReplaceService的api统一处理。

    定义如下：

    // Implement the PathReplaceService interface
    @Route(path = "/xxx/xxx")
    public class PathReplaceServiceImpl implements PathReplaceService {
        /**
        * For normal path.
        *
        * @param path raw path
        */
        String forString(String path) {
            // Custom logic
            return path;
        }
    
    /**
        * For uri type.
        *
        * @param uri raw uri
        */
        Uri forUri(Uri uri) {
            // Custom logic
            return url;
        }
    }
    

    同样，定义多个只会以ARouter$$Providers$$moduleName的loadInto里面put的最后一个key为com.alibaba.android.arouter.facade.service.PathReplaceService的为准。

• 其他API description

  // Build a standard route request
  ARouter.getInstance().build("/home/main").navigation();
  
  // Build a standard route request, via URI
  Uri uri;
  ARouter.getInstance().build(uri).navigation();
  
  // Build a standard route request, startActivityForResult
  // The first parameter must be Activity and the second parameter is RequestCode
  ARouter.getInstance().build("/home/main", "ap").navigation(this, 5);
  
  // Pass Bundle directly
  Bundle params = new Bundle();
  ARouter.getInstance()
      .build("/home/main")
      .with(params)
      .navigation();
  
  // Set Flag
  ARouter.getInstance()
      .build("/home/main")
      .withFlags();
      .navigation();
  
  // For fragment
  Fragment fragment = (Fragment) ARouter.getInstance().build("/test/fragment").navigation();
                      
  // transfer the object 
  ARouter.getInstance()
      .withObject("key", new TestObj("Jack", "Rose"))
      .navigation();
  
  // Think the interface is not enough, you can directly set parameter into Bundle
  ARouter.getInstance()
          .build("/home/main")
          .getExtra();
  
  // Transition animation (regular mode)
  ARouter.getInstance()
      .build("/test/activity2")
      .withTransition(R.anim.slide_in_bottom, R.anim.slide_out_bottom)
      .navigation(this);
  
  // Transition animation (API16+)
  ActivityOptionsCompat compat = ActivityOptionsCompat.
      makeScaleUpAnimation(v, v.getWidth() / 2, v.getHeight() / 2, 0, 0);
  
  // ps. makeSceneTransitionAnimation, When using shared elements, you need to pass in the current Activity in the navigation method
  
  ARouter.getInstance()
      .build("/test/activity2")
      .withOptionsCompat(compat)
      .navigation();
          
  // Use green channel (skip all interceptors)
  ARouter.getInstance().build("/home/main").greenChannel().navigation();
  
  // Use your own log tool to print logs
  ARouter.setLogger();
  
  // Use your custom thread pool
  ARouter.setExecutor();