Spring Boot中通过自定义注解注入方法逻辑的教程

package com.example.demo.annotation;

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

/**
 * 自定义注解，用于标记需要额外逻辑处理的类或方法
 */
@Target({ElementType.TYPE, ElementType.METHOD}) // 作用于类和方法
@Retention(RetentionPolicy.RUNTIME) // 运行时保留，AOP可以读取
public @interface MyCustomAnnotation {
    String key() default "defaultKey"; // 可选属性，用于在切面中获取值
    String value() default "defaultValue"; // 可选属性
}

package com.example.demo.aspect;

import com.example.demo.annotation.MyCustomAnnotation;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import org.springframework.ui.Model;

import java.lang.reflect.Method;

/**
 * 自定义注解的切面，用于注入额外逻辑
 */
@Aspect // 标记这是一个切面
@Component // 注册为Spring组件
public class MyCustomAnnotationAspect {

    /**
     * 定义一个环绕通知，匹配所有带有 @MyCustomAnnotation 注解的方法
     * 或者其所属类带有 @MyCustomAnnotation 注解的方法
     *
     * @param joinPoint 提供了访问目标方法信息的接口
     * @param myCustomAnnotation 匹配到的自定义注解实例
     * @return 目标方法的返回值
     * @throws Throwable 目标方法抛出的异常
     */
    @Around("(@annotation(myCustomAnnotation) || @within(myCustomAnnotation)) && execution(* *(..))")
    public Object applyCustomLogic(ProceedingJoinPoint joinPoint, MyCustomAnnotation myCustomAnnotation) throws Throwable {
        System.out.println("--- 进入自定义注解切面 ---");

        // 获取目标方法的参数
        Object[] args = joinPoint.getArgs();
        // 获取方法签名，以便获取方法上的注解
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();

        // 尝试从方法或类上获取注解实例，以获取其属性值
        MyCustomAnnotation annotation = method.getAnnotation(MyCustomAnnotation.class);
        if (annotation == null) {
            // 如果方法上没有，则尝试从类上获取
            annotation = joinPoint.getTarget().getClass().getAnnotation(MyCustomAnnotation.class);
        }

        String key = (annotation != null) ? annotation.key() : "defaultKeyFromAspect";
        String value = (annotation != null) ? annotation.value() : "defaultValueFromAspect";

        // 遍历方法参数，查找 Model 类型的参数并进行修改
        for (int i = 0; i < args.length; i++) {
            if (args[i] instanceof Model) {
                Model model = (Model) args[i];
                model.addAttribute(key, value);
                System.out.println("切面已向 Model 添加属性: " + key + " = " + value);
                // 可以根据需求修改其他参数
                // args[i] = newModelInstance;
            }
        }

        // 执行目标方法
        Object result = joinPoint.proceed(args);

        System.out.println("--- 退出自定义注解切面 ---");
        return result;
    }
}

package com.example.demo.controller;

import com.example.demo.annotation.MyCustomAnnotation;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

@MyCustomAnnotation(key = "controllerKey", value = "controllerValue") // 注解在类上
@Controller
public class ExController {

    @RequestMapping(value = "/index", method = RequestMethod.GET)
    public String index(Model model){
        // 这里的 model.addAttribute("controllerKey", "controllerValue") 将由切面自动添加
        System.out.println("--- 进入 ExController.index 方法 ---");
        System.out.println("Model 中是否包含 'controllerKey': " + model.containsAttribute("controllerKey"));
        return "index"; // 假设有一个名为 index.html 的 Thymeleaf/JSP 模板
    }

    @MyCustomAnnotation(key = "methodKey", value = "methodValue") // 注解在方法上
    @RequestMapping(value = "/data", method = RequestMethod.GET)
    @ResponseBody
    public String getData(Model model) {
        // 这里的 model.addAttribute("methodKey", "methodValue") 将由切面自动添加
        System.out.println("--- 进入 ExController.getData 方法 ---");
        System.out.println("Model 中是否包含 'methodKey': " + model.containsAttribute("methodKey"));
        return "Data fetched successfully!";
    }

    @RequestMapping(value = "/no-annotation", method = RequestMethod.GET)
    public String noAnnotationMethod(Model model) {
        // 此方法没有直接或间接的自定义注解，因此不会被切面增强
        System.out.println("--- 进入 ExController.noAnnotationMethod 方法 ---");
        System.out.println("Model 中是否包含 'controllerKey': " + model.containsAttribute("controllerKey")); // 应该为 false
        return "no-annotation";
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

--- 进入自定义注解切面 ---
切面已向 Model 添加属性: controllerKey = controllerValue
--- 进入 ExController.index 方法 ---
Model 中是否包含 'controllerKey': true
--- 退出自定义注解切面 ---

--- 进入自定义注解切面 ---
切面已向 Model 添加属性: methodKey = methodValue
--- 进入 ExController.getData 方法 ---
Model 中是否包含 'methodKey': true
--- 退出自定义注解切面 ---

--- 进入 ExController.noAnnotationMethod 方法 ---
Model 中是否包含 'controllerKey': false