Spring AOP的实现原理

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: Spring AOP的实现原理

前言

一、Spring的aop的概念

AOP是什么

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

横切关注点

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

AOP的特点

  1. 横向切面:AOP 的主要目的是解决横向切面的问题,即对多个对象的同种操作进行统一的处理,比如日志记录、性能统计、事务处理等。
  2. 切面集中处理:AOP 将切面的逻辑从业务逻辑中分离出来,实现了切面的集中处理。这样可以更好地实现代码的模块化和重用。
  3. 低侵入性:AOP 对原有业务逻辑的侵入性较小,只需要在切面中进行逻辑编写,不需要对原有类进行大量修改,提高了代码的可维护性和可扩展性。
  4. 动态代理:AOP 通过动态代理实现了切面的实现,在运行期间动态生成代理对象,实现了透明化的切面处理。
  5. 面向接口编程:AOP 一般采用面向接口编程的方式,使应用与具体实现相分离,提高了系统的可扩展性和可维护性。
  6. 与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)是一种结构型设计模式,用于将两个不兼容的接口协同工作。适配器模式的核心思想是解决新旧接口之间的兼容性问题,让不同接口之间能够无缝衔接。

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

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

  1. 目标接口(Target):定义客户端使用的与特定领域相关的接口,客户端只能看到这个接口而不知道具体实现。
  2. 源接口(Adaptee):需要被适配的接口,即客户端需要调用的接口,但由于与客户端的接口不兼容而无法直接使用。
  3. 适配器(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底层原理到这就结束啦,希望各位大佬能一键三连哦!!


相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
相关文章
|
2月前
|
安全 Java 数据库
一天十道Java面试题----第四天(线程池复用的原理------>spring事务的实现方式原理以及隔离级别)
这篇文章是关于Java面试题的笔记,涵盖了线程池复用原理、Spring框架基础、AOP和IOC概念、Bean生命周期和作用域、单例Bean的线程安全性、Spring中使用的设计模式、以及Spring事务的实现方式和隔离级别等知识点。
|
2月前
|
Java
Spring5入门到实战------9、AOP基本概念、底层原理、JDK动态代理实现
这篇文章是Spring5框架的实战教程,深入讲解了AOP的基本概念、如何利用动态代理实现AOP,特别是通过JDK动态代理机制在不修改源代码的情况下为业务逻辑添加新功能,降低代码耦合度,并通过具体代码示例演示了JDK动态代理的实现过程。
Spring5入门到实战------9、AOP基本概念、底层原理、JDK动态代理实现
|
11天前
|
设计模式 Java 测试技术
spring复习04,静态代理动态代理,AOP
这篇文章讲解了Java代理模式的相关知识,包括静态代理和动态代理(JDK动态代理和CGLIB),以及AOP(面向切面编程)的概念和在Spring框架中的应用。文章还提供了详细的示例代码,演示了如何使用Spring AOP进行方法增强和代理对象的创建。
spring复习04,静态代理动态代理,AOP
|
2天前
|
Java Spring 容器
Spring IOC、AOP与事务管理底层原理及源码解析
Spring框架以其强大的控制反转(IOC)和面向切面编程(AOP)功能,成为Java企业级开发中的首选框架。本文将深入探讨Spring IOC和AOP的底层原理,并通过源码解析来揭示其实现机制。同时,我们还将探讨Spring事务管理的核心原理,并给出相应的源码示例。
23 9
|
12天前
|
XML Java 开发者
经典面试---spring IOC容器的核心实现原理
作为一名拥有十年研发经验的工程师,对Spring框架尤其是其IOC(Inversion of Control,控制反转)容器的核心实现原理有着深入的理解。
35 3
|
25天前
|
Java 数据库连接 数据库
Spring基础3——AOP,事务管理
AOP简介、入门案例、工作流程、切入点表达式、环绕通知、通知获取参数或返回值或异常、事务管理
Spring基础3——AOP,事务管理
|
2月前
|
XML Java 数据格式
Spring5入门到实战------11、使用XML方式实现AOP切面编程。具体代码+讲解
这篇文章是Spring5框架的AOP切面编程教程,通过XML配置方式,详细讲解了如何创建被增强类和增强类,如何在Spring配置文件中定义切入点和切面,以及如何将增强逻辑应用到具体方法上。文章通过具体的代码示例和测试结果,展示了使用XML配置实现AOP的过程,并强调了虽然注解开发更为便捷,但掌握XML配置也是非常重要的。
Spring5入门到实战------11、使用XML方式实现AOP切面编程。具体代码+讲解
|
2月前
|
XML Java 数据格式
Spring5入门到实战------2、IOC容器底层原理
这篇文章深入探讨了Spring5框架中的IOC容器,包括IOC的概念、底层原理、以及BeanFactory接口和ApplicationContext接口的介绍。文章通过图解和实例代码,解释了IOC如何通过工厂模式和反射机制实现对象的创建和管理,以及如何降低代码耦合度,提高开发效率。
Spring5入门到实战------2、IOC容器底层原理
|
2月前
|
Java 程序员 数据库连接
女朋友不懂Spring事务原理,今天给她讲清楚了!
该文章讲述了如何解释Spring事务管理的基本原理,特别是针对女朋友在面试中遇到的问题。文章首先通过一个简单的例子引入了传统事务处理的方式,然后详细讨论了Spring事务管理的实现机制。
女朋友不懂Spring事务原理,今天给她讲清楚了!
|
2月前
|
缓存 Java 开发者
Spring高手之路22——AOP切面类的封装与解析
本篇文章深入解析了Spring AOP的工作机制,包括Advisor和TargetSource的构建与作用。通过详尽的源码分析和实际案例,帮助开发者全面理解AOP的核心技术,提升在实际项目中的应用能力。
24 0
Spring高手之路22——AOP切面类的封装与解析
下一篇
无影云桌面