Spring AOP及事务说明

秒速五厘米 2023-09-27 17:11 108阅读 0赞

**目录**

1.事务管理

1.1 事务说明

1.2 Spring事务管理

1.3 事务进阶

(1)Transactional属性说明

(2)rollbackFor属性

(3)propagation属性

1.4 总结

2.AOP

2.1 AOP概述

2.2 AOP核心概念

2.3 AOP进阶

(1) 通知类型

(2)切点表达式

(3) 通知顺序

(4)连接点

--------------------

## 1.事务管理 ##

### 1.1 事务说明 ###

事务是一组操作的集合，它是一个不可分割的工作单位。事务会把所有的操作作为一个整体，一起向数据库提交或者是撤销操作请求。所以这组操作要么同时成功，要么同时失败。

事务的操作主要有三步：

\* 开启事务（一组操作开始前，开启事务）：start transaction / begin ;  
\* 提交事务（这组操作全部成功后，提交事务）：commit ;  
\* 回滚事务（中间任何一个操作出现异常，回滚事务）：rollback ;

### 1.2 Spring事务管理 ###

在spring框架中，我们只需要通过一个简单的注解@Transactional就搞定了。

Transactional注解：

@Transactional作用：就是在当前这个方法执行开始之前来开启事务，方法执行完毕之后提交事务。如果在这个方法执行的过程当中出现了异常，就会进行事务的回滚操作。

@Transactional注解：我们一般会在业务层当中来控制事务，因为在业务层当中，一个业务功能可能会包含多个数据访问的操作。在业务层来控制事务，我们就可以将多个数据访问操作控制在一个事务范围内。

@Transactional注解书写位置：

方法：当前方法交给spring进行事务管理  
类： 当前类中所有的方法都交由spring进行事务管理  
接口：接口下所有的实现类当中所有的方法都交给spring 进行事务管理

一般我们是在业务层的增删改的方法上，并且是一个方法中有多个表的增删改的处理，需要添加此注解，将多个表的操作纳入一个事务进行管理。

可以在application.yml配置文件中开启事务管理日志，这样就可以在控制看到和事务相关的日志信息了。

#spring事务管理日志
    logging:
      level:
        org.springframework.jdbc.support.JdbcTransactionManager: debug

### 1.3 事务进阶 ###

#### (1)Transactional属性说明 ####

spring事务管理注解@Transactional已经控制了业务层方法的事务。接下来我们要来详细的介绍一下@Transactional事务管理注解的使用细节。我们这里主要介绍@Transactional注解当中的两个常见的属性：

1. 异常回滚的属性：rollbackFor  
2. 事务传播行为：propagation

#### (2)rollbackFor属性 ####

默认情况下，只有出现RuntimeException(运行时异常)才会回滚事务。

假如我们想让所有的异常都回滚，需要来配置@Transactional注解当中的rollbackFor属性，通过rollbackFor这个属性可以指定出现何种异常类型回滚事务。

一般我们指定rollbackFor属性的值为Exception.class，即当发生任意异常都回滚。

@Transactional(rollbackFor=Exception.class)

#### (3)propagation属性 ####

这个属性是用来配置事务的传播行为的。

什么是事务的传播行为呢？

\* 就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。

例如：两个事务方法，一个A方法，一个B方法。在这两个方法上都添加了@Transactional注解，就代表这两个方法都具有事务，而在A方法当中又去调用了B方法。

所谓事务的传播行为，指的就是在A方法运行的时候，首先会开启一个事务，在A方法当中又调用了B方法， B方法自身也具有事务，那么B方法在运行的时候，到底是加入到A方法的事务当中来，还是B方法在运行的时候新建一个事务？这个就涉及到了事务的传播行为。

我们要想控制事务的传播行为，在@Transactional注解的后面指定一个属性propagation，通过 propagation 属性来指定传播行为。接下来我们就来介绍一下常见的事务传播行为。

![b3b9bbe725c24f2caa188b3aaea2f60b.png][]

对于这些事务传播行为，我们只需要关注以下两个就可以了：

1. REQUIRED（默认值）  
2. REQUIRES\_NEW

默认情况下，我们不需要设置此属性，使用默认值就可以了，有事务就加入事务。

但有一种情况特殊，如下：

\*\*需求：\*\*解散部门时需要记录操作日志

由于解散部门是一个非常重要而且非常危险的操作，所以在业务当中要求每一次执行解散部门的操作都需要留下痕迹，就是要记录操作日志。而且还要求无论是执行成功了还是执行失败了，都需要留下痕迹。

首先如果我们不设置事务的传播行为的时候，执行情况如下：

*  在执行delete操作时开启了一个事务
 *  当执行insert操作时，insert设置的事务传播行是默认值REQUIRED，表示有事务就加入，没有则新建事务
 *  此时：delete和insert操作使用了同一个事务，同一个事务中的多个操作，要么同时成功，要么同时失败，所以当异常发生时进行事务回滚，就会回滚delete和insert操作。

这样结果不符合我们的设计需求，记录操作日志的操作不应该受其他操作的影响，所以需要设置一下事务的传播行为，设置为REQUIRES\_NEW，重新开启一个事务。

delete方法运行时，会开启一个事务。 当调用insert(deptLog) 时，也会创建一个新的事务，那此时，当insert方法运行完毕之后，事务就已经提交了。 即使外部的事务出现异常，内部已经提交的事务，也不会回滚了，因为是两个独立的事务。

### 1.4 总结 ###

事务的传播行为我们只需要掌握两个：REQUIRED、REQUIRES\_NEW。

REQUIRED ：大部分情况下都是用该传播行为即可。  
REQUIRES\_NEW ：当我们不希望事务之间相互影响时，可以使用该传播行为。比如：下订单前需要记录日志，不论订单保存成功与否，都需要保证日志记录能够记录成功。

##    2.AOP ##

### 2.1 AOP概述 ###

什么是AOP？

\* AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。

然而有一些业务功能执行效率比较低，执行耗时较长，我们需要针对于这些业务方法进行优化。 那首先第一步就需要定位出执行耗时比较长的业务方法，再针对于业务方法再来进行优化。

此时我们就需要统计当前这个项目当中每一个业务方法的执行耗时。那么统计每一个业务方法的执行耗时该怎么实现？

可能多数人首先想到的就是在每一个业务方法运行之前，记录这个方法运行的开始时间。在这个方法运行完毕之后，再来记录这个方法运行的结束时间。拿结束时间减去开始时间，不就是这个方法的执行耗时吗？

以上分析的实现方式是可以解决需求问题的。但是对于一个项目来讲，里面会包含很多的业务模块，每个业务模块又包含很多增删改查的方法，如果我们要在每一个模块下的业务方法中，添加记录开始时间、结束时间、计算执行耗时的代码，就会让程序员的工作变得非常繁琐。

而AOP面向方法编程，就可以做到在不改动这些原始方法的基础上，针对特定的方法进行功能的增强。

AOP的作用：在程序运行期间在不修改源代码的基础上对已有方法进行增强（无侵入性: 解耦）

我们要想完成统计各个业务方法执行耗时的需求，我们只需要定义一个模板方法，将记录方法执行耗时这一部分公共的逻辑代码，定义在模板方法当中，在这个方法开始运行之前，来记录这个方法运行的开始时间，在方法结束运行的时候，再来记录方法运行的结束时间，中间就来运行原始的业务方法。

那此时，当我们再调用部门管理的 list 业务方法时，并不会直接执行 list 方法的逻辑，而是会执行我们所定义的 模板方法 ， 然后在模板方法中：

*  记录方法运行开始时间
 *  运行原始的业务方法（那此时原始的业务方法，就是 list 方法）
 *  记录方法运行结束时间，计算方法执行耗时

AOP面向切面编程和OOP面向对象编程一样，它们都仅仅是一种编程思想，而动态代理技术是这种思想最主流的实现方式。而Spring的AOP是Spring框架的高级技术，旨在管理bean对象的过程中底层使用动态代理机制，对特定的方法进行编程(功能增强)。

AOP的优势：

*  1. 减少重复代码
 *  2. 提高开发效率
 *  3. 维护方便
 *  4. 代码无侵入：没有修改原始的业务方法，就已经对原始的业务方法进行了功能的增强或者是功能的改变

常见的应用场景：

*  记录系统的操作日志
 *  权限控制
 *  事务管理：我们前面所讲解的Spring事务管理，底层其实也是通过AOP来实现的，只要添加@Transactional注解之后，AOP程序自动会在原始方法运行前先来开启事务，在原始方法运行完毕之后提交或回滚事务

### 2.2 AOP核心概念 ###

1. 连接点：JoinPoint，可以被AOP控制的方法（暗含方法执行时的相关信息）

连接点指的是可以被aop控制的方法。例如：入门程序当中所有的业务方法都是可以被aop控制的方法。

2. 通知：Advice，指那些重复的逻辑，也就是共性功能（最终体现为一个方法）

在入门程序中是需要统计各个业务方法的执行耗时的，此时我们就需要在这些业务方法运行开始之前，先记录这个方法运行的开始时间，在每一个业务方法运行结束的时候，再来记录这个方法运行的结束时间。

但是在AOP面向切面编程当中，我们只需要将这部分重复的代码逻辑抽取出来单独定义。抽取出来的这一部分重复的逻辑，也就是共性的功能。

3. 切入点：PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用

在通知当中，我们所定义的共性功能到底要应用在哪些方法上？此时就涉及到了切入点pointcut概念。切入点指的是匹配连接点的条件。通知仅会在切入点方法运行时才会被应用。

在aop的开发当中，我们通常会通过一个切入点表达式来描述切入点(后面会有详解)。

4. 切面：Aspect，描述通知与切入点的对应关系（通知+切入点）

当通知和切入点结合在一起，就形成了一个切面。通过切面就能够描述当前aop程序需要针对于哪个原始方法，在什么时候执行什么样的操作。

5. 目标对象：Target，通知所应用的对象

目标对象指的就是通知所应用的对象，我们就称之为目标对象。

### 2.3 AOP进阶 ###

#### (1) 通知类型 ####

Spring中AOP的通知类型：

@Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行。  
@Before：前置通知，此注解标注的通知方法在目标方法前被执行。  
@After ：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行。  
@AfterReturning ： 返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行。  
@AfterThrowing ： 异常后通知，此注解标注的通知方法发生异常后执行。

程序没有发生异常时的执行结果：

![ebd89d6ca1e641dea528264c9dab6407.png][]

程序发生异常时的执行结果：

![e5538d603c874dd4b88cbf759affbb73.png][]

在使用通知时的注意事项：

@Around环绕通知需要自己调用 ProceedingJoinPoint.proceed() 来让原始方法执行，其他通知不需要考虑目标方法执行。  
@Around环绕通知方法的返回值，必须指定为Object，来接收原始方法的返回值，否则原始方法执行完毕，是获取不到返回值的。

#### (2)切点表达式 ####

1.抽取

//前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    
    //环绕通知
    @Around("execution(* com.itheima.service.*.*(..))")
    
    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    
    //返回后通知（程序在正常执行的情况下，会执行的后置通知）
    @AfterReturning("execution(* com.itheima.service.*.*(..))")
    
    //异常通知（程序在出现异常的情况下，执行的后置通知）
    @AfterThrowing("execution(* com.itheima.service.*.*(..))")

每一个注解里面都指定了切入点表达式，而且这些切入点表达式都一模一样。此时我们的代码当中就存在了大量的重复性的切入点表达式，假如此时切入点表达式需要变动，就需要将所有的切入点表达式一个一个的来改动，就变得非常繁琐了。

Spring提供了@PointCut注解，该注解的作用是将公共的切入点表达式抽取出来，需要用到时引用该切入点表达式即可。

@Slf4j
    @Component
    @Aspect
    public class MyAspect1 {
    
        //切入点方法（公共的切入点表达式）
        @Pointcut("execution(* com.itheima.service.*.*(..))")
        private void pt(){
    
        }
    
        //前置通知（引用切入点）
        @Before("pt()")
        public void before(JoinPoint joinPoint){
            log.info("before ...");
    
        }
    
        //环绕通知
        @Around("pt()")
        public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
            log.info("around before ...");
    
            //调用目标对象的原始方法执行
            Object result = proceedingJoinPoint.proceed();
            //原始方法在执行时：发生异常
            //后续代码不在执行
    
            log.info("around after ...");
            return result;
        }
    
        //后置通知
        @After("pt()")
        public void after(JoinPoint joinPoint){
            log.info("after ...");
        }
    
        //返回后通知（程序在正常执行的情况下，会执行的后置通知）
        @AfterReturning("pt()")
        public void afterReturning(JoinPoint joinPoint){
            log.info("afterReturning ...");
        }
    
        //异常通知（程序在出现异常的情况下，执行的后置通知）
        @AfterThrowing("pt()")
        public void afterThrowing(JoinPoint joinPoint){
            log.info("afterThrowing ...");
        }
    }

需要注意的是：当切入点方法使用private修饰时，仅能在当前切面类中引用该表达式， 当外部其他切面类中也要引用当前类中的切入点表达式，就需要把private改为public，而在引用的时候，具体的语法为：

全类名.方法名()，具体形式如下：

@Slf4j
    @Component
    @Aspect
    public class MyAspect2 {
        //引用MyAspect1切面类中的切入点表达式
        @Before("com.itheima.aspect.MyAspect1.pt()")
        public void before(){
            log.info("MyAspect2 -> before ...");
        }
    }

2.切点表达式写法

切入点表达式是描述切入点方法的一种表达式，主要用来决定项目中的哪些方法需要加入通知。

常见形式：

1.execution(……)：根据方法的签名来匹配

![8bc26542d61d4bde8da49ee5fbd265a4.png][]

execution主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配，语法为：

execution(访问修饰符?  返回值  包名.类名.?方法名(方法参数) throws 异常?)

其中带\`?\`的表示可以省略的部分

访问修饰符：可省略（比如: public、protected）  
包名.类名： 可省略  
throws 异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）

示例：

@Before("execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))")

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

“\*”：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分。  
“..”：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数。

切入点表达式的语法规则：

1. 方法的访问修饰符可以省略  
2. 返回值可以使用\`\*\`号代替（任意返回值类型）  
3. 包名可以使用\`\*\`号代替，代表任意包（一层包使用一个\`\*\`）  
4. 使用\`..\`配置包名，标识此包以及此包下的所有子包  
5. 类名可以使用\`\*\`号代替，标识任意类  
6. 方法名可以使用\`\*\`号代替，表示任意方法  
7. 可以使用 \`\*\` 配置参数，一个任意类型的参数  
8. 可以使用\`..\` 配置参数，任意个任意类型的参数

切入点表达式示例:

省略方法的修饰符号

execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))

使用\`\*\`代替返回值类型

execution(* com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))

使用\`\*\`代替包名（一层包使用一个\`\*\`）

execution(* com.itheima.*.*.DeptServiceImpl.delete(java.lang.Integer))

使用\`..\`省略包名

execution(* com..DeptServiceImpl.delete(java.lang.Integer))

使用\`\*\`代替类名

execution(* com..*.*(java.lang.Integer))

使用\`\*\`代替方法名

execution(* com..*.*(java.lang.Integer))

使用 \`\*\` 代替参数

execution(* com.itheima.service.impl.DeptServiceImpl.delete(*))

使用\`..\`省略参数

execution(* com..*.*(..))

注意事项：

根据业务需要，可以使用 且（&&）、或（||）、非（!） 来组合比较复杂的切入点表达式。

execution(* com.itheima.service.DeptService.list(..)) || execution(* com.itheima.service.DeptService.delete(..))

切入点表达式的书写建议：

所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如：查询类方法都是 find 开头，更新类方法都是update开头。

描述切入点方法通常基于接口描述，而不是直接描述实现类，增强拓展性。

在满足业务需要的前提下，尽量缩小切入点的匹配范围。如：包名匹配尽量不使用 ..，使用 \* 匹配单个包。

2.@annotation(……) ：根据注解匹配

![d46e8a491fe7464f83b0c6d77efa112f.png][]

如果我们要匹配多个无规则的方法，比如：list()和 delete()这两个方法。这个时候我们基于execution这种切入点表达式来描述就不是很方便了。而在之前我们是将两个切入点表达式组合在了一起完成的需求，这个是比较繁琐的。

我们可以借助于另一种切入点表达式annotation来描述这一类的切入点，从而来简化切入点表达式的书写。

实现步骤：

1. 编写自定义注解  
  
2. 在业务类要做为连接点的方法上添加自定义注解

示例：

自定义注解：

@Target(ElementType.METHOD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyLog {
    }

实现类：

@Slf4j
    @Service
    public class DeptServiceImpl implements DeptService {
        @Autowired
        private DeptMapper deptMapper;
    
        @Override
        @MyLog //自定义注解（表示：当前方法属于目标方法）
        public List<Dept> list() {
            List<Dept> deptList = deptMapper.list();
            //模拟异常
            //int num = 10/0;
            return deptList;
        }
    
        @Override
        @MyLog  //自定义注解（表示：当前方法属于目标方法）
        public void delete(Integer id) {
            //1. 删除部门
            deptMapper.delete(id);
        }
    
    
        @Override
        public void save(Dept dept) {
            dept.setCreateTime(LocalDateTime.now());
            dept.setUpdateTime(LocalDateTime.now());
            deptMapper.save(dept);
        }
    
        @Override
        public Dept getById(Integer id) {
            return deptMapper.getById(id);
        }
    
        @Override
        public void update(Dept dept) {
            dept.setUpdateTime(LocalDateTime.now());
            deptMapper.update(dept);
        }
    }

切面类：

@Slf4j
    @Component
    @Aspect
    public class MyAspect6 {
        //针对list方法、delete方法进行前置通知和后置通知
    
        //前置通知
        @Before("@annotation(com.itheima.anno.MyLog)")
        public void before(){
            log.info("MyAspect6 -> before ...");
        }
    
        //后置通知
        @After("@annotation(com.itheima.anno.MyLog)")
        public void after(){
            log.info("MyAspect6 -> after ...");
        }
    }

3. 总结

execution切入点表达式  
根据我们所指定的方法的描述信息来匹配切入点方法，这种方式也是最为常用的一种方式。  
如果我们要匹配的切入点方法的方法名不规则，或者有一些比较特殊的需求，通过execution切入点表达式描述比较繁琐。  
annotation 切入点表达式  
基于注解的方式来匹配切入点方法。这种方式虽然多一步操作，我们需要自定义一个注解，但是相对来比较灵活。我们需要匹配哪个方法，就在方法上加上对应的注解就可以了。

#### (3) 通知顺序 ####

当在项目开发当中，我们定义了多个切面类，而多个切面类中多个切入点都匹配到了同一个目标方法。此时当目标方法在运行的时候，这多个切面类当中的这些通知方法都会运行。

此时我们就有一个疑问，这多个通知方法到底哪个先运行，哪个后运行？

通过程序运行可以看出在不同切面类中，默认按照切面类的类名字母排序：

\* 目标方法前的通知方法：字母排名靠前的先执行  
\* 目标方法后的通知方法：字母排名靠前的后执行

如果我们想控制通知的执行顺序有两种方式：

1. 修改切面类的类名（这种方式非常繁琐、而且不便管理）  
2. 使用Spring提供的@Order注解

使用@Order注解，控制通知的执行顺序：前置通知：数字越小先执行; 后置通知：数字越小越后执行。

@Slf4j
    @Component
    @Aspect
    @Order(2)  //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
    public class MyAspect2 {
        //前置通知
        @Before("execution(* com.itheima.service.*.*(..))")
        public void before(){
            log.info("MyAspect2 -> before ...");
        }
    
        //后置通知 
        @After("execution(* com.itheima.service.*.*(..))")
        public void after(){
            log.info("MyAspect2 -> after ...");
        }
    }

总结：

通知的执行顺序大家主要知道两点即可：

1. 不同的切面类当中，默认情况下通知的执行顺序是与切面类的类名字母排序是有关系的。  
2. 可以在切面类上面加上@Order注解，来控制不同的切面类通知的执行顺序。

#### (4)连接点 ####

我们前面在讲解AOP核心概念的时候，我们提到过什么是连接点，连接点可以简单理解为可以被AOP控制的方法。

我们目标对象当中所有的方法都是可以被AOP控制的方法。而在SpringAOP当中，连接点又特指方法的执行。

在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等。

对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型。  
对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型。

@Slf4j
    @Component
    @Aspect
    public class MyAspect7 {
    
        @Pointcut("@annotation(com.itheima.anno.MyLog)")
        private void pt(){}
    
        //前置通知
        @Before("pt()")
        public void before(JoinPoint joinPoint){
            log.info(joinPoint.getSignature().getName() + " MyAspect7 -> before ...");
        }
    
        //后置通知
        @Before("pt()")
        public void after(JoinPoint joinPoint){
            log.info(joinPoint.getSignature().getName() + " MyAspect7 -> after ...");
        }
    
        //环绕通知
        @Around("pt()")
        public Object around(ProceedingJoinPoint pjp) throws Throwable {
            //获取目标类名
            String name = pjp.getTarget().getClass().getName();
            log.info("目标类名：{}",name);
    
            //目标方法名
            String methodName = pjp.getSignature().getName();
            log.info("目标方法名：{}",methodName);
    
            //获取方法执行时需要的参数
            Object[] args = pjp.getArgs();
            log.info("目标方法参数：{}", Arrays.toString(args));
    
            //执行原始方法
            Object returnValue = pjp.proceed();
    
            return returnValue;
        }
    }

(5)AOP的实现步骤

导入依赖

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

创建AOP的通知类，交由spring容器进行管理。在程序中，定义切点，通过织入操作组成切面。

基于annotation定义的切入点，还需要定义注解，及将注解添加到要增强的方法上。

package com.itheima.aspect;
    
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.stereotype.Component;
    
    /**
     * @Author linaibo
     * @Date 2023/4/5 8:18
     * @PackageName:com.itheima.aspect
     * @ClassName: TestAspect
     * @Version 1.0
     */
    @Component
    @Aspect
    @Slf4j
    public class TestAspect {
    
        @Pointcut("execution(* com.itheima.controller.OrderController.message(..))")
        // @Pointcut("@annotation(com.itheima.ano.Myaop)")
        private void pc() {
        }
    
        @Before("pc()")
        public void before(JoinPoint joinPoint) {
            System.out.println(joinPoint.getSignature().getName());
            log.info("方法执行前");
        }
    
        @AfterReturning("pc()")
        public void afterReturn(JoinPoint joinPoint) {
            log.info("方法之后后");
        }
    
        @Around("pc()")
        public Object round(ProceedingJoinPoint joinPoint) throws Throwable {
            System.out.println(joinPoint.getSignature().getName());
            log.info("环绕方法执行前");
            Object result = joinPoint.proceed();
            log.info("环绕方法执行后");
            return result;
        }
    
        @After("pc()")
        public void after(JoinPoint joinPoint) {
            log.info("最后方法执行");
        }
    
        @AfterThrowing("pc()")
        public void afterThrowing(JoinPoint joinPoint) {
            log.info("抛出异常时执行");
        }
    }

spring会根据上面的处理，生成代理对象供请求调用。

[b3b9bbe725c24f2caa188b3aaea2f60b.png]: https://img-blog.csdnimg.cn/b3b9bbe725c24f2caa188b3aaea2f60b.png
[ebd89d6ca1e641dea528264c9dab6407.png]: https://img-blog.csdnimg.cn/ebd89d6ca1e641dea528264c9dab6407.png
[e5538d603c874dd4b88cbf759affbb73.png]: https://img-blog.csdnimg.cn/e5538d603c874dd4b88cbf759affbb73.png
[8bc26542d61d4bde8da49ee5fbd265a4.png]: https://img-blog.csdnimg.cn/8bc26542d61d4bde8da49ee5fbd265a4.png
[d46e8a491fe7464f83b0c6d77efa112f.png]: https://img-blog.csdnimg.cn/d46e8a491fe7464f83b0c6d77efa112f.png