spring-AOP

已于 2023-11-17 18:16:43 修改
阅读量51 收藏
点赞数
分类专栏： ssm学习 文章标签： spring java
于 2023-11-14 23:00:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36684207/article/details/134382351
版权

        AOP（Aspect Oriented Programming），即面向切面编程，是spring框架的核心内容之一。

 在使用时，需要将aspectj-1.8.5.jar和spring-aop.jar，aspectjweaver-1.8.5.jar一起使用，以便在Spring应用程序中实现AOP功能。

1、AOP的全称(aspect oriented programming),面向切面编程

2、一张示意图说明AOP的相关概念

概念
1）日志
2)   连接点：切面类可以通过连接点，获取到目标类的目标方法签名
3）通知（五种）
4）切入表达式

3、aop的实现方式

(1)基于动态代理的方式[内置aop实现]

(2)使用框架aspectj来实现

4、aop编程的基本说明

基本说明：
1.需要引入核心的aspect包， 即aop的核心包


2.在切面类中声明通知方法

前置通知：@Before

返回通知：@AfterReturning

异常通知：@AfterThrowing

后置通知：@After

环绕通知：@Around   // 环绕通知可以完成另外四个通知的所有事情

执行顺序


3.五种通知和前面写的动态代理类方法的对应关系

5、关于@After与@AfterReturning的区别  （区别！！！！！）

  1. @After：

    • @After 用于在目标方法执行之后执行一个通知（advice）。无论目标方法是否成功，@After 通知都会被执行。
    • 这是一种通用的后期通知，适用于任何返回类型的方法。

  2. @AfterReturning：

    • @AfterReturning 用于在目标方法成功执行并返回值之后执行一个通知。只有当目标方法正常返回时，@AfterReturning 通知才会被执行。如果目标方法抛出异常，@AfterReturning 通知不会被执行。
    • 与 @After 不同，@AfterReturning 需要指定一个参数来接收从目标方法返回的值。这个参数的类型和目标方法的返回类型应该匹配。
    • 这是一种更细粒度的后期通知，通常用于在方法返回特定值之后执行某些操作。

以下是一个简单的示例来说明这两个注解的区别：

假设有一个名为 ServiceMethod 的类，其中有一个名为 execute 的方法：

public class ServiceMethod {  
    public String execute(String input) {  
        // 处理输入并返回结果  
        return "处理结果";  
    }  
}

 如果你想在 execute 方法执行之后打印一些信息，可以使用 @After：

@Aspect  
public class LoggingAspect {  
    @After("execution(* com.example.ServiceMethod.execute(..))")  
    public void logAfterExecution(JoinPoint joinPoint) {  
        System.out.println("execute 方法执行后：");  
    }  
}

 如果你想在 execute 方法成功返回结果之后打印返回值，可以使用 @AfterReturning：

@Aspect  
public class LoggingAspect {  
    @AfterReturning(pointcut = "execution(* com.example.ServiceMethod.execute(..))", returning = "result")  
    public void logAfterExecution(JoinPoint joinPoint, String result) {  
        System.out.println("execute 方法返回结果：" + result);  
    }  
}

 在这个例子中，@After 会无条件地打印信息，而 @AfterReturning 只有在 execute 方法成功返回结果时才会打印信息。

5.aop编程入门案例

        1>先开发两个类

package com.spring.aop;

public interface SmartAnimalable {
    float getSum(float i,float j);
    float getSub(float i, float j);
}

package com.spring.aop;

import org.springframework.stereotype.Component;

@Component(value = "dog")
public class SmartDog implements SmartAnimalable{
    float result ;
    @Override
    public float getSum(float i, float j) {
        result = i+j;
        System.out.println("method执行完");
        return result;
    }

    @Override
    public float getSub(float i, float j) {
        result = i-j;
        return result;
    }
}

        2>在容器中开启基于注解的aop功能

    <!--    开启基于注解的aop功能-->
    <aop:aspectj-autoproxy/>

    <context:component-scan base-package="com.spring.*"/>

        3>开发切面类, 注意 通配 写法

package com.spring.aop;

import org.aspectj.lang.annotation.*;

import org.springframework.stereotype.Component;
@Aspect
@Component
public class SmartAspect {
    //开发一个方法， 在目标类的目标方法之前执行
    /***@Before：前置通知
     *value=值后面写的时候切入表达式execution(public float com.spring.aop.SmartDog.*(..))
     *execution:关键字不要改
     *public float com.spring.aop.SmartDog·getSum(float，float)你有对哪个类的哪个方法切面编码
     *特别强调回显 public float 【访问修饰符和返回值要有..】
     */
    @Before(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))")
    public void showSmartlog() {
        System.out.println("前置通知");
    }


    @AfterReturning(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))")
    public void showSuccesslog() {
        System.out.println("返回通知");
    }

    @AfterThrowing(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))")
    public void showExceptionlog() {
        System.out.println("异常通知");
    }

    @After(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))")
    public void showFinallylog() {
        System.out.println("最终通知");
    }
}

4、测试

package com.spring.test;

import com.spring.aop.SmartAnimalable;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AopTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        SmartAnimalable smartAnimalable =  applicationContext.getBean(SmartAnimalable.class);
     //   SmartDog smartDog = (SmartDog) applicationContext.getBean("dog"); //会报错，因为”dog“
        //已经被代理类代理了，代理类也实现了SmartAnimalable接口。 具体原因是动态代理
        smartAnimalable.getSum(3.4f,3.2f);
    }
}

5、run

6、细节：切入表达式的更多说明

细节说明：
1.对切入表达式的基本使用

@Before(value="execution(public float com.spring.aop.SmartDog.getSum(float, float))"
2.切入表达式的更多配置，比如使用模糊配置

//@Before(value="execution(*com.spring.aop.SmartDog.*(..))")

//表示所有访问权限，的所有包的下所有类的所有方法，都会被执行该前置通知方法@Before(value="execution(* *.*(..))")

7、AOP-JoinPoint

JoinPoint连接点， 这个类可以获取到调用函数的签名。

可以在前置通知，后置通知，任意通知当中使用连接点。

具体示例

package com.spring.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;

import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;

@Aspect
@Component
public class SmartAspect {
   
    @Before(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))")
    public void showSmartlog(JoinPoint joinPoint) {
        System.out.println("前置通知");
        //获取函数签名
        Signature signature = joinPoint.getSignature();
        //获取函数名
        String name = signature.getName();
        //获取方法参数
        Object[] args = joinPoint.getArgs();
        List<Object> list = Arrays.asList(args);
        System.out.println("目标方法的名称"+name+"参数"+list);
    }

8、在返回通知方法获取返回结果

用法示例

其中，需要在切入表达式后，再加 returning = "abc"， 切入的方法参数加 Object abc

 @AfterReturning(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))",returning = "abc")
    public void showSuccesslog(JoinPoint joinPoint,Object abc) {
        System.out.println("返回通知");
        System.out.println("拿到的调用函数的返回值"+abc);
    }

9、在异常通知，获取异常对象

   @AfterThrowing(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))",throwing = "except")
    public void showExceptionlog(JoinPoint joinPoint,Throwable except) {
        System.out.println("异常通知");
        System.out.println("异常是 "+except);
    }

10、环绕通知 （可以做完其他四个通知的所有事情）

 @Around(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))")
    public Object showAroundlog(ProceedingJoinPoint joinPoint) {
       Object result = null;
       //获取调用函数的签名
            String name = joinPoint.getSignature().getName();
            //获取调用函数的参数
            Object[] args = joinPoint.getArgs();
            try{
                //输出前置通知的内容,
                System.out.println("前置通知 调用函数名称" +name+ "参数"+Arrays.asList(args));
                //调用目标方法，获取返回值
                result = joinPoint.proceed();
                System.out.println("返回通知"+result); //干的是@AfterReturning的事儿

            }catch (Throwable exp){
                System.out.println("异常通知"+ "异常消息" + exp.getMessage());
            }finally {
                System.out.println("最终通知"); //干的是@After的事儿
            }
            return result;
        }

11、切面表达式重用

为了统一管理切面表达式， 可以使用切面表达式重用技术。

切面表达式重用：  类似于在一个类当中声明一个属性，各个方法可以调用这个属性

具体示例：

使用

@PointCut(value= "切面表达式")

 public void myPointCut() {
    }

其他通知的切面表达式直接引用 即可， 例如

@Before(value="myPointCut")

  public void showSmartlog(JoinPoint joinPoint) {
       ........
    }

package com.spring.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;

import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;

@Aspect
@Component
public class SmartAspect {
   
    @Before(value="myPointCut()")
    public void showSmartlog(JoinPoint joinPoint) {
        System.out.println("前置通知");
        //获取函数签名
        Signature signature = joinPoint.getSignature();
        //获取函数名
        String name = signature.getName();
        //获取方法参数
        Object[] args = joinPoint.getArgs();
        List<Object> list = Arrays.asList(args);
        System.out.println("目标方法的名称"+name+"参数"+list);
    }



    @Pointcut(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))")
    public void myPointCut() {
    }

}

12、切面表达式优先级

如果同一个函数，有多个切面在同一个切入点切入，那么执行的优先级如何控制？

基本语法：

@Order(value=n)     // n值越小，代表优先级越高

示例：

package com.spring.aop;

@Aspect
@Order(value = 1)
@Component
public class SmartAspect {

    @Before(value="myPointCut()")
    public void showSmartlog(JoinPoint joinPoint) {
        System.out.println("前置通知");
        //获取函数签名
        Signature signature = joinPoint.getSignature();
        //获取函数名
        String name = signature.getName();
        //获取方法参数
        Object[] args = joinPoint.getArgs();
        List<Object> list = Arrays.asList(args);
      //  System.out.println("目标方法的名称"+name+"参数"+list);
    }


    @AfterReturning(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))",returning = "abc")
    public void showSuccesslog(JoinPoint joinPoint,Object abc) {

        System.out.println("最终通知"+"拿到的调用函数的返回值"+abc);
    }


    @After(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))")
    public void showFinallylog() {
        System.out.println("返回通知");
    }
    @Pointcut(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))")
    public void myPointCut() {
    }


}

 复制粘贴一个新的切面类， 改输出为**通知2， 优先级设置为2

package com.spring.aop;

@Aspect
@Order(value = 2)
@Component
public class SmartAspect2 {

    @Before(value="myPointCut()")
    public void showSmartlog(JoinPoint joinPoint) {
        System.out.println("前置通知2");
        //获取函数签名
        Signature signature = joinPoint.getSignature();
        //获取函数名
        String name = signature.getName();
        //获取方法参数
        Object[] args = joinPoint.getArgs();
        List<Object> list = Arrays.asList(args);
       // System.out.println("目标方法的名称"+name+"参数"+list);
    }


    @AfterReturning(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))",returning = "abc")
    public void showSuccesslog(JoinPoint joinPoint,Object abc) {

        System.out.println("最终通知2"+"拿到的调用函数的返回值"+abc);
    }


    @After(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))")
    public void showFinallylog() {
        System.out.println("返回通知2");
    }
    @Pointcut(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))")
    public void myPointCut() {
    }
=
}

public class AopTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        SmartAnimalable smartAnimalable =  applicationContext.getBean(SmartAnimalable.class);
    
        smartAnimalable.getSum(3.4f,3.2f);
    }
}

结果：

结果分析：

1、容易看到切面1的before通知被执行，然后才到切面2的before通知被执行。

2、但是返回通知 却是切面2先执行， 为什么呢？因为

想像 切面一的所有方法为一个整体， 切面二的所有方法为一个整体， 然后切面1的优先级高， 先压入栈中， 切面2后被压入栈中。 那么， 切面一的前置通知先被执行， 切面2的前置通知后执行。 

在出栈时，是切面2先出栈， 所以切面2的返回通知，最终通知先执行， 而切面1的后执行。

栈：后进先出

13、AOP的xml配置

像配置bean一样， AOP不仅可以使用注解配置， 也可以使用xml配置。 注意 AOP使用xml配置，  那么相关的 切面类 就是一个普通类，需要去掉任何注解

1、首先是， xml配置

  <!--    开启基于注解的aop功能-->
    <aop:aspectj-autoproxy/>

    <context:component-scan base-package="com.spring.*"/>
<!--    配置一个切面类的bean-->
    <bean id="smartAspect" class="com.spring.aop.SmartAspect"/>
<!--    配置切面与切面表达式-->
    <aop:config>
        <aop:pointcut id="myPointCut" expression
                ="execution(public float com.spring.aop.SmartDog.getSum(float,float))"/>
        <aop:aspect ref="smartAspect" order="1">
            <aop:before method="showSmartlog" pointcut-ref="myPointCut"/>
            <aop:after-returning method="showSuccesslog" pointcut-ref="myPointCut" returning="abc"/>
            <aop:after-throwing method="showExceptionlog" pointcut-ref="myPointCut" throwing="except"/>
            <aop:after method="showFinallylog" pointcut-ref="myPointCut" />
<!--            此处也可以配置环绕通知-->
        </aop:aspect>
    </aop:config>

2、 切面类， 注意此时是一个普通类

package com.spring.aop;


import java.util.Arrays;
import java.util.List;

public class SmartAspect {
   
    public void showSmartlog(JoinPoint joinPoint) {
        System.out.println("前置通知");
        //获取函数签名
        Signature signature = joinPoint.getSignature();
        //获取函数名
        String name = signature.getName();
        //获取方法参数
        Object[] args = joinPoint.getArgs();
        List<Object> list = Arrays.asList(args);
        System.out.println("目标方法的名称"+name+"参数"+list);
    }


   // @AfterReturning(value="execution(public float com.spring.aop.SmartDog.getSum(float,float))",returning = "abc")
    public void showSuccesslog(JoinPoint joinPoint,Object abc) {

        System.out.println("返回通知"+"拿到的调用函数的返回值"+abc);
    }


    public void showExceptionlog(JoinPoint joinPoint,Throwable except) {
        System.out.println("异常通知");
        System.out.println("异常是 "+except);
    }

    public void showFinallylog() {
        System.out.println("最终通知");
    }


}

3、测试

package com.spring.test;

import com.spring.aop.SmartAnimalable;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AopTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        SmartAnimalable smartAnimalable =  applicationContext.getBean(SmartAnimalable.class);
     //   SmartDog smartDog = (SmartDog) applicationContext.getBean("dog"); //会报错，因为”dog“
        //已经被代理类代理了，代理类也实现了SmartAnimalable接口。 具体原因是动态代理
        smartAnimalable.getSum(3.4f,3.2f);
    }
}

4、结果

 

象鼻山大王、
关注
专栏目录
Spring AOP中通知获取方法信息详解
xycxycooo的博客
08-13 48
Spring AOP提供了多种类型的通知，每种通知都有其特定的应用场景和执行时机。前置通知在方法执行前执行，后置通知在方法执行后执行，返回通知在方法正常返回后执行，异常通知在方法抛出异常后执行，环绕通知在方法执行前后执行，可以完全控制方法的执行流程。理解并掌握这些通知类型，有助于构建灵活、可维护的软件系统，提高代码的复用性和扩展性。无论是日志记录、事务管理还是异常处理，Spring AOP的通知类型都能为开发者提供一种优雅且高效的编程方式。
Sping-AOP中获取目标对象上的方法名，参数列表，方法上的注解
weixin_42119753的博客
09-11 2835
Spring Boot使用AOP实现日志后台管理模块的日志数据添加 自己定义一个注解： package com.cy.pj.common.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.R...
Spring AOP获取方法的参数名称和参数值
diankunqian0766的博客
03-11 3823
aop配置:<aop:aspectj-autoproxy expose-proxy="true" /> @Before(value = "execution(* com..xxxxx.web..*.*(..))") public void methodBefore(JoinPoint joinPoint) { try { ...
SpringAOP中，获取参数名称
ThinkingT_T的博客
04-02 2万+
由于项目中打印日志的需要，研究了一下在aop中，获取参数名称的方法。 1、jdk1,8中，比较简单，直接通过joinPoint中的getSignature()方法即可获取 Signature signature = joinpoint.getSignature(); MethodSignature methodSignature = (MethodSignature) signature;
Spring Aop 获取参数名参数值
weixin_39931896的博客
10-28 2万+
原创地址：https://blog.csdn.net/weixin_39931896/article/details/83451311  前言： 有时候我们在用Spring Aop面向切面编程，需要获取连接点(JoinPoint)方法参数名、参数值。 环境： Mac OSX Intellij IDEA Spring Boot 2x Jdk 1.8x  Code：  package ...
AOP使用重点（获取方法名、参数值、参数值类型、目标注解对象、目标方法所在类）
stubborn的博客
10-13 8945
1、引入pom.xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 2、创建一个自定义注解类CacheableTest @Retention(RetentionPolicy.RUNTIME) @Target(ElementTy
开发工具 spring-aop-4.3.6.RELEASE
05-31
开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE...
spring-aop-5.2.0.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-aop-5.2.0.RELEASE.jar； 赠送原API文档：spring-aop-5.2.0.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.2.0.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.2.0.RELEASE.pom；...
spring-aop-5.0.10.RELEASE-API文档-中文版.zip
04-23
赠送jar包：spring-aop-5.0.10.RELEASE.jar； 赠送原API文档：spring-aop-5.0.10.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.0.10.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.0.10.RELEASE....
spring，spring-aop-5.3.22.jar+aop+IDEA本地包
09-09
spring-aop-5.3.22.jar Spring AOP provides an Alliance-compliant aspect-oriented programming implementation allowing you to define method interceptors and pointcuts to cleanly decouple code that ...
spring-aop-6.0.2.jar
10-25
spring-aop-6.0.2.jar
Spring面向切面编程（AOP）
m0_56188609的博客
07-14 540
AOP简介 ➠***AOP核心概念*** 🍹● AOP（Aspect Oriented Programming）面向切面编程，一种编程范式，指导开发者如何组织程序结构 🍹🍹◆OOP（Object Oriented Programming）面向对象编程 ➠***AOP作用*** 🍹●在不惊动原始设计的基础上为其进行功能增强（追加功能） ➠***Spring理念*** 🍹●无入侵式/无侵入式 （IOC里面的setter注入也是典型的无入侵式编程，提供一个变量，对象就会有值） eg：（为了使其他
spring注解详解与用法（3）切面环绕
qq_25861361的博客
09-28 2378
导航：更多的spring注解标签点击这里 声明了切面类我们还需要定义切面的内容面向切面编程是spring的一个重要思想，也是精华之一 @Aspect 这是一个切面的注解，声明是一个额外的面向切面的功能 用法示例： @Aspect public class AspectTest { } 当然，别忘了添加maven依赖 <dependency> ...
通过AOP的ProceedingJoinPoint获取方法信息
weixin_43790613的博客
08-05 1767
若切入点表达式是方法，则获得的是切入点方法的信息。若切入点表达式是注解，则获得的是使用了切入点注解的方法的信息。本处Method指的是java.lang.reflect.Method。获得切点对应的方法（Method）
java+aop+参数名称_AspectJ(AOP)切面获取参数名称和参数
weixin_33901614的博客
02-25 1357
@Async@AfterReturning(value="execution(public * com.zhx.recharge.service.RechargeService.buildOrder(..))", returning = "result")public void buildOrder(JoinPoint joinPoint, Object result) throwsThrowab...
AOP获取方法的参数名和参数值
csq676622362的博客
03-25 9183
1.背景：在AOP中进行方法的执行监控往往可能会需要获取方法的方法名和方法值，来记录方法的调用情况。 2.实现： MethodSignature signature = (MethodSignature) joinPoint.getSignature(); Method method = signature.getMethod(); // 请求的方法参数值 Object[] args =...
springboot 中使用 AOP 打印 类名、方法名、方法参数名称和方法参数值
热门推荐
张斌的博客
05-08 2万+
package com.eparty.ccp.order.aop; import javassist.*; import javassist.bytecode.CodeAttribute; import javassist.bytecode.LocalVariableAttribute; import javassist.bytecode.MethodInfo; import org.apa...
【Spring】AOP 面向切面编程-环绕通知（掌握）
爱写bug的王六六
11-08 1万+
总结： Aspectj表示切面执行时间，用的通知（Advice）。 这个通知可以使用注解表示。 5个注解表示切面的5个执行时间， 这些注解叫做通知注解。 @Before ： 前置通知 @AfterRetunring： 后置通知 @Around: 环绕通知 @AfterThrowing:异常通知 @After:最终通知 环绕置通知方法的定义 1）方法是public 2）方法是必须有返回值， 推荐使用Object类型 3）方法名称自定义 4）方法必须有ProceedingJoinPoint参数 使用aspe
spring-aop maven
最新发布
12-21
Spring AOP是Spring框架中的一个模块，用于实现面向切面编程（AOP）。在Maven中，你可以通过添加以下Maven坐标来引入Spring AOP依赖： ```xml <groupId>org.springframework <artifactId>spring-aop <version>...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值