Spring-Aop详解（环境+配置+实现+运行结果）

已于 2024-09-11 13:44:06 修改
阅读量812 收藏 14
点赞数 13
分类专栏： spring 文章标签： spring java mysql 单元测试 后端 junit idea
于 2024-09-11 00:45:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76862031/article/details/142105891
版权

Spring-Aop

Aop概念

        pring AOP（面向切面编程）是Spring框架的一个重要组成部分，它提供了在应用的多个模块中复用某些行为的能力。AOP允许开发者定义“切面”，这些切面可以封装横切关注点，如事务管理、日志记录、安全检查等，这些关注点通常分散在应用程序的多个部分。通过使用AOP，开发人员可以在不修改对象本身的代码的情况下，将这些关注点添加到应用程序中。

Spring AOP的基本组成部分

1.切面（Aspect）：

        切面是横切关注点的模块化。一个切面封装了许多关注点，比如日志记录、事务管理等。一个切面包含了一系列的通知（Advice），这些通知会在特定的连接点（Joinpoint）被激活。

2.通知（Advice）：

        这是在特定连接点上采取的动作。Spring支持多种类型的通知，包括但不限于：

  • @Before：在方法执行前执行。
  • @After：无论方法是否成功执行都会被执行。
  • @AfterReturning：如果方法成功执行，则会被执行。
  • @AfterThrowing：如果方法抛出了异常，则会被执行。
  • @Around：环绕通知，可以控制方法的执行流程。

3.连接点（Joinpoint）：

        应用程序执行过程中的某个特定点，例如方法执行、字段访问等。

4.切入点（Pointcut）：

        一个或多个连接点的集合。它是通知将要被应用的地方的定义。可以通过表达式来指定切入点，比如execution(* com.example.service.*.*(..))。

5.目标对象（Target Object）：

        被一个或多个切面所通知的对象。

6.代理（Proxy）：

        被织入了通知的对象。客户端代码与代理交互，而不是直接与目标对象交互。

7.织入（Weaving）：

        将切面连接到其他应用程序类型或对象上的过程。织入可以在编译时、加载时或运行时进行。

环境准备

新建module:

  1. 填写Name
  2. 选择语言
  3. 选择build工具Maven
  4. ,选择jdk
  5. 填写GroupdId
  6. 填写ArtifactId
  7. 点击create

注:项目创建完毕后不要忘记刷新maven,否则依赖不会导入

导入依赖

        在项目的pom文件中导入以下依赖

<dependencies>
    <!--导入spring-context依赖-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.1.12</version>

    </dependency>
    <!--导入测试依赖-->
    
    <!--spring对junit-->
    <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>6.1.12</version>
    </dependency>

    <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.11.0</version>
            <scope>test</scope>
    </dependency>
    <!--aop相关的jar包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>6.1.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>6.1.12</version>
    </dependency>
</dependencies>

新建springConfig.xml文件

        下面是springConfig.xml文件中的内容

<?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
">
    <!--配置包扫描-->
    <context:component-scan base-package="org.xiji"/>


</beans>

实体准备

package org.xiji;

import org.springframework.stereotype.Component;

/**
 * 计算类
 */
@Component
public class Calculation {

    /**
     * 相加
     */
    public int add(int a, int b)
    {
        return a + b;
    }


    /**
     * 相减
     */
    public int sub(int a, int b)
    {
        return a - b;
    }

    /**
     * 相乘
     */
    public int mul(int a, int b)
    {
        return a * b;
    }

    /**
     * 相除
     */
    public int div(int a, int b)
    {
        return a / b;
    }
}
 

编写springConfig.xml文件

文件内容如下：

<?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
">
    <!--配置包扫描-->
    <context:component-scan base-package="org.xiji"/>

    <aop:aspectj-autoproxy />

</beans>

注:需要开启包扫描和aop自动代理

Spring测试类配置

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
import org.xiji.Calculation;

/**
 *
 * JUNIT5第一种
 * @ExtendWith(SpringExtension.class)
 * @ContextConfiguration(locations = {"classpath:/SpringConfig.xml"})
 *
 *
 * JUNIT5第二种
 * @SpringJUnitConfig(locations = {"classpath:/SpringConfig.xml"})
 */
//@ExtendWith(SpringExtension.class)
//@ContextConfiguration(locations = {"classpath:/SpringConfig.xml"})

@SpringJUnitConfig(locations = {"classpath:/springConfig.xml"})
public class SpringTestJunit5 {

    @Autowired
    private Calculation calculation;

    @Test
    public void test()
    {
        System.out.println(calculation.add(1, 2));


    }
}

切点配置类

切点表达式

        "execution(权限修饰符 包名.类名.方法名(参数)) "

                * 代表任意一个

                .. 代表任意参数

前置通知

/**
 * 方法执行前执行的代码
 */
@Before("execution(* org.xiji.Calculation.*(..))")
public void before(JoinPoint joinPoint)
{
    /**
     * 遍历输出参数
     */
    System.out.println("==========================");
    Object[] args = joinPoint.getArgs();
    for (Object arg : args) {
        System.out.println(arg);
    }
    System.out.println(joinPoint.getSignature().getName());
    System.out.println(joinPoint.getTarget());
    System.out.println("Aop前置处理器");
    System.out.println("before");
    System.out.println("==========================");
}

后置通知

/**
 * 后置方法,无论方法执行是否成功都会返回
 */
@After("execution(* org.xiji.Calculation.*(..))")
public void after(JoinPoint joinPoint)
{
    System.out.println("==========================");
    System.out.println(joinPoint.getTarget());
    System.out.println("Aop后置处理器");
    System.out.println("after");
    System.out.println("==========================");
}

返回通知

注:returning 的名字，与参数中接受返回结果的值是一致的

/**
 *
 * 返回处理器
 */
@AfterReturning(pointcut = "execution(* org.xiji.Calculation.*(..))",returning = "returning")
public void afterReturning(JoinPoint joinPoint,Object returning)
{
    System.out.println("==========================");
    System.out.println(returning.toString());
    System.out.println(joinPoint.getTarget());
    System.out.println("Aop返回处理器");
    System.out.println("afterReturning");
    System.out.println("==========================");
}

异常通知

注：throwing 定义的参数是throwable 那么在接受参数时的名字也是 throwable

/**
 * 异常处理器
 */
@AfterThrowing(pointcut = "execution(* org.xiji.Calculation.*(..))",throwing = "throwable")
public void afterThrowing(JoinPoint joinPoint,Throwable throwable)
{
    System.out.println("==========================");
    System.out.println(throwable.getMessage());
    System.out.println(joinPoint.getTarget());
    System.out.println("Aop异常处理器");
    System.out.println("afterThrowing");
    System.out.println("==========================");
}

定义切点

/**
 * 定义切点
 */
@Pointcut("execution(* org.xiji.Calculation.*(..))")
public void pointCut()
{

}

注：使用切点时直接 输入pointCut() 即可

环绕通知

/**
 * 环绕通知
 */
@Around("pointCut()")
public Object around(ProceedingJoinPoint joinPoint)
{
    Object result = null;
    try {
        System.out.println("环绕通知前");
        result = joinPoint.proceed();
        System.out.println("result = " + result);
        System.out.println("环绕通知后");
    } catch (Throwable throwable) {
        System.out.println("环绕通知异常");
        throwable.printStackTrace();
    }finally {
            System.out.println("无论结果好坏必然运行");
    }
    return result;
}

完整的Point类

package org.xiji;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;


@Component
@Aspect
public class PointCutAop {

    /**
     * 方法执行前执行的代码
     */
    @Before("execution(* org.xiji.Calculation.*(..))")
    public void before(JoinPoint joinPoint)
    {
        /**
         * 遍历输出参数
         */
        System.out.println("==========================");
        Object[] args = joinPoint.getArgs();
        for (Object arg : args) {
            System.out.println(arg);
        }
        System.out.println(joinPoint.getSignature().getName());
        System.out.println(joinPoint.getTarget());
        System.out.println("Aop前置处理器");
        System.out.println("before");
        System.out.println("==========================");
    }

    /**
     * 后置方法,无论方法执行是否成功都会返回
     */
    @After("execution(* org.xiji.Calculation.*(..))")
    public void after(JoinPoint joinPoint)
    {
        System.out.println("==========================");
        System.out.println(joinPoint.getTarget());
        System.out.println("Aop后置处理器");
        System.out.println("after");
        System.out.println("==========================");
    }

    /**
     *
     * 返回处理器
     */
    @AfterReturning(pointcut = "execution(* org.xiji.Calculation.*(..))",returning = "returning")
    public void afterReturning(JoinPoint joinPoint,Object returning)
    {
        System.out.println("==========================");
        System.out.println(returning.toString());
        System.out.println(joinPoint.getTarget());
        System.out.println("Aop返回处理器");
        System.out.println("afterReturning");
        System.out.println("==========================");
    }

    /**
     * 异常处理器
     */
    @AfterThrowing(pointcut = "execution(* org.xiji.Calculation.*(..))",throwing = "throwable")
    public void afterThrowing(JoinPoint joinPoint,Throwable throwable)
    {
        System.out.println("==========================");
        System.out.println(throwable.getMessage());
        System.out.println(joinPoint.getTarget());
        System.out.println("Aop异常处理器");
        System.out.println("afterThrowing");
        System.out.println("==========================");
    }


    /**
     * 定义切点
     */
    @Pointcut("execution(* org.xiji.Calculation.*(..))")
    public void pointCut()
    {

    }


    /**
     * 环绕通知
     */
    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint)
    {
        Object result = null;
        try {
            System.out.println("环绕通知前");
            result = joinPoint.proceed();
            System.out.println("result = " + result);
            System.out.println("环绕通知后");
        } catch (Throwable throwable) {
            System.out.println("环绕通知异常");
            throwable.printStackTrace();
        }finally {
            System.out.println("无论结果好坏必然运行");
        }
        return result;
    }
}

xml自定义AOP

xml文件中的内容

注：开启包扫描，注入切点，配置aop，配置前置方法，或其他的等等

        并且注入的切面类不需要加上@Aspect 和 @Before注解,需要加入@Component

<?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
">
    <!--配置包扫描-->
    <context:component-scan base-package="org.xiji"/>

    <aop:config>
        <aop:aspect ref="pointCutAop" >
            <!--配置前置-->
            <aop:before method="before" pointcut="execution(* org.xiji.Calculation.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>

    <!--导入aop切点-->
    <bean id="pointCutAop" class="org.xiji.PointCutAop">

    </bean>

</beans>

惜.己
关注
专栏目录
template-spring-mybatis:spring+mybatis 模板项目
06-02
Spring作为一款全面的后端应用框架，可以管理依赖、处理事务、实现AOP（面向切面编程）等，而MyBatis则是一个轻量级的持久层框架，专注于SQL映射和数据库操作，两者结合可以简化开发流程，提高开发效率。 【Spring...
SpringAOP+RabbitMQ+WebSocket实战详解
08-26
本文将详细介绍 SpringAOP、RabbitMQ 和 WebSocket 的实战详解，包括 SpringAOP 的基本概念、RabbitMQ 的结构和 WebSocket 的工作原理。 SpringAOP SpringAOP 是一个面向切面编程的框架，主要用来解决系统层面的...
Spring-AOP详解
qq_42861526的博客
10-27 1346
一、Spring-AOP的作用 在实际开发中，我们往往会遇到对已有功能做扩展的情况，我们需要在不对源码进行修改的情况下扩展功能，在没有spring-aop的情况下我们应该这么做： 情景1：我们现在要对AServiceImpl(实现了AService接口)中的login方法进行扩展，这种情形我们可以使用代理模式来做，过程如下：创建一个BServiceImpl类并实现AService接口，并重现doLogin方法。 class BServiceImpl implements AService{ private
JavaSpring-AOP详解（Maven导入 深入浅出）
Garson的博客
10-07 2987
在CSDN上看了很多关于配置AOP的文章，不是很复杂就是省略了很多步骤。本文用最简单并且最清晰的方法从导入依赖到AOP底层原理。逐步讲解SpringAOP的相关操作帮你快速了解AOP。
Spring AOP详解
这河里吗l的博客
06-17 1230
AOP(Aspect-Oriented Programming)面向切面编程，作为面向对象的一种补充，将公共逻辑（事务管理、日志、缓存等）封装成切面，跟业务代码进行分离，可以减少系统的重复代码和降低模块之间的耦合度，并有利于未来的可拓展性和可维护性。
细说Spring——AOP详解（AOP概览）
热门推荐
啦啦啦的博客
05-30 53万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
Spring-AOP详解及其使用
qq_43828345的博客
11-06 1253
Spring-AOP 1、AOP 基本概念 （1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得 业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。​ （2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能​ （3）使用登录例子说明 2、AOP（底层原理） ​ a）AOP 底层使用动态代理 ，动态代理有两种情况： 第一种 有接口情况，使用 JDK 动态代理 ；创建接口实现类代理对象，增强类的方法 第二种 没有接口情况，使用 CGLIB 动态
Spring Boot AOP 详解
学习编程的小羊的博客
06-07 1366
AOP 通过在程序执行过程中，将关注点（如日志记录、安全检查等）从业务逻辑中分离出来，使代码更加清晰和易于维护。切面（Aspect）：关注点模块化的方式。切面是横切关注点的具体实现，比如日志记录切面。连接点（Join Point）：程序执行过程中的一个点，例如方法调用或异常抛出。Spring AOP 只支持方法级别的连接点。通知（Advice）：在特定的连接点上执行的代码。通知有多种类型，如前置通知、后置通知、环绕通知等。切入点（Pointcut）：定义了在哪些连接点上执行通知。
Spring-AOP的实现详解(一)
qq_41359998的博客
02-23 672
Spring-AOP的实现详解(一) 一、什么是AOP AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 二、Aop在Spring中的作用 提供声明式事务；允许用户自定义
Spring-AOP切入点表达式详解
m0_61961937的博客
06-17 2900
Spring-AOP切入点表达式格式、通配符及书写技巧
Spring进阶 - Spring AOP实现原理详解之AOP切面的实现
qq_63353796的博客
06-17 1136
前文，我们分析了Spring IOC的初始化过程和Bean的生命周期等，而Spring AOP也是基于IOC的Bean加载来实现的。本文主要介绍Spring AOP原理解析的切面实现过程（将切面类的所有切面方法根据使用的注解生成对应Advice，并将Advice连同切入点匹配器和切面类等信息一并封装到Advisor，为后续交给代理增强实现做准备的过程）
SpringAOP详解--配置文件配置--注解配置
it白白的博客
01-25 1225
FBB经纪人打开了话筒 FBB在唱歌！！1
SpringMVC精品资源--Maven + Mysql + Shiro + SpringMVC + Spring.zip
02-18
【SpringMVC精品资源——Maven、Mysql、Shiro、SpringMVC与Spring整合详解】 在当前的Java Web开发领域，SpringMVC框架因其强大的功能和灵活性而被广泛使用。这个压缩包“SpringMVC精品资源--Maven + Mysql + Shiro...
管理系统系列--基于Spring MVC+MyBatis+Shiro+Dubbo开发的分布式后台管理系统.zip
02-26
《基于Spring MVC+MyBatis+Shiro+Dubbo的分布式后台管理系统详解》 在现代企业级应用开发中，构建高效、稳定且可扩展的后台管理系统是至关重要的。本系统采用了业界广泛使用的四大核心技术——Spring MVC、MyBatis...
spring-aop底层1
08-03
【Spring-AOP底层详解】 Spring AOP，即Spring的面向切面编程，是Spring框架中的一个重要组成部分，它提供了一种在运行时动态插入代码的能力，主要用于处理横切关注点，如日志记录、事务管理、权限校验等，从而降低...
spring揭秘19-spring事务01-事务抽象
PacosonSWJTU的博客
09-08 1314
1）spring对事务元素进行抽象， 客户端仅按照统一的编程模型管理事务，而不用关心数据访问技术以及具体要访问什么类型的事务资源；此外：spring事务管理与spring提供的数据访问技术（如JdbcTemplate）进行结合；2）spring事务框架设计的基本原则： 让事务管理逻辑与数据访问逻辑解耦；spring揭秘15-spring集成数据访问技术(orm框架)总结事务隔离级别；isolation；事务传播行为；事务超时时间；timeout；是否为只读事务；readOnly；
Spring05——注解开发定义bean、Spring纯注解开发模式
最新发布
后端小白个人学习记录
09-08 911
注解开发定义bean、Spring纯注解开发模式
SpringMVC启动与请求处理流程解析
业精于勤荒于嬉，行成于思毁于随
09-06 1454
实现了Controller接口的Bean对象实现了HttpRequestHandler接口的Bean对象添加了@RequestMapping注解的方法一个HandlerFunction对象@Override@Override@Component@Autowired@Bean.build();HandlerMapping负责去寻找Handler，并且保存路径和Handler之间的映射关系。
SpringSecurity原理解析（二）：认证流程
liang8999的博客
09-08 1079
attemptAuthentication 方法在子类UsernamePasswordAuthenticationFilter 中实现的。attemptAuthentication方法的作用是获取Authentication对象其实就是对应的认证过程，用该AuthenticationProvider的authenticate函数认证，如果认证成功则整个认证过程结束。AuthenticationManager接口中就定义了一个方法authenticate方法，用于处理认证的请求；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值