要创建自定义注解，我们需要定义一个注解接口，并使用 @interface 关键字进行声明。定义注解时，还可以使用元注解来指定注解的目标、生命周期等元数据。

(资料图)

例如，创建一个用于权限控制的自定义注解：

import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface RequirePermission {    String value() default "";}

上述示例中，我们使用 @Target 注解指定该注解适用于方法，使用 @Retention 注解设置注解保留至运行时。接下来，我们在需要进行权限控制的方法上应用自定义注解：

public class UserController {        @RequirePermission("user:view")    public void viewUserInfo() {        // ...    }    @RequirePermission("user:edit")    public void editUserInfo() {        // ...    }}

在自定义注解中，我们可以定义属性来传递额外的信息。注解的属性可以是基本数据类型、字符串、枚举、注解类型，以及它们的数组形式。在上述示例中，我们为 RequirePermission 注解定义了一个字符串类型的属性 value，用于表示所需的权限。

当使用自定义注解时，可以为属性赋值。如果属性具有默认值，则在不指定值时将使用默认值。

假设我们需要为一个 Web 应用程序实现权限控制。我们可以使用自定义注解 @RequirePermission 和 Java 反射技术来实现这个功能。

以下是一个简化的权限控制实现：

public class PermissionInterceptor {        public void checkPermission(Method method) throws IllegalAccessException {        RequirePermission requirePermission = method.getAnnotation(RequirePermission.class);        if (requirePermission != null) {            String requiredPermission = requirePermission.value();            if (!hasPermission(requiredPermission)) {                throw new IllegalAccessException("Permission denied: " + requiredPermission);            }        }    }        private boolean hasPermission(String requiredPermission) {        // 实现具体的权限检查逻辑，如从数据库或缓存中查询用户是否具有所需权限        // ...        return true;    }}

在上述示例中，PermissionInterceptor 类的 checkPermission 方法接收一个 Method 对象作为参数。通过调用 method.getAnnotation(RequirePermission.class) 方法，我们可以获取方法上的 @RequirePermission 注解实例（如果存在）。然后根据注解的属性值来判断用户是否具有所需权限。

在本章节中，我们将讨论 Java 注解处理器的基本概念、编写注解处理器的方法以及如何使用注解处理器实现代码生成。最后，我们将探讨注解处理器与编译时代码生成的关系。

Java 注解处理器是一种在编译期间对注解进行处理的工具。它可以用于生成额外的源代码、资源文件或者验证代码的正确性等。Java 注解处理器基于javax.annotation.processing.Processor 接口。

要编写一个注解处理器，需要创建一个类并实现 Processor 接口。通常，我们会继承javax.annotation.processing.AbstractProcessor 类，该类提供了 Processor 接口的基本实现。

以下是一个简单的注解处理器示例：

import javax.annotation.processing.*;import javax.lang.model.SourceVersion;import javax.lang.model.element.TypeElement;import java.util.Set;@SupportedAnnotationTypes("com.example.MyAnnotation")@SupportedSourceVersion(SourceVersion.RELEASE_8)public class MyAnnotationProcessor extends AbstractProcessor {    @Override    public boolean process(Set annotations, RoundEnvironment roundEnv) {        // 在此处处理注解，例如生成代码或资源文件        // ...        // 返回 true 表示已处理完毕，不再调用其他处理器；返回 false 则继续调用其他处理器        return true;    }}

在上述示例中，我们通过 @SupportedAnnotationTypes 和 @SupportedSourceVersion 注解指定处理器支持的注解类型和源代码版本。process 方法是注解处理器的主要逻辑，可以在其中实现代码生成、资源文件生成等操作。

假设我们需要为一个项目生成数据库访问层（DAO）代码。我们可以使用注解处理器自动生成 DAO 接口和实现类。

首先，定义一个 @Entity 注解，用于标记需要生成 DAO 的实体类：

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

接下来，编写一个注解处理器，用于生成 DAO 接口和实现类：

public class EntityAnnotationProcessor extends AbstractProcessor {    @Override    public boolean process(Set annotations, RoundEnvironment roundEnv) {        for (Element element : roundEnv.getElementsAnnotatedWith(Entity.class)) {            if (element.getKind() == ElementKind.CLASS) {                // 获取实体类信息，生成 DAO 接口和实现类                // ...            }        }        return true;    }}

在上述示例中，我们遍历所有使用 @Entity 注解的元素，获取实体类的信息，然后根据实体类信息生成相应的 DAO 接口和实现类。

注解处理器在编译期间运行，因此可以用于实现编译时代码生成。这使得注解处理器成为一种强大的编程工具，可以用于提高代码质量、减少人工编写代码的工作量以及保持代码的一致性。

编译时代码生成的优势：

以下是一些常见的编译时代码生成场景：

为了让编译器在编译时自动执行自定义注解处理器，需要在项目中进行注册。在 Maven 或 Gradle 项目中，可以使用注解处理器插件进行注册。

以 Maven 为例，可以在 pom.xml 文件中添加以下配置：

            org.apache.maven.plugins      maven-compiler-plugin      3.8.1              1.8        1.8                              com.example            my-annotation-processor            1.0.0                              

在上述示例中，我们将自定义注解处理器的依赖添加到了 maven-compiler-plugin 插件的 annotationProcessorPaths 配置中，这样在编译时就会自动执行自定义注解处理器。

通过使用注解处理器，我们可以在编译时对注解进行处理，实现代码生成、验证等功能。注解处理器与编译时代码生成相结合，能够提高代码的质量和一致性，减少手动编写样板代码的工作量。

在本章节中，我们将讨论 Java 反射的基本概念，以及如何利用反射读取注解信息。我们还将通过实战示例来探讨注解与反射在轻量级框架设计中的应用。

Java 反射是 Java 提供的一种动态访问和操作类、方法、属性等元素的机制。通过反射，我们可以在运行时获取类的信息、创建对象、调用方法以及访问和修改属性等。

在 Java 中，反射 API 提供了一系列方法来访问和操作注解。以下是一些常用的方法：

@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.METHOD)public @interface Log {    String value() default "";}

public class LogProcessor {        public void processLogAnnotation(Class clazz) {        for (Method method : clazz.getDeclaredMethods()) {            Log logAnnotation = method.getAnnotation(Log.class);            if (logAnnotation != null) {                String logMessage = logAnnotation.value();                // 根据注解的属性值进行日志处理                // ...            }        }    }}

@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.FIELD)public @interface Inject {}

public class DependencyInjector {    private Map, Object> dependencyMap = new HashMap<>();    public void register(Class clazz, Object instance) {        dependencyMap.put(clazz, instance);    }    public void injectDependencies(Object target) throws IllegalAccessException {        Class clazz = target.getClass();        for (Field field : clazz.getDeclaredFields()) {            if (field.isAnnotationPresent(Inject.class)) {                Object dependency = dependencyMap.get(field.getType());                if (dependency != null) {                    boolean accessible = field.isAccessible();                    field.setAccessible(true);                    field.set(target, dependency);                    field.setAccessible(accessible);                } else {                    throw new IllegalStateException("No registered dependency for " + field.getType());                }            }        }    }}

public class UserService {    // ...}public class UserController {    @Inject    private UserService userService;        public void handleRequest() {        // 使用 userService 处理请求        // ...    }}public class Main {    public static void main(String[] args) throws IllegalAccessException {        DependencyInjector injector = new DependencyInjector();        injector.register(UserService.class, new UserService());        UserController userController = new UserController();        injector.injectDependencies(userController);        userController.handleRequest();    }}

public @interface Cache {    int durationMinutes() default 30;}