Java注解处理器的代码生成案例

// src/main/java/com/example/annotations/GenerateMapper.java
package com.example.annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.SOURCE) // 关键：只在源码阶段保留
@Target(ElementType.TYPE) // 作用于类/接口/枚举
public @interface GenerateMapper {
    // 目标实体类的全限定名，例如 "com.example.entities.UserEntity"
    String targetEntity();
}

// src/main/java/com/example/processors/MapperProcessor.java
package com.example.processors;

import com.example.annotations.GenerateMapper;
import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.TypeSpec;
import javax.annotation.processing.*;
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.tools.Diagnostic;
import java.io.IOException;
import java.util.Set;

@SupportedAnnotationTypes("com.example.annotations.GenerateMapper")
@SupportedSourceVersion(SourceVersion.RELEASE_8) // 支持的Java版本
public class MapperProcessor extends AbstractProcessor {

    private Filer filer; // 用于创建新文件
    private Messager messager; // 用于报告错误/警告

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        this.filer = processingEnv.getFiler();
        this.messager = processingEnv.getMessager();
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        // 如果没有要处理的注解，直接返回
        if (annotations.isEmpty()) {
            return false;
        }

        // 获取所有被 @GenerateMapper 注解的元素
        Set<? extends Element> annotatedElements = roundEnv.getElementsAnnotatedWith(GenerateMapper.class);

        for (Element element : annotatedElements) {
            // 确保被注解的是一个类
            if (!(element instanceof TypeElement)) {
                messager.printMessage(Diagnostic.Kind.ERROR, "Only classes can be annotated with @GenerateMapper", element);
                continue;
            }

            TypeElement annotatedClass = (TypeElement) element;
            GenerateMapper annotation = annotatedClass.getAnnotation(GenerateMapper.class);
            String targetEntityFullName = annotation.targetEntity();

            try {
                // 解析目标实体类的包名和类名
                int lastDot = targetEntityFullName.lastIndexOf('.');
                String targetPackage = lastDot > 0 ? targetEntityFullName.substring(0, lastDot) : "";
                String targetSimpleName = lastDot > 0 ? targetEntityFullName.substring(lastDot + 1) : targetEntityFullName;

                ClassName sourceDtoClass = ClassName.get(annotatedClass);
                ClassName targetEntityClass = ClassName.get(targetPackage, targetSimpleName);
                ClassName mapperClass = ClassName.get(sourceDtoClass.packageName(), sourceDtoClass.simpleName() + "Mapper");

                // 构建 toEntity 方法
                MethodSpec toEntityMethod = MethodSpec.methodBuilder("to" + targetSimpleName)
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .returns(targetEntityClass)
                        .addParameter(sourceDtoClass, "dto")
                        .addStatement("if (dto == null) return null")
                        .addStatement("$T entity = new $T()", targetEntityClass, targetEntityClass)
                        // 假设DTO和Entity有同名属性，这里可以循环复制，简化起见只写一个示例
                        // 实际中可能需要更复杂的反射或AST操作来匹配属性
                        .addStatement("entity.setName(dto.getName())") // 示例属性映射
                        .addStatement("return entity")
                        .build();

                // 构建 Mapper 类
                TypeSpec mapperType = TypeSpec.classBuilder(mapperClass.simpleName())
                        .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
                        .addMethod(toEntityMethod)
                        .build();

                // 使用 Filer 写入文件
                filer.createSourceFile(mapperClass.toString())
                        .openWriter()
                        .append(mapperType.toString())
                        .close();

                messager.printMessage(Diagnostic.Kind.NOTE, "Generated mapper for " + annotatedClass.getQualifiedName());

            } catch (IOException e) {
                messager.printMessage(Diagnostic.Kind.ERROR, "Failed to generate mapper: " + e.getMessage(), element);
            } catch (Exception e) { // 捕获更广的异常，例如 targetEntity 解析失败
                messager.printMessage(Diagnostic.Kind.ERROR, "Error processing " + annotatedClass.getQualifiedName() + ": " + e.getMessage(), element);
            }
        }
        return true; // 表示我们处理了这些注解
    }
}

// src/main/java/com/example/dto/UserDto.java
package com.example.dto;

import com.example.annotations.GenerateMapper;

@GenerateMapper(targetEntity = "com.example.entity.UserEntity")
public class UserDto {
    private String name;
    // ... 其他属性和getter/setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

// src/main/java/com/example/entity/UserEntity.java
package com.example.entity;

public class UserEntity {
    private String name;
    // ... 其他属性和getter/setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

// 假设生成路径是这样，实际由构建工具决定
// target/generated-sources/annotations/com/example/dto/UserDtoMapper.java
package com.example.dto;

import com.example.entity.UserEntity;

public final class UserDtoMapper {
  public static UserEntity toUserEntity(UserDto dto) {
    if (dto == null) return null;
    UserEntity entity = new UserEntity();
    entity.setName(dto.getName());
    return entity;
  }
}