Spring AOP的实现原理-阿里云开发者社区

前言

一、Spring的aop的概念

AOP是什么

AOP（面向切面编程）是一种编程范式，用于将横切关注点与业务逻辑分离。横切关注点是指在应用程序中多个模块或组件中重复出现的功能，如日志记录、事务管理、安全性等。通过AOP，可以将这些横切关注点抽象出来，以便在需要的地方进行重用。
AOP（面向切面编程）是一种编程范式，用于将横切关注点与业务逻辑分离。横切关注点是指在应用程序中多个模块或组件中重复出现的功能，如日志记录、事务管理、安全性等。通过AOP，可以将这些横切关注点抽象出来，以便在需要的地方进行重用。

横切关注点

与业务主要流程关系不大的部分
经常发生在核心关注点的多处，而各处都是基本相似的功能
如权限认证、日志、事务处理

AOP的特点

横向切面：AOP 的主要目的是解决横向切面的问题，即对多个对象的同种操作进行统一的处理，比如日志记录、性能统计、事务处理等。
切面集中处理：AOP 将切面的逻辑从业务逻辑中分离出来，实现了切面的集中处理。这样可以更好地实现代码的模块化和重用。
低侵入性：AOP 对原有业务逻辑的侵入性较小，只需要在切面中进行逻辑编写，不需要对原有类进行大量修改，提高了代码的可维护性和可扩展性。
动态代理：AOP 通过动态代理实现了切面的实现，在运行期间动态生成代理对象，实现了透明化的切面处理。
面向接口编程：AOP 一般采用面向接口编程的方式，使应用与具体实现相分离，提高了系统的可扩展性和可维护性。
与OOP关联性弱：AOP 与 OOP（面向对象编程）有较弱的关联性，可以与任何编程语言和编程模型兼容，提高了代码的通用性和移植性。

AOP带来的好处

模块化：通过将横切关注点与业务逻辑分离，可以提高代码的模块化和可维护性。
重用性：可以将横切关注点作为独立的模块进行重用，减少了代码的重复编写。
解耦性：AOP可以将横切关注点与业务逻辑解耦，使得代码更加清晰和可读。
灵活性：通过AOP，可以在不修改原始代码的情况下，动态地添加、修改或删除横切关注点。
可维护性：将横切关注点抽象出来，使得对其进行修改或调整更加方便和可控。

二、AOP的实现原理

1、基于代理的实现

Spring使用动态代理技术来实现AOP。当一个bean被代理时，Spring会根据该bean实现的接口或父类创建一个代理对象，然后拦截目标方法的调用，并在目标方法的前后加入额外的行为，从而实现AOP。

2、切点

切点是AOP中的重要概念，它定义了需要被切入的连接点，即目标对象中哪些方法需要被拦截。Spring AOP中，切点可以使用AspectJ切点表达式来定义。AspectJ切点表达式可以匹配目标对象的方法，由此确定了需要被织入增强逻辑的方法，是AOP执行的入口。、

3、切面

切面定义了横切逻辑的实现，它是一个包含了advice和pointcut的类。Advice是指增强逻辑，它定义了需要织入目标方法前、后或者代替目标方法执行的代码，可以使用before、after、around等方式实现；Pointcut是指切点，它定义了对哪些方法进行拦截。

4、通知

通知是切面中的实际增强逻辑，它是指在特定的切点上执行的具体操作，Spring AOP中常见的Advice有before、after、after-returning、after-throwing和around等。

5、织入

织入是指将切面应用到目标对象的过程。Spring AOP支持三种织入方式，分别是编译时织入、类加载时织入和运行时织入。

在运行时织入时，Spring AOP使用动态代理实现，即在目标对象的方法执行的前、后或者代替目标方法执行增加了额外的逻辑。而JDK动态代理的机制是利用反射来动态生成代理类，这个代理类实现了需要代理的接口，并在InvocationHandler的中的回调方法中执行目标方法的前、后或者代替目标方法执行额外的逻辑。

三、Spring AOP concepts（AOP术语）

【术语】：

切面（Aspect）：

一个关注点的模块化，这个关注点可能会横切多个对象。

事务管理是 J2EE 应用中一个关于横切关注点的很好列子。

在 Spring AOP 中，切面可以使用基于模式或者基于 @Aspect 注解的方式来实现。

连接点（Joinpoint）：

在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。

在 Spring AOP 中，一个连接点总是表示一个方法的执行。

切入点（Pointcut）：

匹配连接点的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如：当执行某个特定名称的方法时）。

切入点表达式如何和连接点匹配是 AOP 的核心：Spring 缺省使用 Aspect 切入点语法。

引入（Introduction）：

用来给一个类型声明额外的方法或属性（也被称为连接类型声明（inter-type declaration））

Spring 允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，可以使用引入来使一个 bean 实现 isModified 接口，以便简化缓存机制。

目标对象（Target Object）：

被一个或者多个切面所通知的对象，也被称为通知（advised）对象。

既然 Spring AOP 是通过运行时代理实现的。这个对象永远是一个被代理（proxied）对象。

AOP 代理（AOP Proxy）：

AOP 框架创建的对象，用来实现切面契约（例如，通知方法执行等等）。

在 Spring 中，AOP 代理可以是 JDK 动态代理或者 CGLIB 代理。

织入（Weaving）：

把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象。这些可以在编译时（例如使用 AspectJ 编译器），类加载时和运行时完成。Spring 和其他纯 Java AOP 框架一样，在运行时完成织入。

通知（Advice）：

在切面的某个特定的连接点上执行的动作。其中包括“around”、“before” 和 “after” 等不同类型的通知。

许多 AOP 框架（包括 Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。

适配器

适配器（Adapter）是一种结构型设计模式，用于将两个不兼容的接口协同工作。适配器模式的核心思想是解决新旧接口之间的兼容性问题，让不同接口之间能够无缝衔接。

作用：把一个接口（源接口）转换成另一个接口（目标接口），以满足目标接口的需求。适配器模式一般分为类适配器和对象适配器两种实现方式。

适配器模式中的三个角色：

目标接口（Target）：定义客户端使用的与特定领域相关的接口，客户端只能看到这个接口而不知道具体实现。

源接口（Adaptee）：需要被适配的接口，即客户端需要调用的接口，但由于与客户端的接口不兼容而无法直接使用。

适配器（Adapter）：用于将源接口转换成目标接口的中间件，把客户端的请求传递给适配者，完成客户端需要的功能。

适配器模式常用于系统升级或接口变更时，通过适配器来实现旧接口向新接口的转换，以保证系统的兼容性和稳定性。

四、常用通知

定义一个接口

package com.ctb.aop.biz;
public interface IBookBiz {
  // 购书
  public boolean buy(String userName, String bookName, Double price);
  // 发表书评
  public void comment(String userName, String comments);
}

实现接口

package com.ctb.aop.biz.impl;
import com.ctb.aop.biz.IBookBiz;
import com.ctb.aop.exception.PriceException;
public class BookBizImpl implements IBookBiz {
  public BookBizImpl() {
    super();
  }
  public boolean buy(String userName, String bookName, Double price) {
    // 通过控制台的输出方式模拟购书
    if (null == price || price <= 0) {
      throw new PriceException("book price exception");
    }
    System.out.println(userName + " buy " + bookName + ", spend " + price);
    return true;
  }
  public void comment(String userName, String comments) {
    // 通过控制台的输出方式模拟发表书评
    System.out.println(userName + " say:" + comments);
  }
}

异常处理类

package com.ctb.aop.exception;
public class PriceException extends RuntimeException {
  public PriceException() {
    super();
  }
  public PriceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
    super(message, cause, enableSuppression, writableStackTrace);
  }
  public PriceException(String message, Throwable cause) {
    super(message, cause);
  }
  public PriceException(String message) {
    super(message);
  }
  public PriceException(Throwable cause) {
    super(cause);
  }
}

测试类

package com.ctb.aop.demo;
import com.ctb.aop.biz.IBookBiz;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * @author 彪
 * @remark
 * @create  2023-08-17 15:54
 */
public class Demo1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring_context.xml");
//        IBookBiz bookBiz= (IBookBiz) context.getBean("bookBiz");
        IBookBiz bookBiz= (IBookBiz) context.getBean("bookProxy");
        bookBiz.buy("死仔","死亡药剂",9.9d);
        bookBiz.comment("死仔","爽歪歪");
    }
}

前置通知（Before advice）：

@Before

在某连接点之前执行的通知，但这个通知不能阻止了连接点之前的执行流程（除非它抛出一个异常）。

实现前置通知接口

package com.ctb.aop.advice;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
 * 买书、评论前加系统日志
 * @author biao
 *
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {
  @Override
  public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
//    在这里，可以获取到目标类的全路径及方法及方法参数，然后就可以将他们写到日志表里去
    String target = arg2.getClass().getName();
    String methodName = arg0.getName();
    String args = Arrays.toString(arg1);
    System.out.println("【前置通知：系统日志】："+target+"."+methodName+"("+args+")被调用了");
  }
}

spring_context.xml

 <!--目标对象-->
    <bean class="com.ctb.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.ctb.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <!-- 代理   -->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
        <!--配置目标对象-->
    <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口，目标对象的接口         
        -->
        <property name="proxyInterfaces">
                  <list>
                      <value>com.ctb.aop.biz.IBookBiz</value>
                  </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
            </list>
        </property>
    </bean>

测试结果

后置通知（After returning advice）：

@After-returning

在某连接点正常完成后执行的通知，例如，一个方法么有抛出任何异常，正常返回。

实现后置通知接口

package com.ctb.aop.advice;
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
 * 买书返利
 * @author biao
 *
 */
public class MyAfterReturningAdvice implements AfterReturningAdvice {
  @Override
  public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
    String target = arg3.getClass().getName();
    String methodName = arg1.getName();
    String args = Arrays.toString(arg2);
    System.out.println("【后置通知：买书返利】："+target+"."+methodName+"("+args+")被调用了，"+"该方法被调用后的返回值为："+arg0);
  }
}

spring_context.xml

    <!--目标对象-->
    <bean class="com.ctb.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.ctb.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyAfterReturningAdvice" id="afterReturningAdvice"></bean>
    <!-- 代理   -->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
        <!--配置目标对象-->
    <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口，目标对象的接口          
        -->
        <property name="proxyInterfaces">
                  <list>
                      <value>com.ctb.aop.biz.IBookBiz</value>
                  </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
                <value>afterReturningAdvice</value>
            </list>
        </property>
    </bean>

测试结果

环绕通知（Around advice）：

@Around

包围一个连接点的通知，如方法调用，这是最强大的一种通知类型。

实现环绕通知接口

package com.ctb.aop.advice;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import java.util.Arrays;
/**
 * 环绕通知
 *  包含了前置和后置通知
 * 
 * @author biao
 *
 */
public class MyMethodInterceptor implements MethodInterceptor {
  @Override
  public Object invoke(MethodInvocation arg0) throws Throwable {
    String target = arg0.getThis().getClass().getName();
    String methodName = arg0.getMethod().getName();
    String args = Arrays.toString(arg0.getArguments());
    System.out.println("【环绕通知调用前：】："+target+"."+methodName+"("+args+")被调用了");
//    arg0.proceed()就是目标对象的方法
    Object proceed = arg0.proceed();
    System.out.println("【环绕通知调用后：】：该方法被调用后的返回值为："+proceed);
    return proceed;
  }
}

spring_context.xml

    <!--目标对象-->
    <bean class="com.ctb.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.ctb.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyAfterReturningAdvice" id="afterReturningAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyMethodInterceptor" id="methodInterceptor"></bean>
    <!-- 代理   -->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
        <!--配置目标对象-->
    <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口，目标对象的接口          动态代理中的jdk代理与cglib代理有什么区别,代理模式，是什么样的，什么是动态代理，什么是静态代理
                                                 在编码中是怎么用到cglib代理和jdk代理的，在什么场景下用的
        -->
        <property name="proxyInterfaces">
                  <list>
                      <value>com.ctb.aop.biz.IBookBiz</value>
                  </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
                <value>afterReturningAdvice</value>
                <value>methodInterceptor</value>
            </list>
        </property>
    </bean>

测试结果

异常通知（After throwing advice）：

@After-throwing

在方法抛出异常退出时执行的通知。

实现异常通知接口

package com.ctb.aop.advice;
import org.springframework.aop.ThrowsAdvice;
import com.ctb.aop.exception.PriceException;
/**
 * 出现异常执行系统提示，然后进行处理。价格异常为例
 * @author biao
 *
 */
public class MyThrowsAdvice implements ThrowsAdvice {
  public void afterThrowing(PriceException ex) {
    System.out.println("【异常通知】：当价格发生异常，那么执行此处代码块！！！");
  }
}

spring_context.xml

    <!--目标对象-->
    <bean class="com.ctb.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.ctb.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyAfterReturningAdvice" id="afterReturningAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyMethodInterceptor" id="methodInterceptor"></bean>
    <bean class="com.ctb.aop.advice.MyThrowsAdvice" id="myThrowsAdvice"></bean>
    <!-- 代理   -->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
        <!--配置目标对象-->
    <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口，目标对象的接口          动态代理中的jdk代理与cglib代理有什么区别,代理模式，是什么样的，什么是动态代理，什么是静态代理
                                                 在编码中是怎么用到cglib代理和jdk代理的，在什么场景下用的
        -->
        <property name="proxyInterfaces">
                  <list>
                      <value>com.ctb.aop.biz.IBookBiz</value>
                  </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
                <value>afterReturningAdvice</value>
                <value>methodInterceptor</value>
                <value>myThrowsAdvice</value>
            </list>
        </property>
    </bean>

我们将测试类中的价格改成负数，进行异常测试

测试结果

过滤通知（Filtering Notifications advice）：

@Filtering Notifications

根据一定的条件对通知进行筛选和过滤，只选择符合条件的通知进行处理或显示。

spring_context.xml

 <!--目标对象-->
    <bean class="com.ctb.aop.biz.impl.BookBizImpl" id="bookBiz"></bean>
    <!--通知-->
    <bean class="com.ctb.aop.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyAfterReturningAdvice" id="afterReturningAdvice"></bean>
    <bean class="com.ctb.aop.advice.MyMethodInterceptor" id="methodInterceptor"></bean>
    <bean class="com.ctb.aop.advice.MyThrowsAdvice" id="myThrowsAdvice"></bean>
    <bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="regexpMethodPointcutAdvisor">
        <property name="advice" ref="afterReturningAdvice"></property>
        <property name="pattern" value=".*buy"></property>
    </bean>
    <!-- 代理   -->
    <bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookProxy">
        <!--配置目标对象-->
    <property name="target" ref="bookBiz"></property>
        <!--配置代理的接口，目标对象的接口         
        -->
        <property name="proxyInterfaces">
                  <list>
                      <value>com.ctb.aop.biz.IBookBiz</value>
                  </list>
        </property>
        <!--配置通知-->
        <property name="interceptorNames">
            <list>
                <value>methodBeforeAdvice</value>
<!--                <value>afterReturningAdvice</value>-->
                <value>regexpMethodPointcutAdvisor</value>
                <value>methodInterceptor</value>
                <value>myThrowsAdvice</value>
            </list>
        </property>
    </bean>

在过滤通知中，我们可以在过滤通知配置中设置一些正则表达式，

减少不必要的干扰，提高工作效率，同时确保不会错过重要的通知。

测试结果

spring aop底层原理到这就结束啦，希望各位大佬能一键三连哦！！

Spring AOP的实现原理

前言

一、Spring的aop的概念

AOP是什么

横切关注点

AOP的特点

AOP带来的好处

二、AOP的实现原理

1、基于代理的实现

2、切点

3、切面

4、通知

5、织入

三、Spring AOP concepts（AOP术语）

【术语】：

适配器

四、常用通知

前置通知（Before advice）：

后置通知（After returning advice）：

环绕通知（Around advice）：

异常通知（After throwing advice）：

过滤通知（Filtering Notifications advice）：

热门文章

最新文章

相关课程

相关电子书

相关实验场景