【Spring框架】SpringAOP

发布于：2025-08-16 ⋅ 阅读:(12) ⋅ 点赞:(0)

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程。 AOP是一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构。AOP最早由AOP联盟的组织提出，制定了一套规范，而Spring将AOP思想引入到框架中,必须遵守AOP联盟的规范，是通过预编译方式或者运行期动态代理实现程序功能的统一维护的一种技术。

AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（事务管理、安全检查、缓存），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

而我们学习AOP，就是为了在不修改源代码的前提下，对程序进行增强。

SpringAOP

为了更好的了解AOP，我们先来看一个例子。

如上图所示这是一个基本的登录原理图，登录的原理：用户输入用户名和密码，后台数据库进行查询并判断是否正确，如果正确则跳转进主页面，错误则依旧停留在登录界面。

如果我们想要在这个登录之上添加一些新的功能，比如权限校验，那么我们能想到的就有两种方法：

①：通过对源代码的修改实现（破坏了封闭性原则）

②：不通过修改源代码方式添加新的功能 （AOP），将权限验证模块注入到判断成功之后

这就是AOP所起到的作用，我们来了解一下SpringAOP的主要术语：

  1. 连接点（JoinPoint）：类里面有哪些方法可以增强，这些方法称为连接点
  2. 切入点（Pointcut）：实际被增强的方法就是切入点
  3. 通知/增强（Advice）：实质增强的逻辑部分称为通知，比如我们上面登录逻辑中的权限判断就是通知。通知分为前置通知,后置通知,异常通知,最终通知,环绕通知
  4. 切面（Aspect）：是一个动作，将通知应用到切入点的过程

下面我们来具体使用一下SpringAOP技术

AOP配置文件方式

AspectJ 是 AOP 思想的具体实现者，是一个面向切面的框架，它扩展了Java语言，且是目前最完善、最流行的 AOP 框架之一。AspectJ定义了AOP语法，AspectJ实际上是对AOP编程思想的一个实践。
Spring AOP 虽然是另一种 AOP 实现，但它借鉴了 AspectJ 的核心概念和注解（如@Aspect、@Before等），不过实现机制与 AspectJ 不同（Spring AOP 基于动态代理，而 AspectJ 基于字节码操作）。可以说，AspectJ 为 AOP 思想的落地提供了成熟的技术方案，是 AOP 领域的事实标准之一。

首先我们创建maven项目，引入坐标依赖。每个dependency标签都定义了一个需要引入的 jar 包，包含三个核心属性：groupId（组织 / 公司标识）、artifactId（库名称）、version（版本号）。

spring-context是Spring框架的核心上下文依赖，Spring 应用的基础，几乎所有 Spring 项目都需要引入；log4j 与 commons-logging 配合使用，commons-logging 定义日志接口，log4j提供具体实现；spring-test 是Spring 提供的测试支持库；junit 是Java 领域最常用的单元测试框架；aopalliance是 AOP 联盟定义的 AOP 规范接口，是 Spring AOP 实现的基础规范；spring-aspects 是 Spring 框架的 AOP 模块实现，提供基于注解的 AOP 功能；aspectjweaver 是 AspectJ 框架的织入器Weaver，负责将切面代码织入到目标对象中，Spring AOP 借鉴了 AspectJ 的切入点表达式语法，需要 aspectjweaver 来解析这些表达式。

<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>

创建被增强的类Login，里面的login方法就是切入点

public class Login {
    public void login(String username,String password){
        System.out.println("登录...");
    }
}

定义切面类QX

public class QX {
    public void 验证(){
        System.out.println("进行权限验证...");
    }
}

创建Spring.xml配置文件，定义了被增强的类和切面类，完成AOP配置：

<aop:config> 为AOP 配置的根标签，所有 AOP 相关配置都需要放在这个标签内。

<aop:aspect ref="qx"> 定义一个切面，ref=“qx” 表示引用上面定义的 qx Bean 作为切面的实现类

<aop:after>表示最终通知，目标方法执行成功或者失败，都会进行增强。

method 表示当切点匹配的方法执行时调用切面类中的增强方法，也就是通知

pointcut 为切入点，用来精准匹配程序中需要被切面增强的方法，通过切入点表达式来定义匹配规则，最常用的是 execution() 表达式，语法如下：

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

其中：修饰符可以省略不写，不是必须要出现的。

返回值类型不能省略不写的，根据你的方法来编写返回值，可以使用 * 代替。

包名，类名，方法名，参数的规则如下：

首先包名，类名，方法名是不能省略不写的，但是可以使用 * 代替

中间的包名可以使用 * 号代替，类名也可以使用 * 号代替，方法也可以使用 * 号代替

参数如果是一个参数可以使用 * 号代替，如果想代表任意参数使用 . .

    <bean id="login" class="com.qcby.Login"/>
    <bean id="qx" class="com.qcby.QX"/>

    <aop:config>
        <aop:aspect ref="qx">
			<aop:after method="验证" pointcut="execution(* com.qcby.Login.login(..))"/>
        </aop:aspect>
    </aop:config>

执行结果如下：

通知的类型

前面我们用到了最终通知作为展示，现在来说一下不同通知的表现形式：

  1. <aop:before> 前置通知，方法执行之前进行通知，方法执行失败也会通知
  2. <aop:after> 最终通知，方法执行之后进行通知，只要目标方法被调用，无论方法执行是否成功都会执行都会通知
  3. <aop:after-returning> 后置通知，方法成功执行之后执行通知，仅在目标方法成功执行后通知，如果目标方法抛出异常，则不会触发该通知
  4. <aop:after-throwing> 异常通知，只有在方法执行异常的时候才会执行通知
  5. <aop:around> 环绕通知，在方法执行之前和执行之后都会执行，如果方法执行出错则只会出现执行之前的通知。通知方法必须接收ProceedingJoinPoint参数并调用proceed()

除了环绕通知，其他通知方法只需将上面最终通知的标签改为自己的标签，环绕通知还需要单独定义下面的通知方法：

package com.qcby;
import org.aspectj.lang.ProceedingJoinPoint;

public class QX {
    // 环绕通知
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("before.............");
        //  执行被增强的方法
        proceedingJoinPoint.proceed();

        System.out.println("after.............");
    }
}

AOP技术-注解方式

首先我们需要更改Spring.xml配置文件，其中：

<context:component-scan base-package="com.qcby"/>：Spring 会扫描com.qcby包及其子包中所有带有@Component（以及衍生注解@Service、@Controller、@Repository）的类，自动将它们注册为 Spring 容器中的 Bean，无需再通过bean标签手动配置。

<aop:aspectj-autoproxy/>
开启基于注解的 AOP 支持，允许 Spring 识别@Aspect等 AOP 注解并生成代理对象。当 Spring 检测到某个类被 @Aspect 标记为切面，并且定义了针对其他类的切入点时，它会为被增强的类自动创建一个代理对象。这个代理对象在执行目标方法前后，自动插入切面中定义的增强逻辑。

<!--   注解开发 -->
<!--    通过这种方式能扫描这个包下所有的注解-->
    <context:component-scan base-package="com.qcby"/>

    <!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy/>

需要使用@Aspect注解标识一个类为切面类，并通过@Component将其纳入 Spring 容器管理，@After是最终通知的注解，后面（）内通过切入点表达式标明切入点所在

@Component
@Aspect
public class QX {
    @After("execution(public void com.qcby.Login.login(..))")
    public void 验证(){
        System.out.println("进行权限验证...");
    }
通知类型注解

@Before -- 前置通知  @AfterReturing -- 后置通知

@Around -- 环绕通知（目标对象方法默认不执行的，需要手动执行）

@After -- 最终通知  @AfterThrowing -- 异常抛出通知

切入点所在类也要通过@Component将其纳入 Spring 容器管理

@Component
public class Login {
    public void login(String username,String password){
        System.out.println("登录...");
    }
}

之后也能正常执行

环绕通知的注解方式切面类如下：

@Component
@Aspect
public class QX {
    @Around("execution(* com.qcby.Login.login(..))")
    // 环绕通知
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("before.............");
        //  执行被增强的方法
        proceedingJoinPoint.proceed();

        System.out.println("after.............");
    }
}

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布