组件化系列博客 :

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

在 【Android 组件化】路由组件 ( 注解处理器获取被注解的节点 ) 博客中 声明了 支持的注解类型 , 并在 Activity 中使用了注解 , 在 注解处理器 中检测出来使用注解的 类节点 TypeElement ;

本篇博客中讲解 " 注解处理器 " 后续开发 , 生成 Java 代码 ;

一、注解节点类型

在 " 注解处理器 " AbstractProcessor 中的 process 方法中 , 可以获取使用注解的节点 ;

使用注解标注的 Element 节点类型 : 注解节点都是 javax.lang.model.element.Element 的子类

• ExecutableElement : 使用注解的 方法 节点类型 ;

• VariableElement : 使用注解的 字段 节点类型 , 类的成员变量 ;

• TypeElement : 使用注解的 类 节点类型 ;

• PackageElement : 使用注解的 包 节点类型 ;

在类上使用 @Route 注解 , 则获取的节点类型都是 TypeElement ;

二、JavaPoet 简介

JavaPoet 的作用是用于生成 Java 源代码 ;

JavaPoet 项目 GitHub 地址 : https://github.com/square/javapoet

添加依赖库 : 在 Android Studio 项目中的 Module 下的 build.gradle 添加如下依赖库 , 即可使用 JavaPoet ;

compile 'com.squareup:javapoet:1.13.0'

  

 

  
1
 

使用 JavaPoet 生成方法 : 调用 MethodSpec 的如下方法可以完成 Java 函数创建 ;

• methodBuilder 静态方法 , 创建方法 , 参数是函数名 ,
• addModifiers 方法可以设置函数的可见性 , 是否是静态方法 ,
• returns 方法设置返回值 ,
• addParameter 方法设置函数参数类型 , 以及参数名称 ,
• addStatement 方法设置函数体 ,
• build 方法正式生成函数 ;

// 生成 public static void main(String[] args) 函数
MethodSpec main = MethodSpec.methodBuilder("main")
    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
    .returns(void.class)
    .addParameter(String[].class, "args")
    .addStatement("$T.out.println($S)", System.class, "Hello, JavaPoet!")
    .build();

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
 

生成的 Java 函数如下 :

  public static void main(String[] args) {
    System.out.println("Hello, JavaPoet!");
  }

  

 

  
1
  
2
  
3
 

使用 JavaPoet 生成方法 : 调用 TypeSpec 的如下方法可以完成 Java 类创建 ;

• classBuilder 静态方法 , 创建类 , 参数是类名 ,
• addModifiers 方法可以设置类的可见性 , 是否是 final 方法 ,
• addMethod 方法设置类中的函数 ;

// 指定 public final class HelloWorld 类 
TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
    .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
    .addMethod(main)
    .build();

  

 

  
1
  
2
  
3
  
4
  
5
 

生成的 HelloWoirld 类如下 :

public final class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello, JavaPoet!");
  }
}

  

 

  
1
  
2
  
3
  
4
  
5
 

三、注解处理器中使用 JavaPoet 生成代码

在 【Android APT】注解处理器 ( 根据注解生成 Java 代码 ) 博客中使用 字符输出流 Writer 直接写出字符串的方式 , 生成了 Java 代码 , 不过每行代码都需要自己生成 ,

注解处理器 中 , 使用 Filer 对象写出 Java 代码 , 获取 Filer 对象 , 保存在成员字段 Filer mFiler 中 ;

AbstractProcessor 注解处理器的 init 方法中 , 调用 ProcessingEnvironment processingEnvironment 参数的 getFiler 方法 , 获取 Filer 对象 ;

在 AbstractProcessor 注解处理器的 process 中根据获取的注解 , 生成相关代码 ;

注解处理器 使用 JavaPoet 示例 :

package kim.hsl.router_compiler;

import com.google.auto.service.AutoService;
import com.squareup.javapoet.JavaFile;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.TypeSpec;

import java.io.IOException;
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.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Modifier;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;

// 自动注册注解处理器
@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;

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

    /**
     * 该函数在注解处理器注册时自动执行, 是处理注解的核心函数
     *
     * Set<? extends TypeElement> set 参数 : 该集合表示使用了相关注解的节点的集合
     *
     * @param set
     * @param roundEnvironment
     * @return
     */
    @Override
    public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
        for (TypeElement typeElement: set){
            mMessager.printMessage(Diagnostic.Kind.NOTE, "SupportedAnnotationTypes : " + typeElement.getQualifiedName());
        }

        // 生成 public static void main(String[] args) 函数
        MethodSpec main = MethodSpec.methodBuilder("main")
                .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                .returns(void.class)
                .addParameter(String[].class, "args")
                .addStatement("$T.out.println($S)", System.class, "Hello, JavaPoet!")
                .build();

        // 指定 public final class HelloWorld 类
        TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
                .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
                .addMethod(main)
                .build();

        // 正式在 "com.example.helloworld" 包名下创建 HelloWorld 类
        JavaFile javaFile = JavaFile.builder("com.example.helloworld", helloWorld)
                .build();

        try {
            javaFile.writeTo(mFiler);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return false;
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
74
  
75
  
76
  
77
  
78
  
79
  
80
  
81
  
82
  
83
  
84
  
85
  
86
  
87
  
88
  
89
  
90
  
91
  
92
  
93
  
94
  
95
  
96
  
97
 

生成代码如下 :

package com.example.helloworld;

import java.lang.String;
import java.lang.System;

public final class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello, JavaPoet!");
  }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
 

代码生成在 " app\build\generated\ap_generated_sources\debug\out\com\example\helloworld " 路径下 ;

利用 编译时技术 APT 生成的 HelloWorld 类在 Android 应用中是可以被调用的 ;

四、路由框架说明

路由框架 主要是利用 编译时技术 APT , 依据开发者在开发时 标注的 编译时注解 , 在编译的时候 生成一系列 Java 代码 , 然后在运行时 , 可以调用这些 Java 代码 ;

生成的 Java 代码就是 路由表数据 , 路由表中有若干路由选项 , 每个路由选项都由 路由地址 和 路由信息 组成 ,

• 路由地址 : 字符串地址 ;
• 路由信息 : Class 对象 , Activity 或 Service 的字节码类对象 ;

从路由表中 , 根据路由地址 , 获取相应的路由对象 , 可以直接跳转到对应 Activity 界面 , 或调用 相应的 Service 服务 ;

下一篇博客开始开发上述路由表逻辑 ;

五、博客资源

博客源码 :

• GitHub : https://github.com/han1202012/Component
• CSDN 下载 : https://download.csdn.net/download/han1202012/18977569

文章来源: hanshuliang.blog.csdn.net，作者：韩曙亮，版权归原作者所有，如需转载，请联系作者。

原文链接：hanshuliang.blog.csdn.net/article/details/117157837