Springboot注解@Aspect（一）之@Aspect 作用和Aop关系详解

目录

@Aspect的使用

配置

作用

通知相关的注解

例子

结果：

@Aspect作用和Spring Aop关系

示例

标签表达式

@Aspect的使用

配置

        要启用 Spring AOP 和 @Aspect 注解，需要在 Spring 配置中启用 AspectJ 自动代理，但是在 Spring Boot 中，通常不需要显式地添加 @EnableAspectJAutoProxy，因为 Spring Boot 的自动配置特性已经包含了这一设置。：

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {// ...
}

         @Aspect 注解也要写@Component，或通过其他方式注册为 Spring Bean，以确保 Spring 容器能够识别并管理这个切面。

@Aspect
@Component
public class LoggingAspect {
}

作用

1. 定义切面（Aspect）：

   切面是跨多个类或对象的横切关注点的模块化。在 Spring AOP 中，切面是通过使用 @Aspect 注解的类来表示的。

2. 切入点（Pointcut）：

   使用 @Pointcut 注解来定义切入点表达式，指定切面应用的位置。切入点定义了切面应该在何处插入其横切逻辑，即切面应该应用的连接点（如方法执行）的集合。

3. 通知（Advice）：

• 前置通知（Before advice）：在某连接点（方法执行等）之前执行，但这个通知不能阻止连接点之前的执行流程（除非它抛出一个异常）。
• 后置通知（After advice）：在某连接点之后执行，无论该连接点是正常完成还是抛出异常。

• 返回后通知（After-returning advice）：在某连接点正常完成后执行。

• 抛出异常后通知（After-throwing advice）：如果方法抛出异常退出，则执行通知。

• 环绕通知（Around advice）：在方法调用之前和之后执行，它将决定是否继续执行连接点或直接返回自己的返回值或抛出异常。

通知相关的注解

1.  @Around：环绕增强: 就是既可以前置增强，也可以后置增强。环绕通知会影响到AfterThrowing通知的运行,不要同时使用。

2.  @Before：标识一个前置增强方法，

3. @AfterReturning：后置增强，如无返回结果，此注解不会执行

4. @After:final增强，不管是抛出异常或者正常退出都会执行

5. @AfterThrowing： 异常抛出增强

例子

假设我们有一个服务类 SampleService，我们想在其方法执行的不同阶段添加日志。

public class SampleService {public void performAction() {System.out.println("Performing action in SampleService");}
}

现在，我们定义一个切面 LoggingAspect 来添加日志：

@Aspect
@Component
public class LoggingAspect {// 前置通知：在方法执行之前执行@Before("execution(* SampleService.performAction(..))")public void logBefore(JoinPoint joinPoint) {System.out.println("Before executing: " + joinPoint.getSignature().getName());}// 后置通知：在方法执行之后执行（无论是否发生异常）@After("execution(* SampleService.performAction(..))")public void logAfter(JoinPoint joinPoint) {System.out.println("After executing: " + joinPoint.getSignature().getName());}// 返回后通知：在方法成功执行之后执行@AfterReturning("execution(* SampleService.performAction(..))")public void logAfterReturning(JoinPoint joinPoint) {System.out.println("After returning from: " + joinPoint.getSignature().getName());}// 异常后通知：在方法抛出异常后执行@AfterThrowing(pointcut = "execution(* SampleService.performAction(..))", throwing = "ex")public void logAfterThrowing(JoinPoint joinPoint, Throwable ex) {System.out.println("After throwing in: " + joinPoint.getSignature().getName() + ", Exception: " + ex);}// 环绕通知：在方法执行之前和之后执行@Around("execution(* SampleService.performAction(..))")public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("Around before: " + joinPoint.getSignature().getName());Object result = joinPoint.proceed(); // 继续执行方法System.out.println("Around after: " + joinPoint.getSignature().getName());return result;}
}

结果：

        就@Before来说，只要performAction方法被调用，那么第一步就是先执行这段代码：System.out.println("Before executing: " + joinPoint.getSignature().getName());执行完后在执行performAction方法。其他方法也是如此只是触发时机不同罢了。

@Aspect作用和Spring Aop关系

   @Aspect 是 AspectJ 框架中的一个注解，它是面向切面编程（AOP）的一个关键部分。AspectJ 是一个独立的 AOP 框架，而 Spring 框架（包括 Spring Boot）则集成了 AspectJ 的一部分功能，使得开发者可以在 Spring 应用中方便地使用 AOP。

        AOP 是一种编程范式（软件工程中的一类典型的编程风格。），用于增加程序的模块化，通过将横切关注点（如日志、安全、事务管理等）从业务逻辑中分离出来，提高代码的可重用性和可维护性。说白了其实我感觉就是动态代理，可以为相关方法前后等统一进行一些处理。

        Spring Boot 作为 Spring 框架的一个扩展，继承了 Spring 的 AOP 功能。在 Spring Boot 应用中，AOP 使用代理模式来实现 AOP，其中 @Aspect 注解的类被当作一个带有通知（Advice）和切入点（Pointcut）的切面。

        Spring AOP 使用代理模式来拦截对对象的方法调用。当在 Spring 应用中定义了 AOP 切面时，Spring 容器会为匹配切面指定的切入点的 Bean 创建一个代理对象。这个代理对象在调用原始方法之前或之后执行切面中定义的逻辑。

• 动态代理：如果一个 Bean 至少实现了一个接口，Spring AOP 默认会使用 JDK 的动态代理来创建这个 Bean 的代理。
• CGLIB 代理：如果一个 Bean 没有实现任何接口，Spring AOP 会使用 CGLIB 库来创建代理。

        虽然使用 @Aspect 注解和 @Before、@After 等注解定义了切面的行为，但这些注解本身并不负责拦截方法调用。真正的方法拦截是由 Spring AOP 在背后通过动态代理机制来实现的。当方法被调用时，实际上是先调用代理对象的对应方法，代理对象再根据 AOP 配置来决定是否调用原始对象的方法，以及在调用前后执行哪些额外的逻辑。

示例

        假设有一个简单的服务类 MyService，我们想在其 performAction 方法执行前后添加日志：

public class MyService {public void performAction() {System.out.println("Performing action");}
}@Aspect
@Component
public class LoggingAspect {@Before("execution(* MyService.performAction(..))")public void logBefore() {System.out.println("Before action");}@After("execution(* MyService.performAction(..))")public void logAfter() {System.out.println("After action");}
}

        在这里，LoggingAspect 定义了在 MyService 的 performAction 方法执行前后要执行的日志操作。但实际上，当 performAction 方法被调用时，它是通过 MyService 的代理来调用的，代理负责根据 LoggingAspect 的配置执行相应的 AOP 逻辑。

发现通知参数中的joinPoint不知道做什么用，请看我的下一章 Springboot注解@Aspect（二）JoinPoint 使用详解

标签表达式

        上述例子中你会好奇 @Before("execution(* SampleService.performAction(..))")，这中间的execution是什么意思后面括号内是什么意思。这其实是注解使用的标签表达式，有如下这些：

• within：用于匹配指定类型内的方法执行

• this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也* 类型匹配

• target：用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配

• args：用于匹配当前执行的方法传入的参数为指定类型的执行方法

• @within：用于匹配所以持有指定注解类型内的方法

• @target：用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解，和@annotation区别是不用全路径

• @args：用于匹配当前执行的方法传入的参数持有指定注解的执行

• @annotation：用于匹配当前执行方法持有指定注解的方法

主要记住execution和@annotation用的比较多，一个是用在方法上一个是用在相关注解上

如何编写切入点表达式：

• 匹配特定方法：execution([权限加返回类型] [类路径].[方法名称]([参数]))

匹配带有特定注解的方法：@annotation(com.example.MyAnnotation)

• 匹配所有被 @MyAnnotation 注解的方法。

其中：

(..)代表所有参数

(*，String)代表第一个参数为任何值,第二个为String类型，

(..,String)代表最后一个参数是String类型

发现通知参数中的joinPoint不知道做什么用，请看我的下一章 Springboot注解@Aspect（二）JoinPoint 使用详解

------------------------------------------与正文内容无关------------------------------------
如果觉的文章写对各位读者老爷们有帮助的话，麻烦点赞加关注呗！作者在这拜谢了!

混口饭吃了！如果你需要Java 、Python毕设、商务合作、技术交流、就业指导、技术支持度过试用期。请在关注私信我，本人看到一定马上回复！