java怎样实现自定义注解并进行解析 java自定义注解解析的详细操作指南​

@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 Loggable {
    String value() default "默认操作"; // 注解的属性，可以给日志一个描述
    boolean enabled() default true; // 是否启用日志
}

// 假设我们有一个服务类
public class MyService {

    @Loggable(value = "执行用户登录", enabled = true)
    public void userLogin(String username, String password) {
        System.out.println("用户 " + username + " 正在尝试登录...");
        // 实际的登录逻辑
        System.out.println("用户 " + username + " 登录成功。");
    }

    @Loggable(value = "查询订单详情")
    public void getOrderDetails(String orderId) {
        System.out.println("查询订单 " + orderId + " 的详情...");
        // 实际的查询逻辑
        System.out.println("订单 " + orderId + " 详情已获取。");
    }

    public void anotherMethod() {
        System.out.println("这是一个没有注解的方法。");
    }
}

@Loggable

java.lang.reflect

import java.lang.reflect.Method;

public class AnnotationParser {

    public static void parseService(Class<?> clazz) {
        System.out.println("--- 开始解析类: " + clazz.getName() + " ---");

        // 获取类中所有声明的方法
        for (Method method : clazz.getDeclaredMethods()) {
            // 判断这个方法上是否有 @Loggable 注解
            if (method.isAnnotationPresent(Loggable.class)) {
                // 如果有，就获取这个注解实例
                Loggable loggable = method.getAnnotation(Loggable.class);

                System.out.println("\n发现带 @Loggable 注解的方法: " + method.getName());
                System.out.println("  - 日志描述: " + loggable.value());
                System.out.println("  - 日志启用: " + loggable.enabled());

                // 这里可以模拟执行方法，或者在实际应用中，在这里插入日志记录逻辑
                // 比如： if (loggable.enabled()) { log.info(loggable.value() + " executed."); }
                try {
                    // 模拟调用方法，但通常在AOP场景下，这里是代理逻辑，而不是直接调用
                    // method.invoke(clazz.newInstance(), "testUser", "testPass");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else {
                System.out.println("\n方法 " + method.getName() + " 没有 @Loggable 注解。");
            }
        }
        System.out.println("--- 类解析完成 ---");
    }

    public static void main(String[] args) {
        parseService(MyService.class);
    }
}

AnnotationParser

main

MyService

@Loggable

value

enabled

@Autowired

@Service

@Controller

@RequestMapping

@NotNull

@Size

@Pattern

@Loggable

@RequiresRoles("admin")

@RequiresPermissions("user:create")

@Data

int

long

boolean

String

CLASS

@Loggable

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

enum LogLevel {
    INFO, DEBUG, WARN, ERROR
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AdvancedLoggable {
    String description(); // 强制要求提供描述
    LogLevel level() default LogLevel.INFO; // 日志级别，枚举类型
    String[] tags() default {}; // 标签数组
    Class<?> targetClass() default Object.class; // 关联的类
    // 嵌套注解，这里只是示例，实际中可能不常用
    // NestedAnnotation nested() default @NestedAnnotation;
}

// 假设有一个嵌套注解
// @interface NestedAnnotation {
//     String value() default "default";
// }

MyService

@AdvancedLoggable

// public class MyService { // 沿用之前的MyService类
    @AdvancedLoggable(
        description = "执行用户注册流程",
        level = LogLevel.DEBUG,
        tags = {"user", "registration", "security"},
        targetClass = MyService.class
    )
    public void registerUser(String username, String email) {
        System.out.println("注册用户: " + username + ", 邮箱: " + email);
    }

    @AdvancedLoggable(description = "处理支付请求", level = LogLevel.INFO)
    public void processPayment(String orderId, double amount) {
        System.out.println("处理订单 " + orderId + ", 金额 " + amount + " 的支付。");
    }
// }

String

boolean

// public class AnnotationParser { // 沿用之前的AnnotationParser类
    public static void parseAdvancedService(Class<?> clazz) {
        System.out.println("\n--- 开始解析类 (Advanced): " + clazz.getName() + " ---");

        for (Method method : clazz.getDeclaredMethods()) {
            if (method.isAnnotationPresent(AdvancedLoggable.class)) {
                AdvancedLoggable advancedLoggable = method.getAnnotation(AdvancedLoggable.class);

                System.out.println("\n发现带 @AdvancedLoggable 注解的方法: " + method.getName());
                System.out.println("  - 描述: " + advancedLoggable.description()); // String
                System.out.println("  - 日志级别: " + advancedLoggable.level()); // Enum

                // 处理数组类型
                System.out.print("  - 标签: [");
                for (String tag : advancedLoggable.tags()) {
                    System.out.print(tag + " ");
                }
                System.out.println("]");

                System.out.println("  - 目标类: " + advancedLoggable.targetClass().getName()); // Class类型
                // 如果有嵌套注解，也会直接返回嵌套注解的实例，然后可以继续调用其方法
                // System.out.println("  - 嵌套注解值: " + advancedLoggable.nested().value());
            }
        }
        System.out.println("--- 类解析完成 (Advanced) ---");
    }

    public static void main(String[] args) {
        // parseService(MyService.class); // 之前的调用
        parseAdvancedService(MyService.class); // 新的调用
    }
// }

String

enum

String[]

Class<?>

advancedLoggable.methodName()

Class<?>

CLASS