Android 组件化路由组件 ( 构造路由表中的路由信息 )

Posted 2021-05-26 韩曙亮

文章目录

• 一、封装路由信息
• 二、注解处理器 生成路由表信息
• • 1、Activity 中使用 @Route 注解
  • 2、注解处理器中判定注解是否检测出来
  • 3、获取被 @Route 标注的 注解节点
  • 4、判断被 @Route 标注的 注解节点的类型
  • 5、路由信息分组
• 三、完整的 注解处理器 代码
• 四、博客资源

组件化系列博客 :

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

在【Android 组件化】路由组件 ( 注解处理器参数选项设置 ) 博客中在注解处理器中 , 获取了在 build.gradle 中设置的参数 ;

本篇博客中讲解 " 注解处理器 " 后续开发 , 生成路由表中的 路由信息 ;

一、封装路由信息

---

在 " 编译时注解 " 依赖库 Module 中 , 定义 封装 路由信息 的 JavaBean 类 , 其中需要封装以下数据 ;

① 被 " kim.hsl.router_annotation.Route " 注解的 路由类型 , Activity 界面组件 / Service 服务组件 ;

② 被 " kim.hsl.router_annotation.Route " 注解的 " javax.lang.model.element.Element " 类型 注解节点 ;

③ 被 " kim.hsl.router_annotation.Route " 注解的 Activity 界面组件 / Service 服务组件的 组件类对象 ;

④ 路由地址 , 字符串类型 ,

⑤ 路由分组 , 字符串类型 , 将路由信息根据路由分组拆分开进行放置 ,

代码示例 :

package kim.hsl.router_annotation.model;

import javax.lang.model.element.Element;
import kim.hsl.router_annotation.Route;

/**
 * 存储路由节点信息的 Bean
 */
public class RouteBean {

    /**
     * 注解类的类型
     * Activity 界面 / Service 服务
     */
    public enum Type {
        ACTIVITY,
        SERVICE
    }

    private Type type;

    /**
     * 被注解的节点
     */
    private Element element;

    /**
     * 被注解类
     */
    private Class<?> clazz;

    /**
     * 路由地址
     */
    private String routeAddress;

    /**
     * 路由组
     */
    private String routeGroup;

    public RouteBean(Type type, Element element, Route route) {
        this.type = type;
        this.element = element;
        this.clazz = null;
        this.routeAddress = route.path();
        this.routeGroup = route.group();
    }

    public RouteBean(Type type, Element element, Class<?> clazz, String routeAddress, String routeGroup) {
        this.type = type;
        this.element = element;
        this.clazz = clazz;
        this.routeAddress = routeAddress;
        this.routeGroup = routeGroup;
    }

    public Type getType() {
        return type;
    }

    public void setType(Type type) {
        this.type = type;
    }

    public Element getElement() {
        return element;
    }

    public void setElement(Element element) {
        this.element = element;
    }

    public Class<?> getClazz() {
        return clazz;
    }

    public void setClazz(Class<?> clazz) {
        this.clazz = clazz;
    }

    public String getRouteAddress() {
        return routeAddress;
    }

    public void setRouteAddress(String routeAddress) {
        this.routeAddress = routeAddress;
    }

    public String getRouteGroup() {
        return routeGroup;
    }

    public void setRouteGroup(String routeGroup) {
        this.routeGroup = routeGroup;
    }
}

二、注解处理器 生成路由表信息

---

1、Activity 中使用 @Route 注解

下面开始开发 AbstractProcessor 注解处理器中的 process 方法 , 在该方法中生成 Java 代码 ;

在 MainActivity 中使用了 @Route(path = “/app/MainActivity”) 标注了 MainActivity 类 ;

@Route(path = "/app/MainActivity")
public class MainActivity extends Activity {
}

2、注解处理器中判定注解是否检测出来

在 注解处理器 中的 process 方法中 , 首先判定解析到了 注解节点 , 如果没有解析到注解节点 , 就立刻退出 , 参考之前出现的问题 【错误记录】Android 编译时技术报错 ( 注解处理器 process 方法多次调用问题 ) ;

if (set == null || set.isEmpty()){
    // 如果没有检测到注解 , 直接退出
    return false;
}

3、获取被 @Route 标注的 注解节点

获取被 Route 注解标注的类节点 , 调用 RoundEnvironment 参数的 getElementsAnnotatedWith 方法 , 传入要获取的注解类对象 ;

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

4、判断被 @Route 标注的 注解节点的类型

判断被 @Route 标注的 注解节点的类型 : 是否是 Activity 子类类型 ;

获取 android.app.Activity 类型的 的 TypeElement 注解节点 ;

// 获取 android.app.Activity 类型的注解节点
TypeElement activityElement = mElementUtils.getTypeElement("android.app.Activity");

判定获取的 Set<? extends Element> routeElements 节点是否是 " android.app.Activity " 子类节点 , 如果是则创建路由信息对象 ;

mTypeUtils.isSubtype(element.asType(), activityElement.asType())

创建路由信息对象 完整代码示例 :

private void generateRouteClass(Set<? extends Element> routeElements) {
        // 获取 android.app.Activity 类型的注解节点
        TypeElement activityElement = mElementUtils.getTypeElement("android.app.Activity");

        // 处理 @Route(path = "app/MainActivity") 节点
        for (Element element : routeElements) {
            // 获取 Route 注解
            Route route = element.getAnnotation(Route.class);
            // 路由表中的单个路由对象
            RouteBean routeBean = null;

            // 打印类节点全类名
            mMessager.printMessage(Diagnostic.Kind.NOTE,
                    "打印类节点 typeElement : " + activityElement.getQualifiedName());

            // 判断 typeMirror 注解节点是否是 Activity 类型
            if (mTypeUtils.isSubtype(element.asType(), activityElement.asType())) {
                // 该节点是 android.app.Activity 类型的
                routeBean = new RouteBean(
                        RouteBean.Type.ACTIVITY,    // 路由对象类型
                        element,         // 路由节点
                        null,    // 类对象
                        route.path(),   // 路由地址
                        route.group()); // 路由组

                // 检查路由地址
                checkRouteAddress(routeBean);

                // 打印路由信息
                mMessager.printMessage(Diagnostic.Kind.NOTE,
                        "打印路由信息 : " + routeBean.toString());

            }else{
                // 该节点不是 android.app.Activity 类型的
                throw new RuntimeException("@Route 注解节点类型错误");
            }
        }
    }

5、路由信息分组

每个路由信息都有一个分组 , 在定义 Route 注解时 , 分组为 “” 空字符串 ;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.CLASS)
public @interface Route {
    /**
     * 路由路径, 标识一个路由节点
     * 该字段没有默认值, 必须设置
     * @return
     */
    String path();

    /**
     * 路由分组, 默认为空, 选择性设置
     * 路由节点可以按照分组进行加载
     * @return
     */
    String group() default "";
}

根据设置的路由路径 , @Route(path = “/app/MainActivity”) 中的 “/app/MainActivity” , 将其中的 app 作为路由分组 ;

截取路由地址 “/app/MainActivity” 中前两个斜线之间字符串作为路由分组 ;

    /**
     * 验证路由地址
     * @Route(path = "/app/MainActivity")
     * @param routeBean
     */
    private void checkRouteAddress(RouteBean routeBean){
        // 获取路由地址
        String routeAddress = routeBean.getRouteAddress();
        // 获取路由分组
        String routeGroup = routeBean.getRouteGroup();

        // 验证路由地址是否以 "/" 开头
        if (!routeAddress.startsWith("/")) {
            throw new RuntimeException("路由地址 " + routeAddress + " 格式错误");
        }

        // 如果路由地址的分组为空 ,
        // 则截取第 0 和 第 1 个 "/" 之间的字符串作为分组名称
        if (routeGroup == null || "".equals(routeGroup)){
            String group = routeAddress.substring(
                    routeAddress.indexOf("/", 0) + 1,
                    routeAddress.indexOf("/", 1)
            );

            if (group == null || "".equals(group)){
                throw new RuntimeException("路由地址 " + routeAddress + " 获取分组错误");
            }

            // 打印组名
            mMessager.printMessage(Diagnostic.Kind.NOTE,
                    "打印路由地址 " + routeAddress + " 的组名为 " + group);

            // 正式设置路由地址分组
            routeBean.setRouteGroup(group);
        }
    }

三、完整的 注解处理器 代码

---

完整的 注解处理器 代码 :

package kim.hsl.router_compiler;

import com.google.auto.service.AutoService;

import java.util.Map;
import java.util.Set;

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.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;

// 注解处理器接收的参数
@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;

    /**
     * 该函数在初始化时调用 , 相当于构造函数
     * @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);

        return false;
    }

    private void generateRouteClass(Set<? extends Element> routeElements) {
        // 获取 android.app.Activity 类型的注解节点
        TypeElement activityElement = mElementUtils.getTypeElement("android.app.Activity");

        // 处理 @Route(path = "app/MainActivity") 节点
        for (Element element : routeElements) {
            // 获取 Route 注解
            Route route = element.getAnnotation(Route.class);
            // 路由表中的单个路由对象
            RouteBean routeBean = null;

            // 打印类节点全类名
            mMessager.printMessage(Diagnostic.Kind.NOTE,
                    "打印类节点 typeElement : " + activityElement.getQualifiedName());

            // 判断 typeMirror 注解节点是否是 Activity 类型
            if (mTypeUtils.isSubtype(element.asType(), activityElement.asType())) {
                // 该节点是 android.app.Activity 类型的
                routeBean = new RouteBean(
                        RouteBean.Type.ACTIVITY,    // 路由对象类型
                        element,         // 路由节点
                        null,    // 类对象
                        route.path(),   // 路由地址
                        route.group()); // 路由组

                // 检查路由地址
                checkRouteAddress(routeBean);

                // 打印路由信息
                mMessager.printMessage(Diagnostic.Kind.NOTE,
                        "打印路由信息 : " + routeBean.toString());

            }else{
                // 该节点不是 android.app.Activity 类型的
                throw new RuntimeException("@Route 注解节点类型错误");
            }
        }
    }

    /**
     * 验证路由地址
     * @Route(path = "/app/MainActivity")
     * @param routeBean
     */
    private void checkRouteAddress(RouteBean routeBean){
        // 获取路由地址
        String routeAddress = routeBean.getRouteAddress();
        // 获取路由分组
        String routeGroup = routeBean.getRouteGroup();

        // 验证路由地址是否以 "/" 开头
        if (!routeAddress.startsWith("/")) {
            throw new RuntimeException("路由地址 " + routeAddress + " 格式错误");
        }

        // 如果路由地址的分组为空 ,
        // 则截取第 0 和 第 1 个 "/" 之间的字符串作为分组名称
        if (routeGroup == null || "".equals(routeGroup)){
            String group = routeAddress.substring(
                    routeAddress.indexOf("/", 0) + 1,
                    routeAddress.indexOf("/", 1)
            );

            if (group == null || "".equals(group)){
                throw new RuntimeException("路由地址 " + routeAddress + " 获取分组错误");
            }

            // 打印组名
            mMessager.printMessage(Diagnostic.Kind.NOTE,
                    "打印路由地址 " + routeAddress + " 的组名为 " + group);

            // 正式设置路由地址分组
            routeBean.setRouteGroup(group);
        }
    }
}

执行结果 :

注: Messager Print Log
注: 打印 moduleName 参数 : app
注: 打印类节点 typeElement : android.app.Activity
注: 打印路由地址 /app/MainActivity 的组名为 app
注: 打印路由信息 : RouteBean{type=ACTIVITY, element=kim.hsl.component.MainActivity, clazz=null, routeAddress='/app/MainActivity', routeGroup='app'}

四、博客资源

---

博客源码 :

• GitHub : https://github.com/han1202012/Component
• CSDN 下载 :