aop基础使用测试记录

于 2023-04-07 18:55:23 发布
阅读量444 收藏
点赞数
分类专栏： Spring 文章标签： java spring 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hcwbr123/article/details/129925619
版权

现象：
spring-aop基础使用测试记录

1：切入点表达式

  • execution： 通过指定包路径和方法 可匹配到方法级别
  • within：通过指定类路径 只能匹配类级别不能详细控制方法
  • target：目标对象类为指定的类型被拦截
  • args：匹配方法中的参数
  • @target：匹配调用的目标对象类有一个指定的注解
  • @within：匹配被调用的方法所属的类中是否声明了指定注解
  • @annotation：匹配被调用的方法上有指定的注解
  • @args：匹配被调用的方法参数上有指定的注解

2：五种通知

  • @Before 前置通知：在我们执行目标方法之前运行
  • @After 后置通知：在我们执行目标方法结束之后，不管有没有异常
  • @AfterReturning 返回通知：在我们的目标方法正常返回后运行
  • @AfterThrowing 异常通知：在我们的目标方法出现异常后运行
  • @Around：环绕通知：动态代理，需要手动执行jionPoint.process(）可包含上面四种通知

3：JoinPoint、ProceedingJoinPoint 参数

  • getignature 获取目标方法名、参数、所属class类等信息
    • joinPoint.getSignature().getDeclaringType().getSimpleName() 获取类名
    • joinPoint.getSignature().getName() 获取方法名
  • getArgs() 获取传入方法的参数
  • getTarget() 获取被代理的对象
  • getThis() 获取代理的对象

4：jar包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

方法：

定义RequestController 做为拦截对象
在这里插入图片描述
定义MyTestAop做aop测试
在这里插入图片描述

定义自定义注解MyAnnitation 拥有两个属性 message和order
在这里插入图片描述

一：使用前置通知 测试 execution表达式

1：定义controller test/a方法 返回A
在这里插入图片描述
2：aop定义execution表达式
在这里插入图片描述
代码：

	/**
	 * 定义切入点 : execution表达式
	 * 通过指定包路径和方法 可匹配到方法级别
	 * ..* : 这个包下全部类
	 * .*(..) : 这个类下面全部方法
	 * 可 && || ! 使用
	 */
	@Pointcut("execution(public * com.spring.aop.api..*.*(..))")
	public void pointE(){}

3：定义前置通知测试
在这里插入图片描述代码：

	/**
	 * 前置通知:在我们执行目标方法之前运行
	 * 使用execution表达式
	 */
	@Before(value = "pointE()")
	public void requestBefore(JoinPoint joinPoint){
	    var args = joinPoint.getArgs();
	    var first = Arrays.stream(args).findFirst().orElse("");
	    var json = String.valueOf(first);
	    log.debug("=================前置通知执行中:{}",json);
	}

4：启动项目访问test/a
在这里插入图片描述在这里插入图片描述

二：使用后置通知测试within表达式

1：定义需要拦截的controller方法 test/b

 @PostMapping("/b")
 public String getB(@RequestBody AopTestRequest request){
     log.debug("b请求执行:{}",request);
     return "B";
 }

2：aop定义within表达式

 /**
  * 定义切入点 : within表达式
  * 通过指定类路径  只能匹配类、包等级别不能详细控制方法
  * 指定拦截RequestController类
  */
 @Pointcut("within(com.spring.aop.api.RequestController)")
 public void pointW(){}

3：使用后置通知测试

/**
  * 在我们执行目标方法结束之后，不管有没有异常
  * 后置通知测试within表达式
  */
 @After(value = "pointW()")
 public void requestAfter(JoinPoint joinPoint){
     var args = joinPoint.getArgs();
     var first = Arrays.stream(args).findFirst().orElse("");
     var json = String.valueOf(first);
     log.debug("=================后置通知执行中:{}",json);
 }

4：访问test/b方法测试
在这里插入图片描述

三：使用返回通知测试target表达式

1：定义需要拦截的test/c方法

    @PostMapping("/c")
    public String getC(@RequestBody AopTestRequest request){
        log.debug("c请求执行:{}",request);
        return "C";
    }

2：定义target表达式

    /**
     * 定义切入点 : target表达式
     * 目标对象为指定的类型被拦截
     * 此处拦截RequestController类型的对象
     */
    @Pointcut("target(com.spring.aop.api.RequestController)")
    public void pointT(){}

3：使用返回通知测试

    /**
     * 在我们的目标方法正常返回后运行
     * 返回通知测试target表达式
     */
    @AfterReturning(value ="pointT()" ,returning = "result")
    public void requestAfterReturning(JoinPoint joinPoint, Object result){
        var args = joinPoint.getArgs();
        var first = Arrays.stream(args).findFirst().orElse("");
        var json = String.valueOf(first);
        log.debug("=================返回通知执行中:{}",json);
        log.debug("=================返回通知执行中返回:{}",result);
    }

4：访问test/c测试
在这里插入图片描述

四：使用异常通知测试args表达式

1：定义test/d方法

   @PostMapping("/d")
    public String getD(@RequestBody AopTestRequest request){
        log.debug("d请求执行:{}",request);
        var i = 4 / 0;
        return "D";
    }

2：定义aop args表达式

    /**
     * 定义切入点 : args 表达式
     * 匹配方法中的参数
     *  args(com.spring.aop.api.request.AopTestRequest) 匹配只有一个参数且指定类型
     *  args(com.spring.aop.api.request.AopTestRequest,..) 匹配多个参数第一个指定类型
     *  args(com.spring.aop.api.request.AopTestRequest,com.spring.aop.api.request.AopTestRequest2) 匹配多个参数指定多个类型
     *  within 指定包路径只匹配自己的  防止匹配到其他包里面的final对象 导致无法代理报错
     */
    @Pointcut("args(com.spring.aop.api.request.AopTestRequest) && within(com.spring.aop..*)")
    public void pointA(){}

3：定义异常通知测试

    /**
     * 异常通知:在我们的目标方法出现异常后运行
     */
    @AfterThrowing(value = "pointA()",throwing = "e")
    public void requestAfterThrowing(JoinPoint joinPoint,Exception e){
        var args = joinPoint.getArgs();
        var first = Arrays.stream(args).findFirst().orElse("");
        var json = String.valueOf(first);
        log.debug("=================异常通知执行中:{}",json);
        log.debug("=================异常通知执行中e:{}",e.getMessage());
    }

4：访问test/d方法测试
在这里插入图片描述

五：使用环绕通知测试 @target表达式

1：定义方法test/e

    @PostMapping("/e")
    public String getE(@RequestBody AopTestRequest request){
        log.debug("e请求执行:{}",request);
        return "e";
    }

2：aop定义@target表达式

    /**
     * 定义切入点 : @target表达式
     * 匹配的目标的类有一个指定的注解
     * 这个类全部方法都拦截
     * 此处拦截有自定义注解MyAnnitation的类 
     */
    @Pointcut("@target(com.spring.aop.annotation.MyAnnitation) && within(com.spring.aop..*)")
    public void pointTA(){}

3：在controller 上使用自定义注解MyAnnitation
在这里插入图片描述
4：定义环绕通知测试

    /**
     * 动态代理，需要手动执行jionPoint.process(),其实就是执行我们的目标方法执行之前，相当于前置通知，执行之后就相当于我们的后置通知
     */
    @Around("pointTA()")
    public void requestAround(ProceedingJoinPoint point){
        var methodName = point.getSignature().getName();
        try{
            // 先执行前置通知
            log.debug("=================环绕通知-前置通知:执行中:{}",methodName);

            // 执行目标方法
            var result = point.proceed();

            // 正常返回通知
            log.debug("=================环绕通知-正常返回通知:执行中:{}",result);
        }catch (Throwable e){
            log.debug("=================环绕通知-异常通知执行中:",e);
        }
        // 后置通知
        log.debug("=================环绕通知-后置通知:执行中:{}",methodName);
    }

5：访问test/e方法测试
在这里插入图片描述

六：使用前置通知测试@within表达式

1：定义方法test/f

    @PostMapping("/f")
    public String getF(@RequestBody AopTestRequest2 request){
        log.debug("f请求执行:{}",request);
        return "f";
    }

2：定义aop @within表达式

    /**
     * 定义切入点 : @within表达式
     * 判断被调用的方法所属的类中是否声明了指定注解
     * 此处被调用方法所属的类是RequestController
     */
    @Pointcut("@within(com.spring.aop.annotation.MyAnnitation) && within(com.spring.aop..*)")
    public void pointWI(){}

3:定义前置通知测试

    /**
     * 前置通知:在我们执行目标方法之前运行
     *  测试@within表达式
     */
    @Before(value = "pointWI()")
    public void requestBefore(JoinPoint joinPoint){
        var args = joinPoint.getArgs();
        var first = Arrays.stream(args).findFirst().orElse("");
        var json = String.valueOf(first);
        log.debug("=================前置通知执行中:{}",json);
    }

4：被调用方法所属类 RequestController增加自定义注解
在这里插入图片描述5：访问test/f方法测试
在这里插入图片描述

七：使用前置通知测试@args表达式

1：定义test/g方法 使用AopTestRequest2 入参

    @PostMapping("/g")
    public String getG(@RequestBody AopTestRequest2 request){
        log.debug("g请求执行:{}",request);
        return "g";
    }

2：定义aop表达式

    /**
     * 定义切入点 : @args表达式
     * 方法参数上有指定的注解，被匹配
     * within指定只匹配自己的路径 防止匹配到其他final的对象
     */
    @Pointcut("@args(com.spring.aop.annotation.MyAnnitation) && within(com.spring.aop..*)")
    public void pointAR(){}

3: 使用前置通知测试

    /**
     * 前置通知:在我们执行目标方法之前运行
     */
    @Before(value = "pointAR()")
    public void requestBefore(JoinPoint joinPoint){
        var args = joinPoint.getArgs();
        var first = Arrays.stream(args).findFirst().orElse("");
        var json = String.valueOf(first);

        var simpleName = joinPoint.getSignature().getDeclaringType().getSimpleName();

        log.debug("=================前置通知执行中:类名:{}",simpleName);
        log.debug("=================前置通知执行中:{}",json);
    }

4：访问的方法入参对象增加自定义注解
在这里插入图片描述
5：test/g方法参数的类使自定义注解@MyAnnitation
在这里插入图片描述5：方法test/g方法测试
在这里插入图片描述

八：使用前置通知测试自定义注解

1：定义方法test/h
方法上携带自定义注解@MyAnnitation

    @PostMapping("/h")
    @MyAnnitation(message = "消息",order = 100)
    public String getH(@RequestBody AopTestRequest request){
        log.debug("h请求执行:{}",request);
        return "H";
    }

2: aop定义前置通知测试@annotation

    /**
     * 前置通知:自定义注解
     */
    @Before(value = "@annotation(myAnnitation)")
    public void requestBefore(JoinPoint joinPoint,MyAnnitation myAnnitation){
        var args = joinPoint.getArgs();
        var first = Arrays.stream(args).findFirst().orElse("");
        var json = String.valueOf(first);
        log.debug("=================前置通知执行中:{}",json);

        // 1,获取自定义注解中的数据内容
        var message = myAnnitation.message();
        var order = myAnnitation.order();

        log.debug("=================前置通知执行获取自定义注解的内容-message:{}、order:{}",message,order);

    }

3：访问test/h方法
在这里插入图片描述

淡乄然
关注
专栏目录
SpringBoot使用AOP记录接口操作日志
m0_67400973的博客
08-02 612
AOP为AspectOrientedProgramming的缩写，意为面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。**这种在运行时，动态地将代码切入到类的指定方法或指定位置上的编程思想就是面向切面的编程。**利用AOP可以将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来作为公共部分，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。/**?*定义操作日志注解?*/{??//操作。...
Spring AOP 测试
11-22
掌握AOP的测试源码，仅为学习使用，我在学习时也困惑了很长时间，主要是看不到AOP的结果。经过分析，主要是不会用org.junit.Test 注意运行步骤为： 1.选中工程 2.右键选择Run As Junit Test 3.正常运行就可看到结果了
12-AOP-aop功能测试
weixin_42985717的博客
01-28 423
本文知识点来源于尚硅谷，感谢尚硅谷为广大学子提供的优质教育资源，感谢各位老师热情指导，本文仅作为学习笔记使用，记录学习心得，如有不适，请联系作者。
AOP简介和测试
Alan_Xiang的博客
12-28 3501
AOP简介　　AOP，即面向切面编程，它是Spring中的两个重要内容之一。它是为了把逻辑代码和处理琐碎事务的代码分离开，以便能够分离复杂度。 　　设想这样一种需求：要实现一个计算器，除了能够进行加减乘除运算之外，还有两个功能，一是日志功能，即能够记录程序的执行情况；二是验证功能，即对要计算的参数进行验证。 　　传统的实现方法是在每一个方法上都添加日志和验证功能，例如，对于日志功能，实现代码如下
AOP-AOP功能测试
weixin_30374009的博客
05-27 506
1、将业务逻辑和切面类要放到Spring容器中，并且注明哪个是切面类（@Aspect）； 2、切面类上的通知方法标注通知注解，告诉Spring何时何地运行（@Pointcut("execution()")）； 3、开启基于注解的AOP模式（@EnableAspectJAutoProxy）。 @EnableAspectJAutoProxy @Configuration public c...
spring 注解版(4 aop)
lunaticCode1的博客
11-20 257
4–±-±±-±±±-±±-±±–±+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++±±-±±–+
Spring基础：Spring AOP简单使用
05-04
创建一个简单的Spring AOP应用，首先定义一个切面类，包含切点和通知，然后在Spring配置文件中启用AOP并注册切面，最后编写测试类验证AOP功能是否正常工作。 8. **最佳实践** - 适度使用AOP，过多的切面可能导致...
IOC和AOP深刻理解基础代码测试
09-17
总之，通过这个基础测试项目，初学者可以深入了解Spring框架如何实现IOC和AOP，从而更好地应用于实际的Java Web开发中，提高代码质量，降低维护成本。记住，理论结合实践是学习的关键，动手操作这些示例代码，将会对...
activiti aop测试
04-14
2. **AOP基础**：介绍AOP的核心概念，如切面、通知、切入点表达式等。 3. **整合Activiti与AOP**：讲解如何在Activiti流程中引入AOP，包括配置Spring容器，定义切面，以及如何选择合适的切入点。 4. **测试策略**：...
spring aop 附带测试实例
03-25
### 一、Spring AOP基础 1. **切面（Aspect）**：切面是关注点的模块化，例如日志、事务等。在Spring AOP中，一个切面通常由一个或多个通知（advises）和一个切点（join point）定义组成。 2. **通知（Advice）**...
【Spring【AOP】】——20、搭建一个AOP测试环境？
最新发布
zhouhengzhe的博客
12-27 927
AOP的全称是Aspect Oriented Programming，即面向切面编程。是实现功能统一维护的一种技术，它将业务逻辑的各个部分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。
Spring AOP总结测试
poetteaes的博客
09-01 351
AOP（Aspect Oriented Programming），即面向切面的编程。 （一）什么是面向切面的编程 切面是指代码中一些公共的非核心模块的抽象，比如日志打印，可以将其从核心代码中剥离出来，当程序运行需要时通过切面插入公共代码即可，从而降低代码的耦合度，提高代码的可复用性，并使得我们编程的时候能够更专注于核心业务代码的编写，这种编程模式叫做面向切面的编程。 类可以继承，因此可以看做...
Spring 的 AOP的测试 --(二)
GressLove的博客
06-10 314
一，AOP原理和基础 : a.面向切面(方面) 编程，扩展的功能根不该原代码 b.采用横向抽取机制，取代了传统的纵向继承体系重复性代码（性能监控，事物管理，安全性检查，缓存） 纵向继承体系是定义个父类来实现代码复用 Joinpoint (连接点):类中可以被增强的那些方法叫连接点 Pointcut (切入点)：在类中可以有很多方法可以被增强，比如实际操作中，只是增强了中add和u
AOP的两种模式代码测试
SmallTenMr的博客
05-18 476
public interface Service { void say(); void run(); }public class ServiceImpl implements Service{ @Override public void say() { System.out.println("我会说话了"); } @Overr...
27、AOP-AOP功能测试
Lei_Da_Gou的博客
09-19 216
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>4.3.12.RELEASE</version> </dependency...
springAop开发测试demo
weixin_45118229的博客
02-25 607
文章目录前言一、pom文件二、配置文件形式2.1 target 目标对象2.2 Advice 增强对象2.3 target 目标函数接口2.4 applicationContext.xml2.4.1 切点表达式的写法2.4.2 通知的类型2.5 aop测试三、注解形式3.1 target 目标对象3.2 Advice增强对象3.3 target 目标对象接口3.4 applicationContext-anno.xml3.5 anno测试 前言 springAop+aspectJ可以实现： 1 配置文件
（二十一）AOP-测试-原理
欧阳惜竹的博客
08-06 882
文章目录结论先行bean定义切面类配置类启动类结果 结论先行 AOP：【动态代理】 指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式； 1、导入aop模块；Spring AOP：(spring-aspects) 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常，xxx） 3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行； 通
Spring AOP初识 + swagger测试
小猿成长之路
05-01 624
什么是AOP AOP（Aspect Oriented Programming），面向切面编程，是Spring的核心技术之一。在程序中，AOP可以实现权限校验、日志记录等操作，AOP编程可以使我们的程序便于维护，思路更清晰；可以抽离重复的代码，例如日志等增强其代码的复用性。 AOP概念 切点：即切入点，需要明确我们是要在哪里切入。切点有两种方式，一是通过 excution + 路径表达式指定哪些类织入切入面；二是通过 annotation + 注解，将添加此注解的类织入切面。 切面 ：即 Pointcut
AOP简单实例
jzyang_16的博客
01-02 2850
1、自定义注解 @Target(value = {ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface MyAnnotation { } 2、切面类 @Aspect @Component public class MyAnnotationAspect { /** * 定义切点，拦截的位置，可避免下面重复声明变量
Spring AOP自主实现教程与java基础整合
通过学习这个资源，开发者可以了解到如何在不使用Spring框架提供的AOP功能的情况下，通过Java的基础特性和API手动实现AOP，并且能够在实际应用中，例如Web应用的各个层次中应用AOP技术。这对于深入理解AOP原理以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值