源码分析 — ARouter路由框架

最新推荐文章于 2024-06-19 10:35:31 发布
最新推荐文章于 2024-06-19 10:35:31 发布
阅读量1.7k 收藏 3
点赞数 1
分类专栏： 开源框架源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Love667767/article/details/79494952
版权

一、ARouter整体结构

这里写图片描述

主要的类：

类名类的描述
ARouterARouter facade(门面模式)；
_ARouterARouter core (Facade patten)
LogisticsCenterLogisticsCenter contain all of the map.
PostcardA container that contains the roadmap.
WarehouseStorage of route meta and other data.
ClassUtils获取ARouter自动生成的代码文件

二、ARouter初始化流程的源码分析

1. ARouter初始化时序图

这里写图片描述

2. ARouter初始化代码分析

在Application中初始化代码：ARouter.init(application) ；

// ARouter.class
public static void init(Application application) {
 if (!hasInit) {
        logger = _ARouter.logger;
        _ARouter.logger.info(Consts.TAG, "ARouter init start.");
        // 初始化init()
        hasInit = _ARouter.init(application);

        if (hasInit) {
            // 启动InterceptorService
            _ARouter.afterInit();
        }

        _ARouter.logger.info(Consts.TAG, "ARouter init over.");
    }
}

// _ARouter.class
protected static synchronized boolean init(Application application) {
    mContext = application;
    // LogisticsCenter的初始化
    LogisticsCenter.init(mContext, executor);
    logger.info(Consts.TAG, "ARouter init success!");
    hasInit = true;
    return true;
}

// LogisticsCenter.class
public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {
    mContext = context;
    executor = tpe;

    try {
        loadRouterMap();
        if (registerByPlugin) {
            logger.info(TAG, "Load router map by arouter-auto-register plugin.");
        } else {
            Set<String> routerMap;

            // 如果是Debug模式，则执行从if代码块；
            // 如果是Release模式：通过PackageUtils.isNewVersion(context)判断当前应用是否是第一次启动；
            if (ARouter.debuggable() || PackageUtils.isNewVersion(context)) {
                // 获取arouter-compiler生成的文件
                routerMap = ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE);
                // 存储在sp中，下次启动应用的时候，直接从sp缓存中读取
                if (!routerMap.isEmpty()) {
                    context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).edit().putStringSet(AROUTER_SP_KEY_MAP, routerMap).apply();
                }
                // 存储当前应用的版本号
                PackageUtils.updateVersion(context);    // Save new version name when router map update finish.
            } else {
                // 从sp缓存中读取arouter-compiler生成的文件
                routerMap = new HashSet<>(context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).getStringSet(AROUTER_SP_KEY_MAP, new HashSet<String>()));
            }

            // 遍历arouter-compiler生成的文件，将他们按照类型分别存储到Warehouse的对应字段中
            for (String className : routerMap) {
                // 类名前缀为com.alibaba.android.arouter.routes.ARouter$$Root的文件
                if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) {
                    // 将类名前缀为com.alibaba.android.arouter.routes.ARouter$$Group的文件添加进Warehouse.groupsIndex中
                    ((IRouteRoot) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex);

                } 
                // 类名前缀为com.alibaba.android.arouter.routes.ARouter$$Interceptors的文件
                else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_INTERCEPTORS)) {

                    ((IInterceptorGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.interceptorsIndex);
                }
                // 类名前缀为com.alibaba.android.arouter.routes.ARouter$$Providers的文件
                else if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_PROVIDERS)) {

                    ((IProviderGroup) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.providersIndex);
                }
            }
        }
        //...代码省略...
    } catch (Exception e) {
        throw new HandlerException(TAG + "ARouter init logistics center exception! [" + e.getMessage() + "]");
    }
}

LogisticsCenter.init() 小结：

  1. 查找指定包名(com.alibaba.android.arouter)下的文件，并将之缓存到SP中；
  2. 按照文件的前缀不同，将他们添加到路由映射表Warehouse的groupsIndex、interceptorsIndex、providersIndex 中；

PackageUtils 类：用来管理应用的版本

// PackageUtils .class
// 判断当前版本是否是新版本(第一次启动)
public static boolean isNewVersion(Context context) {
    //...代码省略...
    SharedPreferences sp = context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE);
    // 从sp文件中获取之前存储的VersionName和VersionCode
    if (!versionName.equals(sp.getString(LAST_VERSION_NAME, null)) || versionCode != sp.getInt(LAST_VERSION_CODE, -1)) {
        //...代码省略...
        return true;
    } else {
        return false;
    }
}

// 保存当前版本的VersionName和VersionCode
public static void updateVersion(Context context) {
    if (TextUtils.isEmpty(NEW_VERSION_NAME) && NEW_VERSION_CODE != 0) {
        SharedPreferences sp = context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE);
        sp.edit()
          .putString(LAST_VERSION_NAME, NEW_VERSION_NAME)
          .putInt(LAST_VERSION_CODE, NEW_VERSION_CODE)
          .apply();
    }
}

ClassUtils 类：获取com.alibaba.android.arouter.routes包下 的文件：

// ClassUtils.class
// 通过指定包名，扫描包下面包含的所有的ClassName
public static Set<String> getFileNameByPackageName(Context context, final String packageName) throws PackageManager.NameNotFoundException, IOException, InterruptedException {
    // Set类型的数据结构，防止重复
    final Set<String> classNames = new HashSet<>();

    List<String> 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);
                    }
                    // 从DexFile中获取所有的文件
                    Enumeration<String> dexEntries = dexfile.entries();
                    while (dexEntries.hasMoreElements()) {
                        String className = dexEntries.nextElement();
                        // 匹配所有包名路径为com.alibaba.android.arouter.routes的文件
                        if (className.startsWith(packageName)) {
                            classNames.add(className);
                        }
                    }
                } catch (Throwable ignore) {
                    Log.e("ARouter", "Scan map file in dex files made error.", ignore);
                } finally {
                    //...代码省略...
                }
            }
        });
    }
    //...代码省略...
    return classNames;// 返回所有包名路径为com.alibaba.android.arouter.routes的文件集合
}

Warehouse类：路由文件映射表

class Warehouse {
    // Cache route and metas
    // LogisticsCenter.init() 中被赋值
    static Map<String, Class<? extends IRouteGroup>> groupsIndex = new HashMap<>();
    // LogisticsCenter.completion(postcard) 中被赋值
    static Map<String, RouteMeta> routes = new HashMap<>();

    // Cache provider
    // LogisticsCenter.completion(postcard) 中被赋值
    static Map<Class, IProvider> providers = new HashMap<>();
    // LogisticsCenter.init() 中被赋值
    static Map<String, RouteMeta> providersIndex = new HashMap<>();


    /* 
     * Cache interceptor
     * LogisticsCenter.init() 中被赋值;
     * 此处拦截器的存储使用TreeMap，存储的时候，已经对拦截器的优先级进行排序
     */
    static Map<Integer, Class<? extends IInterceptor>> interceptorsIndex = new UniqueKeyTreeMap<>("More than one interceptors use same priority [%s]");
    // InterceptorServiceImpl.init()中被赋值
    static List<IInterceptor> interceptors = new ArrayList<>();
}

至此，_ARouter.init(application)的整个流程结束；

下面开始分析_ARouter.afterInit()代码：

// _ARouter.class
static void afterInit() {
    // Trigger interceptor init, use byName.
    interceptorService = (InterceptorService) 
            ARouter.getInstance()
                .build("/arouter/service/interceptor") //生成一个Postcard对象
                //这个navigation()经过多次调用之后，
                //最终调用的是_ARouter.navigation(context, postcard, requestCode, navigationCallback)方法
                .navigation();
}

build("/arouter/service/interceptor") 代码分析：

// _ARouter.class
protected Postcard build(String path) {
    // navigation(clazz)这种方式是属于根据类型查找，而build(path)是根据名称进行查找
    // 如果应用中没有实现PathReplaceService这个接口，则pService=null
    PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
   if (null != pService) {
        // PathReplaceService可以对所有的路径进行预处理，然后返回一个新的值
        path = pService.forString(path);
    }
    //extractGroup(path)是获取分组名称，默认为path中第一部分；
    return build(path, extractGroup(path));
}

// _ARouter.class
protected Postcard build(String path, String group) {
    PathReplaceService pService = ARouter.getInstance().navigation(PathReplaceService.class);
    if (null != pService) {
        path = pService.forString(path);
    }
    // 返回含有path和group组别的Postcard
    return new Postcard(path, group);
}

public interface PathReplaceService extends IProvider {
    String forString(String path);
    Uri forUri(Uri uri);
}

navigation() 代码分析：

// _ARouter.class
protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
    try {
        // 重点：分析部分在下面
        // 1. 将IProvider映射到`Warehouse.providers`中；
        // 2. 将添加@Route注解的类映射到`Warehouse.routes`中
        LogisticsCenter.completion(postcard);
    } catch (NoRouteFoundException ex) {
        // ...代码省略...

        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);
    }
    // 忽略拦截器(在LogisticsCenter.completion(postcard)中，PROVIDER和FRAGMENT是忽略拦截器的)
    if (!postcard.isGreenChannel()) {   // It must be run in async thread, maybe interceptor cost too mush time made ANR.

        // interceptorService对象就是通过_ARouter.afterInit()实例化的;
        interceptorService.doInterceptions(postcard, new InterceptorCallback() {
            @Override
            public void onContinue(Postcard postcard) {
                _navigation(context, postcard, requestCode, callback);
            }

            @Override
            public void onInterrupt(Throwable exception) {
                if (null != callback) {
                    callback.onInterrupt(postcard);
                }
            }
        });
    } else {
        return _navigation(context, postcard, requestCode, callback);
    }

    return null;
}

// _ARouter.class
private Object _navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
    // 这里如果navigation()不传入Activity作为context，则使用Application作为context
    final Context currentContext = null == context ? mContext : context;

    switch (postcard.getType()) {
        case ACTIVITY:
            // Build intent
            final Intent intent = new Intent(currentContext, postcard.getDestination());
            // Activity的参数传递
            intent.putExtras(postcard.getExtras());

            // Set flags.
            int flags = postcard.getFlags();
            if (-1 != flags) {// 如果在跳转时，设置了flags，且没有设置Activity作为context，则下面的startActivity()方法会发生错误，因为缺少Activity的Task栈；
                intent.setFlags(flags);
            } else if (!(currentContext instanceof Activity)) {    // Non activity, need less one flag.
                intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            }

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

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

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

            break;
        case PROVIDER:
            //在LogisticsCenter.completion(postcard)中，我们将IProvider对象设置进postcard中，所以可以通过postcard.getProvider()获取；
            return postcard.getProvider();
        case BOARDCAST:
        case CONTENT_PROVIDER:
        case FRAGMENT:
            Class fragmentMeta = postcard.getDestination();
            try {
                Object instance = fragmentMeta.getConstructor().newInstance();
                // Fragment的参数传递
                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;
}


LogisticsCenter.completion() 小结：

  1. 将IProvider映射到Warehouse.providers中；
  2. 将添加@Route注解的类映射到Warehouse.routes中；
// LogisticsCenter.class
public synchronized static void completion(Postcard postcard) {
   if (null == postcard) {
        throw new NoRouteFoundException(TAG + "No postcard!");
    }

    /*
     * 根据path在Warehouse.routes映射表中查找对应的RouteMeta；
     * 
     * 如果是第一次启动，要查找path = "/arouter/service/interceptor"，
     * 而此时Warehouse.routes里面是没有元素的(在LogisticsCenter.init()中，只有`Warehouse`的`groupsIndex、interceptorsIndex、providersIndex` 有数据)，因此routeMeta=null
     */
    RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath());
    if (null == routeMeta) {
        // 从Warehouse.groupsIndex中取出类名前缀为com.alibaba.android.arouter.routes.ARouter$$Group$$group的文件
        Class<? extends IRouteGroup> 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 {
                IRouteGroup iGroupInstance = groupMeta.getConstructor().newInstance();
                // 将我们添加@Route注解的类映射到Warehouse.routes中；
                iGroupInstance.loadInto(Warehouse.routes);
                // 将已经加载过的组从Warehouse.groupsIndex中移除，避免重复添加进Warehouse.routes
                Warehouse.groupsIndex.remove(postcard.getGroup());

            } catch (Exception e) {
                throw new HandlerException(TAG + "Fatal exception when loading group meta. [" + e.getMessage() + "]");
            }
            // 这个时候Warehouse.routes已经有值了，所以重新调用本方法执行else代码块
            completion(postcard);   // Reload
        }
    } else {
        postcard.setDestination(routeMeta.getDestination());
        postcard.setType(routeMeta.getType());//设置routeMeta的Type
        postcard.setPriority(routeMeta.getPriority());
        postcard.setExtra(routeMeta.getExtra());

        Uri rawUri = postcard.getUri();
        if (null != rawUri) {   // Try to set params into bundle.
            Map<String, String> resultMap = TextUtils.splitQueryParameters(rawUri);
            Map<String, Integer> paramsType = routeMeta.getParamsType();

            if (MapUtils.isNotEmpty(paramsType)) {
                // Set value by its type, just for params which annotation by @Param
                for (Map.Entry<String, Integer> 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 be implememt IProvider
                Class<? extends IProvider> providerMeta = (Class<? extends IProvider>) routeMeta.getDestination();
                IProvider instance = Warehouse.providers.get(providerMeta);
                if (null == instance) { // There's no instance of this provider
                    IProvider provider;
                    try {
                        provider = providerMeta.getConstructor().newInstance();
                        // IProvider的子类进行初始化
                        provider.init(mContext);
                        // 将IProvider的子类添加进Warehouse.providers中
                        Warehouse.providers.put(providerMeta, provider);
                        instance = provider;
                    } catch (Exception e) {
                        throw new HandlerException("Init provider failed! " + e.getMessage());
                    }
                }
                // 将IProvider的实现类保存在postcard中，因此可以从postcard获取IProvider的实例对象；
                postcard.setProvider(instance);
                // greenChannel()会忽略拦截器
                postcard.greenChannel();    // Provider should skip all of interceptors
                break;
            case FRAGMENT:
                // greenChannel()会忽略拦截器
                postcard.greenChannel();    // Fragment needn't interceptors
            default:
                break;
        }
    }
}

到这里，我们看到了Warehouse.providers、Warehouse.routes的赋值；那么Warehouse.interceptors又是在哪里赋值的呢？

InterceptorServiceImpl 的初始化：

// InterceptorService是IProvider的子类
public interface InterceptorService extends IProvider {
    void doInterceptions(Postcard postcard, InterceptorCallback callback);
}
/*
 * 因此InterceptorServiceImpl也是IProvider的子类;
 * 在LogisticsCenter.completion()中，有provider.init(context)的初始化;
 */
public class InterceptorServiceImpl implements InterceptorService {

    // ...代码省略...

    @Override
    public void init(final Context context) {
        LogisticsCenter.executor.execute(new Runnable() {
            @Override
            public void run() {
                if (MapUtils.isNotEmpty(Warehouse.interceptorsIndex)) {
                    for (Map.Entry<Integer, Class<? extends IInterceptor>> entry : Warehouse.interceptorsIndex.entrySet()) {
                        Class<? extends IInterceptor> interceptorClass = entry.getValue();
                        try {
                            IInterceptor iInterceptor = interceptorClass.getConstructor().newInstance();
                            // 具体的拦截器的初始化
                            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() + "]");
                        }
                    }
                    // ...代码省略...
                }
            }
        });
    }
}

至此，整个路由的初始化已经结束；

三、ARouter使用时常见的问题：

3.1 ARouter拦截器优先级的问题


class Warehouse {
    // Cache interceptor
    static Map<Integer, Class<? extends IInterceptor>> interceptorsIndex = new UniqueKeyTreeMap<>("More than one interceptors use same priority [%s]");
}

public class UniqueKeyTreeMap<K, V> extends TreeMap<K, V> {
    private String tipText;

    public UniqueKeyTreeMap(String exceptionText) {
        super();
        tipText = exceptionText;
    }

    @Override
    public V put(K key, V value) {
        /*
         * 将拦截器添加进UniqueKeyTreeMap时，以优先级priority作为键,
         * 所以应用中拦截器的优先级不能重复，否则会抛出异常;
         */
        if (containsKey(key)) {
            throw new RuntimeException(String.format(tipText, key));
        } else {
            return super.put(key, value);
        }
    }
}

小结：

将拦截器添加进UniqueKeyTreeMap时，以优先级priority作为键，所以应用中拦截器的优先级不能重复，否则会抛出异常；

3.2 Group分组的问题

在使用@Route(path= "/main/index") 进行路由标注时，会默认使用第一部分的 /main 作为分组；在 build 应用后，会生成对应的 ARouter$$Group$$main.java 文件；

注意：

当一个 Module 使用过 /main 组别后，其他 Module 不能再使用此作为组别，否则会出现无法找到指定文件的错误；

原因：

因为在 Warehouse 类中，有一个 Map 类型的字段 interceptorsIndex，他是以组别作为Key (例如上面提到的/main)，value则是 ARouter$$Group$$main.java ，所以当不同的 Module 中存在相同的组别(如 /main)时，由于Map键的唯一性，因此Warehouse.interceptorsIndex 也只能存入其中一个ARouter$$Group$$main.java。

四、其他

Activity跳转的原理：

  1. 从DexFile文件中查找到被@Route注解修饰的类；
  2. 存储在Warehouse中；
  3. 在跳转的时候，将所需查找的Class赋值给Postcard对象；
  4. 最后使用的时候从postcard的Destination中获取需跳转的Class对象；
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
            // 这里从postcard的Destination中获取需跳转的Class对象
            final Intent intent = new Intent(currentContext, postcard.getDestination());
            intent.putExtras(postcard.getExtras());        

            // ...代码省略...
            ActivityCompat.startActivity(currentContext, intent, postcard.getOptionsBundle());

            //...代码省略...
    }
    return null;
}

// 另一种方式：通过类名直接跳转
try {
    // GoodsQueryActivity.class为KitBundle组件中的页面，当前组件为MainBundle组件;通过类名查找到对应的Class，也能进行页面跳转；
    Class clazz = Class.forName("com.elson.kitbundle.ui.GoodsQueryActivity");
    Intent intent = new Intent(this, clazz);
    startActivity(intent);
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

五、总结

  1. 由于拦截器的优先级具有唯一性(数据结构决定的)，当在组件化开发的时候，不同组件如果都设置了拦截器的优先级，那么可能出现优先级重复的问题；

  2. 关于路由启动Activity，在启动Activity的时候添加了withFlags()，如果 navigation() 方法没有传入 Activity作为 Context，那默认使用Application作为Context；此时会出现异常，因为用Application启动的Activity，都需要添加一个Activity栈来管理；

  3. 关于拦截器：无法拦截 IProvider 的子类和Fragment，可在 LogisticsCenter.completion() 中找到答案；

  4. 在跳转Activity时，使用了 Postcard.withObject() 方法，则必须实现 SerializationService 接口；

Elson_6
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
ARouter源码分析（一）—— 路由跳转分析
茅屋
04-24 421
相关工程githubhttps://github.com/AlexMahao/ARouter 逻辑分析 Arouter的路由跳转整体可分为三个步骤： 编译时期利用Processor生成路由清单文件。 运行时期加载路由清单文件。 跳转时期根据标识符查询路由清单，完成路由地址跳转。 编译时期 arouter-compiler RouteProcessor是处理路由清单生成的类。其初始化方法如下...
ARouter 源码解析
不再烦恼
12-21 338
ARouter 源码解析
源码分析 — ARouter
weixin_34018202的博客
03-09 177
目录 ARouter整体结构 ARouter初始化流程的源码分析 ARouter拦截器优先级的问题 ARouter整体结构 主要的类： 类名 类的描述 ARouter ARouter facade(门面模式)； _ARouter ARouter core (Facade patten) LogisticsCenter LogisticsCenter contain a...
Arouter系列（一）：总体流程分析
qq_30329621的博客
02-18 826
组件化系列-Arouter路由实现源码分析 基本使用 ARouter.getInstance().build("/base/LoginActivity").navigation(); 流程分析 Arouter.getInstance() Arouter.java 返回Arouter对象。 Arouter.getInstance().build() Arouter.java public Postcard build(String path) { ret...
路由框架 ARouter 原理及源码解析
最新发布
neuHenry
06-19 1006
在日常开发中，随着项目业务越来越复杂，项目中的代码量也越来越多，如何维护、扩展、解耦等成了一个非常头疼问题。为解决此问题而衍生出的诸如：插件化、组件化、模块化等热门技术。 使用组件化来改造项目时的难点，就是实现各个组件之间的通讯，通常解决方案采用路由中间件，来实现页面之间的跳转关系。本文要解析的 ARouter路由框架就是众多解决方案中比较优秀的一个开源库，并且是国人团队开发的，所以中文文档非常详细，以便使用者快速接入。
ARouter 配合Fragment :"Fetch fragment instance error"异常的处理
long for us
03-14 2303
现在的项目中使用ARouter来处理组件化开发中的跳转和部分数据传递的需求,使用一直很顺畅,今天遇到一个不太常见的异常.记录一下: 异常信息 E/ARouter::: Fetch fragment instance error, at java.lang.reflect.Constructor.newInstance0(Native Method) ...
组件化学习-3-源码分析ARouter
行者Sun
03-30 1862
源码分析ARouter
Android跳转-ARouter详细使用教程
热门推荐
KeepStudy
09-14 2万+
一、简介Android平台中对页面、服务提供路由功能(跳转)的一个库1.1 最新版本 模块 arouter-api arouter-compiler arouter-annotation 最新版本 1.2 实例图片1.3 功能介绍 支持直接解析标准URL进行跳转，并自动注入参数到目标页面中 支持多模块工程使用 支持添加多个拦截器，自定义拦截顺序 支持依赖注入，可单
Android ARouter路由框架解析
08-27
Android ARouter路由框架解析 一、Android ARouter路由框架简介 Android ARouter路由框架是阿里巴巴开源的Android平台中对页面、服务提供路由功能的中间件，提倡的是简单且够用。ARouter路由框架的主要应用场景是...
Android路由框架ARouter分析
08-27
【Android路由框架ARouter分析】 Android路由框架ARouter是一款强大的组件化工具，它解决了原生Android路由机制的诸多问题，提供了高效、灵活的解决方案。原生的路由方式存在显式依赖（类直接耦合）和隐式路由...
ARouter路由框架的使用
05-15
一篇文档教你完美的使用ARouter实现模块化开发，一个宿主模块，两个子模块的完整配置，详细教程文档
阿里路由框架ARouter 源码解析之Compiler
08-27
阿里路由框架ARouter 源码解析之Compiler 阿里路由框架ARouter 是一个流行的 Android 路由框架，提供了强大的路由管理功能。在ARouter 中，有两个核心组件：Compiler SDK 和 API SDK。其中，Compiler SDK 负责在...
Java反射之java.lang.reflect.Constructor
feigeswjtu的专栏
01-14 5672
我们知道每个类都至少有一个构造器，因为一个类如果没有显示定义一个构造器，编译器自动会自动生成一个默认无参的构造器，构造器作为一个类的入口方法，在使用类的成员变量和方法之前，类的构造器必须被调用，生成一个实例，另外构造器不能被继承，如果子类的构造器没有显示的调用父类的构造器，执行器会默认的调用父类的构造器。 说了这么多，我们该进入正题了，本文讲解一个反射中怎么获取一个构造器的声明、参数等信息，怎么
Arouter源码系列之拦截器原理详解
xiatiandefeiyu的博客
09-01 1522
Arouter源码详解，Arouter拦截器原理详解
Android开发问题记录-ARouter init logistics center exception
Geek马走日
06-22 6759
在Bugly中发现存在偶现的崩溃问题如下： #5404 com.alibaba.android.arouter.exception.HandlerException 更详细的信息如下： java.lang.RuntimeException:Unable to create application com.xxx: com.alibaba.android.arouter.exception.HandlerException: ARouter::ARouter init logistics center
Android 组件化+ARouter 开发之路
JiaoJunfeng
09-14 915
本文主要做一个记录，搭建组件化+ARouter+MVP 框架过程中遇到的一些问题 一、参考资料 1、https://www.jianshu.com/p/8098961bd30c 2、https://mp.weixin.qq.com/s?__biz=MzUxMzcxMzE5Ng==&mid=2247488201&amp;idx=1&amp;sn=eaefec375237a51726aaa4089e5fc670&source=41#wechat_redirect 3、ht
Android组件化之ARouter的使用
躬行之
03-10 2502
原文首发于微信公众号：躬行之(jzman-blog)，欢迎关注交流！ 前面两篇文章分别介绍了 Android 组件化基础知识以及 Android 组件化过程 Application 的相关知识，在阅读本文之前可以先阅读下面两篇文章： Android组件化基础 Android组件化之Application Android 组件化过程中涉及到不同 module 之间界面的跳转也是分厂重要的，如...
alibaba-ARouter（2）—ARouter IProvider 跨moudle的服务调用
点滴积累
04-12 1万+
IProvider 它首先是Arouter包下的一个类文件： package com.alibaba.android.arouter.facade.template; import android.content.Context; /** * Provider interface, base of other interface. * * @author Alex &amp;lt;a ...
Arouter源码解读
u011791526的博客
09-26 1039
  作者catRuan ，转载请注明出处               由于作者公司在做组件化开发，有幸使用到大名鼎鼎的Arouter来进行module之间的通讯和跳转解耦，阅读源码之后感觉受益良多，因此写下此文，本文属于作者的个人理解，若有不当之处欢迎指出。      另外，基于Arouter，作者改造了一个更加适用于组件化开发的路由框架：     https://blog.csdn.ne...
"ARouter源码解析之Compiler：解决组件化数据传输问题
本文主要讨论阿里路由框架ARouter的Compiler部分的源码解析。在公司进行组件化重构期间，模块间的数据传输问题成为了一个关键的痛点。组件化的核心在于根据项目和业务进行模块化分离，但是模块间不再相互依赖，因此...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值