Spring AOP概念及原理

于 2024-09-13 09:59:10 发布
阅读量160 收藏
点赞数
文章标签： spring java 后端
合集 - Java相关(5)
1.设计模式 2.JVM
3. Spring AOP概念及原理
4.当运行程序发生CPU飙升怎么排查问题？ 5.JVM的架构，具体阐述一下各个部分的功能？还有.class文件的加载执行过程。
收起

Spring AOP（面向切面编程）

以下内容由ChatGPT生成

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，旨在通过分离关注点来提高程序的模块化。Spring AOP 主要用于横切关注点（如日志记录、安全、事务管理等）的实现。在 Spring 中，AOP 的主要功能是为 Bean 增强功能，如添加额外的行为。

1. 静态代理与动态代理

静态代理和动态代理是实现 AOP 的两种主要方式。

静态代理：

  • 在编译时就已经知道代理的目标类，代理类在代码中显式地定义。
  • 静态代理的缺点是需要为每个代理的类手动编写代理类，导致代码冗余且难以维护。

动态代理：

  • 动态代理是在运行时生成代理类的，Java 中有两种实现动态代理的方式：JDK 动态代理和 CGLIB。
  • 动态代理的优点是可以为任意接口生成代理，不需要手动编写代理类。
JDK 动态代理
  • JDK 动态代理只代理实现了接口的类。它通过 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口实现。
  • InvocationHandler 接口中定义了 invoke 方法，当代理对象调用方法时，会执行该方法。

    
    import java.lang.reflect.InvocationHandler;

     
     import java.lang.reflect.Method;

     
     import java.lang.reflect.Proxy;

     
     

     
     public class JdkProxyExample {

     
     public static void main(String[] args) {

     
     Foo foo = new FooImpl();

     
     Foo proxyFoo = (Foo) Proxy.newProxyInstance(

     
     Foo.class.getClassLoader(),

     
     new Class<?>[]{Foo.class},

     
     new InvocationHandler() {

     
     @Override

     
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

     
     // 前置增强

     
     System.out.println("Before method: " + method.getName());

     
     Object result = method.invoke(foo, args);

     
     // 后置增强

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

     
     return result;

     
     }

     
     });

     
     proxyFoo.doSomething();

     
     }

     
     }

     
     

     
     interface Foo {

     
     void doSomething();

     
     }

     
     

     
     class FooImpl implements Foo {

     
     public void doSomething() {

     
     System.out.println("Doing something...");

     
     }

     
     }
CGLIB 动态代理
  • CGLIB 动态代理通过生成目标类的子类来实现代理，因此可以代理没有接口的类。CGLIB 使用 ASM 字节码操作库来生成代理类。
  • CGLIB 的代理类重写目标类的方法，通过调用父类的 super 方法来实现对目标方法的调用。

    
    import net.sf.cglib.proxy.Enhancer;

     
     import net.sf.cglib.proxy.MethodInterceptor;

     
     import net.sf.cglib.proxy.MethodProxy;

     
     

     
     public class CglibProxyExample {

     
     public static void main(String[] args) {

     
     Enhancer enhancer = new Enhancer();

     
     enhancer.setSuperclass(Foo.class);

     
     enhancer.setCallback(new MethodInterceptor() {

     
     @Override

     
     public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {

     
     // 前置增强

     
     System.out.println("Before method: " + method.getName());

     
     Object result = proxy.invokeSuper(obj, args);

     
     // 后置增强

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

     
     return result;

     
     }

     
     });

     
     Foo fooProxy = (Foo) enhancer.create();

     
     fooProxy.doSomething();

     
     }

     
     }

     
     

     
     class Foo {

     
     public void doSomething() {

     
     System.out.println("Doing something...");

     
     }

     
     }
2. Spring AOP 实现原理

Spring AOP 支持 JDK 动态代理和 CGLIB 两种代理机制。

  • JDK 动态代理：当目标类实现了一个或多个接口时，Spring 默认使用 JDK 动态代理来为目标类创建代理对象。
  • CGLIB：如果目标类没有实现任何接口，Spring 则会使用 CGLIB 来生成目标类的代理对象。

Spring 使用 AopProxy 接口和其两个实现类 JdkDynamicAopProxy 和 CglibAopProxy 来分别处理这两种代理机制。

Bean 被包装成 Proxy
  1. Spring 容器启动时，解析配置文件或注解，生成 Bean 定义信息。
  2. 在 Bean 初始化后，Spring AOP 的 BeanPostProcessor 之一（如 AbstractAutoProxyCreator 的子类）会检查该 Bean 是否需要 AOP 增强。
  3. 如果需要增强，则会生成一个代理对象，替换掉原始的 Bean。这一过程是通过调用 getProxy() 方法来完成的。
创建 Proxy 对象

AopProxy 接口定义了 getProxy() 方法：

  • JdkDynamicAopProxy：通过 JDK 动态代理的 Proxy.newProxyInstance() 方法创建代理对象。
  • CglibAopProxy：通过 CGLIB 的 Enhancer 类创建代理对象。
获取代理对象

getProxy() 方法返回代理对象。代理对象的创建是在调用 getProxy() 方法时动态生成的，并且在这个方法中处理了所有的 AOP 增强逻辑。

InvocationHandler 的实现

在 JDK 动态代理中，InvocationHandler 的 invoke() 方法包含了拦截器链的逻辑。CglibAopProxy 通过 Callback 和 MethodInterceptor 实现类似的功能。


    
    public class MyInvocationHandler implements InvocationHandler {

     
     private final Object target;

     
     

     
     public MyInvocationHandler(Object target) {

     
     this.target = target;

     
     }

     
     

     
     @Override

     
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

     
     // 前置处理

     
     System.out.println("Before method: " + method.getName());

     
     

     
     // 调用目标对象的方法

     
     Object result = method.invoke(target, args);

     
     

     
     // 后置处理

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

     
     

     
     return result;

     
     }

     
     }

在 invoke() 方法中：

  1. 执行前置增强逻辑。
  2. 使用反射调用目标对象的方法。
  3. 执行后置增强逻辑。
3. 拦截器链与方法链的执行

Spring AOP 中的拦截器链是由 Advisor 和 MethodInterceptor 组成的。Advisor 包含切点（Pointcut）和通知（Advice），切点定义了哪些方法需要拦截，通知则定义了拦截时执行的逻辑。

在代理对象调用方法时：

  1. AopProxy 调用链会依次调用拦截器链中的拦截器。
  2. 拦截器链通过责任链模式处理每一个拦截器。
  3. 如果拦截器链中的某个拦截器决定执行目标方法，则会调用 MethodInvocation.proceed() 方法。

    
    public class MyMethodInterceptor implements MethodInterceptor {

     
     @Override

     
     public Object invoke(MethodInvocation invocation) throws Throwable {

     
     // 前置处理

     
     System.out.println("Before method: " + invocation.getMethod().getName());

     
     

     
     // 调用目标对象的方法

     
     Object result = invocation.proceed();

     
     

     
     // 后置处理

     
     System.out.println("After method: " + invocation.getMethod().getName());

     
     

     
     return result;

     
     }

     
     }

在 invoke() 方法中，proceed() 方法用于继续执行下一个拦截器或目标方法。如果没有其他拦截器，则执行目标方法。

总结

Spring AOP 使用代理模式实现横切关注点的管理，主要通过 JDK 动态代理和 CGLIB 动态代理实现。代理对象是通过 AopProxy 创建的，其中的 InvocationHandler 和 MethodInterceptor 负责执行拦截器链的逻辑。Spring AOP 提供了强大的功能来增强 Bean 的行为，使得切面逻辑与核心业务逻辑分离，提升了代码的模块化和可维护性。

以日志管理为例，Spring项目中如何使用AOP？

在 Spring 项目中使用 AOP 实现日志管理是一种常见的实践。通过 AOP，我们可以将日志记录等横切关注点与业务逻辑分离，使代码更加清晰、模块化。下面是一个使用 Spring AOP 实现日志管理的示例，包括如何定义切面、配置切面以及如何在应用中使用它。

1. 引入依赖

首先，需要在项目中引入 Spring AOP 相关的依赖。如果使用的是 Maven，可以在 pom.xml 中添加以下依赖：

   
   <dependency>

    
        <groupId>org.springframework.boot</groupId>

    
        <artifactId>spring-boot-starter-aop</artifactId>

    
    </dependency>
2. 定义切面（Aspect）

切面是包含横切逻辑的类。在日志管理的示例中，我们将创建一个切面类来拦截方法调用并记录日志。


    
    package com.example.logging;

     
     

     
     import org.aspectj.lang.annotation.Aspect;

     
     import org.aspectj.lang.annotation.Before;

     
     import org.aspectj.lang.annotation.AfterReturning;

     
     import org.aspectj.lang.annotation.AfterThrowing;

     
     import org.aspectj.lang.annotation.Pointcut;

     
     import org.aspectj.lang.JoinPoint;

     
     import org.slf4j.Logger;

     
     import org.slf4j.LoggerFactory;

     
     import org.springframework.stereotype.Component;

     
     

     
     @Aspect

     
     @Component

     
     public class LoggingAspect {

     
     

     
         private static final Logger logger = LoggerFactory.getLogger(LoggingAspect.class);

     
     

     
         // 定义切点，拦截所有com.example.service包及其子包下的所有方法

     
         @Pointcut("execution(* com.example.service..*(..))")

     
         public void serviceMethods() {}

     
     

     
         // 方法执行之前调用

     
         @Before("serviceMethods()")

     
         public void logBefore(JoinPoint joinPoint) {

     
             logger.info("Before method: " + joinPoint.getSignature().getName() + " - Arguments: " + joinPoint.getArgs());

     
         }

     
     

     
         // 方法正常返回之后调用

     
         @AfterReturning(pointcut = "serviceMethods()", returning = "result")

     
         public void logAfterReturning(JoinPoint joinPoint, Object result) {

     
             logger.info("After method: " + joinPoint.getSignature().getName() + " - Result: " + result);

     
         }

     
     

     
         // 方法抛出异常时调用

     
         @AfterThrowing(pointcut = "serviceMethods()", throwing = "error")

     
         public void logAfterThrowing(JoinPoint joinPoint, Throwable error) {

     
             logger.error("Exception in method: " + joinPoint.getSignature().getName() + " - Exception: " + error);

     
         }

     
     }
3. 解释切面中的注解和方法
  • @Aspect: 标注该类为一个切面类。
  • @Component: 将该切面类作为 Spring 的 Bean 进行管理。
  • @Pointcut: 定义一个切点，execution(* com.example.service..*(..)) 表示匹配 com.example.service 包及其子包下的所有方法。
  • @Before: 表示在目标方法执行之前执行 logBefore() 方法。
  • @AfterReturning: 表示在目标方法正常返回之后执行 logAfterReturning() 方法，其中 returning 属性指定了返回值的变量名。
  • @AfterThrowing: 表示在目标方法抛出异常时执行 logAfterThrowing() 方法，其中 throwing 属性指定了异常的变量名。
4. 配置切面扫描

确保 Spring 能够扫描到定义的切面类。可以在主配置类（通常是启动类）中添加 @EnableAspectJAutoProxy 注解，启用 AOP 功能：


    
    package com.example;

     
     

     
     import org.springframework.boot.SpringApplication;

     
     import org.springframework.boot.autoconfigure.SpringBootApplication;

     
     import org.springframework.context.annotation.EnableAspectJAutoProxy;

     
     

     
     @SpringBootApplication

     
     @EnableAspectJAutoProxy

     
     public class MyApp {

     
         public static void main(String[] args) {

     
             SpringApplication.run(MyApp.class, args);

     
         }

     
     }
5. 使用日志管理的示例

假设有一个服务类 UserService，日志切面将记录其方法调用：


    
    package com.example.service;

     
     

     
     import org.springframework.stereotype.Service;

     
     

     
     @Service

     
     public class UserService {

     
     

     
         public String getUserInfo(String userId) {

     
             // 模拟获取用户信息的操作

     
             return "User info for " + userId;

     
         }

     
     

     
         public void createUser(String userId, String name) {

     
             // 模拟创建用户的操作

     
             System.out.println("User created: " + userId + ", " + name);

     
         }

     
     }

在 UserService 的方法调用之前、正常返回之后，以及抛出异常时，日志切面将分别记录相关信息。

6. 总结

通过使用 Spring AOP 实现日志管理，我们可以将日志记录的逻辑从业务逻辑中分离出来，简化了代码的维护。Spring AOP 提供了一种强大的方式来处理横切关注点，使得业务逻辑更为简洁和集中。


__EOF__

  • 本文作者： SiWuxie
  • 本文链接： https://www.cnblogs.com/Si-wuxie/p/18333322
  • 关于博主： 评论和私信会在第一时间回复。或者直接私信我。
  • 版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
  • 声援博主： 如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。
原创作者: Si-wuxie 转载于: https://www.cnblogs.com/Si-wuxie/p/18333322
Krine
关注
Spring AOP —— 详解、实现原理、简单demo
CYK_byte的博客
03-05 2644
AOP 就是面向切面的编程， 是一种思想，是对某一类事情的集中处理。
Spring AOP的重要概念
weixin_45709134的博客
03-05 521
文章目录0.Spring AOP的重要概念1.通知：就是会在目标方法执行前后执行的方法1.1.1JoinPoint 对象1.1.2前置通知@Before1.1.3环绕通知@Around1.1.4后置返回通知@AfterReturning1.1.5异常通知 @AfterThrowing1.1.6后置通知@After2.定义切入点函数：应用通知进行增强的目标方法2.1直接把切入点函数作为值传递给通知类型2.2通过@pointcut2.3execution基本格式3.连接点：连接点就是可以应用通知进行增强的方法4
Spring-AOP概念
qq_43290295的博客
02-26 180
AOP的概念 AOP即面向切面编程，以Aspect（切面）为基本单元。（OOP：面向对象编程 以类为基本单元） AOP采取横向抽取机制，即将分散在各个方法中的重复代码提取出来，然后在程序编程或运行阶段将这些抽取出来的代码应用到需要执行的地方。-------提高代码复用率，解耦。 AOP的术语 切面（Aspect） 指封装横切到系统功能的类，即上图中的function。 链接点（Joinpoint...
spring aop 概念
qq_38480786的博客
06-28 705
image 一、AOP的基本概念： 1、什么是aop： AOP（Aspect Oriented Programming）称为面向切面编程，在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限等待，Struts2的拦截器设计就是基于AOP的思想，是个比较经典的例子。 在不改变原有的逻辑的基础上，增加一些额外的功能。代理也是这个功能，读写分离也能用aop来做。 AOP可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP...
Spring AOP概念
weixin_57763462的博客
02-27 257
是一种动态编译期增强性AOP的实现 与IOC进行整合，不是全面的切面框架 与动态代理相辅相成 有两种实现：基于jdk动态代理、cglib Spring AOP与AspectJ区别 Spring的AOP是基于动态代理的，动态增强目标对象，而AspectJ是静态编译时增强，需要使用自己的编译器来编译，还需要织入器 使用AspectJ编写的java代码无法直接使用javac编译，必须使用AspectJ增强的ajc增强编译器才可以通过编译，写法不符合原生Java的语法；而Spring AOP是...
Spring aop 概念
秒怂_z
03-17 193
Spring aop 一、aop概念 1.aop:面向切面编程，拓展功能不修改源代码实现。 2.AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（解释看aop原理） 二、aop原理 1.没有aop时的一种解决办法：纵向继承体系。 2.aop的解决方法：横向抽取机制 第一种情况：有接口的情况 第二种情况：没有接口的情况 三、aop操作术语 术语(加重为重点)： 1.Joinpoint...
Spring AOP面向方面编程原理：AOP概念
11-21
### Spring AOP面向方面编程原理：AOP概念详解 #### 一、引言 随着软件系统的日益复杂，传统的面向对象编程(OOP)逐渐暴露出难以应对某些横切关注点(cross-cutting concerns)的问题。为了解决这一挑战，面向方面编程...
Spring AOP的实现原理详解及实例
10-19
Spring AOP提供了Pointcut和Advice的概念来精准控制哪些方法需要被拦截以及如何拦截。Pointcut用于定义匹配特定连接点（Join point）的规则，而Advice则定义了当匹配的连接点触发时应该执行的增强操作。 最后，...
反射实现 AOP 动态代理模式(Spring AOP 的实现原理）
08-26
Spring框架中的AOP模块使用了动态代理来实现AOP概念。Spring AOP允许开发者定义切面，并在这些切面中指定拦截的方法。Spring AOP支持不同的代理策略，包括JDK动态代理和CGLIB代理。如果被代理的类没有实现接口，...
深入理解spring的AOP机制原理
08-29
深入理解 Spring 的 ...本篇文章对 Spring 的 AOP 机制原理进行了详细的介绍，包括 AOP 的基本概念、Spring 的 AOP 支持、AspectJ 切点表达式语言等。理解 Spring 的 AOP 机制原理对于深入学习 Spring 框架非常重要。
spring中AOP概念
csdnlaiyanqi的博客
10-28 572
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 然后我们举一个比较容易理解的例子（来自：Spring 之 AOP）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序
Spring AOP 基本概念
苍漠胡杨
03-12 346
Spring AOP 基本概念 **AOP到底是什么 Spring AOP和IOC是听到的关于Spring最频繁的两个词了。现在来重点关注AOP这个词，IOC先放一边，下面这段话摘自Spring优势中关于面向切面的介绍：** 面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内...
Spring AOP的基本概念
ikaraide的专栏
01-10 780
AOP本质                 AOP（Aspect-Oriented Programming， 面相方面编程），可以说是OOP的补充和完善。OOP 引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们 需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上 到下的关系，但并不适合定义从左到右的关系。例如日志功
SpringAOP切点函数实现原理详解
08-19
本篇文章将深入探讨Spring AOP切点函数的实现原理。 首先，我们来看一下在函数入参中使用通配符的情况。Spring AOP的切点函数支持三种通配符：`*`、`...` 和 `+`。`*` 可以匹配任意单个字符，常用于方法名或返回...
Spring基础（十）：AOP概念和原理
Lansonli（蓝深李）的博客
09-10 853
表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。AOP切面编程一般可以帮助我们在不修改现有代码的情况下,对程序的功能进行拓展，往往用于实现日志处理，权限控制，性能检测，事务控制等。Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。AOP实现的原理就是动态代理,在有接口的情况下，使用JDK动态代理，在没有接口的情况下使用cglib动态代理。
Spring中AOP的相关概念
KDLin‘s Blog
01-03 504
Spring中AOP的相关概念 摘要 通过一些spring的小demo来解释, 切面 ,连接点, 切入点, 通知, 目标对象, 代理, 织入 中文翻译比较多, 英文如下: Aspect, Joinpoint , Pointcut, Advice, Target ,Object ,Proxy Weaving 这一组重要的概念. 案例 public class ProductService { ...
SpringAOP的基本概念
A2460865183的博客
02-29 1176
一、SpringAOP的基本概念 （一）Spring 框架的 AOP Spring 框架的一个关键组件是面向方面的编程(AOP)框架。面向方面的编程需要把程序逻辑分解成不同的部分称为所谓的关注点。跨一个应用程序的多个点的功能被称为横切关注点，这些横切关注点在概念上独立于应用程序的业务逻辑。有各种各样的常见的很好的方面的例子，如日志记录、审计、声明式事务、安全性和缓存等。 在 OOP 中，关键单元...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值