【JavaWeb】事务管理 & AOP

逃离我推掉我的手 2024-04-26 01:59 39阅读 0赞

> ? 本文由 [程序喵正在路上][Link 1] 原创，CSDN首发！  
> ? 系列专栏：[JavaWeb开发][JavaWeb]  
> ? 首发时间：2024年3月18日  
> ? 欢迎关注?点赞?收藏?留言?

#### 目录 ####

*  事务管理
 *   *  事务回顾
     *  Spring事务管理
     *  事务进阶
 *  AOP基础
 *   *  AOP概述
     *  AOP快速入门
     *  AOP核心概念
 *  AOP进阶
 *   *  通知类型
     *  通知顺序
     *  切入点表达式
     *  连接点
 *  AOP案例

## 事务管理 ##

### 事务回顾 ###

**概念**

*  事务是一组操作的集合，它是一个不可分割的工作单位，这些操作要么同时成功，要么同时失败。

**操作**

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

这里，我们来看一个案例 —— 解散部门，即删除部门，同时删除该部门下的员工

在前面，我们写了一个根据id来删除部门的操作，但是我们只删除了部门，缺没有删除该部门下的员工，这样就会造成数据的不一致问题

![在这里插入图片描述][c49282e7fbc84b9b9ab663f1ab8ff141.png]

所以，我们需要添加根据部门id来删除员工的操作：

![在这里插入图片描述][0aeb19dc963049beb5de6c36a9a9b302.png]

虽然我们添加了删除员工的操作，但是无法避免删除部门后，在删除员工操作时会不会出现异常，从而导致无法删除部门员工的情况。

前面，我们是在 SQL 语句中添加事务，而在 spring 项目中，spring 框架已经将这一系列操作给我们封装好了，我们只需要调用一个注解即可实现事务

### Spring事务管理 ###

*  注解：`@Transactional`
 *  位置：业务（service）层的方法上、类上、接口上
 *  作用：将当前方法交给 spring 进行事务管理，方法执行前，开启事务；成功执行完毕，提交事务；出现异常，回滚事务

![在这里插入图片描述][3f5713b153bf4bdfb1d4a1e1625387e2.png]

接下来，我们来添加事务，同时添加一个语句方便后面测试：

![在这里插入图片描述][c9bd4e8cd58a46018ccfe86169d433ae.png]

然后我们再来添加一个开关事务管理日志的配置：

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

开启服务，来到前端页面测试，我们点击删除教研部，发现出现了异常信息，教研部并没有被删除掉，这说明事务管理起作用了，如果没有事务管理，就会出现教研部被删除了，而删除员工的操作因为异常而无法执行

![在这里插入图片描述][ff2252f049d848c18ab2d7616cba3e28.png]

在控制台我们也可以看到事务回滚了：

![在这里插入图片描述][b6f08e8ddf4348678859e09a92eaa75b.png]

### 事务进阶 ###

**rollbackFor**

事务属性 —— 回滚

*  默认情况下，只有出现 RuntimeException 才会回滚事务，而其他异常依旧会提交事务。rollbackFor属性用于控制出现何种异常类型，回滚事务。

我们只要设置所有异常都会进行事务回滚即可：

![在这里插入图片描述][259f6add8f2d40bb9e5fd032f0867e49.png]

**propagation**

事务属性 —— 传播行为

*  事务传播行为：指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。

![在这里插入图片描述][33e2c120e37e4ad0ae7370ad3c259cc8.png]

传播行为的属性值具体有以下几种，前两个比较常用：

![在这里插入图片描述][9defe08927574aa7b0ec33ee88b0d843.png]

**案例：解散部门时，记录操作日志**

*  需求：解散部门时，无论是成功还是失败，都要记录操作日志。
 *  步骤：
    
    1.  解散部门：删除部门、删除部门下的员工
    2.  记录日志到数据库表中

由于要记录日志，所以我们创建一个表 dept\_log 来存储日志信息，同时，我们要创建日志类 DeptLog 并写出其相关操作的三层架构，这些代码在资料中已经给出，[点击此处下载资料][Link 2]，将其导入即可

![在这里插入图片描述][a106f3c3600b4d13a6b6b8dafe493009.png]

在给出的代码中，解散部门和记录日志的操作是在一起，如果它们属于同一个事务，当出现异常后，会一起回滚，从而导致日志记录失败，所以它们不能是同一个事务

![在这里插入图片描述][7300e44d83064e558c68b984e543ac1e.png]

接下来，我们进行测试，随便删除一个部门，因为程序中有异常，所以肯定删除失败：

![在这里插入图片描述][06286b625c6f4a67a6ff07f192b8744a.png]

然后我们看控制台的情况：

![在这里插入图片描述][4a009353fc294c83aff828fab11bc3a6.png]

表中也有了数据：

![在这里插入图片描述][ed251ca41f464e7c93bb0d0963294eba.png]

应用场景

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

## AOP基础 ##

### AOP概述 ###

*  AOP：Aspect Oriented Programming（面向切面编程、面向方面编程），其实就是面向特定方法编程。
 *  应用场景：
    
     *  案例部分功能运行较慢，定位执行耗时较长的业务方法，此时需要统计每一个业务方法的执行耗时

那么我们该如何统计每一个业务方法的执行耗时呢？

*  目前我们能想到的就只有在方法执行前记录开始时间，在方法执行后记录结束时间，以此来计算方法的执行耗时
    
    ![在这里插入图片描述][add9b3b0d2d048cf81c73eba1ea1ad84.png]
 *  AOP
    
    ![在这里插入图片描述][b7bfb8f4bbf6496db680325296604d13.png]
 *  实现：
    
     *  动态代理是面向切面编程最主流的实现。而SpringAOP是Spring框架的高级技术，旨在管理bean对象的过程中，主要通过底层的动态代理机制，对特定的方法进行编程。

### AOP快速入门 ###

Spring AOP快速入门案例：统计各个业务层方法执行耗时

为了演示这个案例，我们新建一个 springboot 工程，这个工程在资料中已给出，我们只需要将其导入即可，工程中已包含部门管理的基本功能

第一步：导入依赖，在pom.xml中导入AOP的依赖

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

第二步：编写AOP程序，针对于特定方法根据业务需要进行编程

创建包 aop 用来存放 AOP 类：

![在这里插入图片描述][e618dcd55a414d1880fd00c37db162b7.png]

import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.stereotype.Component;
    
    @Component
    @Aspect //表示这是一个AOP类
    @Slf4j
    public class TimeAspect {
        
    
        @Around("execution(* com.itheima.service.*.*(..))") //切入点表达式，后面会详细讲解
        public Object recordTime(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        
            long begin = System.currentTimeMillis();
            Object result = proceedingJoinPoint.proceed();  //调用原始方法运行
            long end = System.currentTimeMillis();
            log.info(proceedingJoinPoint.getSignature() + "执行耗时：{}ms", end - begin);
            return result;
        }
    }

第三步：测试

启动服务，来到前端页面，点击部门管理栏目，再返回控制台，我们可以看到其耗时：

![在这里插入图片描述][f63400bea84c4d72af441363f770b7eb.png]

再点击部门管理页面的编辑按钮：

![在这里插入图片描述][3327cdc4dea24eee9786f102ec3d8c04.png]

AOP应用场景：

![在这里插入图片描述][f7e7cbffbaba459ca9f74b1d89a752d6.png]

ps：spring事务管理的底层是通过AOP来实现的

AOP的优势：

![在这里插入图片描述][f369250f3e93492d8d6d6be65d02d74f.png]

### AOP核心概念 ###

*  连接点：JoinPoint，可以被AOP控制的方法（暗含方法执行时的相关信息）
 *  通知：Advice，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法）
 *  切入点：PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用
 *  切面：Aspect，描述通知与切入点的对应关系（通知+切入点）
 *  目标对象：Target，通知所应用的对象

![在这里插入图片描述][98f11bb18bd048dca4c9f143da1d6ef1.png]

**AOP执行流程**  
![在这里插入图片描述][a2a5abfb8e654e53a2961148babe86ed.png]

## AOP进阶 ##

### 通知类型 ###

**通知类型**

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

**注意事项**

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

**@PointCut**

*  该注解的作用是将公共的切点表达式抽取出来，需要使用时引用该切点表达式即可。  
    ![在这里插入图片描述][092cd19341d54fab8a434af9332f3957.png]

演示代码：

import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.stereotype.Component;
    
    @Slf4j
    @Component
    @Aspect
    public class MyAspect1 {
        
    
        @Pointcut("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
        public void pt() {
        
        }
    
        @Before("pt()")
        public void before() {
        
            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() {
        
            log.info("after ...");
        }
    
        @AfterReturning("pt()")
        public void afterReturning() {
        
            log.info("afterReturning ...");
        }
    
        @AfterThrowing("pt()")
        public void afterThrowing() {
        
            log.info("afterThrowing ...");
        }
    }

启动项目，点击一下前端页面的部门管理，来到控制台：

![在这里插入图片描述][fb66e3364d3649ac8a0f9e90f5b7b80e.png]

### 通知顺序 ###

当有多个切面的切入点都匹配到了目标方法，目标方法运行时，多个通知方法都会被执行。

**执行顺序**

*  不同切面类中，默认按照切面类的类名字母排序：
    
     *  目标方法前的通知方法：字母排名靠前的先执行
     *  目标方法后的通知方法：字母排名靠前的后执行
 *  用 `@Order(数字)` 加在切面类上来控制顺序
    
     *  目标方法前的通知方法：数字小的先执行
     *  目标方法后的通知方法：数字小的后执行

### 切入点表达式 ###

*  切入点表达式：描述切入点方法的一种表达式
 *  作用：主要用来决定项目中的哪些方法需要加入通知
 *  常见形式：
    
     *  `execution(……)`：根据方法的签名来匹配
     *  `@annotation(……)` ：根据注解匹配

**切入点表达式 —— execution**

*  execution 主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配，语法为：
    
        execution(访问修饰符?  返回值  包名.类名.?方法名(方法参数) throws 异常?)
 *  其中带 ? 的表示可以省略的部分
    
     *  访问修饰符：可省略（比如: public、protected）
     *  包名.类名： 可省略，但是一般不建议省略
     *  throws 异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）
 *  可以使用通配符描述切入点
    
     *  `*` ：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分
     *  `..` ：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数
 *  根据业务需要，可以使用 且（`&&`）、或（`||`）、非（`!`） 来组合比较复杂的切入点表达式。
 *  书写建议
    
     *  所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如：查询类方法都是 `find` 开头，更新类方法都是 `update` 开头。
     *  描述切入点方法通常基于接口描述，而不是直接描述实现类，增强拓展性。
     *  在满足业务需要的前提下，尽量缩小切入点的匹配范围。如：包名匹配尽量不使用 …，使用 \* 匹配单个包。

//切面类
    @Slf4j
    @Aspect
    @Component
    public class MyAspect {
        
    
    //    @Pointcut("execution(public void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))")
    //    @Pointcut("execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))")
    //    @Pointcut("execution(void delete(java.lang.Integer))") //包名.类名不建议省略
    //    @Pointcut("execution(void com.itheima.service.DeptService.delete(java.lang.Integer))")
    //
    //    @Pointcut("execution(void com.itheima.service.DeptService.*(java.lang.Integer))")
    //    @Pointcut("execution(* com.*.service.DeptService.*(*))")
    //    @Pointcut("execution(* com.itheima.service.*Service.delete*(*))")
    //
    //    @Pointcut("execution(* com.itheima.service.DeptService.*(..))")
    //    @Pointcut("execution(* com..DeptService.*(..))")
    //    @Pointcut("execution(* com..*.*(..))")
    //    @Pointcut("execution(* *(..))") //慎用
    
        @Pointcut("execution(* com.itheima.service.DeptService.list()) || " +
                "execution(* com.itheima.service.DeptService.delete(java.lang.Integer))")
        private void pt() {
        
        }
    
        @Before("pt()")
        public void before() {
        
            log.info("MyAspect ... before ...");
        }
    }

**切入点表达式 —— @annotation**

*  `@annotation` 切入点表达式，用于匹配标识有特定注解的方法。
    
        @annotation(com.itheima.anno.Log)

首先，我们在 aop 包下自定义一个注解：

![在这里插入图片描述][e9c083f59d584e1abaddf66fb4c9c729.png]

import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Retention(RetentionPolicy.RUNTIME) //说明注解什么时候存在
    @Target(ElementType.METHOD)         //说明注解可以存在哪些地方
    public @interface MyLog {
        
    }

如果我们要用 @annotation 切入点表达式去匹配到 list 和 delete 这两个方法，该怎么写呢？

首先，在这两个方法前面添加上 @MyLog 注解：

![在这里插入图片描述][7af7b0f88b6e461c8148e88fa65ac8ea.png]

然后，把注解的全类名写到切入点表达式中即可：

import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    //切面类
    @Slf4j
    @Aspect
    @Component
    public class MyAspect2 {
        
    
        @Pointcut("@annotation(com.itheima.aop.MyLog)")
        private void pt() {
        
        }
    
        @Before("pt()")
        public void before() {
        
            log.info("MyAspect2 ... before ...");
        }
    }

接下来，我们到测试类中来测试：

@SpringBootTest
    class SpringbootAopQuickstart1ApplicationTests {
        
    
        @Autowired
        private DeptService deptService;
    
        @Test
        public void testAopDelete() {
        
            deptService.delete(10);
        }
    
        @Test
        public void testAopList() {
        
            List<Dept> list = deptService.list();
            System.out.println(list);
        }
    
        @Test
        public void testAopGetById() {
        
            Dept dept = deptService.getById(1);
            System.out.println(dept);
        }
    }

将其他 aop 类都注释掉，只留下我们刚刚写的那个，分别运行上面三个测试方法，查看结果中是否有通知：

![在这里插入图片描述][739f756847ca443bafb524f493cd5cec.png]

![在这里插入图片描述][e9ab2ee127e243799f4219a82154e20c.png]

![在这里插入图片描述][b376194215e149479406831d45d78368.png]

### 连接点 ###

*  在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等。
    
     *  对于 `@Around` 通知，获取连接点信息只能使用 `ProceedingJoinPoint`
     *  对于其他四种通知，获取连接点信息只能使用 `JoinPoint` ，它是 `ProceedingJoinPoint` 的父类型

获取信息代码示例：

import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    import java.util.Arrays;
    
    //切面类
    @Slf4j
    @Aspect
    @Component
    public class MyAspect3 {
        
    
        @Pointcut("execution(* com.itheima.service.DeptService.*(..))")
        private void pt() {
        
        }
    
        @Before("pt()")
        public void before(JoinPoint joinPoint) {
        
            log.info("MyAspect3 ... before ...");
        }
    
        @Around("pt()")
        public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        
            log.info("MyAspect3 around before ...");
    
            //1. 获取目标对象的类名
            String className = joinPoint.getTarget().getClass().getName();
            log.info("目标对象的类名:{}", className);
    
            //2. 获取目标方法的方法名
            String methodName = joinPoint.getSignature().getName();
            log.info("目标方法的方法名: {}", methodName);
    
            //3. 获取目标方法运行时传入的参数
            Object[] args = joinPoint.getArgs();
            log.info("目标方法运行时传入的参数: {}", Arrays.toString(args));
    
            //4. 放行目标方法执行
            Object result = joinPoint.proceed();
    
            //5. 获取目标方法运行的返回值
            log.info("目标方法运行的返回值: {}", result);
    
            log.info("MyAspect3 around after ...");
            return result;
        }
    }

启动服务，运行刚才测试类中的其中一个测试方法，可以看到信息已获取到：

![在这里插入图片描述][92ece7518d6349818b5563fd3cb77553.png]

## AOP案例 ##

*  需求：将案例中增、删、改相关接口的操作日志记录到数据库表中。
 *  日志信息包含：操作人、操作时间、执行方法的全类名、执行方法名、方法运行时参数、返回值、方法执行时长
 *  思路分析：
    
     *  需要对所有业务类中的增、删、改方法添加统一功能，使用 `AOP` 技术最为方便，而且需要使用的是 `@Around` 环绕通知
     *  由于增、删、改方法名没有规律，可以自定义 `@Log` 注解完成目标方法匹配

**步骤：**

*  准备：
    
     *  在案例工程中引入AOP的起步依赖
     *  导入准备好的数据库表结构，并引入对应的实体类
 *  编码：
    
     *  自定义注解 `@Log`
     *  定义切面类，完成记录操作日志的逻辑

因为涉及增删改这些操作，所以我们得回到之前 tlias-web-management 这个项目中来进行操作

首先，引入 AOP 的起步依赖

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

下面我们来导入操作日志表结构，用来记录日志信息，并引入对应的实体类用于封装日志信息：

-- 操作日志表
    create table operate_log(
        id int unsigned primary key auto_increment comment 'ID',
        operate_user int unsigned comment '操作人ID',
        operate_time datetime comment '操作时间',
        class_name varchar(100) comment '操作的类名',
        method_name varchar(100) comment '操作的方法名',
        method_params varchar(1000) comment '方法参数',
        return_value varchar(2000) comment '返回值',
        cost_time bigint comment '方法执行耗时, 单位:ms'
    ) comment '操作日志表';

实体类在资料中已给出，同时还有一个 mapper 接口，将它们都复制粘贴到对应的包下即可：

![在这里插入图片描述][3e16c4c91be544159238ca4ce818b3a1.png]

创建一个包 anno 专门用来存放自己写的注解，然后创建注解 @Log：

![在这里插入图片描述][3f7e8017d53a47ccaed7b409ff55a1c9.png]

**如何获取当前登录用户？**

*  获取request对象，从请求头中获取到jwt令牌，解析令牌获取出当前用户的id。

创建包 aop 用来存放 AOP 类，在包下创建切面类 LogAspect：

import com.alibaba.fastjson.JSONObject;
    import com.xixi.mapper.OperateLogMapper;
    import com.xixi.pojo.OperateLog;
    import com.xixi.utils.JwtUtils;
    import io.jsonwebtoken.Jwt;
    import jakarta.servlet.http.HttpServletRequest;
    import lombok.extern.slf4j.Slf4j;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import java.time.LocalDateTime;
    import java.util.Arrays;
    import java.util.Map;
    
    @Slf4j
    @Component
    @Aspect
    public class LogAspect {
        
    
        @Autowired
        private HttpServletRequest request;
    
        @Autowired
        private OperateLogMapper operateLogMapper;
    
        @Around("@annotation(com.xixi.anno.Log)")
        public Object recordLog(ProceedingJoinPoint joinPoint) throws Throwable {
        
            //操作人ID —— 当前登录员工ID
            //获取请求头中的jwt令牌，从令牌中解析出ID
            String jwt = request.getHeader("token");
            Map<String, Object> claims = JwtUtils.parseJWT(jwt);
            Integer operateUser = (Integer) claims.get("id");
    
            //操作时间
            LocalDateTime operateTime = LocalDateTime.now();
    
            //操作类名
            String className = joinPoint.getTarget().getClass().getName();
    
            //操作方法名
            String methodName = joinPoint.getSignature().getName();
    
            //操作方法参数
            Object[] args = joinPoint.getArgs();
            String methodParams = Arrays.toString(args);
    
            long begin = System.currentTimeMillis();
            Object result = joinPoint.proceed();    //调用原始目标方法运行
            long end = System.currentTimeMillis();
    
            //方法返回值
            String returnValue = JSONObject.toJSONString(result);
    
            //操作耗时
            long costTime = end - begin;
    
            //记录操作日志
            OperateLog operateLog = new OperateLog(null, operateUser, operateTime, className, methodName, methodParams, returnValue, costTime);
            operateLogMapper.insert(operateLog);
            log.info("AOP记录操作日志：{}", operateLog);
    
            return result;
        }
    }

然后，在 **DeptController** 和 **EmpController** 中的增删改方法前面添加上注解 `@Log` 即可

最后，启动服务，来到前端页面，我们新增一个部门 “人事部”，然后再把 “人事部” 删掉，回到 IDEA 中查看日志信息表，可以看到多了两条记录：

![在这里插入图片描述][0d9c6ba4483c4b1bb1d23c947bafb3c6.png]

[Link 1]: https://blog.csdn.net/weixin_62511863?spm=1011.2421.3001.5343
[JavaWeb]: https://blog.csdn.net/weixin_62511863/category_12511257.html?spm=1001.2014.3001.5482
[c49282e7fbc84b9b9ab663f1ab8ff141.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/0b3da94552a242ebbbe433a32795828a.png
[0aeb19dc963049beb5de6c36a9a9b302.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/5fbb84e555644b8daf1174e5a02de686.png
[3f5713b153bf4bdfb1d4a1e1625387e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c3f4313d8b8044ca972722c3a50c9395.png
[c9bd4e8cd58a46018ccfe86169d433ae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/e6286340a6664a409d105828c397a9e0.png
[ff2252f049d848c18ab2d7616cba3e28.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/73bf140c0d414b95b360348ca3ae8785.png
[b6f08e8ddf4348678859e09a92eaa75b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c291bbc72c494ff39e887f15eb2f9d64.png
[259f6add8f2d40bb9e5fd032f0867e49.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/a819332e36e343b7aa4f60ebe27c3651.png
[33e2c120e37e4ad0ae7370ad3c259cc8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8fa8205a42894107af7a050023a8d997.png
[9defe08927574aa7b0ec33ee88b0d843.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/389180414cb44586b8a8afbe56ef832d.png
[Link 2]: https://pan.baidu.com/s/13_WUBVdIkiLmdZZM2Qbmzg?pwd=vc60
[a106f3c3600b4d13a6b6b8dafe493009.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/bc16b2f44fa34d6f86247018b525f313.png
[7300e44d83064e558c68b984e543ac1e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/67d1c0b46433473bbd06b788e674c72f.png
[06286b625c6f4a67a6ff07f192b8744a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/6debaf566e144bbb8b41c434aff13f48.png
[4a009353fc294c83aff828fab11bc3a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/459cfdd3ae904eea91d0871a7f3b8eaa.png
[ed251ca41f464e7c93bb0d0963294eba.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/bb451f6bfd264cb892e231d96401cab3.png
[add9b3b0d2d048cf81c73eba1ea1ad84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/a0f7497eb26d43b3b34a74e1a7d8ab2f.png
[b7bfb8f4bbf6496db680325296604d13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/1e119887d21c4639b23e10b56967615b.png
[e618dcd55a414d1880fd00c37db162b7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/79aa1c4322454168afc0a89082e9cbdd.png
[f63400bea84c4d72af441363f770b7eb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/ff977609bb084137a081accf38308679.png
[3327cdc4dea24eee9786f102ec3d8c04.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/540216e2deee48f2bece4dbb21f0ec48.png
[f7e7cbffbaba459ca9f74b1d89a752d6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c2e9acb0b58d4991b0e815a2fecd45f2.png
[f369250f3e93492d8d6d6be65d02d74f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/8be321ebdef346c68bec38ac795e5efb.png
[98f11bb18bd048dca4c9f143da1d6ef1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/78539af6c2ba4aad8d18edcd938d4568.png
[a2a5abfb8e654e53a2961148babe86ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/6d54d27874dc461c8b6f60b10b246b0a.png
[092cd19341d54fab8a434af9332f3957.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/4028d7512e4547f2bcad6fd2131ab328.png
[fb66e3364d3649ac8a0f9e90f5b7b80e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/901813614c33481986b26be18559cedb.png
[e9c083f59d584e1abaddf66fb4c9c729.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/5a3b553c18424757b3356a813c6b9076.png
[7af7b0f88b6e461c8148e88fa65ac8ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/3d8efa9fa191438bb489dafeca23eb73.png
[739f756847ca443bafb524f493cd5cec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/b58160ba1aea4dce9c7807609259d62d.png
[e9ab2ee127e243799f4219a82154e20c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/ce2c5dde871446618befc4ccb53491ac.png
[b376194215e149479406831d45d78368.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/3f95c81012e44a208d08174a6745e6ae.png
[92ece7518d6349818b5563fd3cb77553.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c98ce605939c41e78c227ca72fdb5079.png
[3e16c4c91be544159238ca4ce818b3a1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/7209c266cb714217a467929a68b76f7e.png
[3f7e8017d53a47ccaed7b409ff55a1c9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/4c10e6b267c14c399247f8880650407a.png
[0d9c6ba4483c4b1bb1d23c947bafb3c6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/26/c026256b151f493487b8ba77ac7e1808.png