• (续)SSM整合之spring笔记(AOP 基于注解的AOP之各种通知使用，环绕通知，切面的优先级)（P103—P104）

    一 .各种通知使用

    前置通知：使用 @Before 注解标识，在被代理的目标方法 前 执行
    返回通知：使用 @AfterReturning 注解标识，在被代理的目标方法 成功结束 后执行（ 寿终正寝 ）
    异常通知：使用 @AfterThrowing 注解标识，在被代理的目标方法 异常结束 后执行（ 死于非命 ）
    后置通知：使用 @After 注解标识，在被代理的目标方法 最终结束 后执行（ 盖棺定论 ）
    环绕通知：使用 @Around 注解标识，使用 try...catch...finally 结构围绕 整个 被代理的目标方法，包
    括上面四种通知对应的所有位置
    各种通知的执行顺序：
    Spring 版本 5.3.x 以前：
    前置通知
    目标操作
    后置通知
    返回通知或异常通知
    Spring 版本 5.3.x 以后：
    前置通知
    目标操作
    返回通知或异常通知
    后置通知

    1 . 后置通知

    测试  后置通知在哪个语句里面执行 

    @After：后置通知，在目标对象方法的finally字句中执行

    1. package com.atguigu.spring.aop.annotation;
    2. import org.aspectj.lang.JoinPoint;
    3. import org.aspectj.lang.Signature;
    4. import org.aspectj.lang.annotation.After;
    5. import org.aspectj.lang.annotation.Aspect;
    6. import org.aspectj.lang.annotation.Before;
    7. import org.aspectj.lang.annotation.Pointcut;
    8. import org.springframework.stereotype.Component;
    9.  
    10. import java.util.Arrays;
    11.  
    12. /**
    13.  * Date:2022/7/4
    14.  * Author:ybc
    15.  * Description:
    16.  * 1、在切面中，需要通过指定的注解将方法标识为通知方法
    17.  * @Before：前置通知，在目标对象方法执行之前执行
    18.  * @After：后置通知，在目标对象方法的finally字句中执行
    19.  *
    20.  * 2、切入点表达式：设置在标识通知的注解的value属性中
    21.  * execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int)
    22.  * execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..)
    23.  * 第一个*表示任意的访问修饰符和返回值类型
    24.  * 第二个*表示类中任意的方法
    25.  * ..表示任意的参数列表
    26.  * 类的地方也可以使用*，表示包下所有的类
    27.  * 3、重用切入点表达式
    28.  * //@Pointcut声明一个公共的切入点表达式
    29.  * @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    30.  * public void pointCut(){}
    31.  * 使用方式：@Before("pointCut()")
    32.  *
    33.  * 4、获取连接点的信息
    34.  * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息
    35.  * //获取连接点所对应方法的签名信息
    36.  * Signature signature = joinPoint.getSignature();
    37.  * //获取连接点所对应方法的参数
    38.  * Object[] args = joinPoint.getArgs();
    39.  *
    40.  */
    41.  
    42. @Component
    43. @Aspect  //将当前组件标识为切面
    44. public class LoggerAspect {
    45.  
    46.     @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    47.     public void pointCut(){}
    48.  
    49.     //@Before("execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int))")
    50.     //@Before("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    51.     @Before("pointCut()")
    52.     public void beforeAdviceMethod(JoinPoint joinPoint) {
    53.         //获取连接点所对应方法的签名信息
    54.         Signature signature = joinPoint.getSignature();
    55.         //获取连接点所对应方法的参数
    56.         Object[] args = joinPoint.getArgs();
    57.         System.out.println("LoggerAspect，方法："+signature.getName()+"，参数："+ Arrays.toString(args));
    58.     }
    59.  
    60.     @After("pointCut()")
    61.     public void afterAdviceMethod(){
    62.         System.out.println("LoggerAspect,后置通知");
    63.  
    64.     }
    65. }

    测试

    1. public class AOPByAnnotationTest {
    2.  
    3.     @Test
    4.     public void testAOPByAnnotation(){
    5.         //获取IOC容器
    6.         ApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
    7.         //获取目标对象
    8.         // CalculatorImpl calculator = ioc.getBean(CalculatorImpl.class);
    9.         //获取代理对象
    10.         Calculator calculator = ioc.getBean(Calculator.class);
    11.         calculator.div(1, 0);
    12.     }
    13. }

     添加连接点

    1.  
    2. /**
    3.  * 1、在切面中，需要通过指定的注解将方法标识为通知方法
    4.  * @Before：前置通知，在目标对象方法执行之前执行
    5.  * @After：后置通知，在目标对象方法的finally字句中执行
    6.  *
    7.  * 2、切入点表达式：设置在标识通知的注解的value属性中
    8.  * execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int)
    9.  * execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..)
    10.  * 第一个*表示任意的访问修饰符和返回值类型
    11.  * 第二个*表示类中任意的方法
    12.  * ..表示任意的参数列表
    13.  * 类的地方也可以使用*，表示包下所有的类
    14.  * 3、重用切入点表达式
    15.  * //@Pointcut声明一个公共的切入点表达式
    16.  * @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    17.  * public void pointCut(){}
    18.  * 使用方式：@Before("pointCut()")
    19.  *
    20.  * 4、获取连接点的信息
    21.  * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息
    22.  * //获取连接点所对应方法的签名信息
    23.  * Signature signature = joinPoint.getSignature();
    24.  * //获取连接点所对应方法的参数
    25.  * Object[] args = joinPoint.getArgs();
    26.  *
    27.  */
    28.  
    29. @Component
    30. @Aspect  //将当前组件标识为切面
    31. public class LoggerAspect {
    32.  
    33.     @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    34.     public void pointCut(){}
    35.  
    36.     //@Before("execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int))")
    37.     //@Before("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    38.     @Before("pointCut()")
    39.     public void beforeAdviceMethod(JoinPoint joinPoint) {
    40.         //获取连接点所对应方法的签名信息
    41.         Signature signature = joinPoint.getSignature();
    42.         //获取连接点所对应方法的参数
    43.         Object[] args = joinPoint.getArgs();
    44.         System.out.println("LoggerAspect，方法："+signature.getName()+"，参数："+ Arrays.toString(args));
    45.     }
    46.  
    47.     @After("pointCut()")
    48.     public void afterAdviceMethod(JoinPoint joinPoint){
    49.         // System.out.println("LoggerAspect,后置通知");
    50.         //获取连接点所对应方法的签名信息
    51.         Signature signature = joinPoint.getSignature();
    52.         System.out.println("LoggerAspect，方法："+signature.getName()+"，执行完毕");
    53.  
    54.     }
    55. }

     

    2 . 返回通知

    测试有没有输出

    1.  
    2. /**
    3.  * 1、在切面中，需要通过指定的注解将方法标识为通知方法
    4.  * @Before：前置通知，在目标对象方法执行之前执行
    5.  * @After：后置通知，在目标对象方法的finally字句中执行
    6.    @AfterReturning：返回通知，在目标对象方法返回值之后执行
    7.  *
    8.  * 2、切入点表达式：设置在标识通知的注解的value属性中
    9.  * execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int)
    10.  * execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..)
    11.  * 第一个*表示任意的访问修饰符和返回值类型
    12.  * 第二个*表示类中任意的方法
    13.  * ..表示任意的参数列表
    14.  * 类的地方也可以使用*，表示包下所有的类
    15.  * 3、重用切入点表达式
    16.  * //@Pointcut声明一个公共的切入点表达式
    17.  * @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    18.  * public void pointCut(){}
    19.  * 使用方式：@Before("pointCut()")
    20.  *
    21.  * 4、获取连接点的信息
    22.  * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息
    23.  * //获取连接点所对应方法的签名信息
    24.  * Signature signature = joinPoint.getSignature();
    25.  * //获取连接点所对应方法的参数
    26.  * Object[] args = joinPoint.getArgs();
    27.  *
    28.  */
    29.  
    30. @Component
    31. @Aspect  //将当前组件标识为切面
    32. public class LoggerAspect {
    33.  
    34.     @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    35.     public void pointCut(){}
    36.  
    37.     //前置通知
    38.     //@Before("execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int))")
    39.     //@Before("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    40.     @Before("pointCut()")
    41.     public void beforeAdviceMethod(JoinPoint joinPoint) {
    42.         //获取连接点所对应方法的签名信息
    43.         Signature signature = joinPoint.getSignature();
    44.         //获取连接点所对应方法的参数
    45.         Object[] args = joinPoint.getArgs();
    46.         System.out.println("LoggerAspect，方法："+signature.getName()+"，参数："+ Arrays.toString(args));
    47.     }
    48.  
    49.     //后置通知
    50.     @After("pointCut()")
    51.     public void afterAdviceMethod(JoinPoint joinPoint){
    52.         // System.out.println("LoggerAspect,后置通知");
    53.         //获取连接点所对应方法的签名信息
    54.         Signature signature = joinPoint.getSignature();
    55.         System.out.println("LoggerAspect，方法："+signature.getName()+"，执行完毕");
    56.     }
    57.  
    58.  
    59.     //返回通知
    60.      @AfterReturning("pointCut()")
    61.     public void afterReturningAdviceMethod(){
    62.          System.out.println("LoggerAspect,返回通知");
    63.      }
    64. }

     

    测试：

    1.  
    2. public class AOPByAnnotationTest {
    3.  
    4.     @Test
    5.     public void testAOPByAnnotation(){
    6.         //获取IOC容器
    7.         ApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
    8.         //获取目标对象
    9.        // CalculatorImpl calculator = ioc.getBean(CalculatorImpl.class);
    10.         //获取代理对象
    11.         Calculator calculator = ioc.getBean(Calculator.class);
    12.         calculator.div(1, 0);
    13.     }
    14. }

    并没有输出返回通知  因为方法执行过程出现了异常  有了异常 所以没有返回值  

    返回通知是在有返回的时候执行的   因为有了异常 没有返回值  所以执行返回通知

    我们把发生异常的地方修改下  修改后如下

    1. public class AOPByAnnotationTest {
    2.  
    3.     @Test
    4.     public void testAOPByAnnotation(){
    5.         //获取IOC容器
    6.         ApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
    7.         //获取目标对象
    8.        // CalculatorImpl calculator = ioc.getBean(CalculatorImpl.class);
    9.         //获取代理对象
    10.         Calculator calculator = ioc.getBean(Calculator.class);
    11.         calculator.div(1, 1);
    12.     }
    13. }

     

    1. /**
    2.  * 1、在切面中，需要通过指定的注解将方法标识为通知方法
    3.  * @Before：前置通知，在目标对象方法执行之前执行
    4.  * @After：后置通知，在目标对象方法的finally字句中执行
    5.  * @AfterReturning：返回通知，在目标对象方法返回值之后执行
    6.  *
    7.  * 2、切入点表达式：设置在标识通知的注解的value属性中
    8.  * execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int)
    9.  * execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..)
    10.  * 第一个*表示任意的访问修饰符和返回值类型
    11.  * 第二个*表示类中任意的方法
    12.  * ..表示任意的参数列表
    13.  * 类的地方也可以使用*，表示包下所有的类
    14.  * 3、重用切入点表达式
    15.  * //@Pointcut声明一个公共的切入点表达式
    16.  * @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    17.  * public void pointCut(){}
    18.  * 使用方式：@Before("pointCut()")
    19.  *
    20.  * 4、获取连接点的信息
    21.  * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息
    22.  * //获取连接点所对应方法的签名信息
    23.  * Signature signature = joinPoint.getSignature();
    24.  * //获取连接点所对应方法的参数
    25.  * Object[] args = joinPoint.getArgs();
    26.  *
    27.  */
    28.  
    29. @Component
    30. @Aspect  //将当前组件标识为切面
    31. public class LoggerAspect {
    32.  
    33.     @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    34.     public void pointCut(){}
    35.  
    36.     //前置通知
    37.     //@Before("execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int))")
    38.     //@Before("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    39.     @Before("pointCut()")
    40.     public void beforeAdviceMethod(JoinPoint joinPoint) {
    41.         //获取连接点所对应方法的签名信息
    42.         Signature signature = joinPoint.getSignature();
    43.         //获取连接点所对应方法的参数
    44.         Object[] args = joinPoint.getArgs();
    45.         System.out.println("LoggerAspect，方法："+signature.getName()+"，参数："+ Arrays.toString(args));
    46.     }
    47.  
    48.     //后置通知
    49.     @After("pointCut()")
    50.     public void afterAdviceMethod(JoinPoint joinPoint){
    51.         // System.out.println("LoggerAspect,后置通知");
    52.         //获取连接点所对应方法的签名信息
    53.         Signature signature = joinPoint.getSignature();
    54.         System.out.println("LoggerAspect，方法："+signature.getName()+"，执行完毕");
    55.     }
    56.  
    57.     //返回通知
    58.     /**
    59.      * 在返回通知中若要获取目标对象方法的返回值
    60.      * 只需要通过@AfterReturning注解的returning属性
    61.      * 就可以将通知方法的某个参数指定为接收目标对象方法的返回值的参数
    62.      */
    63.     @AfterReturning(value = "pointCut()", returning = "result")
    64.     public void afterReturningAdviceMethod(JoinPoint joinPoint, Object result){
    65.         // System.out.println("LoggerAspect,返回通知");
    66.         //获取连接点所对应方法的签名信息
    67.         Signature signature = joinPoint.getSignature();
    68.         System.out.println("LoggerAspect，方法："+signature.getName()+"，结果："+result);
    69.     }
    70.     
    71. }

    3 .异常通知

    1. /*
    2.  * 1、在切面中，需要通过指定的注解将方法标识为通知方法
    3.  * @Before：前置通知，在目标对象方法执行之前执行
    4.  * @After：后置通知，在目标对象方法的finally字句中执行
    5.  * @AfterReturning：返回通知，在目标对象方法返回值之后执行
    6.  * @AfterThrowing：异常通知，在目标对象方法的catch字句中执行
    7.  *
    8.  * 2、切入点表达式：设置在标识通知的注解的value属性中
    9.  * execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int)
    10.  * execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..)
    11.  * 第一个*表示任意的访问修饰符和返回值类型
    12.  * 第二个*表示类中任意的方法
    13.  * ..表示任意的参数列表
    14.  * 类的地方也可以使用*，表示包下所有的类
    15.  * 3、重用切入点表达式
    16.  * //@Pointcut声明一个公共的切入点表达式
    17.  * @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    18.  * public void pointCut(){}
    19.  * 使用方式：@Before("pointCut()")
    20.  *
    21.  * 4、获取连接点的信息
    22.  * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息
    23.  * //获取连接点所对应方法的签名信息
    24.  * Signature signature = joinPoint.getSignature();
    25.  * //获取连接点所对应方法的参数
    26.  * Object[] args = joinPoint.getArgs();
    27.  *
    28.  */
    29.  
    30. @Component
    31. @Aspect  //将当前组件标识为切面
    32. public class LoggerAspect {
    33.  
    34.     @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    35.     public void pointCut(){}
    36.  
    37.     //前置通知
    38.     //@Before("execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int))")
    39.     //@Before("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    40.     @Before("pointCut()")
    41.     public void beforeAdviceMethod(JoinPoint joinPoint) {
    42.         //获取连接点所对应方法的签名信息
    43.         Signature signature = joinPoint.getSignature();
    44.         //获取连接点所对应方法的参数
    45.         Object[] args = joinPoint.getArgs();
    46.         System.out.println("LoggerAspect，方法："+signature.getName()+"，参数："+ Arrays.toString(args));
    47.     }
    48.  
    49.     //后置通知
    50.     @After("pointCut()")
    51.     public void afterAdviceMethod(JoinPoint joinPoint){
    52.         // System.out.println("LoggerAspect,后置通知");
    53.         //获取连接点所对应方法的签名信息
    54.         Signature signature = joinPoint.getSignature();
    55.         System.out.println("LoggerAspect，方法："+signature.getName()+"，执行完毕");
    56.     }
    57.  
    58.     //返回通知
    59.     /**
    60.      * 在返回通知中若要获取目标对象方法的返回值
    61.      * 只需要通过@AfterReturning注解的returning属性
    62.      * 就可以将通知方法的某个参数指定为接收目标对象方法的返回值的参数
    63.      */
    64.     @AfterReturning(value = "pointCut()", returning = "result")
    65.     public void afterReturningAdviceMethod(JoinPoint joinPoint, Object result){
    66.         // System.out.println("LoggerAspect,返回通知");
    67.         //获取连接点所对应方法的签名信息
    68.         Signature signature = joinPoint.getSignature();
    69.         System.out.println("LoggerAspect，方法："+signature.getName()+"，结果："+result);
    70.     }
    71.    
    72.  
    73.      //异常通知
    74.     @AfterThrowing( "pointCut()")
    75.     public void afterThrowingAdviceMethod(JoinPoint joinPoint){
    76.         //获取连接点所对应方法的签名信息
    77.         Signature signature = joinPoint.getSignature();
    78.         System.out.println("LoggerAspect，方法："+signature.getName()+",异常通知");
    79.     }
    80.  
    81.  
    82.  
    83. }

     

     测试：

    1.  
    2. public class AOPByAnnotationTest {
    3.  
    4.     @Test
    5.     public void testAOPByAnnotation(){
    6.         //获取IOC容器
    7.         ApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
    8.         //获取目标对象
    9.        // CalculatorImpl calculator = ioc.getBean(CalculatorImpl.class);
    10.         //获取代理对象
    11.         Calculator calculator = ioc.getBean(Calculator.class);
    12.         calculator.div(1, 0);
    13.     }
    14. }

    获取异常

    1. /**
    2.  * 1、在切面中，需要通过指定的注解将方法标识为通知方法
    3.  * @Before：前置通知，在目标对象方法执行之前执行
    4.  * @After：后置通知，在目标对象方法的finally字句中执行
    5.  * @AfterReturning：返回通知，在目标对象方法返回值之后执行
    6.  * @AfterThrowing：异常通知，在目标对象方法的catch字句中执行
    7.  *
    8.  * 2、切入点表达式：设置在标识通知的注解的value属性中
    9.  * execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int)
    10.  * execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..)
    11.  * 第一个*表示任意的访问修饰符和返回值类型
    12.  * 第二个*表示类中任意的方法
    13.  * ..表示任意的参数列表
    14.  * 类的地方也可以使用*，表示包下所有的类
    15.  * 3、重用切入点表达式
    16.  * //@Pointcut声明一个公共的切入点表达式
    17.  * @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    18.  * public void pointCut(){}
    19.  * 使用方式：@Before("pointCut()")
    20.  *
    21.  * 4、获取连接点的信息
    22.  * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息
    23.  * //获取连接点所对应方法的签名信息
    24.  * Signature signature = joinPoint.getSignature();
    25.  * //获取连接点所对应方法的参数
    26.  * Object[] args = joinPoint.getArgs();
    27.  *
    28.  */
    29.  
    30. @Component
    31. @Aspect  //将当前组件标识为切面
    32. public class LoggerAspect {
    33.  
    34.     @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    35.     public void pointCut(){}
    36.  
    37.     //前置通知
    38.     //@Before("execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int))")
    39.     //@Before("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    40.     @Before("pointCut()")
    41.     public void beforeAdviceMethod(JoinPoint joinPoint) {
    42.         //获取连接点所对应方法的签名信息
    43.         Signature signature = joinPoint.getSignature();
    44.         //获取连接点所对应方法的参数
    45.         Object[] args = joinPoint.getArgs();
    46.         System.out.println("LoggerAspect，方法："+signature.getName()+"，参数："+ Arrays.toString(args));
    47.     }
    48.  
    49.     //后置通知
    50.     @After("pointCut()")
    51.     public void afterAdviceMethod(JoinPoint joinPoint){
    52.         // System.out.println("LoggerAspect,后置通知");
    53.         //获取连接点所对应方法的签名信息
    54.         Signature signature = joinPoint.getSignature();
    55.         System.out.println("LoggerAspect，方法："+signature.getName()+"，执行完毕");
    56.     }
    57.  
    58.     //返回通知
    59.     /**
    60.      * 在返回通知中若要获取目标对象方法的返回值
    61.      * 只需要通过@AfterReturning注解的returning属性
    62.      * 就可以将通知方法的某个参数指定为接收目标对象方法的返回值的参数
    63.      */
    64.     @AfterReturning(value = "pointCut()", returning = "result")
    65.     public void afterReturningAdviceMethod(JoinPoint joinPoint, Object result){
    66.         // System.out.println("LoggerAspect,返回通知");
    67.         //获取连接点所对应方法的签名信息
    68.         Signature signature = joinPoint.getSignature();
    69.         System.out.println("LoggerAspect，方法："+signature.getName()+"，结果："+result);
    70.     }
    71.  
    72.       //异常通知
    73.  /*   @AfterThrowing( "pointCut()")
    74.     public void afterThrowingAdviceMethod(JoinPoint joinPoint){
    75.         //获取连接点所对应方法的签名信息
    76.         Signature signature = joinPoint.getSignature();
    77.         System.out.println("LoggerAspect，方法："+signature.getName()+",异常通知");
    78.     }*/
    79.  
    80.     /**
    81.      * 在异常通知中若要获取目标对象方法的异常
    82.      * 只需要通过AfterThrowing注解的throwing属性
    83.      * 就可以将通知方法的某个参数指定为接收目标对象方法出现的异常的参数
    84.      */
    85.     @AfterThrowing(value = "pointCut()", throwing = "ex")
    86.     public void afterThrowingAdviceMethod(JoinPoint joinPoint, Throwable ex){
    87.         //获取连接点所对应方法的签名信息
    88.         Signature signature = joinPoint.getSignature();
    89.         System.out.println("LoggerAspect，方法："+signature.getName()+"，异常："+ex);
    90.     }
    91. }

     

    4 . 环绕通知

    1. /**
    2.  * 1、在切面中，需要通过指定的注解将方法标识为通知方法
    3.  * @Before：前置通知，在目标对象方法执行之前执行
    4.  * @After：后置通知，在目标对象方法的finally字句中执行
    5.  * @AfterReturning：返回通知，在目标对象方法返回值之后执行
    6.  * @AfterThrowing：异常通知，在目标对象方法的catch字句中执行
    7.  *
    8.  * 2、切入点表达式：设置在标识通知的注解的value属性中
    9.  * execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int)
    10.  * execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..)
    11.  * 第一个*表示任意的访问修饰符和返回值类型
    12.  * 第二个*表示类中任意的方法
    13.  * ..表示任意的参数列表
    14.  * 类的地方也可以使用*，表示包下所有的类
    15.  * 3、重用切入点表达式
    16.  * //@Pointcut声明一个公共的切入点表达式
    17.  * @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    18.  * public void pointCut(){}
    19.  * 使用方式：@Before("pointCut()")
    20.  *
    21.  * 4、获取连接点的信息
    22.  * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息
    23.  * //获取连接点所对应方法的签名信息
    24.  * Signature signature = joinPoint.getSignature();
    25.  * //获取连接点所对应方法的参数
    26.  * Object[] args = joinPoint.getArgs();
    27.  *
    28.  */
    29.  
    30. @Component
    31. @Aspect  //将当前组件标识为切面
    32. public class LoggerAspect {
    33.  
    34.     @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    35.     public void pointCut(){}
    36.  
    37.     //前置通知
    38.     //@Before("execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int))")
    39.     //@Before("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    40.     @Before("pointCut()")
    41.     public void beforeAdviceMethod(JoinPoint joinPoint) {
    42.         //获取连接点所对应方法的签名信息
    43.         Signature signature = joinPoint.getSignature();
    44.         //获取连接点所对应方法的参数
    45.         Object[] args = joinPoint.getArgs();
    46.         System.out.println("LoggerAspect，方法："+signature.getName()+"，参数："+ Arrays.toString(args));
    47.     }
    48.  
    49.     //后置通知
    50.     @After("pointCut()")
    51.     public void afterAdviceMethod(JoinPoint joinPoint){
    52.         // System.out.println("LoggerAspect,后置通知");
    53.         //获取连接点所对应方法的签名信息
    54.         Signature signature = joinPoint.getSignature();
    55.         System.out.println("LoggerAspect，方法："+signature.getName()+"，执行完毕");
    56.     }
    57.  
    58.     //返回通知
    59.     /**
    60.      * 在返回通知中若要获取目标对象方法的返回值
    61.      * 只需要通过@AfterReturning注解的returning属性
    62.      * 就可以将通知方法的某个参数指定为接收目标对象方法的返回值的参数
    63.      */
    64.     @AfterReturning(value = "pointCut()", returning = "result")
    65.     public void afterReturningAdviceMethod(JoinPoint joinPoint, Object result){
    66.         // System.out.println("LoggerAspect,返回通知");
    67.         //获取连接点所对应方法的签名信息
    68.         Signature signature = joinPoint.getSignature();
    69.         System.out.println("LoggerAspect，方法："+signature.getName()+"，结果："+result);
    70.     }
    71.  
    72.       //异常通知
    73.  /*   @AfterThrowing( "pointCut()")
    74.     public void afterThrowingAdviceMethod(JoinPoint joinPoint){
    75.         //获取连接点所对应方法的签名信息
    76.         Signature signature = joinPoint.getSignature();
    77.         System.out.println("LoggerAspect，方法："+signature.getName()+",异常通知");
    78.     }*/
    79.  
    80.     /**
    81.      * 在异常通知中若要获取目标对象方法的异常
    82.      * 只需要通过AfterThrowing注解的throwing属性
    83.      * 就可以将通知方法的某个参数指定为接收目标对象方法出现的异常的参数
    84.      */
    85.     @AfterThrowing(value = "pointCut()", throwing = "ex")
    86.     public void afterThrowingAdviceMethod(JoinPoint joinPoint, Throwable ex){
    87.         //获取连接点所对应方法的签名信息
    88.         Signature signature = joinPoint.getSignature();
    89.         System.out.println("LoggerAspect，方法："+signature.getName()+"，异常："+ex);
    90.     }
    91.  
    92.  
    93.     //环绕通知
    94.     @Around("pointCut()")
    95.     //环绕通知的方法的返回值一定要和目标对象方法的返回值一致
    96.     public Object aroundAdviceMethod(ProceedingJoinPoint joinPoint){
    97.         Object result = null;
    98.         try {
    99.             System.out.println("环绕通知-->前置通知");
    100.             //表示目标对象方法的执行
    101.             result = joinPoint.proceed();
    102.             System.out.println("环绕通知-->返回通知");
    103.         } catch (Throwable throwable) {
    104.             throwable.printStackTrace();
    105.             System.out.println("环绕通知-->异常通知");
    106.         } finally {
    107.             System.out.println("环绕通知-->后置通知");
    108.         }
    109.         return result;
    110.     }
    111.  
    112.  
    113.  
    114.  
    115. }

     

    测试：

    1. /**
    2. public class AOPByAnnotationTest {
    4.     @Test
    5.     public void testAOPByAnnotation(){
    6.         //获取IOC容器
    7.         ApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
    8.         //获取目标对象
    9.        // CalculatorImpl calculator = ioc.getBean(CalculatorImpl.class);
    10.         //获取代理对象
    11.         Calculator calculator = ioc.getBean(Calculator.class);
    12.         calculator.div(10, 1);
    13.     }
    14. }

     

     二 .切面的优先级

    相同目标方法上同时存在多个切面时，切面的优先级控制切面的 内外嵌套 顺序。
    优先级高的切面：外面
    优先级低的切面：里面
    使用 @Order 注解可以控制切面的优先级：
    @Order( 较小的数 ) ：优先级高
    @Order( 较大的数 ) ：优先级低

     创建验证功能切面 ValidateAspect

    1.  
    2. @Component
    3. @Aspect
    4. public class ValidateAspect {
    5.  
    6.     //@Before("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    7.     @Before("com.atguigu.spring.aop.annotation.LoggerAspect.pointCut()")
    8.     public void beforeMethod(){
    9.         System.out.println("ValidateAspect-->前置通知");
    10.     }
    11.  
    12. }
    测试
    1. package com.atguigu.spring.test;
    2. public class AOPByAnnotationTest {
    3.  
    4.     @Test
    5.     public void testAOPByAnnotation(){
    6.         //获取IOC容器
    7.         ApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
    8.         //获取目标对象
    9.        // CalculatorImpl calculator = ioc.getBean(CalculatorImpl.class);
    10.         //获取代理对象
    11.         Calculator calculator = ioc.getBean(Calculator.class);
    12.         calculator.div(10, 1);
    13.     }
    14. }

    设置优先级@Order(1)

    1. @Component
    2. @Aspect
    3. @Order(1)
    4. public class ValidateAspect {
    5.  
    6.     //@Before("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
    7.     @Before("com.atguigu.spring.aop.annotation.LoggerAspect.pointCut()")
    8.     public void beforeMethod(){
    9.         System.out.println("ValidateAspect-->前置通知");
    10.     }
    11.  
    12. }
    测试;
    1. public class AOPByAnnotationTest {
    2.  
    3.     @Test
    4.     public void testAOPByAnnotation(){
    5.         //获取IOC容器
    6.         ApplicationContext ioc = new ClassPathXmlApplicationContext("aop-annotation.xml");
    7.         //获取目标对象
    8.        // CalculatorImpl calculator = ioc.getBean(CalculatorImpl.class);
    9.         //获取代理对象
    10.         Calculator calculator = ioc.getBean(Calculator.class);
    11.         calculator.div(10, 1);
    12.     }
    13. }

     

     总结：

    切面的优先级
* 可以通过@Order注解的value属性设置优先级，默认值Integer的最大值
* @Order注解的value属性值越小，优先级越高

     全部总结：

    /*
 * 1、在切面中，需要通过指定的注解将方法标识为通知方法
 * @Before：前置通知，在目标对象方法执行之前执行
 * @After：后置通知，在目标对象方法的finally字句中执行
 * @AfterReturning：返回通知，在目标对象方法返回值之后执行
 * @AfterThrowing：异常通知，在目标对象方法的catch字句中执行
 *
 *
 * 2、切入点表达式：设置在标识通知的注解的value属性中
 * execution(public int com.atguigu.spring.aop.annotation.CalculatorImpl.add(int, int)
 * execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..)
 * 第一个*表示任意的访问修饰符和返回值类型
 * 第二个*表示类中任意的方法
 * ..表示任意的参数列表
 * 类的地方也可以使用*，表示包下所有的类
 * 3、重用切入点表达式
 * //@Pointcut声明一个公共的切入点表达式
 * @Pointcut("execution(* com.atguigu.spring.aop.annotation.CalculatorImpl.*(..))")
 * public void pointCut(){}
 * 使用方式：@Before("pointCut()")
 *
 * 4、获取连接点的信息
 * 在通知方法的参数位置，设置JoinPoint类型的参数，就可以获取连接点所对应方法的信息
 * //获取连接点所对应方法的签名信息
 * Signature signature = joinPoint.getSignature();
 * //获取连接点所对应方法的参数
 * Object[] args = joinPoint.getArgs();
 *
 * 5、切面的优先级
 * 可以通过@Order注解的value属性设置优先级，默认值Integer的最大值
 * @Order注解的value属性值越小，优先级越高
 *
 */

  • 相关阅读:
    【SwitchyOmega】SwitchyOmega 安装及使用
    SpringBoot——全局异常处理
    对比CentOS与Ubuntu：选择最适合你的Linux发行版
    STM32H750之FreeRTOS学习--------（五）临界段代码保护
    Java中实现线程等待和唤醒总结
    Baumer工业相机堡盟工业相如何使用BGAPISDK通过两种不同的方法进行图像回调函数的使用（C#）
    通过Windbg动态调试去捕获C++软件异常的完整过程介绍
    信使mRNA甲基化偶联3-甲基胞嘧啶(m3C)|mRNA-m3C
    Hadoop
    感知+平台+应用：忽米打造4款工业智能硬件产品
  • 原文地址：https://blog.csdn.net/m0_59281987/article/details/127723761