【Spring基础——AOP】

Blank_10

已于 2022-11-30 10:54:53 修改

阅读量97

点赞数

分类专栏： spring 文章标签： spring java 后端

于 2022-11-13 14:20:39 首次发布

本文链接：https://blog.csdn.net/weixin_49890533/article/details/127809828

版权

spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

AOP（Aspect Oriented Programming）面向切面编程，一种编程范式，指导开发者如何组织程序结构
- 作用：在不惊动原始设计（不改动源代码）的基础上为其进行功能增强。
AOP核心概念：
- 连接点（JoinPoint）：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等...
  - 在SpringAOP中，理解为方法的执行
- 切入点（PointCut）：匹配连接的式子
  - 在SpringAOP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法
    - 一个具体方法：唯一、独一无二的方法（例如：com.it包下的BookDao接口中的无形参无返回值的save方法）
    - 匹配多个方法：例如：所有的save方法，所有的get开头的方法等等...
- 通知（Advice）：在切入点处执行的操作，也就是共性功能
  - 在SpringAOP中，功能最终以方法的形式呈现
- 通知类：定义通知的类
- 切面（Aspect）：描述通知与切入点的对应关系

AOP应用：

在poom.xml中导入坐标
- 导入aspectjweaver坐标即可（spring-aop坐标默认被spring-context依赖）

<!-- 在dependencies标签中导入坐标 -->
<dependencies>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <vsersion>1.9.4</version>
    </dependency>
</dependencies>

原来的接口实现类代码（保持原有功能代码，无需改动）

@Repository
public class BookDaoImpl implements BookDao {
    public void save(){
        // 打印时间戳
        System.out.println(System.currentTimeMillis());
        System.out.println(book dao save...);
    }

    public void update(){
        System.out.println(book dao update...);
    }
}

================================================================
/** BookDao接口 */
public interface BookDao {
    public void save();
    public void update();
}
================================================================
// Spring执行程序
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.save();
        bookDao.update();
    }
}

Spring核心配置

@Configuration
@ComponentScan("com.it")
@EnableAspectJAutoProxy   // 开启Spring对AOP注解驱动支持
public class SpringConfig {
}

定义通知类（切入点定义依托一个不具有实际意义的方法进行，即无参数、无返回值、方法体无实际逻辑）

@Component
@Aspect   // 告诉Spring以下是用来做AOP的
public class MyAdvice {
    // 定义切入点
    @Pointcut("execution(void com.it.dao.BookDao.update())")
    private void pt(){}   // 定义任意私有方法（无参、无返回值的）
    
    @Before("pt()")  // 绑定切入点和通知
    // 定义通知
    public void method(){
        // 打印时间戳
        System.out.println(System.currentTimeMillis());
    }
}

AOP工作流程：

Spring容器启动
读取所有切面配置中的切入点
初始化bean，判定bean对应的类中的方法是否匹配到任意切入点
1. 匹配失败，创建对象
2. 匹配成功，创建原始对象（目标对象）的代理对象
获取bean执行方法
1. 获取bean，调用方法并执行，完成操作
2. 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

AOP切入点表达式：

切入点表达式标准格式：动作关键字( 访问修饰符返回值包名.类/接口名.方法名(参数) 异常名 )

execution( public User com.it.service.UserService.findById(int) )

动作关键字：描述切入点的行为动作，例如execution表示执行到指定切入点
访问修饰符：public private等，可以省略
返回值
包名
类/接口名：通常采用接口名
方法名
参数
异常名：方法定义中抛出指定异常，可以省略

可以使用通配符描述切入点，快速描述

* ：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现

execution( public * com.it.*.UserService.find*(*) )

匹配com.it包下的任意包中的UserService类或接口中所有find开头的带有任意一个参数的方法

.. ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

execution( public User com..UserService.findById(..) )

匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

+ ：专用于匹配子类类型

execution( * *..*Service+.*(..) )

AOP通知类型：

AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置。
AOP通知类型共分为五种：
- 前置通知：@Before
  - 位置：通知方法定义上方
  - 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前运行。

@Before("pt()")
public void before(){
    System.out.println(before advice...);
}

后置通知：@After
- 位置：通知方法定义上方
- 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法后运行。

@After("pt()")
public void after(){
    System.out.println(after advice...);
}

环绕通知：@Around
- 位置：通知方法定义上方
- 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法前后运行。

@Around("pt()")
/** 通过ProceedingJoinPoint参数对原始方法进行调用 */
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println(after advice...);
    // 调用原始方法，可以获得返回值
    Object ret = pjp.proceed();
    System.out.println(after advice...);
    return ret;
}

注意事项：

环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知。
通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行（实现对原始方法的隔离）。
对原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，通常设定为Object类型。
原始方法的返回值如果是void类型，通知方法的返回值类型可以设置为void，也可以设置为Object（返回null）。
由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须抛出Throwable异常。

返回后通知：@AfterReturning
- 位置：通知方法定义上方
- 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法正常执行完毕后运行。

@AfterReturning("pt()")
public void afterReturning(){
    System.out.println(afterReturning advice...);
}

抛出异常后通知：@AfterThrowing
- 位置：通知方法定义上方
- 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方法抛出异常后运行（不抛异常不运行）。

AOP通知获取数据：

JoinPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数

@Before("pt()")
public void before(JoinPoint jp){
    Object args = jp.getArgs();
    System.out.println(Arrays.toString(args));
}

ProceedingJoinPoint是JoinPoint的子类

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    Object[] args = pjp.getArgs();
    Object ret = pjp.proceed();
    return ret;
}

AOP通知获取返回值数据：

抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的异常对象

@AfterReturning(value="pt()",returning="ret1")
public void afterReturning(String ret1){
    System.out.println("afterReturning advice..."+ret1);
}

环绕通知中可以手工书写对原始方法的调用，得到结果即为原始方法的返回值

@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
    Object ret = pjp.proceed();
    return ret;
}

抛出异常后通知可以获取切点方法中出现的异常信息，使用形参可以接收对应的异常对象

@AfterThrowing(value="pt()",throwing="t")
public void afterThrowing(Throwable t){
    System.out.println("afterThrowing advice..."+t);
}