28. 在Spring中如何实现自定义注解和切面逻辑？

PangHu大约 3 分钟

在Spring中，通过自定义注解和切面逻辑（Aspect），你可以将一些通用的逻辑（如日志记录、权限检查、事务管理等）抽离出来，以实现代码的模块化和可复用性。以下是实现自定义注解和切面逻辑的步骤。

1. 创建自定义注解

首先，定义一个自定义注解。这个注解可以用于标记你希望应用切面逻辑的方法或类。

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

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

@Retention(RetentionPolicy.RUNTIME)：指定注解的保留策略为运行时，这样注解信息可以在运行时通过反射获取。
@Target(ElementType.METHOD)：指定注解的目标是方法。

2. 创建切面类并实现切面逻辑

接下来，使用 @Aspect 注解创建一个切面类，并在其中实现切面逻辑。

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 MyCustomAspect {

    @Around("@annotation(com.example.MyCustomAnnotation)")
    public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Before method execution: " + joinPoint.getSignature().getName());

        // 获取自定义注解的值
        MyCustomAnnotation annotation = joinPoint.getTarget()
                .getClass()
                .getMethod(joinPoint.getSignature().getName(), 
                           ((MethodSignature) joinPoint.getSignature()).getParameterTypes())
                .getAnnotation(MyCustomAnnotation.class);

        System.out.println("Annotation value: " + annotation.value());

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

        System.out.println("After method execution: " + joinPoint.getSignature().getName());

        return result;
    }
}

@Aspect：将类声明为切面。
@Component：将切面类注册为Spring的Bean。
@Around("@annotation(com.example.MyCustomAnnotation)")：表示该通知应用于任何标注了 @MyCustomAnnotation 注解的方法。

aroundAdvice 方法会在标注了 @MyCustomAnnotation 的方法执行之前和之后执行自定义逻辑。ProceedingJoinPoint 提供了对被拦截方法的访问，proceed() 方法调用实际的方法执行。

3. 使用自定义注解

现在，你可以在Spring管理的Bean的方法上使用自定义注解，以应用切面逻辑。

import org.springframework.stereotype.Service;

@Service
public class MyService {

    @MyCustomAnnotation(value = "Test Annotation")
    public void myMethod() {
        System.out.println("Executing myMethod in MyService");
    }
}

当调用 myMethod() 时，Spring AOP 会拦截该调用，并执行 MyCustomAspect 中定义的切面逻辑。

4. 配置Spring AOP（如果需要）

如果你使用的是Spring Boot，Spring AOP会自动配置并启用。如果是普通的Spring项目，确保在配置类或XML配置文件中启用了注解驱动的切面支持：

配置类方式

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // 其他配置
}

XML配置方式

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd">

    <aop:aspectj-autoproxy/>
    
    <!-- 定义切面类的Bean -->
    <bean id="myCustomAspect" class="com.example.MyCustomAspect"/>
</beans>

5. 测试自定义注解和切面逻辑

通过调用标注了自定义注解的方法，你可以看到切面逻辑是如何被应用的。

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myService = context.getBean(MyService.class);
        myService.myMethod();
    }
}

运行结果

运行上述代码，你会看到以下输出：

Before method execution: myMethod
Annotation value: Test Annotation
Executing myMethod in MyService
After method execution: myMethod

这表明自定义的注解和切面逻辑已成功应用，并且在目标方法执行的前后插入了额外的操作。

总结

自定义注解 提供了一种标记特定逻辑的方式。
切面（Aspect） 中包含的切面逻辑可以通过 @Aspect 注解定义，并使用 @Around 等通知来拦截带有自定义注解的方法。
Spring AOP 的配置可以通过注解或XML来启用，并且可以灵活地应用于Spring管理的Bean中。

通过这些步骤，你可以将跨越多个类或模块的通用功能抽离到切面中，从而使代码更加模块化和可维护。