网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
ARouter项目中包含了API、编译器Compiler、插件Gradle Plugin和注解Annotation4 个模块。
API
API 模块由launcher、core、exception、thread、facede、utils和base子模块组成。
- launcher:包含了启动器 ARouter。
- core:包含物流中心 LogsticsCenter 和仓库 Warehouse 等类。
- exception:包含了一些异常类。
- thread:包含了CancellableCountDownLatch,ARouter 的拦截器链是放在子线程中执行的,就用到了它。
- facede:包含了导航回调 NavigationCallback 和 拦截器IInterceptor 等接口。
- utils:包含了 ARouter 自定义的日志打印器等工具类。
- base:只有一个用于保存拦截器的 UnitqueKeyTreeMap。
Compiler
Compiler 模块用于生成路由表,@Autowired、@Interceptor 和 @Route 注解对应的注解处理器分别是 AutowiredProcessor、InterceptorProcessor 以及 RouteProcessor ,都在 Compiler 中。
Register Plugin
Register Plugin 模块包含了注册代码生成器 RegisterCodeGenerator 和 RegisterTransform,如果使用了ARouter的路由表加载插件,那这个路由表就会由Register插件加载。
Annotaion
Annotaion模块比较简单,只包含了一些注解和枚举类。
APT原理
ARouter的使用非常方便,得益于APT技术。APT的作用是在编译阶段扫描并处理代码中的注解,然后根据注解输出Java文件。
ARouter为了方便实现注解处理器还额外用了两个库。
- JavaPoet,提供了调用对象方法的方式生成需要的代码,而不再需要人为地用StringBuilder去拼接代码,再使用IO写入文件。
- Auto-Service,提供了简便的方式去注册APT,避免了原本繁琐的注册步骤。
@Route
@Route的定义:
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.CLASS)
public @interface Route {
/**
-
Path of route
*/
String path();
…
} -
@Target({ElementType.TYPE}):表示这个注解是修饰类的
-
@Retention(RetentionPolicy.CLASS):表示需要保留到编译时
使用该注解时有一个主要的参数path:
// 在支持路由的页面上添加注解(必选)
// 这里的路径需要注意的是至少需要有两级,/xx/xx
@Route(path = “/test/activity”)
public class YourActivity extend Activity {
…
}
这样编译时能获取到@Route所注解的类,并且能获取到path路径。
RouteProcessor
RouteProcessor是@Route注解对应的注解处理器。
@AutoService(Processor.class)
@SupportedAnnotationTypes({ANNOTATION_TYPE_ROUTE, ANNOTATION_TYPE_AUTOWIRED})
public class RouteProcessor extends BaseProcessor
- Auto-Service这个库为Processor完成了自动注册.
- @SupportedAnnotationTypes({ANNOTATION_TYPE_ROUTE, ANNOTATION_TYPE_AUTOWIRED}):表明了当前Processor是处理哪些注释的。
RouteProcessor继承于BaseProcessor,在init方法中获取到了每个模块的moduleName。
// Attempt to get user configuration [moduleName]
Map<String, String> options = processingEnv.getOptions();
if (MapUtils.isNotEmpty(options)) {
moduleName = options.get(KEY_MODULE_NAME);
generateDoc = VALUE_ENABLE.equals(options.get(KEY_GENERATE_DOC_NAME));
}
RouteProcessor的process方法是对注解处理的地方,它直接获取了所有使用@Route注解的元素。
Set<? extends Element> routeElements = roundEnv.getElementsAnnotatedWith(Route.class);
拿到使用注解的元素后就会进入this.parseRoutes(routeElements)方法。这个方法使用JavaPoet生成Java文件。如果不用这个库也可以使用StringBuilder去写Java文件的内容。
IRouteGroup
先来看一下RouteProcessor生成的产物,在下图路径下可以看到ARouter的生成产物
public class ARouter
G
r
o
u
p
Group
Grouptest implements IRouteGroup {
@Override
public void loadInto(Map<String, RouteMeta> atlas) {
atlas.put(“/test/activity”, RouteMeta.build(RouteType.ACTIVITY, YourActivity.class, “/test/activity”, “test”, null, -1, -2147483648));
}
}
RouteMeta是包含了@Route所注解的元素的必要信息,最明显的就是YourActivity.class,有了它,我们就可以通过Intent跳转到这个Activity了。
ARouter$$Group$$test
这个类继承自IRouteGroup ,实现了接口中的loadInto方法。
loadInto方法逻辑很简单,传入一个map,将注解的path值作为key,将元素(RouteMeta)作为value作为Value放入map。如果完成了这个方法,就完成了Activity的注册。
IRouteRoot
public class ARouter
R
o
o
t
Root
Rootapp implements IRouteRoot {
@Override
public void loadInto(Map<String, Class<? extends IRouteGroup>> routes) {
routes.put(“test”, ARouter
G
r
o
u
p
Group
Grouptest.class);
}
}
ARouter$$Root$$app
实现了IRouteRoot接口,内容非常相似。通过loadInto方法,往Map中插入以group名为Key,IRouteGroup实现类为Value的内容。
group默认就是path中第一个斜杠之后的内容(@Route(path=“/group/xxx”))
如果调用了这个方法,那么可以通过group拿到IRouteGroup实现类的class,有了class实例化之后就能通过前面所说的拿到Activity.class了。
整体的结构如下图所示:
RouteProcessor.process()
回过头来继续看RouteProcessor的process方法
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (CollectionUtils.isNotEmpty(annotations)) {
Set<? extends Element> routeElements = roundEnv.getElementsAnnotatedWith(Route.class);
try {
logger.info(“>>> Found routes, start… <<<”);
this.parseRoutes(routeElements);
} catch (Exception e) {
logger.error(e);
}
return true;
}
return false;
}
获取了所有使用@Route注解的元素,将它们放进了parseRoutes方法用于生成IRouteGroup和IRouteRoot。这里面使用JavaPoet提供的类,通过方法调用的形式生成代码。
路由表的生成
RouteProcessor的process方法对于声明了 @Route 注解的类的处理,大概分为4个步骤: 1、获取路由元素
2、创建路由元信息
3、把路由元信息进行分组
4、生成路由文件
在上面的分析中,通过roundEnv.getElementsAnnotatedWith(),已经获取了所有使用@Route注解的元素,然后将它们放进了parseRoutes方法。
这里说的路由元信息指的是 RouteMeta,RouteProcessor 会把声明了 @Route 注解的的 Activity、Provider、Service 或 Fragment 和一个 RouteMeta 关联起来。
for (Element element : routeElements) {
…
// Activity or Fragment
if (types.isSubtype(tm, type_Activity) || types.isSubtype(tm, fragmentTm) || types.isSubtype(tm, fragmentTmV4)) {
// Get all fields annotation by @Autowired
Map<String, Integer> paramsType = new HashMap<>();
Map<String, Autowired> injectConfig = new HashMap<>();
injectParamCollector(element, paramsType, injectConfig);
if (types.isSubtype(tm, type_Activity)) {
// Activity
logger.info(“>>> Found activity route: " + tm.toString() + " <<<”);
routeMeta = new RouteMeta(route, element, RouteType.ACTIVITY, paramsType);
} else {
// Fragment
logger.info(“>>> Found fragment route: " + tm.toString() + " <<<”);
routeMeta = new RouteMeta(route, element, RouteType.parse(FRAGMENT), paramsType);
}
routeMeta.setInjectConfig(injectConfig);
}
…
categories(routeMeta);
}
在这段代码中,完成了RouteMeta类的构建,还获取了Activity通过@AutoWired注解的接收参数。然后通过categories(routeMeta)方法,对所有RouteMeta进行分组。
为什么要分组呢?随着项目的迭代,组件数量会越来越多,将这么多的组件信息都放到一个map里,显然会对内存造成很大的问题,且加载耗时也会随之增加。Arouter采用的方法就是“分组+按需加载”,同时,分组也利于管理。
private void categories(RouteMeta routeMete) {
if (routeVerify(routeMete)) {
logger.info(">>> Start categories, group = " + routeMete.getGroup() + “, path = " + routeMete.getPath() + " <<<”);
Set routeMetas = groupMap.get(routeMete.getGroup());
if (CollectionUtils.isEmpty(routeMetas)) {
…
routeMetaSet.add(routeMete);
groupMap.put(routeMete.getGroup(), routeMetaSet);
} else {
routeMetas.add(routeMete);
}
}
…
}
在 RouteProcessor 中有一个 groupMap,在 RouteMeta 创建好后,RouteProcessor 会根据其group作为Key进行分组,放入到 groupMap 中。RouteMeta本身会放入一个Set,Set中所有RouteMeta的group都是相同的,作为Map的Value。
当 RouteProcessor 把 RouteMeta 分组好后,就会用 JavaPoet 生成 Group、Provider 和 Root 路由文件,路由表就是由这些文件组成的,JavaPoet 是 Square 开源的代码生成框架。
// Write root meta into disk.
String rootFileName = NAME_OF_ROOT + SEPARATOR + moduleName;
JavaFile.builder(PACKAGE_OF_GENERATE_FILE,
TypeSpec.classBuilder(rootFileName)
.addJavadoc(WARNING_TIPS)
.addSuperinterface(ClassName.get(elementUtils.getTypeElement(ITROUTE_ROOT)))
.addModifiers(PUBLIC)
.addMethod(loadIntoMethodOfRootBuilder.build())
.build()
).build().writeTo(mFiler);
生成的路由文件就是前面所看到RouteProcessor的产物,就是下面这些:
路由表的加载
加载路由表,其实就是加载RouteProcessor所生成的类文件。
在调用ARouter的init()初始化方法时,ARouter会调用LogisticsCenter的init()方法,在该方法中,会loadRouterMap()优先通过插件加载路由表,然后判断当前路由表加载方式是否为插件,不是的话则从Dex中加载路由表。
/**
- LogisticsCenter init, load all metas in memory. Demand initialization
*/
public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {
…
try {
long startInit = System.currentTimeMillis();
//load by plugin first
loadRouterMap();
if (registerByPlugin) {
//通过插件加载路由表
logger.info(TAG, “Load router map by arouter-auto-register plugin.”);
} else {
//从Dex中加载路由表
…
}
…
} catch (Exception e) {
throw new HandlerException(TAG + “ARouter init logistics center exception! [” + e.getMessage() + “]”);
}
}
从Dex中加载路由表
通过Dex加载路由表的流程大致如上图,接下去来一点一点看一下LogisticsCenter的init()方法中从Dex中加载路由表部分:
// 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()));
}
如果是设置了debug模式或者是新版本的情况下,扫描所有Dex文件查找所有com.alibaba.android.arouter.routes开头的文件,然后更新到SharePreferences。否则直接从SharePreferences读缓存,减少解析时间。
这里使用了ClassUtils读取Dex文件,并从Dex文件中读取路由表。
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);
}
}
把路由表保存到 SharedPreferences 后,就会根据类名的后缀判断类是 IRouteRoot 、IInterceptorGroup 还是 IProviderGroup ,然后实例化成不同的对象并调用loadInto方法把类文件的内容加载到索引中。
通过插件加载路由表
如果想缩短ARouter初始化的时间,可以用ARouter的Gradle插件,这个插件能自动加载路由表,这样ARouter初始化的时候就不需要读取类的信息,从而缩短初始化时间。
插件的工作原理就是在代码编译的时候,插件会找到LogisticsCenter类的loadRouterMap方法,然后在方法中插入路由相关的代码,这样初始化的时候就不会从dex文件中扫描路由表了。
路由表的跳转
使用ARouter.getInstance().build(“/test/activity”).navigation()发起路由操作,进行跳转,会调用_ARouter的navigation()方法。
_ARouter的navigation()方法有两种重载。一种是用于创建服务service,一种是用于路由跳转。
protected T navigation(Class<? extends T> 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;
}
// Set application to postcard.
postcard.setContext(mContext);
LogisticsCenter.completion(postcard);
return (T) postcard.getProvider();
} catch (NoRouteFoundException ex) {
logger.warning(Consts.TAG, ex.getMessage());
return null;
}
}
创建服务service流程相对比较简单,通过LogisticsCenter.buildProvider创建一张Postcard明信片,包含最基本的group和path信息,然后给Postcard设置Context,最后通过LogisticsCenter.completion获取路由元信息并填充至Postcard中。
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;
}
// Set context to postcard.
postcard.setContext(null == context ? mContext : context);
try {
//完善Postcard
LogisticsCenter.completion(postcard);
} catch (NoRouteFoundException ex) {
//完善失败降级策略
…
}
…
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(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(postcard, requestCode, callback);
}
return null;
}
用于路由跳转流程相对复杂一点,大致有这么几步:
1、预处理服务
2、完善Postcard
3、完善失败降级策略
4、拦截器链路
5、按类型跳转
预处理服务
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
}
});
} else {
//按类型跳转
return _navigation(postcard, requestCode, callback);
}
return null;
}
用于路由跳转流程相对复杂一点,大致有这么几步:
1、预处理服务
2、完善Postcard
3、完善失败降级策略
4、拦截器链路
5、按类型跳转
预处理服务
[外链图片转存中…(img-kIDQpn1p-1715287814167)]
[外链图片转存中…(img-QwvALAvW-1715287814168)]
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!