49. 如何在Spring Boot中处理自定义注解？

在 Spring Boot 中，自定义注解可以用于扩展框架的功能，简化代码，或者为某些操作提供元数据支持。处理自定义注解通常涉及三个主要步骤：定义注解、使用注解、以及通过拦截器、AOP（Aspect-Oriented Programming，面向切面编程）或 Bean 后处理器来解析和处理这些注解。

1. 定义自定义注解

首先，你需要定义一个自定义注解。自定义注解通常是用 @interface 关键字定义的，可以根据需要指定元注解（如 @Target、@Retention）。

示例：

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 LogExecutionTime {
    String value() default "";
}

• @Target：定义注解可以应用的目标（如方法、字段、类等）。
• @Retention：定义注解的生命周期（如源代码、编译时、运行时）。

2. 使用自定义注解

一旦定义了注解，你就可以在代码中使用它。注解可以应用在方法、类、字段、参数等处。

示例：

import org.springframework.stereotype.Service;

@Service
public class MyService {

    @LogExecutionTime
    public void serve() {
        // 模拟一些逻辑处理
        System.out.println("Serving...");
    }
}

3. 处理自定义注解

处理自定义注解可以通过多种方式实现，常见的有以下几种：

3.1 使用 AOP 处理自定义注解

AOP 是处理自定义注解的常见方式，特别是当你希望在方法执行前后插入一些逻辑时。

步骤：

1. 定义切面类：通过 @Aspect 和 @Around 等注解定义切面，拦截带有自定义注解的方法。
2. 处理注解：在切面方法中，获取注解信息并执行相关逻辑。

示例：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LogExecutionTimeAspect {

    @Around("@annotation(LogExecutionTime)")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();

        Object proceed = joinPoint.proceed();

        long executionTime = System.currentTimeMillis() - start;

        System.out.println(joinPoint.getSignature() + " executed in " + executionTime + "ms");
        return proceed;
    }
}

• @Aspect：声明一个切面。
• @Around：定义一个环绕通知，拦截所有带有 @LogExecutionTime 注解的方法。
• ProceedingJoinPoint：用于访问被拦截的方法和参数，并控制方法的执行。

3.2 使用 BeanPostProcessor 处理自定义注解

BeanPostProcessor 是 Spring 提供的一个接口，可以在 Spring 容器初始化 Bean 之前和之后对 Bean 进行处理。

步骤：

1. 实现 BeanPostProcessor 接口：在 postProcessBeforeInitialization 或 postProcessAfterInitialization 方法中处理自定义注解。
2. 扫描注解：通过反射扫描 Bean 中的注解，并执行相应的逻辑。

示例：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Component
public class LogExecutionTimeBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        for (Method method : bean.getClass().getMethods()) {
            if (method.isAnnotationPresent(LogExecutionTime.class)) {
                // 处理带有 @LogExecutionTime 注解的方法
                System.out.println("Found @LogExecutionTime on method: " + method.getName());
            }
        }
        return bean;
    }
}

• postProcessAfterInitialization：在 Bean 初始化后处理注解。
• 反射获取方法：检查方法上是否存在自定义注解并处理。

3.3 使用 Spring 拦截器处理自定义注解

如果注解用于控制请求拦截（如权限校验、日志记录等），可以使用 Spring 的 HandlerInterceptor 来处理。

步骤：

1. 实现 HandlerInterceptor 接口：在 preHandle、postHandle 或 afterCompletion 方法中处理注解。
2. 注册拦截器：在配置类中注册拦截器。

示例：

import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;

@Component
public class LogExecutionTimeInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();

            if (method.isAnnotationPresent(LogExecutionTime.class)) {
                // 处理带有 @LogExecutionTime 注解的方法
                System.out.println("Pre-handle method: " + method.getName());
            }
        }
        return true;
    }
}

注册拦截器：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private LogExecutionTimeInterceptor logExecutionTimeInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(logExecutionTimeInterceptor);
    }
}

• HandlerInterceptor：用于拦截 HTTP 请求，并在请求到达控制器之前和之后执行自定义逻辑。
• preHandle：请求处理之前调用，用于处理自定义注解。

4. 总结

在 Spring Boot 中处理自定义注解可以通过多种方式实现，具体选择哪种方式取决于你的需求：

• AOP (@Aspect)：适用于拦截方法执行、记录日志、性能监控等横切关注点的处理。
• BeanPostProcessor：适用于在 Bean 初始化前后对 Bean 进行处理，适合初始化操作或 Bean 属性检查。
• HandlerInterceptor：适用于 HTTP 请求的拦截和处理，特别是涉及到控制器层面的注解。

通过这些方式，你可以灵活地在 Spring Boot 应用中处理自定义注解，从而实现代码复用、集中处理和增强功能。