2024年最全Java进阶--编译时注解处理器（APT）详解(1)，不吃透都对不起自己

本文链接：https://blog.csdn.net/2401_84689238/article/details/138544008

最后

整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。

其实面试这一块早在第一个说的25大面试专题就全都有的。以上提及的这些全部的面试+学习的各种笔记资料，我这差不多来回搞了三个多月，收集整理真的很不容易，其中还有很多自己的一些知识总结。正是因为很麻烦，所以对以上这些学习复习资料感兴趣，

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

应该怎么做才能满足上述需求呢？在第一节中已经提到了使用APT可以帮助我们自动生成代码。那么这个工厂类是不是可以使用APT技术来自动生成呢？我们唯一要做的事情就是新添加的形状类上加上一个注解，注解处理器就会在编译时根据注解信息自动生成ShapeFactory类的代码了，美哉，美哉！理想很丰满，但是，现实很骨感。虽然已经明确了要做什么，但是想要注解处理器帮我们生成代码，却还有很长的路要走。不过，不当紧，接下来我们将一步步实现注解处理器并让其自动生成Factory类。

三、使用APT处理注解

1.定义Factory注解

首先在annotation模块下添加一个Factory的注解，Factory注解的Target为ElementType，表示它可以注解类、接口或者枚举。Retention指定为RetentionPolicy.CLASS，表示该在字节码中有效。Factory注解添加两个成员，一个Class类型的type，用来表示注解的类的类型，相同的类型表示属于同一个工厂。令需一个String类型的id,用来表示注解的类的名称。Factory注解代码如下：

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.CLASS)

public @interface Factory {

Class type();

String id();

}

接下来我们用@Factory去注解形状类，如下：

@Factory(id = “Rectangle”, type = IShape.class)

public class Rectangle implements IShape {

@Override

public void draw() {

System.out.println(“Draw a Rectangle”);

}

//… 其他形状类代码类似不再贴出

**2.认识AbstractProcessor **

接下来，就到了我们本篇文章所要讲的核心了。没错，就是AbstractProcessor！我们先在factory-compiler模块下创建一个FactoryProcessor类继承AbstractProcessor ，并重写相应的方法，代码如下：

@AutoService(Processor.class)

public class FactoryProcessor extends AbstractProcessor {

@Override

public synchronized void init(ProcessingEnvironment processingEnvironment) {

super.init(processingEnvironment);

}

@Override

public Set getSupportedAnnotationTypes() {

return super.getSupportedAnnotationTypes();

}

@Override

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

return false;

}

@Override

public SourceVersion getSupportedSourceVersion() {

return super.getSupportedSourceVersion();

}

可以看到，在这个类上添加了@AutoService注解，它的作用是用来生成META-INF/services/javax.annotation.processing.Processor文件的，也就是我们在使用注解处理器的时候需要手动添加META-INF/services/javax.annotation.processing.Processor，而有了@AutoService后它会自动帮我们生成。AutoService是Google开发的一个库，使用时需要在factory-compiler中添加依赖，如下：

implementation ‘com.google.auto.service:auto-service:1.0-rc4’

接下来我们将目光移到FactoryProcessor类内部，可以看到在这个类中重写了四个方法，我们由易到难依次来看：

(1) public SourceVersion getSupportedSourceVersion()

这个方法非常简单，只有一个返回值，用来指定当前正在使用的Java版本，通常return SourceVersion.latestSupported()即可。

(2) public Set getSupportedAnnotationTypes()

这个方法的返回值是一个Set集合，集合中指要处理的注解类型的名称(这里必须是完整的包名+类名，例如com.example.annotation.Factory)。由于在本例中只需要处理@Factory注解，因此Set集合中只需要添加@Factory的名称即可。

(3) public synchronized void init(ProcessingEnvironment processingEnvironment)

这个方法用于初始化处理器，方法中有一个ProcessingEnvironment类型的参数，ProcessingEnvironment是一个注解处理工具的集合。它包含了众多工具类。例如：

Filer可以用来编写新文件；

Messager可以用来打印错误信息；

Elements是一个可以处理Element的工具类。

在这里我们有必要认识一下什么是Element

在Java语言中，Element是一个接口，表示一个程序元素，它可以指代包、类、方法或者一个变量。Element已知的子接口有如下几种：

PackageElement 表示一个包程序元素。提供对有关包及其成员的信息的访问。

ExecutableElement 表示某个类或接口的方法、构造方法或初始化程序（静态或实例），包括注释类型元素。

TypeElement 表示一个类或接口程序元素。提供对有关类型及其成员的信息的访问。注意，枚举类型是一种类，而注解类型是一种接口。

VariableElement 表示一个字段、enum 常量、方法或构造方法参数、局部变量或异常参数。

接下来，我希望大家先来理解一个新的概念，即抛弃我们现有对Java类的理解，把Java类看作是一个结构化的文件。什么意思？就是把Java类看作一个类似XML或者JSON一样的东西。有了这个概念之后我们就可以很容易的理解什么是Element了。带着这个概念来看下面的代码：

package com.zhpan.mannotation.factory; // PackageElement

public class Circle { // TypeElement

private int i; // VariableElement

private Triangle triangle; // VariableElement

public Circle() {} // ExecuteableElement

public void draw( // ExecuteableElement

String s) // VariableElement

{

System.out.println(s);

}

@Override

public void draw() { // ExecuteableElement

System.out.println(“Draw a circle”);

}

现在明白了吗？不同类型Element其实就是映射了Java中不同的类元素！知晓这个概念后将对理解后边的代码有很大的帮助。

(4) public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment)

终于，到了FactoryProcessor类中最后一个也是最重要的一个方法了。先看这个方法的返回值，是一个boolean类型，返回值表示注解是否由当前Processor 处理。如果返回 true，则这些注解由此注解来处理，后续其它的 Processor 无需再处理它们；如果返回 false，则这些注解未在此Processor中处理并，那么后续 Processor 可以继续处理它们。

在这个方法的方法体中，我们可以校验被注解的对象是否合法、可以编写处理注解的代码，以及自动生成需要的java文件等。因此说这个方法是AbstractProcessor 中的最重要的一个方法。我们要处理的大部分逻辑都是在这个方法中完成。

了解上述四个方法之后我们便可以初步的来编写FactoryProcessor类的代码了，如下：

@AutoService(Processor.class)

public class FactoryProcessor extends AbstractProcessor {

private Types mTypeUtils;

private Messager mMessager;

private Filer mFiler;

private Elements mElementUtils;

private Map<String, FactoryGroupedClasses> factoryClasses = new LinkedHashMap<>();

@Override

public synchronized void init(ProcessingEnvironment processingEnvironment) {

super.init(processingEnvironment);

mTypeUtils = processingEnvironment.getTypeUtils();

mMessager = processingEnvironment.getMessager();

mFiler = processingEnvironment.getFiler();

mElementUtils = processingEnvironment.getElementUtils();

}

@Override

public Set getSupportedAnnotationTypes() {

Set annotations = new LinkedHashSet<>();

annotations.add(Factory.class.getCanonicalName());

return annotations;

}

@Override

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

// 扫描所有被@Factory注解的元素

for (Element annotatedElement : roundEnv.getElementsAnnotatedWith(Factory.class)) {

}

return false;

}

@Override

public SourceVersion getSupportedSourceVersion() {

return SourceVersion.latestSupported();

}

上述FactoryProcessor 代码中在process方法中通过roundEnv.getElementsAnnotatedWith(Factory.class)方法已经拿到了被注解的元素的集合。正常情况下，这个集合中应该包含的是所有被Factory注解的Shape类的元素，也就是一个TypeElement。但在编写程序代码时可能有新来的同事不太了解@Factory的用途而误把@Factory用在接口或者抽象类上，这是不符合我们的标准的。因此，需要在process方法中判断被@Factory注解的元素是否是一个类，如果不是一个类元素，那么就抛出异常，终止编译。代码如下：

@Override

public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {

// 通过RoundEnvironment获取到所有被@Factory注解的对象

for (Element annotatedElement : roundEnv.getElementsAnnotatedWith(Factory.class)) {

if (annotatedElement.getKind() != ElementKind.CLASS) {

throw new ProcessingException(annotatedElement, “Only classes can be annotated with @%s”,

Factory.class.getSimpleName());

}

TypeElement typeElement = (TypeElement) annotatedElement;

FactoryAnnotatedClass annotatedClass = new FactoryAnnotatedClass(typeElement);

…

}

return true;

}

基于面向对象的思想，我们可以将annotatedElement中包含的信息封装成一个对象，方便后续使用，因此，另外可以另外声明一个FactoryAnnotatedClass来解析并存放annotatedElement的相关信息。FactoryAnnotatedClass代码如下：

public class FactoryAnnotatedClass {

private TypeElement mAnnotatedClassElement;

private String mQualifiedSuperClassName;

private String mSimpleTypeName;

private String mId;

public FactoryAnnotatedClass(TypeElement classElement) {

this.mAnnotatedClassElement = classElement;

Factory annotation = classElement.getAnnotation(Factory.class);

mId = annotation.id();

if (mId.length() == 0) {

throw new IllegalArgumentException(

String.format(“id() in @%s for class %s is null or empty! that’s not allowed”,

Factory.class.getSimpleName(), classElement.getQualifiedName().toString()));

}

// Get the full QualifiedTypeName

try { // 该类已经被编译

Class<?> clazz = annotation.type();

mQualifiedSuperClassName = clazz.getCanonicalName();

mSimpleTypeName = clazz.getSimpleName();

} catch (MirroredTypeException mte) {// 该类未被编译

DeclaredType classTypeMirror = (DeclaredType) mte.getTypeMirror();

TypeElement classTypeElement = (TypeElement) classTypeMirror.asElement();

mQualifiedSuperClassName = classTypeElement.getQualifiedName().toString();

mSimpleTypeName = classTypeElement.getSimpleName().toString();

}

// …省去getter

}

为了生成合乎要求的ShapeFactory类，在生成ShapeFactory代码前需要对被Factory注解的元素进行一系列的校验，只有通过校验，符合要求了才可以生成ShapeFactory代码。根据需求，我们列出如下规则：

1.只有类才能被@Factory注解。因为在ShapeFactory中我们需要实例化Shape对象，虽然@Factory注解声明了Target为ElementType.TYPE，但接口和枚举并不符合我们的要求。

2.被@Factory注解的类中需要有public的构造方法，这样才能实例化对象。

3.被注解的类必须是type指定的类的子类

4.id需要为String类型，并且需要在相同type组中唯一

5.具有相同type的注解类会被生成在同一个工厂类中

根据上面的规则，我们来一步步完成校验，如下代码：

private void checkValidClass(FactoryAnnotatedClass item) throws ProcessingException {

TypeElement classElement = item.getTypeElement();

if (!classElement.getModifiers().contains(Modifier.PUBLIC)) {

throw new ProcessingException(classElement, “The class %s is not public.”,

classElement.getQualifiedName().toString());

}

// 如果是抽象方法则抛出异常终止编译

if (classElement.getModifiers().contains(Modifier.ABSTRACT)) {

throw new ProcessingException(classElement,

“The class %s is abstract. You can’t annotate abstract classes with @%”,

classElement.getQualifiedName().toString(), Factory.class.getSimpleName());

}

// 这个类必须是在@Factory.type()中指定的类的子类，否则抛出异常终止编译

TypeElement superClassElement = mElementUtils.getTypeElement(item.getQualifiedFactoryGroupName());

if (superClassElement.getKind() == ElementKind.INTERFACE) {

// 检查被注解类是否实现或继承了@Factory.type()所指定的类型，此处均为IShape

if (!classElement.getInterfaces().contains(superClassElement.asType())) {

throw new ProcessingException(classElement,

“The class %s annotated with @%s must implement the interface %s”,

classElement.getQualifiedName().toString(), Factory.class.getSimpleName(),

item.getQualifiedFactoryGroupName());

}

} else {

TypeElement currentClass = classElement;

while (true) {

TypeMirror superClassType = currentClass.getSuperclass();

if (superClassType.getKind() == TypeKind.NONE) {

// 向上遍历父类，直到Object也没获取到所需父类，终止编译抛出异常

throw new ProcessingException(classElement,

“The class %s annotated with @%s must inherit from %s”,

classElement.getQualifiedName().toString(), Factory.class.getSimpleName(),

item.getQualifiedFactoryGroupName());

}

if (superClassType.toString().equals(item.getQualifiedFactoryGroupName())) {

// 校验通过，终止遍历

break;

}

currentClass = (TypeElement) mTypeUtils.asElement(superClassType);

}

// 检查是否由public的无参构造方法

for (Element enclosed : classElement.getEnclosedElements()) {

if (enclosed.getKind() == ElementKind.CONSTRUCTOR) {

ExecutableElement constructorElement = (ExecutableElement) enclosed;

if (constructorElement.getParameters().size() == 0 &&

constructorElement.getModifiers().contains(Modifier.PUBLIC)) {

// 存在public的无参构造方法，检查结束

return;

}

// 为检测到public的无参构造方法，抛出异常，终止编译

throw new ProcessingException(classElement,

“The class %s must provide an public empty default constructor”,

classElement.getQualifiedName().toString());

}

如果通过上述校验，那么说明被@Factory注解的类是符合我们的要求的，接下来就可以处理注解信息来生成所需代码了。但是本着面向对象的思想，我们还需声明FactoryGroupedClasses来存放FactoryAnnotatedClass，并且在这个类中完成了ShapeFactory类的代码生成。FactoryGroupedClasses 代码如下：

public class FactoryGroupedClasses {

private static final String SUFFIX = “Factory”;

private String qualifiedClassName;

private Map<String, FactoryAnnotatedClass> itemsMap = new LinkedHashMap<>();

最后

由于文案过于长，在此就不一一介绍了，这份Java后端架构进阶笔记内容包括：Java集合，JVM、Java并发、微服务、SpringNetty与 RPC 、网络、日志、Zookeeper 、Kafka 、RabbitMQ 、Hbase 、MongoDB、Cassandra 、Java基础、负载均衡、数据库、一致性算法、Java算法、数据结构、分布式缓存等等知识详解。