13518219792
前段时间，公司项目在做组件化重构，过程中当然会有很多痛点。
成都创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：做网站、网站建设、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的稷山网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！
组件化最重要的是根据项目和业务进行分模块，至于模块的粒度就看大家自己来把控了！
这里要说的就是模块之间的数据传输问题
组件化之后，各个模块不相互依赖，那么怎么相互跳转和传递数据呢？
答案就是通过隐式Intent 的方式来跳转和传递数据。
以往的显示Intent 跳转，会存在类直接依赖的问题，这样会导致耦合性非常严重；相比而言，隐式Intent则不需要类之间的直接依赖，但是会出现规则集中式管理，扩展性比较差。
所以在调研期间就发现阿里开源了ARouter–路由框架。
ARouter的好处我这里就不多说，大家可以去看官方文档或者去github上看README。
【https://github.com/alibaba/ARouter】
接下来会分为若干篇blog来分析一下ARouter的源码！
看了ARouter的源码就会发现，它提供了两个SDK，一个是API，一个Compiler。
这里先说说Compiler层SDK。
RouteProcessor 路由路径处理器
InterceptorProcessor 拦截器处理器
AutowireProcessor 自动装配处理器
注解处理器的处理流程
（图片转自网络）
实际上，Compiler SDK 只是处根据扫描到的注解生成相应的映射(java)文件。
最后一步通过固定包名加载映射文件是由API SDK来做的。
以官方demo为例来说：
上图所示就是ARouter在编译期间生成的类文件。
arouter-compiler的目录结构如下：
下面分别说说这三种注解处理器：
用过编译时注解的朋友们都知道，注解处理器需要继承AbstractProcessor ，主要涉及的函数有 init()，process() 这两个。
RouteProcessor
类的继承信息：
@AutoService(Processor.class)
@SupportedOptions(KEY_MODULE_NAME)
@SupportedSourceVersion(SourceVersion.RELEASE_7)
@SupportedAnnotationTypes({ANNOTATION_TYPE_ROUTE, ANNOTATION_TYPE_AUTOWIRED})
public class RouteProcessor extends AbstractProcessor {init
init()
// 初始化处理器
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
super.init(processingEnv);
// 文件管理器
mFiler = processingEnv.getFiler(); // Generate class.
// 获取类型处理工具类
types = processingEnv.getTypeUtils(); // Get type utils.
// 获取日志信息工具类
elements = processingEnv.getElementUtils(); // Get class meta.
typeUtils = new TypeUtils(types, elements);
// 封装日志信息类
logger = new Logger(processingEnv.getMessager()); // Package the log utils.
// 获取用户配置的[moduleName]
Map options = processingEnv.getOptions();
if (MapUtils.isNotEmpty(options)) {
moduleName = options.get(KEY_MODULE_NAME);
}
if (StringUtils.isNotEmpty(moduleName)) {
// 格式化
moduleName = moduleName.replaceAll("[^0-9a-zA-Z_]+", "");
logger.info("The user has configuration the module name, it was [" + moduleName + "]");
} else {
// 如果没有在build.gradle中配置moduleName，则会抛出异常。
logger.error("These no module name, at 'build.gradle', like :\n" +
"apt {\n" +
" arguments {\n" +
" moduleName project.getName();\n" +
" }\n" +
"}\n");
throw new RuntimeException("ARouter::Compiler >>> No module name, for more information, look at gradle log.");
}
//
iProvider = elements.getTypeElement(Consts.IPROVIDER).asType();
// RouterProcessor 初始化完毕
logger.info(">>> RouteProcessor init. <<<");
} // Consts.java public static final String KEY_MODULE_NAME = "moduleName";
在使用ARouter注解的时候，按照官方文档是需要在每个module里面的build.gradle中配置如下信息：
javaCompileOptions {
annotationProcessorOptions {
arguments = [ moduleName : project.getName() ]
}
}配置这个属性的目的，就是为了在编译期间生成相关module下的文件和存储文件名称。
process()
一般在process()函数中做的操作如下：
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (CollectionUtils.isNotEmpty(annotations)) {
// 获取所有添加Route注解的元素
Set<? extends Element> routeElements = roundEnv.getElementsAnnotatedWith(Route.class);
try {
logger.info(">>> Found routes, start... <<<");
// 调用arseRoute()函数进行处理获取的注解元素集合
this.parseRoutes(routeElements);
} catch (Exception e) {
logger.error(e);
}
// 如果有Route元素的注解，并且处理过程中无异常则返回true
return true;
}
// 否则返回false
return false;
}parseRoutes()
这个函数的代码有点长，大家耐心看！
// Consts.java public static final String ACTIVITY = "android.app.Activity"; public static final String FRAGMENT = "android.app.Fragment"; public static final String FRAGMENT_V4 = "android.support.v4.app.Fragment"; public static final String SERVICE = "android.app.Service"; private static final String FACADE_PACKAGE = "com.alibaba.android.arouter.facade"; private static final String TEMPLATE_PACKAGE = ".template"; public static final String IROUTE_GROUP = FACADE_PACKAGE + TEMPLATE_PACKAGE + ".IRouteGroup"; public static final String IPROVIDER_GROUP = FACADE_PACKAGE + TEMPLATE_PACKAGE + ".IProviderGroup";
private void parseRoutes(Set<? extends Element> routeElements) throws IOException {
if (CollectionUtils.isNotEmpty(routeElements)) {
// ...
rootMap.clear();
// 获取ACTIVITY, SERVICE, FRAGMENT, FRAGMENT_V4 这四种 类型镜像
TypeMirror type_Activity = elements.getTypeElement(ACTIVITY).asType();
TypeMirror type_Service = elements.getTypeElement(SERVICE).asType();
TypeMirror fragmentTm = elements.getTypeElement(FRAGMENT).asType();
TypeMirror fragmentTmV4 = elements.getTypeElement(Consts.FRAGMENT_V4).asType();
// ARouter的接口
TypeElement type_IRouteGroup = elements.getTypeElement(IROUTE_GROUP);
TypeElement type_IProviderGroup = elements.getTypeElement(IPROVIDER_GROUP);
//
// 下面就是遍历获取的注解信息，通过javapoet来生成类文件了
ClassName routeMetaCn = ClassName.get(RouteMeta.class);
ClassName routeTypeCn = ClassName.get(RouteType.class);
/*
ParameterizedTypeName用来创建类型对象，例如下面
```Map>```
*/
ParameterizedTypeName inputMapTypeOfRoot = ParameterizedTypeName.get(
ClassName.get(Map.class),
ClassName.get(String.class),
ParameterizedTypeName.get(
ClassName.get(Class.class),
WildcardTypeName.subtypeOf(ClassName.get(type_IRouteGroup))
)
);
/*
RouteMeta封装了路由相关的信息
```Map```
*/
ParameterizedTypeName inputMapTypeOfGroup = ParameterizedTypeName.get(
ClassName.get(Map.class),
ClassName.get(String.class),
ClassName.get(RouteMeta.class)
);
/*
创建输入参数
*/
// 1。 生成的参数：Map> routes
ParameterSpec rootParamSpec = ParameterSpec.builder(inputMapTypeOfRoot, "routes").build(); // 第一个参数表示参数类型，第二个函数表示参数名称
// 2。 Map atlas
ParameterSpec groupParamSpec = ParameterSpec.builder(inputMapTypeOfGroup, "atlas").build();
// 3。 Map providers
ParameterSpec providerParamSpec = ParameterSpec.builder(inputMapTypeOfGroup, "providers").build();
// MethodSpec用来创建方法
// public static final String METHOD_LOAD_INTO = "loadInto";
/*
Build method : 'loadInto'
*/
MethodSpec.Builder loadIntoMethodOfRootBuilder = MethodSpec.methodBuilder(METHOD_LOAD_INTO)
.addAnnotation(Override.class) // override
.addModifiers(PUBLIC) // public
.addParameter(rootParamSpec); // 参数
// 创建出来的函数如下
/**
* @Override
* public void loadInto(Map> routes) { }
*/
//
// 接下来的代码就是遍历注解元素，进行分组，进而声称java文件
for (Element element : routeElements) { // 遍历每个元素
TypeMirror tm = element.asType();
Route route = element.getAnnotation(Route.class);
RouteMeta routeMete = null;
// 判断类型
if (types.isSubtype(tm, type_Activity)) { // Activity
logger.info(">>> Found activity route: " + tm.toString() + " <<<");
Map paramsType = new HashMap<>();
// 遍历查找所有添加 @AutoWired 注解的变量
for (Element field : element.getEnclosedElements()) {
// 1. 必须是field
// 2. 必须有注解AutoWired
// 3. 必须不是IProvider类型
if (field.getKind().isField() && field.getAnnotation(Autowired.class) != null && !types.isSubtype(field.asType(), iProvider)) {
// 满足上述条件后，获取注解
Autowired paramConfig = field.getAnnotation(Autowired.class);
// 看过源码就知道，Autowired支持写别名，当指定name属性之后，就会以name为准，否则以field的名字为准。
// TypeUtils是自定义工具类，用来判断field的数据类型的，转换成int值。
paramsType.put(StringUtils.isEmpty(paramConfig.name()) ? field.getSimpleName().toString() : paramConfig.name(), typeUtils.typeExchange(field));
}
// 构建一条路由信息，将字段注解信息保存进去
routeMete = new RouteMeta(route, element, RouteType.ACTIVITY, paramsType);
}
// 如果是IProvider类型的注解，则直接创建一条PROVIDER类型的路由信息
else if (types.isSubtype(tm, iProvider)) {
routeMete = new RouteMeta(route, element, RouteType.PROVIDER, null);
}
// 如果是Service类型的注解，则直接创建一条Service类型的路由信息
else if (types.isSubtype(tm, type_Service)) { // Service
routeMete = new RouteMeta(route, element, RouteType.parse(Service), null);
}
// 如果是fragmentTmV4类型的注解，则直接创建一条Fragment类型的路由信息
else if (types.isSubtype(tm, fragmentTm) || types.isSubtype(tm, fragmentTmV4)) {
routeMete = new RouteMeta(route, element, RouteType.parse(FRAGMENT), null);
}
// 将路由信息进行分组 （每个路由信息对象中都保存着它所属的组别信息，在调用categories()函数之前所有的组别信息都是默认值"" ）
categories(routeMete);
}
// 第一次遍历之前，已经创建了ROOT类的loadInto函数
// 下面开始创建Provider类的loadInto函数
MethodSpec.Builder loadIntoMethodOfProviderBuilder = MethodSpec.methodBuilder(METHOD_LOAD_INTO)
.addAnnotation(Override.class)
.addModifiers(PUBLIC)
.addParameter(providerParamSpec);
// 创建出来的函数如下
/**
* @Override
* public void loadInto(Map providers) { }
*/
// 接着，遍历所有在 categories(routeMete); 得到的所有组别
for (Map.Entry> entry : groupMap.entrySet()) {
String groupName = entry.getKey();
// 创建分组类的函数 -- loadInto(Map atlas)
MethodSpec.Builder loadIntoMethodOfGroupBuilder = MethodSpec.methodBuilder(METHOD_LOAD_INTO)
.addAnnotation(Override.class)
.addModifiers(PUBLIC)
.addParameter(groupParamSpec);
// 往组别函数loadInto中添加数据
Set groupData = entry.getValue();
// PROVIDERL 类型的数据需要特殊处理
for (RouteMeta routeMeta : groupData) {
switch (routeMeta.getType()) {
case PROVIDER:
List<? extends TypeMirror> interfaces = ((TypeElement) routeMeta.getRawType()).getInterfaces();
// 遍历当前类的接口
for (TypeMirror tm : interfaces) {
// 如果当前类直接实现了IProvider接口
if (types.isSameType(tm, iProvider)) {
// 这种情况下，在loadInfo()函数里面添加的语句类似于：
// singleService直接实现IProvider接口
/**
* @Route(path = "/service/single")
* public class SingleService implements IProvider
*
* providers.put("com.alibaba.android.arouter.demo.testservice.SingleService", RouteMeta.build(RouteType.PROVIDER, SingleService.class, "/service/single", "service", null, -1, -2147483648));
*/
loadIntoMethodOfProviderBuilder.addStatement(
"providers.put($S, $T.build($T." + routeMeta.getType() + ", $T.class, $S, $S, null, " + routeMeta.getPriority() + ", " + routeMeta.getExtra() + "))",
(routeMeta.getRawType()).toString(),
routeMetaCn,
routeTypeCn,
ClassName.get((TypeElement) routeMeta.getRawType()),
routeMeta.getPath(),
routeMeta.getGroup());
} else if (types.isSubtype(tm, iProvider)) {
// 如果是接口继承的IProvider
// 这种情况下，在loadInfo()函数里面添加的语句类似于：
// singleService直接实现IProvider接口
/**
* @Route(path = "/service/hello")
* public class HelloServiceImpl implements HelloService
* public interface HelloService extends IProvider
* //
* providers.put("com.alibaba.android.arouter.demo.testservice.HelloService", RouteMeta.build(RouteType.PROVIDER, HelloServiceImpl.class, "/service/hello", "service", null, -1, -2147483648));
*/
loadIntoMethodOfProviderBuilder.addStatement(
"providers.put($S, $T.build($T." + routeMeta.getType() + ", $T.class, $S, $S, null, " + routeMeta.getPriority() + ", " + routeMeta.getExtra() + "))",
tm.toString(), // So stupid, will duplicate only save class name.
routeMetaCn,
routeTypeCn,
ClassName.get((TypeElement) routeMeta.getRawType()),
routeMeta.getPath(),
routeMeta.getGroup());
}
}
break;
default:
break;
}
// 拼接添加注解的字段
StringBuilder mapBodyBuilder = new StringBuilder();
Map paramsType = routeMeta.getParamsType();
if (MapUtils.isNotEmpty(paramsType)) {
for (Map.Entry types : paramsType.entrySet()) {
mapBodyBuilder.append("put(\"").append(types.getKey()).append("\", ").append(types.getValue()).append("); ");
}
}
// // 形式如： put("pac", 9); put("obj", 10);
String mapBody = mapBodyBuilder.toString();
// 往loadInto函数里面添加一个语句
loadIntoMethodOfGroupBuilder.addStatement(
"atlas.put($S, $T.build($T." + routeMeta.getType() + ", $T.class, $S, $S, " + (StringUtils.isEmpty(mapBody) ? null : ("new java.util.HashMap(){{" + mapBodyBuilder.toString() + "}}")) + ", " + routeMeta.getPriority() + ", " + routeMeta.getExtra() + "))",
routeMeta.getPath(), // 完整路径
routeMetaCn, // RouteMeta
routeTypeCn, // RouteType
ClassName.get((TypeElement) routeMeta.getRawType()), // 注解原生类的名称
routeMeta.getPath().toLowerCase(), // 完整路径
routeMeta.getGroup().toLowerCase()); // 组名
}
// 添加的语句如下：
// atlas.put("/test/activity1", RouteMeta.build(RouteType.ACTIVITY, Test1Activity.class, "/test/activity1", "test", new java.util.HashMap(){{put("pac", 9); put("obj", 10); put("name", 8); put("boy", 0); put("age", 3); put("url", 8); }}, -1, -2147483648));
// 生成组类别java文件
// public static final String NAME_OF_GROUP = PROJECT + SEPARATOR + "Group" + SEPARATOR;
// public static final String SEPARATOR = "$$";
// public static final String PROJECT = "ARouter";
String groupFileName = NAME_OF_GROUP + groupName;
JavaFile.builder(PACKAGE_OF_GENERATE_FILE, // package 名称 --"com.alibaba.android.arouter.routes"
TypeSpec.classBuilder(groupFileName) //java类名
.addJavadoc(WARNING_TIPS) // doc
.addSuperinterface(ClassName.get(type_IRouteGroup)) // 添加继承的接口
.addModifiers(PUBLIC) // 作用域为public
.addMethod(loadIntoMethodOfGroupBuilder.build()) // 添加函数（包括了函数里面的代码块）
.build()
).build().writeTo(mFiler);
// 将组名和组文件名放到map中，方便按需加载
rootMap.put(groupName, groupFileName);
}
// .................................................................... //
// 经过了上面的for循环，生成了如 ARouter$$Group$$service.java 和ARouter$$Group$$test.java 文件，它们所在的包是 com.alibaba.android.arouter.routes。
if (MapUtils.isNotEmpty(rootMap)) {
// 遍历这些group，进而生成Root类文件
for (Map.Entry entry : rootMap.entrySet()) {
loadIntoMethodOfRootBuilder.addStatement("routes.put($S, $T.class)", entry.getKey(), ClassName.get(PACKAGE_OF_GENERATE_FILE, entry.getValue()));
// 每一个statement如： routes.put("test", ARouter$$Group$$test.class);
}
}
// 生成provider类文件
// provider文件名为：ARouter$$Providers$$xxx
String providerMapFileName = NAME_OF_PROVIDER + SEPARATOR + moduleName;
JavaFile.builder(PACKAGE_OF_GENERATE_FILE,
TypeSpec.classBuilder(providerMapFileName)
.addJavadoc(WARNING_TIPS)
.addSuperinterface(ClassName.get(type_IProviderGroup))
.addModifiers(PUBLIC)
.addMethod(loadIntoMethodOfProviderBuilder.build())
.build()
).build().writeTo(mFiler);
// 生成root文件
// ARouter$$Root$$xxx
String rootFileName = NAME_OF_ROOT + SEPARATOR + moduleName;
JavaFile.builder(PACKAGE_OF_GENERATE_FILE,
TypeSpec.classBuilder(rootFileName)
.addJavadoc(WARNING_TIPS)
.addSuperinterface(ClassName.get(elements.getTypeElement(ITROUTE_ROOT)))
.addModifiers(PUBLIC)
.addMethod(loadIntoMethodOfRootBuilder.build())
.build()
).build().writeTo(mFiler);
}
} categories()
下面来看一下怎么讲路由进行分组的
private void categories(RouteMeta routeMete) {
// 首先去验证这条路由信息
if (routeVerify(routeMete)) {
// 尝试从groupMap中通过group名称获取路由信息
Set routeMetas = groupMap.get(routeMete.getGroup());
if (CollectionUtils.isEmpty(routeMetas)) { // 如果map中没有相关记录，则表示这个组别还未添加到map中
Set routeMetaSet = new TreeSet<>(new Comparator() {
@Override
public int compare(RouteMeta r1, RouteMeta r2) {
try {
return r1.getPath().compareTo(r2.getPath());
} catch (NullPointerException npe) {
logger.error(npe.getMessage());
return 0;
}
}
});
// 添加该组别到map中
routeMetaSet.add(routeMete);
groupMap.put(routeMete.getGroup(), routeMetaSet);
} else { // 如果存在该组别则添加到这一组中
routeMetas.add(routeMete);
}
} else {
// 验证路由信息不正确是会在编译期间输出错误日志
logger.warning(">>> Route meta verify error, group is " + routeMete.getGroup() + " <<<");
}
} routeVerify()
// 验证路由信息的正确性
private boolean routeVerify(RouteMeta meta) {
String path = meta.getPath();
// 判断路径是否为空或者是否以“/”开头
if (StringUtils.isEmpty(path) || !path.startsWith("/")) { // The path must be start with '/' and not empty!
return false;
}
// 没有分组时，group为""
if (StringUtils.isEmpty(meta.getGroup())) { // Use default group(the first word in path)
try {
// 截取字符串获取group
String defaultGroup = path.substring(1, path.indexOf("/", 1));
if (StringUtils.isEmpty(defaultGroup)) {
return false;
}
meta.setGroup(defaultGroup);
return true;
} catch (Exception e) {
logger.error("Failed to extract default group! " + e.getMessage());
return false;
}
}
return true;
}通过上面的分析可以得到以下几点：
配置Route注解时，路径不允许为空且必须以“/”开头
RouteProcessor注解处理器生成的文件由三种：
1. ARouter$$Group$$xxx (可能有多个)
2. ARouter$$Providers$$xxx (只有一个)
3. ARouter$$Root$$xxx (只有一个)
InterceptorProcessor
@AutoService(Processor.class) @SupportedOptions(KEY_MODULE_NAME) @SupportedSourceVersion(SourceVersion.RELEASE_7) @SupportedAnnotationTypes(ANNOTATION_TYPE_INTECEPTOR) public class InterceptorProcessor extends AbstractProcessor
init()
@Override
public synchronized void init(ProcessingEnvironment processingEnv) {
super.init(processingEnv);
// ... 省略代码与RouteProcressor基本一样
iInterceptor = elementUtil.getTypeElement(Consts.IINTERCEPTOR).asType();
}process()
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (CollectionUtils.isNotEmpty(annotations)) {
// 获取Interceptor注解的集合
Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Interceptor.class);
try {
// 处理注解信息
parseInterceptors(elements);
} catch (Exception e) {
logger.error(e);
}
return true;
}
return false;
}parseInterceptors()
