130.【Spring注解_AOP】(一)

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: 130.【Spring注解_AOP】

130.【Spring注解_AOP】

Spring 注解


(一)、AOP功能测试

AOP是指在程序的运行期间动态地将某段代码切入到指定方法、指定位置进行运行的编程方式。AOP的底层是使用动态代理实现的。

1.AOP 使用步骤

* AOP【动态代理】 : 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式;
 *                  1.如何使用?
 *                      (1).导入AOP的依赖。
 *                      (2).定义一个业务逻辑类(MathCalculator)。在业务逻辑运行的时候将日志进行打印(方法之前,方法结束,方法异常)
 *                      (3).定义一个日志切面类(LogAspect)。切面类里面的方法需要动态的感知 业务逻辑类(MathCalculator)的运行情况
 *                              (3.1).通知方法: 前置通知@Before(在目标方法运行之前运行),
 *                                              后置通知@After(在目标方法运行之后运行,不在意正常结束还是异常结束),
 *                                              返回通知@AfterReturning(在目标方法正常返回之后运行),
 *                                              异常通知@AfterThrowing(在目标方法发生异常之后运行),
 *                                              环绕通知@Round(动态代理,手动推进目标方法运行 joinPoint.)
 *                      (4).给切面类(LogAspect)的目标方法标注何时何处地运行 (通知注解)
 *                      (5).将切面类和业务逻辑类(目标方法所在类) 都加入到容器中
 *                      (6).必须告诉Spring的IOC容器哪个类是切面类(我们需要给切面类添加一个注解 @Aspect)
 *                      (7).在配置类上开启 注解版的切面功能 ( <aop:aspectj-autoproxy></aop:aspectj-autoproxy>  @EnableAspectJAutoProxy)
 *                      (8).测试,这个逻辑类一定要使用IOC容器的类,不能使用new
(1).导入AOP对应的依赖
<!--    Spring切面的包    -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>
(2).编写业务逻辑类
package com.jsxs.aop;
/**
 * @Author Jsxs
 * @Date 2023/8/19 11:49
 * @PackageName:com.jsxs.aop
 * @ClassName: MathCalculator
 * @Description: TODO
 * @Version 1.0
 */
public class MathCalculator {
    public int div(int x,int y){
        return x/y;
    }
}
(3).编写切面
  1. 使用非公共切入点 @Pointcut

标注是切面的注解,且使用四个通知方法和公共切点注解

package com.jsxs.aop;
import org.aspectj.lang.annotation.*;
/**
 * @Author Jsxs
 * @Date 2023/8/19 11:52
 * @PackageName:com.jsxs.aop
 * @ClassName: LogAspect
 * @Description: TODO
 * @Version 1.0
 */
@Aspect // 告诉IOC容器这是一个切面类 ⭐
public class LogAspect {
    // 1.抽取公共地切入点表达式  ⭐⭐
    @Pointcut("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void  pointCut(){}
    // 2.在目标方法之前运行切入:切入点表达式( public int com.jsxs.aop.MathCalculator.div(int,int))
    // *号代表这个类地所有方法, 一个.代表一个变量
    @Before("pointCut()")  ⭐⭐⭐
    public void logStart(){
        System.out.println("除法运行..... 参数列表是:{}");
    }
    // 3.在目标方法之后进行切入, 使用公共地切入点表达式
    @After("pointCut()")  ⭐⭐⭐⭐
    public void endStart(){
        System.out.println("除法运行结束....");
    }
    // 4.在目标方法返回正确地话
    @AfterReturning("pointCut()")  ⭐⭐⭐⭐⭐
    public void success(){
        System.out.println("除法正常运行... 运行结果:{}");
    }
    // 5.在目标方法出现异常地话
    @AfterThrowing("pointCut()")  ⭐⭐⭐⭐⭐⭐
    public void logError(){
        System.out.println("除法异常运行...");
    }
}
  1. 不使用公共切入点

标注是切面的注解,且使用四个通知方法

package com.jsxs.aop;
import org.aspectj.lang.annotation.*;
/**
 * @Author Jsxs
 * @Date 2023/8/19 11:52
 * @PackageName:com.jsxs.aop
 * @ClassName: LogAspect
 * @Description: TODO
 * @Version 1.0
 */
@Aspect // 告诉IOC容器这是一个切面类  ⭐
public class LogAspect {
    // 2.在目标方法之前运行切入:切入点表达式( public int com.jsxs.aop.MathCalculator.div(int,int)) 
    // *号代表这个类地所有方法, 一个.代表一个变量  ⭐⭐
    @Before("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void logStart(){
        System.out.println("除法运行..... 参数列表是:{}");
    }
    // 3.在目标方法之后进行切入, 使用公共地切入点表达式 ⭐⭐⭐
    @After("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void endStart(){
        System.out.println("除法运行结束....");
    }
    // 4.在目标方法返回正确地话  ⭐⭐⭐⭐
    @AfterReturning("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void success(){
        System.out.println("除法正常运行... 运行结果:{}");
    }
    // 5.在目标方法出现异常地话 ⭐⭐⭐⭐⭐
    @AfterThrowing("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void logError(){
        System.out.println("除法异常运行...");
    }
}
(4).编写配置类
  1. 注解版开启aop切面
package com.jsxs.config;
import com.jsxs.aop.LogAspect;
import com.jsxs.aop.MathCalculator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
/**
 * @Author Jsxs
 * @Date 2023/8/19 11:41
 * @PackageName:com.jsxs.config
 * @ClassName: MainConfigOfAOP
 * @Description: TODO  AOP【动态代理】 : 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式;
 *                  1.如何使用?
 *                      (1).导入AOP的依赖。
 *                      (2).定义一个业务逻辑类(MathCalculator)。在业务逻辑运行的时候将日志进行打印(方法之前,方法结束,方法异常)
 *                      (3).定义一个日志切面类(LogAspect)。切面类里面的方法需要动态的感知 业务逻辑类(MathCalculator)的运行情况
 *                              (3.1).通知方法:  前置通知@Before(在目标方法运行之前运行),
 *                                              后置通知@After(在目标方法运行之后运行,不在意正常结束还是异常结束),
 *                                              返回通知@AfterReturning(在目标方法正常返回之后运行),
 *                                              异常通知@AfterThrowing(在目标方法发生异常之后运行),
 *                                              环绕通知@Round(动态代理,手动推进目标方法运行 joinPoint.)
 *                      (4).给切面类的目标方法标注何时何处地运行 (通知注解)⭐⭐
 *                      (5).将切面类和业务逻辑类(目标方法所在类) 都加入到容器中 ⭐⭐⭐
 *                      (6).必须告诉Spring的IOC容器哪个类是切面类(我们需要给切面类添加一个注解 @Aspect)  ⭐⭐⭐⭐
 *                      (7).在配置类上开启 注解版的切面功能 ( <aop:aspectj-autoproxy></aop:aspectj-autoproxy>  @EnableAspectJAutoProxy)
 *                      (8).测试,这个逻辑类一定要使用IOC容器的类,不能使用new
 * @Version 1.0
 */
@Configuration  //⭐
@EnableAspectJAutoProxy //⭐⭐ 开启注解版本的依赖
public class MainConfigOfAOP {
    // 业务逻辑类  ⭐⭐⭐⭐
    @Bean
    public MathCalculator mathCalculator(){
        return new MathCalculator();
    }
    // 切面类 ⭐⭐⭐⭐⭐
    @Bean
    public LogAspect logAspect(){
        return new LogAspect();
    }
}
  1. 非注解版开启aop依赖

(5). 编写测试类
package com.jsxs.Test;
import com.jsxs.aop.MathCalculator;
import com.jsxs.config.MainConfigOfAOP;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
/**
 * @Author Jsxs
 * @Date 2023/8/19 12:47
 * @PackageName:com.jsxs.Test
 * @ClassName: AOP_Test
 * @Description: TODO
 * @Version 1.0
 */
public class AOP_Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
        for (String beanDefinitionName : applicationContext.getBeanDefinitionNames()) {
            System.out.println(beanDefinitionName);
        }
        // 1.这个对象我们不能使用new创建,我们需要使用IOC容器的组件进行调用 ⭐
        MathCalculator calculator = applicationContext.getBean(MathCalculator.class);
        calculator.div(1,3);
    }
}
  1. 测试结果 不写类名 和 结果

  1. 测试结果 写类名 和 结果

1.我们需要在切面类进行更改

JoinPoint 这个类如果要使用一定要写在参数列表的第一位,否则可能不生效

package com.jsxs.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import java.util.Arrays;
/**
 * @Author Jsxs
 * @Date 2023/8/19 11:52
 * @PackageName:com.jsxs.aop
 * @ClassName: LogAspect
 * @Description: TODO
 * @Version 1.0
 */
@Aspect // 告诉IOC容器这是一个切面类  ⭐
public class LogAspect {
    // 2.在目标方法之前运行切入:切入点表达式( public int com.jsxs.aop.MathCalculator.div(int,int))
    // *号代表这个类地所有方法, 一个.代表一个变量
    @Before("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void logStart(JoinPoint joinPoint){  //⭐⭐ 切入点类可以获取名字和参数列表
        System.out.println(joinPoint.getSignature().getName()+"除法运行..... 参数列表是:{"+ Arrays.asList(joinPoint.getArgs())+"}");
    }
    // 3.在目标方法之后进行切入, 使用公共地切入点表达式
    @After("execution(public int com.jsxs.aop.MathCalculator.*(..))")
    public void endStart(){
        System.out.println("除法运行结束....");
    }
    // 4.在目标方法返回正确地话  ⭐⭐⭐ 获取返回结果,注解里面的参数名要和方法里面的参数名一致
    @AfterReturning(value = "execution(public int com.jsxs.aop.MathCalculator.*(..))",returning = "result")
    public void success(JoinPoint joinPoint,Object result){
        System.out.println(joinPoint.getSignature().getName()+"除法正常运行... 运行结果:{"+result+"}");
    }
    // 5.在目标方法出现异常地话 ⭐⭐⭐⭐ 获取异常信息
    @AfterThrowing(value = "execution(public int com.jsxs.aop.MathCalculator.*(..))",throwing = "exception")
    public void logError(Exception exception){
        System.out.println("除法异常运行..."+exception);
    }
}

(二)、AOP 原理

  1. 看给容器中注册了什么组件?
  2. 这个组件什么时候工作?
  3. 这个组件工作时候的功能?

1.@EnableAspectJAutoProxy

(1).@EnableAspectJAutoProxy源码
*                 AOP【原理】
 *                  1.@EnableAspectJAutoProxy ->核心注解
 *                      (1).@Import(AspectJAutoProxyRegistrar.class) -> 给容器中导入AspectJAutoProxyRegistrar这个组件
 *                          internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
 *                          给容器中注入了一个AnnotationAwareAspectJAutoProxyCreator ⭐

@EnableAspectJAutoProxy ->核心注解给容器中导入AspectJAutoProxyRegistrar这个组件

(2).AspectJAutoProxyRegistrar 自定义注册bean源码

通过这个类进行创建自定义组件

(3).打断点进行Debug测试
  1. registerBeanDefinitions 方法处打一个断点

  1. registerOrEscalateApcAsRequired()

  1. 给容器中注入AnnotationAwareAspectJAutoProxyCreator

2.AnnotationAwareAspectJAutoProxyCreator 分析

(1).继承树

CTRL+H 打开目录树

* AOP【原理】
 *                  1.@EnableAspectJAutoProxy ->核心注解
 *                      (1).@Import(AspectJAutoProxyRegistrar.class) -> 给容器中导入AspectJAutoProxyRegistrar这个组件
 *                          internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
 *                          给容器中注入了一个AnnotationAwareAspectJAutoProxyCreator
 *                  2. AnnotationAwareAspectJAutoProxyCreator
 *                      AnnotationAwareAspectJAutoProxyCreator
 *                          ->(继承) AspectJAwareAdvisorAutoProxyCreator
 *                              ->(继承) AbstractAutoProxyCreator implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
 *                                       关注后置处理器(在bean初始化前后) 和 自动装配BeanFactory
 *                                       (2.1). setBeanFactory
 *                                  ->(继承) AbstractAdvisorAutoProxyCreator
 *                                      ->(继承) ProxyConfig
 *                                          ->(继承) Object       
(2).AbstractAutoProxyCreator

AbstractAutoProxyCreator类 具有后置处理器的逻辑

具有setBeanFactry()的功能

(3).AbstractAdvisorAutoProxyCreator

这里初始化了 initBeanFactory()

3.注册 AnnotationAwareAspectJAutoProxyCreator

(1).打断点进行Debug调试

1.打上第一个断点

2.配置类上打上两个断点

(2).运行流程 (创建和注册AnnotationAwareAspectJAutoProxyCreator)
*  3.流程:
 *                      (1).传入配置类,创建IOC容器 -> new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
 *                      (2).注册配置类register(annotatedClasses),重启IOC容器refresh()
 *                      (3).registerBeanPostProcessors(beanFactory); 注册bean的后置处理器来方便拦截bean的创建
 *                          (3.1).先获取IOC容器已经定义了的需要创建对象的所有 BeanPostProcessor
 *                          (3.2).给容器中添加别的BeanPostProcessor
 *                          (3.3).优先注册了priorityOrderedPostProcessors接口的BeanPostProcessor
 *                          (3.4).在给容器中注册实现了Ordered接口的BeanPostProcessor
 *                          (3.5).注册没实现优先级接口的 BeanPostProcessors
 *                          (3.6).注册BeanPostProcessors,实际上就是创建BeanPostProcessors对象,保存在容器中;
 *                              创建internalAutoProxyCreator的BeanPostProcessors【AnnotationAwareAspectJAutoProxyCreator】
 *                                  (1).创建Bean的实列
 *                                  (2).populateBean:给bean的各种属性赋值
 *                                  (3).initializeBean: 初始化bean
 *                                      (1).invokeAwareMethods() :处理Aware接口的方法回调
 *                                      (2).applyBeanPostProcessorsBeforeInitialization() 应用后置处理器
 *                                      (3).invokeInitMethods()执行自定义的初始方法
 *                                      (4).applyBeanPostProcessorsAfterInitialization() 执行后置处理器的postProcessor
 *                                  (4).BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator) 创建成功
 *                         (3.7).把BeanPostProcessor注册到BeanFactory中 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

1.创建IOC容器

2.发现refresh()方法中具有 后置处理器的功能 注册配置类register(annotatedClasses),重启IOC容器refresh()

3.registerBeanPostProcessors(beanFactory); 注册bean的后置处理器来方便拦截bean的创建

3.1 先获取IOC容器已经定义了的需要创建对象的所有 BeanPostProcessor

3.2 给容器中添加别的BeanPostProcessor

3.3 优先注册了priorityOrderedPostProcessors接口的BeanPostProcessor

3.4 在给容器中注册实现了Ordered接口的BeanPostProcessor

3.5注册没实现优先级接口的 BeanPostProcessors

3.6 注册BeanPostProcessors,实际上就是创建BeanPostProcessors对象,保存在容器中;

4.AnnotationAwareAspectJAutoProxyCreator 执行时机

* 4.执行时机
 *                          1.遍历容器中所有的Bean,依次创建对象getBean(beanName)
 *                              getBean->doGetBean()->getSingleton->
 *                          2.创建bean
 *                              (1).先从缓存中获取当前bean,如果能获取到,说明bean是之前被创建过的,直接使用,否则再创建
 *                                  只要创建好的Bean都会被缓存起来。
 *
 *                              (2).CreateBean() 创建bean
 *                                  (2.1).resolveBeforeForeInstantion(beanName,mbdToUse) --> 希望后置处理器在此能返回一个代理对象,如果能返回代理对象就使用,如果不能就继续
 *                                  (2.2).doCreateBean() 真正的去创建一个bean实列
 *                           3.  AnnotationAwareAspectJAutoProxyCreator 在所有的bean创建之前会有一个拦截,InstantionAnwareBeanPostProcessor,会调用PostProcessBeforeInstantiation
 *

5.创建AOP代理对象

*  5.AOP原理
 *          1.每一个bean创建之前,调用postProcessBeforeInstantiation();
 *                              关心 普通组件 和 切面组件 的创建
 *                                  (1).判断当前bean是否在advisedBeans中(保存了所需要增强的bean)
 *                                  (2).判断是否是切面
 *                                  (3).是否需要跳过
 *                                      (3.1).获取候选的增强器(切面里面的通知方法) 每一个封装的通知方法都是一个增强器 ,返回true
 *                                      (3.2). 返回false -> 永远不跳过
 *          2.每一个bean创建之后,调用postProcessAfterInstantiation();
 *                              (1).获取当前bean的所有增强器(增强方法)
 *                                  (1.1).找到的候选的所有增强器(找那些通知方法是需要切入当前bean方法的)
 *                                  (1.2).获取能在当前bean使用的增强器
 *                                  (1.3).给增强器进行排序
 *                              (2).保存当前bean在adviseBeans中
 *                              (3).如果当前bean需要增强,创建当前bean的代理对象。
 *                                  (3.1).获取所有增强器(通知方法)
 *                                  (3.2).保存到proxyFactory
 *                                  (3.3).创建代理对象 ⭐ (两种)
 *                                      (3.3.1).JDKDynamicAopProxy(config)  ->jdk创建代理模式(有接口使用jdk)
 *                                      (3.3.2).ObjenesisCglibAopProxy(config)  ->cglib创建代理模式(无接口使用cglib)
 *                             ⭐      (3.4).给IOC容器返回当前组件使用cglib增强了的代理对象
 *                             ⭐      (3.5).以后容器中获取到的就是这个组件的代理对象,执行目标方法的时候,代理对象就会执行通知方法的流程

6.AOP原理的总结 ⭐

  1. @EnableAspectJAutoProxy 作用: 开启AOP注解功能
  2. @EnableAspectJAutoProxy 作用: 会给容器注册一个组件(AnnotationAwareAspectJAutoProxyCreator)
  3. AnnotationAwareAspectJAutoProxyCreator 是一个后置处理器
  4. 容器的创建流程
  • registerBeanPostProcessors(注册后置处理器),作用:创建registerBeanPostProcessors
  • finishBeanFactoryInitialization(beanFactory);作用:初始化剩下的单实列bean
  • 创建业务逻辑组件和切面组件
  • AnnotationAwareAspectJAutoProxyCreator 拦截组件的创建过程
  • 组件创建完之后,判断组件是否需要增强
  • 是: 切面的通知方法,包装成增强器(Adviros); 业务逻辑组件创建一个代理对象
  1. 执行目标方法
  • 代理对象执行目标方法
  • CglibAopProxy.intercept();
  • 得到目标方法的拦截器链 (增强器包装成拦截器MethodInterceptor)
  • 利用拦截器的链式机制,依次进入每一个拦截器进行执行
  • 效果:
  • 正常执行: 前置通知 -> 目标方法 -> 后置通知 -> 返回通知
  • 出现异常: 前置通知 ->目标方法 -> 后置通知 -> 异常通知

相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
相关文章
|
16天前
|
Java Spring 容器
如何解决spring EL注解@Value获取值为null的问题
本文探讨了在使用Spring框架时,如何避免`@Value(&quot;${xxx.xxx}&quot;)`注解导致值为null的问题。通过具体示例分析了几种常见错误场景,包括类未交给Spring管理、字段被`static`或`final`修饰以及通过`new`而非依赖注入创建对象等,提出了相应的解决方案,并强调了理解框架原理的重要性。
56 4
|
10天前
|
Java API 数据安全/隐私保护
(工作经验)优雅实现接口权限校验控制:基于自定义注解、AOP与@ConditionalOnProperty配置开关的通用解决方案
(工作经验)优雅实现接口权限校验控制:基于自定义注解、AOP与@ConditionalOnProperty配置开关的通用解决方案
41 1
|
3天前
|
存储 缓存 Java
Spring高手之路23——AOP触发机制与代理逻辑的执行
本篇文章深入解析了Spring AOP代理的触发机制和执行流程,从源码角度详细讲解了Bean如何被AOP代理,包括代理对象的创建、配置与执行逻辑,帮助读者全面掌握Spring AOP的核心技术。
11 3
Spring高手之路23——AOP触发机制与代理逻辑的执行
|
13天前
|
XML Java 数据格式
Spring从入门到入土(bean的一些子标签及注解的使用)
本文详细介绍了Spring框架中Bean的创建和使用,包括使用XML配置文件中的标签和注解来创建和管理Bean,以及如何通过构造器、Setter方法和属性注入来配置Bean。
53 9
Spring从入门到入土(bean的一些子标签及注解的使用)
|
8天前
|
XML Java 数据格式
使用完全注解的方式进行AOP功能实现(@Aspect+@Configuration+@EnableAspectJAutoProxy+@ComponentScan)
本文介绍了如何使用Spring框架的注解方式实现AOP(面向切面编程)。当目标对象没有实现接口时,Spring会自动采用CGLIB库进行动态代理。文中详细解释了常用的AOP注解,如`@Aspect`、`@Pointcut`、`@Before`等,并提供了完整的示例代码,包括业务逻辑类`User`、配置类`SpringConfiguration`、切面类`LoggingAspect`以及测试类`TestAnnotationConfig`。通过这些示例,展示了如何在方法执行前后添加日志记录等切面逻辑。
21 2
使用完全注解的方式进行AOP功能实现(@Aspect+@Configuration+@EnableAspectJAutoProxy+@ComponentScan)
|
5天前
|
架构师 Java 开发者
得物面试:Springboot自动装配机制是什么?如何控制一个bean 是否加载,使用什么注解?
在40岁老架构师尼恩的读者交流群中,近期多位读者成功获得了知名互联网企业的面试机会,如得物、阿里、滴滴等。然而,面对“Spring Boot自动装配机制”等核心面试题,部分读者因准备不足而未能顺利通过。为此,尼恩团队将系统化梳理和总结这一主题,帮助大家全面提升技术水平,让面试官“爱到不能自已”。
得物面试:Springboot自动装配机制是什么?如何控制一个bean 是否加载,使用什么注解?
|
10天前
|
XML Java 数据库
Spring boot的最全注解
Spring boot的最全注解
|
11天前
|
JSON NoSQL Java
springBoot:jwt&redis&文件操作&常见请求错误代码&参数注解 (九)
该文档涵盖JWT(JSON Web Token)的组成、依赖、工具类创建及拦截器配置,并介绍了Redis的依赖配置与文件操作相关功能,包括文件上传、下载、删除及批量删除的方法。同时,文档还列举了常见的HTTP请求错误代码及其含义,并详细解释了@RequestParam与@PathVariable等参数注解的区别与用法。
|
11天前
|
Java API Spring
springBoot:注解&封装类&异常类&登录实现类 (八)
本文介绍了Spring Boot项目中的一些关键代码片段,包括使用`@PathVariable`绑定路径参数、创建封装类Result和异常处理类GlobalException、定义常量接口Constants、自定义异常ServiceException以及实现用户登录功能。通过这些代码,展示了如何构建RESTful API,处理请求参数,统一返回结果格式,以及全局异常处理等核心功能。
|
13天前
|
Java 编译器 Spring
Spring AOP 和 AspectJ 的区别
Spring AOP和AspectJ AOP都是面向切面编程(AOP)的实现,但它们在实现方式、灵活性、依赖性、性能和使用场景等方面存在显著区别。‌
28 2