Spring AOP

已于 2025-03-22 21:48:35 修改
阅读量1.1k 收藏 15
点赞数 15
文章标签： spring java mysql
于 2025-03-22 21:45:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81096101/article/details/146446714
版权

目录

一、AOP 核心概念解析

1.1 什么是 AOP？

1.2 AOP 的优势

1.3 底层实现原理

二、Spring AOP 配置文件方式实现

2.1 核心术语

2.2 开发步骤

2.3 切入点表达式详解

三、Spring AOP 注解方式实现

3.1 注解开发步骤

3.2 通知类型注解

四、最佳实践建议

五、总结

        在软件开发中，我们经常会遇到需要在不修改源代码的前提下增强方法功能的需求（如日志、事务、权限校验等）。传统面向对象编程（OOP）通过继承或组合实现功能扩展，但面对横切关注点时显得力不从心。面向切面编程（AOP）正是解决这类问题的优雅方案，本文将通过代码示例详解 Spring AOP 的核心概念与实现方式。

一、AOP 核心概念解析

1.1 什么是 AOP？

        AOP（Aspect-Oriented Programming）即面向切面编程，是一种通过预编译或动态代理技术，将横切关注点（如日志、安全校验）与业务逻辑分离的编程范式。

核心思想：

  • 将分散在多个类中的相同逻辑（如事务管理）抽取到切面（Aspect）中
  • 通过切入点（Pointcut）定义需要增强的方法
  • 使用通知（Advice）描述切面逻辑的执行时机

1.2 AOP 的优势

优势项传统 OOP 实现方式AOP 实现方式
代码复用继承/组合（冗余代码）横切关注点统一管理
维护成本修改多处代码修改单一切面
系统扩展性纵向继承体系臃肿横向切面灵活扩展

1.3 底层实现原理

Spring AOP 主要通过两种技术实现动态代理：

JDK 动态代理：

  • 基于接口创建代理对象
  • 要求被代理类必须实现接口

CGLIB 代理：

  • 通过生成子类实现代理
  • 支持无接口类的代理

二、Spring AOP 配置文件方式实现

2.1 核心术语

  • Joinpoint（连接点）：可被增强的方法（如 User.add()）
  • Pointcut（切入点）：定义需要增强的方法集合（通过表达式）
  • Advice（通知）：切面执行的具体逻辑（如前置通知）
  • Aspect（切面）：= 切入点 + 通知

2.2 开发步骤

步骤 1：添加 Maven 依赖
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!--AOP联盟-->
    <dependency>
        <groupId>aopalliance</groupId>
        <artifactId>aopalliance</artifactId>
        <version>1.0</version>
    </dependency>
    <!--Spring Aspects-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <!--aspectj-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.3</version>
    </dependency>
</dependencies>
步骤 2：定义目标类
public class Login {

    public void login(String name,String password){
        //第一种方法：直接在login方法里写
        System.out.println("登陆成功！！！");
    }

    //在登录之前进行权限验证

}
步骤 3：配置切面类
public class Authorization {

    //正常通知
    public void authorization(){
        System.out.println("进行了权限验证！！！");
    }

    //环绕通知
    public void authorization(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("在方法执行之前，进行了权限验证！！！");
        proceedingJoinPoint.proceed();
        System.out.println("在方法执行之后，进行了权限验证！！！");
    }

}
步骤 4：XML 配置 AOP
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="login" class="com.qcby.Login"/>
    <bean id="auth" class="com.qcby.Authorization"/>

    <!--配置切面-->
    <aop:config>
        <!--配置切面 = 切入点 + 通知组成-->
        <aop:aspect ref="auth">
            <!--前置通知：UserServiceImpl的save方法执行前，会增强-->
            <!--pointcut：后边是切入点表达式，作用是知道对对面的那个方法进行增强-->

            <!-- 前置通知 -->
<!--            <aop:before method="authorization" pointcut="execution(public void com.qcby.Login.login(..))"/>-->

            <!-- 最终通知：无论我们的切入点是好是坏（成功执行与否）都会进行通知 -->
<!--            <aop:after method="authorization" pointcut="execution(public void com.qcby.Login.login(..))"/>-->

            <!-- 后置通知：切入点只有执行成功后才会执行 -->
<!--            <aop:after-returning method="authorization" pointcut="execution(public void com.qcby.Login.login(..))"/>-->

            <!-- 异常通知：只有在切入点出现问题的时候才会通知 -->
<!--            <aop:after-throwing method="authorization" pointcut="execution(public void com.qcby.Login.login(..))"/>-->

            <!-- 环绕通知：目标方法执行前后，都可以进行增强。目标对象的方法需要手动执行 -->
            <aop:around method="authorization" pointcut="execution(public void com.qcby.Login.login(..))"/>

        </aop:aspect>
    </aop:config>

</beans>
步骤 5：测试验证
public class LoginTest {

    @Test
    public void test(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("Spring.xml");
        Login login=(Login) ac.getBean("login");
        login.login("张三","11");
    }
}

2.3 切入点表达式详解

表达式格式：

execution([修饰符] 返回值类型 包名.类名.方法名(参数列表))

常用通配符：

  1. *：匹配任意字符（不包括包分隔符）
  2. ..：匹配任意参数或子包

示例：

表达式含义
execution(* com.service.*.*(..))匹配 com.service 包下所有类的所有方法
execution(* com.service.User.add(..))精确匹配 User 类的 add 方法

三、Spring AOP 注解方式实现

3.1 注解开发步骤

步骤 1：启用注解扫描
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--1.配置xml扫描注解-->
    <!--开启注解扫描-->
    <context:component-scan base-package="com.aopImpl"></context:component-scan>
    <!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>
步骤 2：定义切面类，使用注解增强方法
//2.配置注解
@Component
@Aspect //增强类
public class Authorization {

    //环绕通知
    @Around(value = "execution(public void com.qcby.Login.login(..))")
    public void authorization(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("在方法执行之前，进行了权限验证！！！");
        proceedingJoinPoint.proceed();
        System.out.println("在方法执行之后，进行了权限验证！！！");
    }

    //正常通知
//    @Before(value = "execution(public void com.qcby.Login.login(..))") //前置通知
//    @After(value = "execution(public void com.qcby.Login.login(..))") //最终通知
//    @AfterReturning(value = "execution(public void com.qcby.Login.login(..))") //后置通知
//    @AfterThrowing(value = "execution(public void com.qcby.Login.login(..))") //异常通知
    public void authorization(){
        System.out.println("进行了权限验证！！！");
    }


}
步骤 3：测试验证
public class LoginTest {

    @Test
    public void test(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("Spring.xml");
        Login login=(Login) ac.getBean("login");
        login.login("张三","11");
    }
}

3.2 通知类型注解

注解类型执行时机方法签名要求
@Before方法执行前无返回值，参数匹配切入点参数
@AfterReturning方法正常返回后可获取返回值
@AfterThrowing方法抛出异常后必须包含异常参数
@After方法最终执行后（无论成功与否）无特殊要求
@Around包裹方法执行必须包含 ProceedingJoinPoint

四、最佳实践建议

  1. 切入点复用：使用 @Pointcut 定义可复用的切入点表达式
  2. 代理方式选择：优先使用 JDK 动态代理（接口代理）；无接口类时使用 CGLIB 代理
  3. 性能考虑：避免在通知中执行耗时操作
  4. 异常处理：在 @AfterThrowing 中处理特定异常类型

五、总结

Spring AOP 通过声明式编程简化了横切关注点的管理，其核心优势在于：

  • 非侵入式增强：无需修改原有业务代码
  • 关注点分离：将系统级功能（日志、安全）与业务逻辑解耦
  • 灵活配置：支持 XML 和注解两种配置方式
Spring AOP 详解
2301_80035594的博客
10-19 6143
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
Spring AOP实现原理
热门推荐
yanweihpu的博客
05-18 3万+
1、Spring AOPspring的面向切面编程，是面向对象编程的一种补充，用于处理系统中分布的各个模块的横切关注点，比如说事务管理、日志、缓存等。它是使用动态代理实现的，在内存中临时为方法生成一个AOP对象，这个对象包含目标对象的所有方法，在特定的切点做了增强处理，并回调原来的方法。Spring AOP的动态代理主要有两种方式实现，JDK动态代理和cglib动态代理。JDK动态代理通过反射来接...
spring aop实现原理
03-15
NULL 博文链接：https://zhang-yingjie-qq-com.iteye.com/blog/319927
Spring AOP原理及简单应用
dawuafang
08-14 267
相信只要使用过Spring框架的，大家对于AOP都不陌生，尤其提起它就能立刻随口说出，一般用在日志处理、异常处理、权限验证等方面。但刚开始接触难免会有各种各样的疑惑，今天抽时间，按照之前的理解整理了一份关于Spring AOP的简单教程，希望能够帮助大家尽快的了解它的实现过程及原理。首先来明确几个概念： JointPoint 系统在运行之前，AOP的功能模块需要织入到OOP的功能模块中。要进行这...
Spring实现AOP的4种方式
08-27 2511
Spring实现AOP的4种方式
SpringAop
CSDN19970806的博客
07-04 527
先在说一下什么是Aop。我们之前在学filter的时候说过一点，当请求进入到servlet的时候，我们进行设置了字符编码以及跨域问题， 那么我们每个servelt都要去写，很麻烦，所以，我们可以利用aop思想，纵向重复，横行抽取。我们可以在过滤器中配置编码以及解决跨域问题，因为我们设置的过滤器是过滤我们的所有请求。所以在过滤器里面可以设置这些。那么SpringAop也是如此，我们每次在servic...
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
Spring源码最难问题：当Spring AOP遇上循环依赖.docx
06-15
Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...
Spring AOP 实现原理
勇往直前的专栏
08-30 607
静态代理 众所周知 Spring 的 AOP 是基于动态代理实现的，谈到动态代理就不得不提下静态代理。实现如下： 假设有一接口 InterfaceA： public interface InterfaceA{ void exec(); } 其中有实现类 RealImplement: public class RealImplement implement Interface...
Spring中AOP实现
简书的专栏
09-11 4457
1.什么是SpringAOP 什么是aop:Aspect Oriented Programming的缩写，面向切面编程，通过预编译和动态代理实现程序功能的 统一维护的一种技术 主要功能：日志记录，性能统计，安全控制，事务处理，异常处理等 2.SpringAOP框架的用途 提供了声明的企业服务，特别是EJB的替代服务的声明 允许用户控制自己的方面，以完成OOP和AOP的互补使用 O
Java丨Spring：三、Aop（面向切面）
FuroOuO的博客
08-12 182
1、概念 面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 通俗描述：不通过修改源代码方式，在主干功能里面添加新功能 使用登录例子说明AOP 2、底层原理 2.1、有接口情况，使用JDK动态代理 创建接口实现类代理对象，增强类的方法 2.2、没有接口情况，使用CGLIB动态代理 创建子类的代理对象，增强类的方法 3、JDK 动态代理 使用JDK动态代理，使用Proxy类里面的方法创建代理对象 调用
Spring框架系列之第三章 AOP
qq_36595761的博客
09-09 590
AOP前奏 提出问题 情景：数学计算器 1) 要求   ①执行加减乘除运算   ②日志：在程序执行期间追踪正在发生的活动   ③验证：希望计算器只能处理正数的运算 2) 常规实现 3) 问题   ①代码混乱：越来越多的非业务需求(日志和验证等)加入后，原有的业务方法急剧膨胀。每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点。   ②代码分散: 以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里多次重复相同的日志代码。如果日志需求发生变化，必须修改所有模块。 动态代理 动态代理的原
Spring中的AOP
weixin_45037981的博客
03-11 170
AOP相关术语 Joinpoint(连接点) Pointcut(切入点) Advice(通知/增强) Introduction(引入) Target(目标对象) Weaving(织入)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值