【Spring5】008-AOP 操作（AspectJ 注解）

来一瓶82年的拉菲就好

已于 2023-01-09 20:57:31 修改

阅读量65

点赞数

分类专栏： Spring5 文章标签： java spring

于 2023-01-09 17:45:12 首次发布

本文链接：https://blog.csdn.net/qq_39413850/article/details/128618465

版权

Spring5 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

文章目录

1.AOP操作过程
2.AOP操作的细节问题
- 2.1.相同的切入点的抽取
- 2.2.多个增强类对同一个方法增强

项目结构：
在这里插入图片描述

1.AOP操作过程

1、创建类User，在类里面定义方法

package com.rqs.spring5.aop_aspectj_annotation;

import org.springframework.stereotype.Component;

/***
 * 被增强的类
 */
@Component // 创建User对象
public class User {
    public void add() {
        //int a = 1/0;
        System.out.println("add");
    }
}

2、创建增强类UserProxy（编写增强逻辑）
（1）在增强类里面，创建方法，让不同方法代表不同通知类型

package com.rqs.spring5.aop_aspectj_annotation;


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

/***
 * 增强的类
 */
@Component //解创建UserProxy对象
@Aspect //生成代理对象
public class UserProxy {
    //前置通知
    //@Before 注解表示作为前置通知
    @Before(value ="execution(* com.rqs.spring5.aop_aspectj_annotation.User.add(..))")
    public void before() {
        System.out.println("前置通知@Before");
    }
    //后置通知
    @AfterReturning(value = "execution(* com.rqs.spring5.aop_aspectj_annotation.User.add(..))")
    public void afterReturning() {
        System.out.println("后置通知（返回通知）@AfterReturning");
    }
    //最终通知
    @After(value = "execution(* com.rqs.spring5.aop_aspectj_annotation.User.add(..))")
    public void after() {
        System.out.println("最终通知@After");
    }
    //异常通知
    @AfterThrowing(value = "execution(* com.rqs.spring5.aop_aspectj_annotation.User.add(..))")
    public void afterThrowing() {
        System.out.println("异常通知@AfterThrowing");
    }
    //环绕通知
    @Around(value = "execution(* com.rqs.spring5.aop_aspectj_annotation.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws
            Throwable {
        System.out.println("环绕通知@Around 环绕之前");
        //被增强的方法需要执行 需要传入ProceedingJoinPoint proceedingJoinPoint参数
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知@Around 环绕之后");
    }
}

3、进行通知的配置
（1）在 spring 配置文件中，开启注解扫描
在这里插入图片描述

<?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="com.rqs.spring5.aop_aspectj_annotation"></context:component-scan>


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

</beans>

（2）使用注解创建 User 和 UserProxy 对象，在增强类上面添加注解 @Aspect生成代理对象
在这里插入图片描述
（3）在 spring 配置文件中开启生成代理对象

4、配置不同类型的通知
（1）在增强类里，在通知方法上添加通知类型注解，使用切入点表达式配置

操作过程的第2点

Spring5通知的执行流程：点击跳转
测试代码：

package com.rqs.spring5.test;

import com.rqs.spring5.aop_aspectj_annotation.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {
    @Test
    public void testAopAnnotation() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        User user = context.getBean("user", User.class);
        user.add();
    }
}

上述代码的最终执行结果如下图所示：
在这里插入图片描述

2.AOP操作的细节问题

2.1.相同的切入点的抽取

上述操作过程第2点的代码中，可以看到5种通知类型的注解分别为@Before，@AfterReturning，@After，@AfterThrowing，@Around。
但是他们的切入点表达式完全相同，均为"execution(* com.rqs.spring5.aop_aspectj_annotation.User.add(..))"，可以将它抽取出来。
在这里插入图片描述

UserProxy类代码如下：

package com.rqs.spring5.aop_aspectj_annotation;


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

/***
 * 增强的类
 */
@Component //解创建UserProxy对象
@Aspect //生成代理对象
public class UserProxy {

    //相同切入点的抽取

    /**
     * 1.定义一个方法，名字随便取
     * 2.添加切入点注解，写入相同的切入点表达式
     * 3.通过在各种类型的通知注解中调用该方法来使用相同的切入点表达式
     */
    @Pointcut(value="execution(* com.rqs.spring5.aop_aspectj_annotation.User.add(..))")
    public void samePointCut() {

    }
    //前置通知
    //@Before 注解表示作为前置通知
    @Before(value ="samePointCut()")
    public void before() {
        System.out.println("前置通知@Before");
    }
    //后置通知（返回通知，在被增强的方法返回值之后执行）
    @AfterReturning(value = "samePointCut()")
    public void afterReturning() {
        System.out.println("后置通知（返回通知）@AfterReturning");
    }
    //最终通知（在被增强的方法执行之后执行）
    @After(value = "samePointCut()")
    public void after() {
        System.out.println("最终通知@After");
    }
    //异常通知
    @AfterThrowing(value = "samePointCut()")
    public void afterThrowing() {
        System.out.println("异常通知@AfterThrowing");
    }
    //环绕通知
    @Around(value = "samePointCut()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws
            Throwable {
        System.out.println("环绕通知@Around 环绕之前");
        //被增强的方法需要执行 需要传入ProceedingJoinPoint proceedingJoinPoint参数
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知@Around 环绕之后");
    }
}

2.2.多个增强类对同一个方法增强

有多个增强类对同一个方法进行增强，设置增强类优先级，确定谁先执行谁后执行。
比如有UserProxy和PersonProxy两个增强类对User类的add方法进行增强，可以在增强类上添加注解 @Order(数字类型值)，数字类型值越小优先级越高
PersonProxy中设置@Order(1)

package com.rqs.spring5.aop_aspectj_annotation;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Order(1)
public class PersonProxy {
    //最终通知（在被增强的方法执行之后执行）
    @Before(value="execution(* com.rqs.spring5.aop_aspectj_annotation.User.add(..))")
    public void after() {
        System.out.println("PersonProxy的Before通知");
    }
}

UserProxy中设置@Order(2)

package com.rqs.spring5.aop_aspectj_annotation;


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

/***
 * 增强的类
 */
@Component //解创建UserProxy对象
@Aspect //生成代理对象
@Order(2)
public class UserProxy {

    //相同切入点的抽取

    /**
     * 1.定义一个方法，名字随便取
     * 2.添加切入点注解，写入相同的切入点表达式
     * 3.通过在各种类型的通知注解中调用该方法来使用相同的切入点表达式
     */
    @Pointcut(value="execution(* com.rqs.spring5.aop_aspectj_annotation.User.add(..))")
    public void samePointCut() {

    }
    //前置通知
    //@Before 注解表示作为前置通知
    @Before(value ="samePointCut()")
    public void before() {
        System.out.println("前置通知@Before");
    }
    //后置通知（返回通知，在被增强的方法返回值之后执行）
    @AfterReturning(value = "samePointCut()")
    public void afterReturning() {
        System.out.println("后置通知（返回通知）@AfterReturning");
    }
    //最终通知（在被增强的方法执行之后执行）
    @After(value = "samePointCut()")
    public void after() {
        System.out.println("最终通知@After");
    }
    //异常通知
    @AfterThrowing(value = "samePointCut()")
    public void afterThrowing() {
        System.out.println("异常通知@AfterThrowing");
    }
    //环绕通知
    @Around(value = "samePointCut()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws
            Throwable {
        System.out.println("环绕通知@Around 环绕之前");
        //被增强的方法需要执行 需要传入ProceedingJoinPoint proceedingJoinPoint参数
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知@Around 环绕之后");
    }
}