1. 定义自定义注解

首先，我们定义一个自定义注解 MyAnnotation，用于标记需要特殊处理的方法。该注解具有一个 value 属性，表示方法的标识。

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 MyAnnotation {
    String value();
}

2. 编写注解处理器

接下来，我们编写一个注解处理器 AnnotationProcessor，负责处理包含 MyAnnotation 注解的方法。该处理器通过反射查找带有注解的方法，并执行与注解值相关的逻辑。

import com.lfsun.annotation.annotations.MyAnnotation;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class AnnotationProcessor {

    public static void processAnnotations(Object obj, String methodName) {
        Class<?> clazz = obj.getClass();

        for (Method method : clazz.getDeclaredMethods()) {
            if (method.isAnnotationPresent(MyAnnotation.class)) {
                MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
                String value = annotation.value();
                
                // 根据注解值调用不同的业务方法
                if (methodName.equals(value)) {
                    System.out.println("处理方法注解: " + method.getName() + "，值为: " + value);
                    executeLogicBasedOnAnnotationValue(obj, value);
                }
            }
        }
    }

    private static void executeLogicBasedOnAnnotationValue(Object obj, String value) {
        // 简单示例：根据不同的注解值执行不同的逻辑
        switch (value) {
            case "methodAA":
                invokeMethod(obj, "methodA");
                break;
            case "methodBB":
                invokeMethod(obj, "methodB");
                break;
            // 添加更多的 case，根据需要执行不同的逻辑
            default:
                System.out.println("未处理的注解值: " + value);
        }
    }

    private static void invokeMethod(Object obj, String methodName) {
        try {
            Method handlerMethod = obj.getClass().getDeclaredMethod(methodName);
            handlerMethod.setAccessible(true);
            handlerMethod.invoke(obj);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

3. 使用自定义注解

现在，我们创建一个包含 MyAnnotation 注解的类 MyClass，并在其中定义两个方法，分别被注解为 “methodAA” 和 “methodBB”。

import com.lfsun.annotation.annotations.MyAnnotation;
import com.lfsun.annotation.processor.AnnotationProcessor;

public class MyClass {

    @MyAnnotation("methodAA")
    public void methodA() {
        System.out.println("执行方法 A");
    }

    @MyAnnotation("methodBB")
    public void methodB() {
        System.out.println("执行方法 B");
    }

    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        
        // 处理注解为 "methodAA" 的方法
        String methodNameAA = "methodAA";
        AnnotationProcessor.processAnnotations(myClass, methodNameAA);
        
        System.out.println("---------------------------");
        
        // 处理注解为 "methodBB" 的方法
        String methodNameBB = "methodBB";
        AnnotationProcessor.processAnnotations(myClass, methodNameBB);
    }
}

在 main 方法中，我们创建了 MyClass 实例，并使用 AnnotationProcessor 处理了两个不同的注解值。运行这个程序，你将看到输出结果，说明我们成功地利用注解和反射处理了方法级别的逻辑。