博客

什么是Java编译期注解？

  • Post category:Java

Java编译期注解（Compile-time Annotation）是指一种在Java代码执行前，预先设计并且需要在编译期间按程序员规定进行自动处理的标记。它是Java语言提供的一种重要的元数据机制，能够在编译阶段自动生成代码或者根据标注信息完成类似检查、预处理、代码生成等功能，从而提供了一些编译期间的便利。

使用Java编译期注解，需要先定义类似下面这样的注解类型：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
public @interface MyAnnotation {
    String value() default "";
}

其中，@Target和@Retention注解分别指定了注解的作用对象和存储生命周期。MyAnnotation类型定义了一个value属性，属性值类型为String，它是一个默认属性默认值为空。

下面介绍Java编译期注解的具体使用步骤：

  1. 使用注解在Java类或者方法上进行标注，例如：
@MyAnnotation(value="Hello World")
public class TestClass {
    // ...
}

这里使用了@MyAnnotation注解标注TestClass类，并设置了value属性值为”Hello World”。

  1. 创建注解处理器，即继承AbstractProcessor类，并重写process方法。例如：
@SupportedAnnotationTypes("com.example.MyAnnotation")
public class MyAnnotationProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations,
                           RoundEnvironment roundEnv) {
        for (Element element : roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
            // do something ...
        }
        return true;
    }
}

这里支持MyAnnotation注解，重写的process方法将会在编译器编译过程中被自动调用，对标注了@MyAnnotation注解的Java类或方法进行处理。

  1. 使用javac命令编译Java源代码，并使用-javaagent启动注解处理器。例如：
javac -processor com.example.MyAnnotationProcessor -javaagent:myagent.jar MyClass.java

这里编译MyClass.java源文件，并启动MyAnnotationProcessor注解处理器。

  1. 运行。在Java程序运行时，可以通过反射等方式访问Java编译期注解（MyAnnotation）类型，获取其中的属性、方法等信息。

下面提供两个Java编译期注解的示例说明：

  1. 生成自定义代码

通过自定义注解和注解处理器，我们可以在编译期对Java源代码进行扩展，例如生成一些自定义的代码，以便在程序运行时更加方便地使用某些功能。示例代码如下：

// Step 1: 定义注解
@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
public @interface Builder {
}

// Step 2: 定义注解处理器
@SupportedAnnotationTypes("com.example.Builder")
public class BuilderProcessor extends AbstractProcessor {

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (TypeElement annotation : annotations) {
            for (Element element : roundEnv.getElementsAnnotatedWith(annotation)) {
                String className = element.getSimpleName().toString();
                ClassName builderClassName = ClassName.get("com.example", className + "Builder");
                TypeSpec.Builder builderClass = TypeSpec.classBuilder(builderClassName)
                        .addModifiers(Modifier.PUBLIC, Modifier.FINAL);
                for (Element field : element.getEnclosedElements()) {
                    if (field.getKind() == ElementKind.FIELD) {
                        builderClass.addField(FieldSpec.builder(TypeName.get(field.asType()), field.getSimpleName().toString())
                                .addModifiers(Modifier.PRIVATE)
                                .build());
                        builderClass.addMethod(MethodSpec.methodBuilder("set" + field.getSimpleName())
                                .addModifiers(Modifier.PUBLIC)
                                .returns(builderClassName)
                                .addParameter(TypeName.get(field.asType()), field.getSimpleName().toString())
                                .addStatement("this." + field.getSimpleName() + " = " + field.getSimpleName())
                                .addStatement("return this")
                                .build());
                    }
                }
                try {
                    JavaFile.builder("com.example", builderClass.build()).build().writeTo(processingEnv.getFiler());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return true;
    }
}

// Step 3: 使用注解
@Builder
public class Person {
    private String name;
    private int age;
}

// Step 4: 编译和运行
javac -processor com.example.BuilderProcessor -javaagent:myagent.jar Person.java

通过上述示例，我们定义了一个Builder的注解类型，以及一个对Builder注解进行处理的注解处理器。当我们在Java源代码中使用@Builder注解标记一个Java类时，注解处理器会自动扫描这个类中所有的成员变量，并生成一个对应的Builder类，这个Builder类包含这些成员变量的setter方法。这样，我们在运行时就可以使用这个Builder类方便地对该Java类对象进行构造。

  1. 检测代码中的注解

通过自定义注解和注解处理器，我们可以在编译期对Java源代码进行检查，以确保代码的正确性和规范性。示例代码如下：

// Step 1: 定义注解
@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.FIELD)
public @interface NotNull {
}

// Step 2: 定义注解处理器
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class NotNullProcessor extends AbstractProcessor {

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (TypeElement annotation : annotations) {
            for (Element element : roundEnv.getElementsAnnotatedWith(annotation)) {
                if (element.getKind() == ElementKind.FIELD) {
                    VariableElement field = (VariableElement) element;
                    if (!field.getModifiers().contains(Modifier.FINAL)) {
                        boolean hasNotNullAnnotation = false;
                        for (AnnotationMirror mirror : field.getAnnotationMirrors()) {
                            if (mirror.getAnnotationType().asElement().getSimpleName().contentEquals("NotNull")) {
                                hasNotNullAnnotation = true;
                                break;
                            }
                        }
                        if (!hasNotNullAnnotation) {
                            processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, "Field " + field.getSimpleName() + " should be annotated with @NotNull", field);
                        }
                    }
                }
            }
        }
        return true;
    }
}

// Step 3: 使用注解
public class Person {
    private String name;

    @NotNull
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// Step 4: 编译和运行
javac -processor com.example.NotNullProcessor -javaagent:myagent.jar Person.java

通过上述示例，我们定义了一个@NotNull注解类型，并定义了一个对它进行处理的注解处理器。我们在Person类中对age变量使用了@NotNull注解，此时编译器会检测这个变量是否被标记了该注解，如果没有标记则编译错误。

总之，Java编译期注解是一种非常灵活和强大的语言机制，可以帮助我们在编译阶段实现自动化代码生成、代码检查、优化等功能，是进行高效、规范化Java编程的好帮手。

Tags: