前篇回顾
上篇文章,我们了解到“路由”是如何进行工作的,并尝试手写了实现代码;
本篇,以ARouter为例,我们将剖析它是如何完成工作的,并通过源码了解其原理。
还是以Activity跳转、Fragment获取、跨模块功能调用三个方向为出发点,看看ARouter将如何实现这些功能。
集成ARouter
咱们先快速将ARouter集成到项目中,当然你也可以参照官方文档来操作。
在第一篇文章中,我们将业务模块的依赖关系集中到了config.gradle文件中,现修改如下:
- 1、config.gradle中管理依赖版本
ext {
// ARouter 版本号
arouter_api_version = "1.5.2"
arouter_compiler_version = "1.5.2"
//各模块引入的第三方公共库
dependenciesImport = [
...
...
arouter_api : "com.alibaba:arouter-api:$arouter_api_version"
]
//注解处理器
dependenciesKapt = [
...
...
arouter: "com.alibaba:arouter-compiler:$arouter_compiler_version"
]
}
- 2、子模块的build.gradle中,传递APT所需参数,并引入依赖
def dependenciesImport = rootProject.ext.dependenciesImport
def dependenciesKapt = rootProject.ext.dependenciesKapt
android {
defaultConfig {
...
...
// ARouter APT 传参
kapt {
arguments {
arg("AROUTER_MODULE_NAME", project.getName())
}
}
}
}
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation project(":lib_comm")
// 导入依赖库
dependenciesImport.each { k, v -> implementation(v) }
// 导入依赖的注解处理器
dependenciesKapt.each { k, v -> kapt(v) }
}
- 3、初始化ARouter
class App : Application() {
override fun onCreate() {
super.onCreate()
initRouter()
}
private fun initRouter() {
if (BuildConfig.DEBUG) {
ARouter.openLog() // 打印日志
ARouter.openDebug() // 开启调试模式
}
ARouter.init(this) // 初始化
}
}
- 4、运行查看Log记录:
2021-09-13 17:47:07.911 10088-10088/com.ljb.component I/ARouter::: ARouter init success![ ]
ARouter - Activity跳转
根据官方文档,只需2步便可完成功能:
- 1、注解标记需要跳转的Activity
@Route(path = "/user/UserMainActivity" , group = "user")
class UserMainActivity : AppCompatActivity() {
...
}
- 2、发起跳转
ARouter.getInstance().build("/user/UserMainActivity").navigation()
很神奇!与前篇我们实现的路由相比,ARouter的代码要简洁很多,完全不需要手动注册路由就可完成跳转,它是怎么做到的呢?
通过跟进navigation()函数调用过程,我们把目光聚焦到两个容器中:
// ARouter源码
class Warehouse {
// Cache route and metas
static Map<String, Class<? extends IRouteGroup>> groupsIndex = new HashMap<>();
static Map<String, RouteMeta> routes = new HashMap<>();
...
}
- Warehouse.groupsIndex: 用于存储所有的路由组
public interface IRouteGroup {
/**
* Fill the atlas with routes in group.
* atlas用于存储当前组里的所有路由,实际传入的就是Warehouse.routes
*/
void loadInto(Map<String, RouteMeta> atlas);
}
- Warehouse.routes:用于存储已注册的所有路由
// 路由包装类,路由目标的Class对象就存储在这里面
public class RouteMeta {
private RouteType type; // Type of route
private Element rawType; // Raw type of route
private Class<?> destination; // Destination
private String path; // Path of route
private String group; // Group of route
private int priority = -1; // The smaller the number, the higher the priority
private int extra; // Extra data
private Map<String, Integer> paramsType; // Param type
private String name;
...
}
ARouter对路由提出了分组概念,上面 UserMainActivity就属于user组下,当路由path存在2级及以上时,group字段也可以省略,ARouter默认会使用第一个反斜杠后面的path作为组名。
// group可省略不写
@Route(path = "/user/UserMainActivity")
class UserMainActivity : AppCompatActivity() {
...
}
一般情况下,我们会将同一模块的路由划分在同一个组下,例如App模块下的所有路由都在“app”这个分组下 , user模块的路由都在“user”分组下;当然,同一模块拥有多个分组也是完全可行的,只要保证与其它模块中的路由分组不重名即可。
通过翻阅源码,分析这两个容器的作用,大致如下:
- 1、当传入path进行跳转时,优先从Warehouse.routes中直接获取路由对象;
- 2、路由对象不存在,就需要通过Warehouse.groupsIndex路由组来完成注册功能;
- 3、注册成功后,当前path所在组的所有路由都将存储到Warehouse.routes中;
- 4、回到第1步,获取路由对象;
- 5、读取路由对象信息;
- 6、完成跳转。
下方是ARouter源码中的实现代码,我把不重要的部分进行了删减:
//ARouter源码
public class LogisticsCenter {
...
public synchronized static void completion(Postcard postcard) {
//1、当传入path进行跳转时,优先从Warehouse.routes中直接获取路由包装对象;
RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath());
if (null == routeMeta) {
//2、包装对象不存在,就需要通过Warehouse.groupsIndex路由组来完成注册功能;
addRouteGroupDynamic(postcard.getGroup(), null);
//4、回到第1步,获取包装对象;
completion(postcard);
} else {
// 5、读取包装对象信息;
postcard.setDestination(routeMeta.getDestination());
postcard.setType(routeMeta.getType());
...
}
public synchronized static void addRouteGroupDynamic(String groupName, IRouteGroup group) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
if (Warehouse.groupsIndex.containsKey(groupName)){
//3、注册成功后,当前path所在组的所有路由都将存储到Warehouse.routes中;
Warehouse.groupsIndex.get(groupName).getConstructor().newInstance().loadInto(Warehouse.routes);
Warehouse.groupsIndex.remove(groupName);
}
if (null != group) {
// 注册本组路由
group.loadInto(Warehouse.routes);
}
}
...
}
final class _ARouter {
protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
...
LogisticsCenter.completion(postcard);
...
// 6、完成跳转。
switch (postcard.getType()) {
case ACTIVITY:
// Build intent
final Intent intent = new Intent(currentContext, postcard.getDestination());
intent.putExtras(postcard.getExtras());
//...
// Navigation in main looper.
runInMainThread(new Runnable() {
@Override
public void run() {
startActivity(requestCode, currentContext, intent, postcard, callback);
}
});
break;
...
}
...
}
}
整个跳转的源代码过程不难理解,但关键点在于:
- Warehouse.groupsIndex容器是何时将路由组加载至内存的?
- group.loadInto(Warehouse.routes)又是如何完成注册的?
回答这两个问题,需回过头来看ARouter初始化都做了什么。
ARouter.init(this) // ARouter初始化
随着代码的跟进,我们会发现下面这几行代码:
//ARouter源码
public final class Consts {
public static final String SDK_NAME = "ARouter";
public static final String SEPARATOR = "$$";
public static final String SUFFIX_ROOT = "Root";
public static final String DOT = ".";
public static final String ROUTE_ROOT_PAKCAGE = "com.alibaba.android.arouter.routes";
}
public class LogisticsCenter {
public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {
// 获取com.alibaba.android.arouter.routes下的所有class文件
routerMap = ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE);
for (String className : routerMap) {
if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) {
// 将名为ARouter$$Root开头的Class对象创建出来,并调用loadInto(),将分组信息加载进Warehouse.groupsIndex中
((IRouteRoot) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex);
}
...
}
}
}
源码中会从com.alibaba.android.arouter.routes包下读取所有的Class文件,并将文件名以ARouter$$Root为开头的Class文件挑选出来,最后通过反射创建对象,并调用其loadInto()函数,注意这里传入参数正是Warehouse.groupsIndex,我们的路由组容器,从而将分组信息载入Warehouse.groupsIndex中。
果不其然,我们在user模块的build文件夹下找到了这些文件:
ARouter生成的文件.png- 关于ARouter$$Root 前缀文件,可以看到其后缀是当前模块名module_user,而其loadInto()函数主要是将user模块下涉及到的所有路由组存储到Warehouse.groupsIndex中;
public class ARouter$$Root$$module_user implements IRouteRoot {
@Override
public void loadInto(Map<String, Class<? extends IRouteGroup>> routes) {
routes.put("user", ARouter$$Group$$user.class);
}
}
- 关于ARouter$$Group前缀文件,其后缀是当前路由所属的的分组名user,前面在梳理Activity跳转的过程中,我们知道当路由未注册时,会通过分组名获取到组,并创建组对象调用其loadInto()函数完成对Warehouse.routes的注册,此文件中编写的既是具体的注册过程。
//3、注册成功后,当前path所在组的所有路由都将存储到Warehouse.routes中;
Warehouse.groupsIndex.get(groupName).getConstructor().newInstance().loadInto(Warehouse.routes);
public class ARouter$$Group$$user implements IRouteGroup {
@Override
public void loadInto(Map<String, RouteMeta> atlas) {
// loadInto被调用时,完成对Warehouse.routes的注册
atlas.put("/user/AppMainActivity", RouteMeta.build(RouteType.ACTIVITY, AppMainActivity.class, "/user/appmainactivity", "user", null, -1, -2147483648));
}
}
ARouter - APT技术
通过上述分析,我们知道路由的注册离不开ARouter生成的这两个文件,那这两文件又是怎么来的呢?
这里不得不提到APT技术( Annotation Processing Tool),译:注解处理器。如果对该技术有所耳闻,你应该知道在Android中我们常用的EventBus、Butterknife、Dagger2等框架都有它的身影。如果你是第一次听说也没关系,暂时只需知道通过这门技术可以做到“在编译期时,可使编译器为我们生成具有一定规则的模板性代码”即可。
显然,这两个文件就是ARouter通过APT生成的模板代码,至于具体的实现过程,本篇中不做过多阐述,后续处理自定义路由时,我们会尝试编写一个自己的注解处理器,到时再细聊APT技术的相关细节。
不过我把ARouter注解处理器中生成这两个文件的核心代码贴在下方,看懂它的思路即可:
//ARouter 注解处理器源码
@AutoService(Processor.class)
@SupportedAnnotationTypes({ANNOTATION_TYPE_ROUTE, ANNOTATION_TYPE_AUTOWIRED})
public class RouteProcessor extends BaseProcessor {
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
// 获取所有被 @Route 注解标记的类元素
Set<? extends Element> routeElements = roundEnv.getElementsAnnotatedWith(Route.class);
//解析这些类元素
this.parseRoutes(routeElements);
}
private void parseRoutes(Set<? extends Element> routeElements) throws IOException {
// 解析元素
for (Element element : routeElements) {
if (types.isSubtype(tm, type_Activity)) {
// Activity
routeMeta = new RouteMeta(route, element, RouteType.ACTIVITY, paramsType);
Set<RouteMeta> routeMetas = groupMap.get(routeMete.getGroup());
routeMetaSet.add(routeMete);
groupMap.put(routeMete.getGroup(), routeMetaSet);
}
}
// 根据解析元素生成Java文件
for (Map.Entry<String, Set<RouteMeta>> entry : groupMap.entrySet()) {
// 生成ARouter$$Group$$前缀文件
String groupFileName = NAME_OF_GROUP + groupName;
JavaFile.builder(PACKAGE_OF_GENERATE_FILE,
TypeSpec.classBuilder(groupFileName)
.addJavadoc(WARNING_TIPS)
.addSuperinterface(ClassName.get(type_IRouteGroup))
.addModifiers(PUBLIC)
.addMethod(loadIntoMethodOfGroupBuilder.build())
.build()
).build().writeTo(mFiler);
}
// 生成ARouter$$Root$$前缀文件
String groupFileName = NAME_OF_GROUP + groupName;
JavaFile.builder(PACKAGE_OF_GENERATE_FILE,
TypeSpec.classBuilder(groupFileName)
.addJavadoc(WARNING_TIPS)
.addSuperinterface(ClassName.get(type_IRouteGroup))
.addModifiers(PUBLIC)
.addMethod(loadIntoMethodOfGroupBuilder.build())
.build()
).build().writeTo(mFiler);
}
}
至此,整个Activity跳转涉及到的源码大致就是这些,总结下ARouter都做了什么:
- 1、在编译期,ARouter注解处理器将所有@Route注解标记的类查找出来,并根据这些类的相关信息生成ARouter$$相关文件;
- 2、ARouter.init()初始化时,将ARouter$$Group前缀文件涉及到的路由组存储到Warehouse.groupsIndex中;
- 3、调用ARouter...navigation()跳转页面时,通过Warehouse.groupsIndex查询路由所在组,将路由组中的所有路由注册到Warehouse.routes中,从Warehouse.routes中取出路由信息(包含Activity.class对象),完成跳转。
Fragment获取
依旧根据文档,获取Fragment歩奏也只需2步:
- 1、注解标记需要获取的Fragemnt
@Route(path = "/user/UserFragment")
class UserFragment : Fragment() {
...
}
- 2、获取Fragment
val f = ARouter.getInstance().build("/user/UserFragment").navigation() as Fragment
有了对Activity跳转源码分析的铺垫,Fragment的获取原理基本是一样的,只是在最后一步发生跳转的代码,变为返回Fragment对象:
final class _ARouter {
protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
...
// 6、完成跳转。
switch (postcard.getType()) {
// Activity跳转
case ACTIVITY:
// Build intent
final Intent intent = new Intent(currentContext, postcard.getDestination());
intent.putExtras(postcard.getExtras());
//...
// Navigation in main looper.
runInMainThread(new Runnable() {
@Override
public void run() {
startActivity(requestCode, currentContext, intent, postcard, callback);
}
});
break;
// Fragment获取
case FRAGMENT:
Class<?> fragmentMeta = postcard.getDestination();
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;
...
}
...
}
}
跨模块功能调用
ARouter的方案和我们之前的实现的方案原理是一样的,都需将对外的服务暴露到lib_comm中,只是如Activity和Fragment一样注册的功能通过APT技术来实现。
- 1、lib_comm中定义暴露的接口
interface IUserService2 : IProvider {
/**
* 是否登录
*/
fun isLogin(): Boolean
}
- 2、业务模块实现接口,并通过@Route注解标记
@Route(path = "/user/UserService")
class IUserServiceImpl2 : IUserService2 {
override fun init(context: Context?) {
}
override fun isLogin(): Boolean {
return UserUtils.isLogin()
}
}
- 3、获取服务
ARouter.getInstance().build("/user/UserService").navigation() as IUserService2
和Fragment类似,只不过在获取时,多了一步缓存操作,缓存相关的核心代码我贴在了下方:
class Warehouse {
// Cache provider
static Map<Class, IProvider> providers = new HashMap<>();
}
// 创建服务,并缓存
switch (routeMeta.getType()) {
case PROVIDER: // if the route is provider, should find its instance
// Its provider, so it must implement 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();
provider.init(mContext);
// 进行缓存
Warehouse.providers.put(providerMeta, provider);
instance = provider;
} catch (Exception e) {
logger.error(TAG, "Init provider failed!", e);
throw new HandlerException("Init provider failed!");
}
}
postcard.setProvider(instance);
postcard.greenChannel(); // Provider should skip all of interceptors
break;
}
获取时,只需从postcard.getProvider()中取即可:
final class _ARouter {
protected Object navigation(final Context context, final Postcard postcard, final int requestCode, final NavigationCallback callback) {
...
// 6、完成跳转。
switch (postcard.getType()) {
// Activity跳转
case ACTIVITY:
// Build intent
final Intent intent = new Intent(currentContext, postcard.getDestination());
intent.putExtras(postcard.getExtras());
//...
// Navigation in main looper.
runInMainThread(new Runnable() {
@Override
public void run() {
startActivity(requestCode, currentContext, intent, postcard, callback);
}
});
break;
// Fragment获取
case FRAGMENT:
Class<?> fragmentMeta = postcard.getDestination();
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;
// 获取Service
case PROVIDER:
return postcard.getProvider();
...
}
...
}
}
OK,ARouter路由核心三剑客功能已摸了个底朝天,与我们自己实现的路由框架相比,其核心思想是一样的,但在细节上ARouter的处理明显优于我们,例如:
- 通过APT来实现路由注册,省掉手动注册的繁琐,且无需在App启动时注册所有路由(与我们startup方案相比),仅在使用到某组路由时才进行注册,避免不必要的内存开销。
- 对外提供功能的Service对象,在使用时进行缓存,避免重复创建。
小结
本篇对ARouter的Activity跳转、Fragment获取、扩模块功能调用花费了大幅篇章来讲解源码,是希望读者能了解其基本原理,后续我在处理自定义路由时,会参考ARouter实现来造轮子,也方便读者对后续篇章的理解。
ARouter还支持很多功能,例如:拦截器、标准Scheme URL跳转、全局降级策略、动态路由注册等,这些功能后续篇章中一部分会讲到,一部分也可能使用不到,但并不代表这些功能没用,每个项目或团队对组件化架构的理解都会有所不同,最后落地的项目结构、路由交互方案也就各具特色。无论是怎样的项目,个人认为:
- 组件化,它是由实际业务开发过程中,开发人员通过经验积累,设计出的一套适用于多人协作开发的架构模式;
- 具备可复用性、可替代性、热插拔、可独立调试特性的模块,就是组件化模块(组件);
- 由多个组件化模块组成的项目架构,就是组件化架构。
下篇,聊聊组件通讯之Scheme URL,我们下篇再见!
网友评论