android 路由总线,利用APT实现android路由框架一

最新推荐文章于 2024-05-07 01:11:51 发布

卢少奇

最新推荐文章于 2024-05-07 01:11:51 发布

阅读量178

点赞数

文章标签： android 路由总线

随着业务的发展，项目会越来越大，实现组件化便于更好的维护项目以及拆分。

a20658b35477

3.png

业务组件相互独立，需要路由来完成之间的跳转与数据传递。

实现方法：

1、使用 EventBus的方式，缺点是：EventBean维护成本太高，不好去管理：

2、使用广播的方式，缺点是：不好管理，都统一发出去了

3、使用隐士意图方式，缺点是：在AndroidManifest.xml里面配置xml写的太多了

4、使用类加载方式，缺点就是，容易写错包名类名，缺点较少

5、使用全局Map的方式，缺点是，要注册很多的对象

6、事件总线的思路。(可以参考CC)

1~5这些不好维护，我们可以利用APT、JavaPoet技术参考阿里的ARouter、ButterKnife等思路来完成自己的一个Router路由框架，先了解一下APT以及JavaPoet。

APT: annotation process tool是一种处理注释的工具，它对源代码文件进行检测找出其中的Annotation，使用Annotation进行额外的处理。

APT 编译的时候 ----------> 处理注解 --------> 生成代码----------> 编译完成

JavaPoet: JavaPoet是square推出的开源java代码生成框架，提供Java Api生成.java源文件,是Java面向对象OOP语法，可以很方便的使用它根据注解生成对应代码，通过这种自动化生成代码的方式，可以让我们用更加简洁优雅的方式要替代繁琐冗杂的重复工作。

传统的APT : package ---> class ---> method

JavaPoet: method---->class----->package

我们看一下我们项目的框架

a20658b35477

image.png

我们类跳转的时候，先找到group,在找到对应的path就可以跳转的目标了。我们可以用两个Map来实现group和path映射。先看一下效果：

group

public class ARouter$$Group$$user implements ARouterGroup {

@Override

public Map> getGroupMap() {

Map> groupMap = new HashMap<>();

groupMap.put("user",ARouter$$Path$$user.class);

return groupMap;

}

path

public class ARouter$$Path$$user implements ARouterPath {

@Override

public Map getPathMap() {

Map pathMap = new HashMap<>();

pathMap.put("/user/User_LoginAcitivty", RouterBean.create(RouterBean.TypeEnum.ACTIVITY,User_LoginAcitivty.class,"/user/User_LoginAcitivty","user"));

pathMap.put("/user/User_MainActivity", RouterBean.create(RouterBean.TypeEnum.ACTIVITY,User_MainActivity.class,"/user/User_MainActivity","user"));

return pathMap;

}

1、我们可以仿照ARouter的架构来搭建自己的框架

a20658b35477

image.png

arouter-annotation、arouter-compiler为java-library。把注解列存放在arouter-annotation包中。(注解不清楚的先了解下)

a20658b35477

image.png

arouter-compiler的gradle要依赖

a20658b35477

image.png

。

ArouterPath接口

public interface ARouterPath {

/**

* 存放的内容key:/app/MainActivity value:RouterBean == App_MainActivity.class

Map getPathMap();

}

RouterBean用于封装app、user等组件中的MainActivity等对象, 封装成对象会有更多的属性

public class RouterBean {

public enum TypeEnum {//可扩展 fragment

ACTIVITY

}

private TypeEnum typeEnum;//枚举类型activity

private Element element;//节点 JavaPoet，可以拿到很多的信息

private Class> myClass;// 被注解 class对象 eg: MainActivity.class

private String path;// 路由地址 eg: /app/MainActivity

private String group;// 路由组 eg: app user等

public TypeEnum getTypeEnum() {

return typeEnum;

}

public void setTypeEnum(TypeEnum typeEnum) {

this.typeEnum = typeEnum;

}

public Element getElement() {

return element;

}

public void setElement(Element element) {

this.element = element;

}

public Class> getMyClass() {

return myClass;

}

public void setMyClass(Class> myClass) {

this.myClass = myClass;

}

public String getPath() {

return path;

}

public void setPath(String path) {

this.path = path;

}

public String getGroup() {

return group;

}

public void setGroup(String group) {

this.group = group;

}

private RouterBean(TypeEnum typeEnum, Class> myClass, String path, String group) {

this.typeEnum = typeEnum;

// this.element = element;

this.myClass = myClass;

this.path = path;

this.group = group;

}

//对外暴露为了方便APT生成代码

public static RouterBean create(TypeEnum typeEnum, Class> clazz,String path, String group) {

return new RouterBean(typeEnum, clazz, path, group);

}

/**

* 构建者模式

public static class Builder {

// 枚举类型：Activity

private TypeEnum type;

// 类节点

private Element element;

// 注解使用的类对象

private Class> clazz;

// 路由地址

private String path;

// 路由组

private String group;

public Builder addType(TypeEnum type) {

this.type = type;

return this;

}

public Builder addElement(Element element) {

this.element = element;

return this;

}

public Builder addClazz(Class> clazz) {

this.clazz = clazz;

return this;

}

public Builder addPath(String path) {

this.path = path;

return this;

}

public Builder addGroup(String group) {

this.group = group;

return this;

}

public RouterBean build() {

if (path == null || path.length() == 0) {

throw new IllegalArgumentException("path路径为空，请检查" + clazz);

}

return new RouterBean(this);

}

private RouterBean(Builder builder) {

this.typeEnum = builder.type;

this.element = builder.element;

this.myClass = builder.clazz;

this.path = builder.path;

this.group = builder.group;

}

@Override

public String toString() {

return "RouterBean{" +

"path='" + path + '\'' +

", group='" + group + '\'' +

'}';

}

public interface ARouterGroup {

/**

* 存放的内容key:app value:app所有的path类

Map> getGroupMap();

}

工具类

package com.htf.arouter_compiler.util;

public interface ProcessorConfig {

// @ARouter注解的包名 + 类名

String AROUTER_PACKAGE = "com.htf.arouter_annotation.ARouter";

String PARAMETER_PACKAGE = "com.htf.arouter_annotation.Parameter";

// 接收module参数

String OPTIONS = "moduleName";

// 目的是接收包名

String APT_PACKAGE = "packageNameForAPT";

// 为了匹配加注解的类是否为Activity

public static final String ACTIVITY_PACKAGE = "android.app.Activity";

// ARouter api 包名

String AROUTER_API_PACKAGE = "com.htf.arouter_api";

// ARouter api 的 ARouterPath 高层标准

String AROUTER_API_PATH = AROUTER_API_PACKAGE + ".ARouterPath";

// ARouter api 的 ARouterGroup 高层标准

String AROUTER_API_GROUP = AROUTER_API_PACKAGE + ".ARouterGroup";

// 路由组，中的 Path 里面的方法名

String PATH_METHOD_NAME = "getPathMap";

// 路由组，中的 Path 里面的变量名

String PATH_VAR1 = "pathMap";

// 路由组，PATH 最终要生成的文件名

String PATH_FILE_NAME = "ARouter$$Path$$";

// 路由组，中的 Group 里面的方法名

String GROUP_METHOD_NAME = "getGroupMap";

// 路由组，中的 Group 里面的变量名 1

String GROUP_VAR1 = "groupMap";

// 路由组，GROUP 最终要生成的文件名

String GROUP_FILE_NAME = "ARouter$$Group$$";

// ARouter api 的 ParameterGet 高层标准

String AROUTER_AIP_PARAMETER_DATA = AROUTER_API_PACKAGE + ".ParameterData";

// ARouter api 的 ParmeterGet 方法的名字

String PARAMETER_METHOD_NAME = "getParameter";

// ARouter api 的 ParameterGet 方法参数的名字

String PARAMETER_NAME = "targetParameter";

// String全类名

String STRING = "java.lang.String";

//用户判断是否是自定义对象类型要实现Parcelable

String PARCELABLE = "android.os.Parcelable";

// ARouter aip 的 ParmeterGet 的生成文件名称 $$Parameter

String PARAMETER_FILE_NAME = "$$Parameter";

//用户判断是否是List类型

String LIST_STRING = "java.util.List";

String LIST_PARCELABLE = "java.util.List";

}

利用APT生成ARouter$$Path$$user和ARouter$$Group$$user文件

@AutoService(Processor.class)

@SupportedSourceVersion(SourceVersion.RELEASE_8)

@SupportedAnnotationTypes("com.htf.arouter_annotation.ARouter")//自己的注解类

@SupportedOptions({"moduleName", "packageNameForAPT"})// moduleName接收module参数;packageNameForAPT目的是接收包名

public class ARouterProcessor extends AbstractProcessor {

private Types typeTool; type(类信息)的工具类，包含用于操作TypeMirror的工具方法

private Elements elementTool;// 操作Element的工具类(类，函数，属性，其实都是Element)

private Messager messager;

private Filer filer;

private String options; // 各个模块传递过来的模块名例如：app user zixun order等

private String aptPackage; // 各个模块传递过来的目录用于统一存放 apt生成的文件

private Map> mAllPathMap = new HashMap<>();

// Map

private Map mAllGroupMap = new HashMap<>();

@Override

public synchronized void init(ProcessingEnvironment processingEnvironment) {

super.init(processingEnvironment);

elementTool = processingEnvironment.getElementUtils();

filer = processingEnvironment.getFiler();

messager = processingEnvironment.getMessager();

typeTool = processingEnvironment.getTypeUtils();

options = processingEnvironment.getOptions().get(ProcessorConfig.OPTIONS);

aptPackage = processingEnvironment.getOptions().get(ProcessorConfig.APT_PACKAGE);

}

@Override

public boolean process(Set extends TypeElement> set, RoundEnvironment roundEnvironment) {

if (set.isEmpty()) {

messager.printMessage(Diagnostic.Kind.NOTE, "没有发现注解的类");

return false;

}

// // 获取所有被 @ARouter 注解的元素集合

Set extends Element> elements = roundEnvironment.getElementsAnnotatedWith(ARouter.class);

// 通过Element工具类，获取android.app.Activity类型

TypeElement activityElement = elementTool.getTypeElement(ProcessorConfig.ACTIVITY_PACKAGE);

TypeMirror activityMirror = activityElement.asType();

for (Element element : elements) {

String className = element.getSimpleName().toString();

ARouter aRouter = element.getAnnotation(ARouter.class);

messager.printMessage(Diagnostic.Kind.NOTE, "aRouter.group() == " + aRouter.group());

RouterBean routerBean = new RouterBean.Builder()

.addElement(element)

.addGroup(options)

.addPath(aRouter.path())

.build();

TypeMirror myMirror = element.asType();//自己类的TypeMirror 用于判断是不是继承android.app.Activity

if (typeTool.isSubtype(myMirror, activityMirror)) {//是activity

routerBean.setTypeEnum(RouterBean.TypeEnum.ACTIVITY);

} else {

throw new RuntimeException(className + "必须是Activity");

}

//把所有的注解类封以module名为key封装到mAllPathMap中

if (checkRouterPath(routerBean)) {

List routerBeanList = mAllPathMap.get(routerBean.getGroup());

if (ProcessorUtils.isEmpty(routerBeanList)) {

routerBeanList = new ArrayList<>();

routerBeanList.add(routerBean);

mAllPathMap.put(routerBean.getGroup(), routerBeanList);

} else {

routerBeanList.add(routerBean);

}

} else {

messager.printMessage(Diagnostic.Kind.ERROR, "@ARouter注解未按规范配置，如：/app/MainActivity");

}

}//循环结束，把所有的注解类以module名为key封装到mAllPathMap

// TODO 开始用javapoet生成文件

//定义文件要实现的接口

TypeElement pathTypeElement = elementTool.getTypeElement(ProcessorConfig.AROUTER_API_PATH);

try {

createPathFile(pathTypeElement);

} catch (IOException e) {

e.printStackTrace();

}

TypeElement groupType = elementTool.getTypeElement(ProcessorConfig.AROUTER_API_GROUP);

try {

createGroupFile(groupType, pathTypeElement);

} catch (IOException e) {

e.printStackTrace();

}

return true;

}

//生成路由组Group文件，如：ARouter$$Group$$app

private void createGroupFile(TypeElement groupType, TypeElement pathType) throws IOException {

if (ProcessorUtils.isEmpty(mAllGroupMap) || ProcessorUtils.isEmpty(mAllPathMap)) return;

//要生成的内容

//Map>

TypeName methodReturn = ParameterizedTypeName.get(

ClassName.get(Map.class),

ClassName.get(String.class),

//Class extends ARouterPath>>

ParameterizedTypeName.get(ClassName.get(Class.class),

WildcardTypeName.subtypeOf(ClassName.get(pathType))) // ? extends ARouterLoadPath)

);

MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(ProcessorConfig.GROUP_METHOD_NAME)

.addAnnotation(Override.class)

.addModifiers(Modifier.PUBLIC)

.returns(methodReturn);

//方法里的内容

// Map> groupMap = new HashMap<>();

methodBuilder.addStatement("$T $N = new $T<>()",

ClassName.get(Map.class),

ClassName.get(String.class),

//Class extends ARouterPath>

ParameterizedTypeName.get(ClassName.get(Class.class),

WildcardTypeName.subtypeOf(ClassName.get(pathType))), // ? extends ARouterPath

ProcessorConfig.GROUP_VAR1,

ClassName.get(HashMap.class));

// groupMap.put("app", ARouter$$Path$$app.class);

// groupMap.put("user", ARouter$$Path$$user.class);

methodBuilder.addStatement("$N.put($S,$T.class)",

ProcessorConfig.GROUP_VAR1,

options,

ClassName.get(aptPackage, mAllGroupMap.get(options)));

methodBuilder.addStatement("return $N", ProcessorConfig.GROUP_VAR1);

///生成文件

String fileClassName = ProcessorConfig.GROUP_FILE_NAME + options;

JavaFile.builder(aptPackage,

TypeSpec.classBuilder(fileClassName)

.addSuperinterface(ClassName.get(groupType))

.addModifiers(Modifier.PUBLIC)

.addMethod(methodBuilder.build())

.build())

.build()

.writeTo(filer);

}

private void createPathFile(TypeElement typeElement) throws IOException {

//先把方法返回类型生成 Map

ParameterizedTypeName methodReturn = ParameterizedTypeName.get(

ClassName.get(Map.class),

ClassName.get(String.class),

ClassName.get(RouterBean.class)

);

//生成方法

MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(ProcessorConfig.PATH_METHOD_NAME)

.addModifiers(Modifier.PUBLIC)

.addAnnotation(Override.class)

.returns(methodReturn);

for (Map.Entry> entry : mAllPathMap.entrySet()) {

方法里的内容 Map pathMap = new HashMap<>();

methodBuilder.addStatement("$T $N = new $T<>()",

ClassName.get(Map.class),

ClassName.get(String.class),

ClassName.get(RouterBean.class),

ProcessorConfig.PATH_VAR1,

ClassName.get(HashMap.class));

List routerBeanList = entry.getValue();

for (RouterBean routerBean : routerBeanList) {

methodBuilder.addStatement("$N.put($S, $T.create($T.$L, $T.class, $S, $S))",

ProcessorConfig.PATH_VAR1,

routerBean.getPath(),

ClassName.get(RouterBean.class),

ClassName.get(RouterBean.TypeEnum.class),

routerBean.getTypeEnum(),

ClassName.get((TypeElement) routerBean.getElement()),

routerBean.getPath(),

routerBean.getGroup());

}

// return pathMap;

methodBuilder.addStatement("return $N", ProcessorConfig.PATH_VAR1);

}

//生成的类文件名ARouter$$Path$$user 有implements所以方法和类要合为一体生成

String fileName = ProcessorConfig.PATH_FILE_NAME + options;

messager.printMessage(Diagnostic.Kind.NOTE, "APT生成路由Path类文件：" +

aptPackage + "." + fileName);

JavaFile.builder(aptPackage,

TypeSpec.classBuilder(fileName)

.addSuperinterface(ClassName.get(typeElement))

.addMethod(methodBuilder.build())

.addModifiers(Modifier.PUBLIC)

.build())

.build()

.writeTo(filer);

mAllGroupMap.put(options, fileName);

}

private boolean checkRouterPath(RouterBean bean) {

String group = bean.getGroup();//app、user、zixun等module

String path = bean.getPath();// /app/MainActivity

// TODO 校验path

// @ARouter注解中的path值，必须要以 / 开头

if (ProcessorUtils.isEmpty(path) || !path.startsWith("/")) {

messager.printMessage(Diagnostic.Kind.ERROR, "@ARouter注解中的path值，必须要以 / 开头");

return false;

}

if (path.lastIndexOf("/") == 0) {//开发者必须遵循

messager.printMessage(Diagnostic.Kind.ERROR, "@ARouter注解未按规范配置，如：/app/MainActivity");

return false;

}

// 从第一个 / 到第二个 / 中间截取，如：/app/MainActivity 截取出 app,order,personal 作为group

String finalGroup = path.substring(1, path.indexOf("/", 1));

if (!ProcessorUtils.isEmpty(group) && !group.equals(options)) {

messager.printMessage(Diagnostic.Kind.ERROR, "@ARouter注解中的group值必须和子模块名一致！");

return false;

} else {

bean.setGroup(finalGroup);

}

return true;

}

ARouterProcessor会检测带注解，利用roundEnvironment.getElementsAnnotatedWith(ARouter.class);来判断哪些是自己ARouter注解类，然后javapoet语法生成Java文件。build一下项目。

不要忘了在类上添加注解

a20658b35477

image.png

最后生成文件的效果

a20658b35477

image.png

最后调用

ARouter$$Group$$user group$$user = new ARouter$$Group$$user();

Map> groupMap = group$$user .getGroupMap();

Class extends ARouterPath> myClass = groupMap.get("user ");

try {

ARouter$$Path$$user path = (ARouter$$Path$$user ) myClass.newInstance();

Map pathMap = path.getPathMap();

RouterBean bean = pathMap.get("/user /User_LoginAcitivty");

if (bean != null) {

Intent intent = new Intent(this, bean.getMyClass());

startActivity(intent);

}

} catch (Exception e) {

e.printStackTrace();

}

现在调用还复杂化、不能参数据，在第二篇文章将会再次封装，源码链接放在第二篇文章里。

卢少奇

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
android 路由总线,利用APT实现android路由框架一

随着业务的发展，项目会越来越大，实现组件化便于更好的维护项目以及拆分。3.png业务组件相互独立，需要路由来完成之间的跳转与数据传递。实现方法：1、使用 EventBus的方式，缺点是：EventBean维护成本太高，不好去管理：2、使用广播的方式，缺点是：不好管理，都统一发出去了3、使用隐士意图方式，缺点是：在AndroidManifest.xml里面配置xml写的太多了4、使用类加载方...
复制链接

扫一扫