Android 组件化路由组件 ( 生成 Root 类记录模块中的路由表 )

Posted 2021-05-26 韩曙亮

文章目录

• 一、Root 表作用
• 二、生成 Root 表
• 三、完整注解处理器代码 及 生成的 Java 代码 ( 仅供参考 )
• • 1、注解处理器代码
  • 2、app 模块中的注解类生成的 Java 源码
  • 3、library2 模块中的注解类生成的 Java 源码
• 四、博客资源

组件化系列博客 :

• 【Android 组件化】从模块化到组件化
• 【Android 组件化】使用 Gradle 实现组件化 ( Gradle 变量定义与使用 )
• 【Android 组件化】使用 Gradle 实现组件化 ( 组件模式与集成模式切换 )
• 【Android 组件化】使用 Gradle 实现组件化 ( 组件 / 集成模式下的 Library Module 开发 )
• 【Android 组件化】路由组件 ( 路由组件结构 )
• 【Android 组件化】路由组件 ( 注解处理器获取被注解的节点 )
• 【Android 组件化】路由组件 ( 注解处理器中使用 JavaPoet 生成代码 )
• 【Android 组件化】路由组件 ( 注解处理器参数选项设置 )
• 【Android 组件化】路由组件 ( 构造路由表中的路由信息 )
• 【Android 组件化】路由组件 ( 使用 JavaPoet 生成路由表类 )
• 【Android 组件化】路由组件 ( 组件间共享的服务 )

一、Root 表作用

---

注解处理器 为每个 Module 模块生成一个路由表 , 该模块下凡是被 @Route 标注的路由节点都在该路由表中维护 ;

package kim.hsl.router;

import java.lang.Override;
import java.lang.String;
import java.util.Map;
import kim.hsl.library2.StringService;
import kim.hsl.route_core.template.IRouteGroup;
import kim.hsl.router_annotation.model.RouteBean;

public class Router_Group_library2 implements IRouteGroup {
  @Override
  public void loadInto(Map<String, RouteBean> atlas) {
    atlas.put("library2", new RouteBean(RouteBean.Type.ISERVICE, StringService.class, "/library2/StringService", "library2"));
  }
}

模块名称是 app , 则路由表的名称是 Router_Group_app.java ;

一个模块中的路由表可能有多个 , 需要为若干路由表再生成一个 Root 表, 用于作为路由表的导航 ;

生成的 Root 表样式 : 其中 “app” 是组名 , Router_Group_app.class 是 app 组对应的路由表类 ;

package kim.hsl.router;

import java.lang.Class;
import java.lang.Override;
import java.lang.String;
import java.util.Map;
import kim.hsl.route_core.template.IRouteGroup;
import kim.hsl.route_core.template.IRouteRoot;

public class Router_Root_app implements IRouteRoot {
  @Override
  public void loadInto(Map<String, Class<? extends IRouteGroup>> routes) {
    routes.put("app", Router_Group_app.class);
  }
}

二、生成 Root 表

---

定义 IRouteRoot 接口 , 所有的 Root 类都实现该接口 , 该接口定义在 route-core 模块中 ;

package kim.hsl.route_core.template;

import java.util.Map;

public interface IRouteRoot {
    void loadInto(Map<String, Class<? extends IRouteGroup>> routes);
}

IRoot 接口定义位置 :

首先 , 获取 IRouteGroup 和 IRouteRoot 接口的节点 ;

// 获取 kim.hsl.route_core.template.IRouteGroup 类节点
TypeElement iRouteGroup = mElementUtils.getTypeElement("kim.hsl.route_core.template.IRouteGroup");
// 获取 kim.hsl.route_core.template.IRouteRoot 类节点
TypeElement iRouteRoot = mElementUtils.getTypeElement("kim.hsl.route_core.template.IRouteRoot");

其次 , 生成 loadInto 函数的参数 Map<String, Class<? extends IRouteGroup>> routes ;

// 生成参数类型名称
// Map<String,Class<? extends IRouteGroup>> routes>
ParameterizedTypeName routesTypeName = ParameterizedTypeName.get(
        ClassName.get(Map.class),
        ClassName.get(String.class),
        ParameterizedTypeName.get(
                ClassName.get(Class.class),
                WildcardTypeName.subtypeOf(ClassName.get(iRouteGroup))
        )
);

// 生成参数
// Map<String,Class<? extends IRouteGroup>> routes> routes
ParameterSpec rootParameterSpec = ParameterSpec.builder(routesTypeName, "routes")
        .build();

再次 , 生成函数及函数体 ;

// 生成函数
// public void loadInfo(Map<String,Class<? extends IRouteGroup>> routes> routes)
MethodSpec.Builder loadIntoMethodBuilder = MethodSpec.methodBuilder("loadInto")
        .addAnnotation(Override.class)
        .addModifiers(Modifier.PUBLIC)
        .addParameter(rootParameterSpec);
        
// 生成函数体
for (Map.Entry<String, String> entry : mRootMap.entrySet()) {
    loadIntoMethodBuilder.addStatement(
            "routes.put($S, $T.class)",
            entry.getKey(),
            ClassName.get("kim.hsl.router", entry.getValue())
    );
}

最后 , 生成 Router_Root_app 类 , 并写出到文件中 ;

// 生成 Root 类
String rootClassName = "Router_Root_" + mModuleName;

// 创建 Java 类
TypeSpec typeSpec = TypeSpec.classBuilder(rootClassName)
        .addSuperinterface(ClassName.get(iRouteRoot))
        .addModifiers(PUBLIC)
        .addMethod(loadIntoMethodBuilder.build())
        .build();
        
// 生成 Java 源文件
JavaFile javaFile = JavaFile.builder("kim.hsl.router", typeSpec).build();

// 写出到文件中
try {
    javaFile.writeTo(mFiler);
} catch (IOException e) {
    e.printStackTrace();
}

三、完整注解处理器代码 及 生成的 Java 代码 ( 仅供参考 )

---

1、注解处理器代码

package kim.hsl.router_compiler;

import com.google.auto.service.AutoService;
import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.JavaFile;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.ParameterSpec;
import com.squareup.javapoet.ParameterizedTypeName;
import com.squareup.javapoet.TypeSpec;
import com.squareup.javapoet.WildcardTypeName;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Filer;
import javax.annotation.processing.Messager;
import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedOptions;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.Elements;
import javax.lang.model.util.Types;
import javax.tools.Diagnostic;

import kim.hsl.router_annotation.Route;
import kim.hsl.router_annotation.model.RouteBean;

import static javax.lang.model.element.Modifier.PUBLIC;

// 注解处理器接收的参数
@SupportedOptions("moduleName")
// 自动注册注解处理器
@AutoService(Processor.class)
// 支持的注解类型
@SupportedAnnotationTypes({"kim.hsl.router_annotation.Route"})
// 支持的 Java 版本
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class RouterProcessor extends AbstractProcessor {

    /**
     * 注解处理器中使用 Messager 对象打印日志
     */
    private Messager mMessager;

    /**
     * 用于写出生成的 Java 代码
     */
    private Filer mFiler;

    /**
     * 注解节点工具
     */
    private Elements mElementUtils;
    /**
     * 类工具
     */
    private Types mTypeUtils;

    /**
     * 获取的 moduleName 参数
     */
    private String mModuleName;

    /**
     * 管理路由信息
     * 键 ( Key ) : 路由分组名称
     * 值 ( Value ) : 路由信息集合
     */
    private HashMap<String, ArrayList<RouteBean>> mGroupMap = new HashMap<>();

    /**
     * 管理 路由表信息
     * 键 ( Key ) : 组名
     * 值 ( Value ) : 类名
     */
    private Map<String, String> mRootMap = new TreeMap<>();

    /**
     * 该函数在初始化时调用 , 相当于构造函数
     * @param processingEnvironment
     */
    @Override
    public synchronized void init(ProcessingEnvironment processingEnvironment) {
        super.init(processingEnvironment);
        // 获取打印日志接口
        this.mMessager = processingEnvironment.getMessager();
        // 测试日志打印
        mMessager.printMessage(Diagnostic.Kind.NOTE, "Messager Print Log");

        this.mFiler = processingEnvironment.getFiler();
        this.mElementUtils = processingEnvironment.getElementUtils();
        this.mTypeUtils = processingEnvironment.getTypeUtils();

        // 获取 moduleName 参数
        // 先获取 注解处理器 选项
        Map<String, String> options = processingEnvironment.getOptions();
        if (options != null){
            mModuleName = options.get("moduleName");
            mMessager.printMessage(Diagnostic.Kind.NOTE, "打印 moduleName 参数 : " + mModuleName);
        }
    }

    /**
     * 该函数在注解处理器注册时自动执行, 是处理注解的核心函数
     *
     * Set<? extends TypeElement> set 参数 : 该集合表示使用了相关注解的节点的集合
     *
     * @param set
     * @param roundEnvironment
     * @return
     */
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        if (set == null || set.isEmpty()){
            // 如果没有检测到注解 , 直接退出
            return false;
        }

        // 获取被 @Route 注解的节点
        // 这些 注解节点 都是类节点 , TypeElement 类型的
        Set<? extends Element> routeElements = roundEnvironment.getElementsAnnotatedWith(Route.class);
        generateRouteClass(routeElements);

        // 生成 路由组件 分组表 对应的 Java 路由表 类
        generateGroupTable();

        // 生成 Root 路由表 , 组名 <-> 路由表类
        generateRootTable();

        return true;
    }

    /**
     * 生成 Root 表
     */
    private void generateRootTable() {
        // 获取 kim.hsl.route_core.template.IRouteGroup 类节点
        TypeElement iRouteGroup = mElementUtils.getTypeElement("kim.hsl.route_core.template.IRouteGroup");
        // 获取 kim.hsl.route_core.template.IRouteRoot 类节点
        TypeElement iRouteRoot = mElementUtils.getTypeElement("kim.hsl.route_core.template.IRouteRoot");

        // 生成参数类型名称
        // Map<String,Class<? extends IRouteGroup>> routes>
        ParameterizedTypeName routesTypeName = ParameterizedTypeName.get(
                ClassName.get(Map.class),
                ClassName.get(String.class),
                ParameterizedTypeName.get(
                        ClassName.get(Class.class),
                        WildcardTypeName.subtypeOf(ClassName.get(iRouteGroup))
                )
        );

        // 生成参数
        // Map<String,Class<? extends IRouteGroup>> routes> routes
        ParameterSpec rootParameterSpec = ParameterSpec.builder(routesTypeName, "routes")
                .build();

        // 生成函数
        // public void loadInfo(Map<String,Class<? extends IRouteGroup>> routes> routes)
        MethodSpec.Builder loadIntoMethodBuilder = MethodSpec.methodBuilder("loadInto")
                .addAnnotation(Override.class)
                .addModifiers(Modifier.PUBLIC)
                .addParameter(rootParameterSpec);

        // 生成函数体
        for (Map.Entry<String, String> entry : mRootMap.entrySet()) {
            loadIntoMethodBuilder.addStatement(
                    "routes.put($S, $T.class)",
                    entry.getKey(),
                    ClassName.get("kim.hsl.router", entry.getValue())
            );
        }

        // 生成 Root 类
        String rootClassName = "Router_Root_" + mModuleName;

        // 创建 Java 类
        TypeSpec typeSpec = TypeSpec.classBuilder(rootClassName)
                .addSuperinterface(ClassName.get(iRouteRoot))
                .addModifiers(PUBLIC)
                .addMethod(loadIntoMethodBuilder.build())
                .build();

        // 生成 Java 源文件
        JavaFile javaFile = JavaFile.builder("kim.hsl.router", typeSpec).build();

        // 写出到文件中
        try {
            javaFile.writeTo(mFiler);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 生成 路由组件 分组表 对应的 Java 类
     */
    private void generateGroupTable() {
        // 获取要生成的类 需要实现的接口节点
        TypeElement iRouteGroup = mElementUtils.getTypeElement(
                "kim.hsl.route_core.template.IRouteGroup");

        // 打印类节点全类名
        mMessager.printMessage(Diagnostic.Kind.NOTE,
                "打印 路由表 需要实现的接口节点 iRouteGroup : " + iRouteGroup.getQualifiedName());

        // 生成参数类型 Map<String, RouteBean> atlas
        ParameterizedTypeName atlasType = ParameterizedTypeName.get(
                ClassName.get(Map.class),
                ClassName.get(String.class),
                ClassName.get(RouteBean.class)
        );

        // 生成参数 Map<String, RouteBean> atlas
        ParameterSpec atlasValue = ParameterSpec.builder(atlasType, "atlas").build();

        // 遍历 HashMap<String, ArrayList<RouteBean>> mGroupMap = new HashMap<>() 路由分组
        // 为每个 路由分组 创建一个类
        for (Map.Entry<String, ArrayList<RouteBean>> entry : mGroupMap.entrySet()){
            // 创建函数 loadInto
            MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("loadInto")
                    .addModifiers(Modifier.PUBLIC)
                    .addAnnotation(Override.class)
                    .addParameter(atlasValue);

            // 函数体中的代码生成

            // 获取 ArrayList<RouteBean> 数据
            ArrayList<RouteBean> groupRoutes = entry.getValue();
            // 组名
            String groupName = "";

            // 生成函数体代码
            for (RouteBean routeBean : groupRoutes){
                // 获取组名
                groupName = routeBean.getRouteGroup();

                // $S 表示字符串
                // $T 表示类
                // $L 表示字面量 , 原封不动的字符串替换
                methodBuilder.addStatement("atlas.put($S, new $T($T.$L, $T.class, $S, $S))",
                        // $S 字符串 : "main"
                        routeBean.getRouteGroup(),
                        // $T 类名 : RouteBean
                        ClassName.get(RouteBean.class),
                        // $T 类名 : Type
                        ClassName.get(RouteBean.Type.class),
                        // $L 字面量 : ACTIVITY
                        routeBean.getType(),
                        // $T 类名 : kim.hsl.component.MainActivity 类
                        ClassName.get((TypeElement) routeBean.getElement()),
                        // $S 字符串 : "/app/MainActivity"
                        routeBean.getRouteAddress(),
                        // $S 字符串 : "app"
                        routeBean.getRouteGroup());
            }

            // 创建类

            // 构造类名  Router_Group_main
            String groupClassName = "Router_Group_" + groupName;

            // 创建类
            TypeSpec typeSpec = TypeSpec.classBuilder(groupClassName)
                    .addSuperinterface(ClassName.get(iRouteGroup))
                    .addModifiers(PUBLIC)
                    .addMethod(methodBuilder.build())
               
以上是关于Android 组件化路由组件 ( 生成 Root 类记录模块中的路由表 )的主要内容，如果未能解决你的问题，请参考以下文章
 
 Android 组件化路由组件 ( 运行时获取 注解处理器 生成的路由表 )
 Android 组件化路由组件 ( 运行时获取 注解处理器 生成的路由表 )
 Android 组件化路由组件 ( 注解处理器中使用 JavaPoet 生成代码 )
 Android 组件化路由组件 ( 组件间共享的服务 )
 Android 组件化路由组件 ( 构造路由表中的路由信息 )
 Android 组件化路由组件 ( 构造路由表中的路由信息 )