Java EE 突击 6 - Bean 作用域和生命周期

清疚 2024-03-22 23:54 3阅读 0赞

#### Bean 的作用域和生命周期 ####

*  一 . 通过一个案例来看 Bean 作用域的问题
 *  二 . 作用域定义
 *   *  2.1 Bean 的 6 种作用域
     *   *  sigleton : 单例模式\[默认的作用域\]
         *  prototype : 原型模式
         *  request : 请求作用域\[只能在 Spring MVC 里面使用\]
         *  session : 会话作用域\[只能在 Spring MVC 里面使用\]
         *  application : 全局作用域\[只能在 Spring MVC 里面使用\]
         *  websocket : HTTP WebSocket 作用域\[只能在 WebSocket 程序中使用\]
         *  单例作用域 (singleton) VS 全局作用域 (application)
     *  2.2 设置作用域
 *  三 . Spring 执行流程与生命周期
 *   *  3.1 Spring 主要的执行流程
     *  3.2 Bean 生命周期
     *   *  生命周期的演示
         *  生命周期的故事
         *  思考：为什么要先设置属性在进行初始化呢？

> 这个专栏给大家介绍一下 Java 家族的核心产品 - SSM 框架  
> [JavaEE 进阶专栏][JavaEE]
> 
> Java 语言能走到现在 , 仍然屹立不衰的原因 , 有一部分就是因为 SSM 框架的存在
> 
> 接下来 , 博主会带大家了解一下 Spring、Spring Boot、Spring MVC、MyBatis 相关知识点
> 
> 并且带领大家进行环境的配置 , 让大家真正用好框架、学懂框架
> 
> 来上一篇文章复习一下吧  
> [点击即可跳转到我的小秘密][Link 1]  
> ![在这里插入图片描述][81d4cbe2664c4deb8bdd90ecd189a2ad.png]

在好久好久之前的学习中 , 我们了解过作用域这个概念 .  
作用域（scope）是程序设计概念，通常来说 , 一段程序代码中所用到的名字并不总是有效/可用的 , 而限定这个名字的可用性的代码范围就是这个名字的作用域。

1.  局部变量的作用域是变量所在的局部范围。
2.  全局变量的作用域是整个工程。

比如这段代码

public class Main {
        
        private int c = 0;// c 可以在整个类当中使用
        public void test() {
        
            int a = 0;// a 只能在这个函数里面使用
        }
    
        public static void main(String[] args) {
        
            int b = 0;// b 可以在 main 方法里面使用
        }
    }

如果还记得这个概念的话 , 那么接下来就都好说了

## 一 . 通过一个案例来看 Bean 作用域的问题 ##

假设张三开发出了一个公共的 Bean 叫做 “张三” , 提供给李四和王五使用 , 但是在使用的过程中 , 李四不小心的把 “张三” 改成了 “李四” , 这个时候王五在使用的时候还按照 “张三” 去使用 , 就会出现问题 .  
那么大家可能感觉不知所云 , 就举个栗子吧 .  
我们创建一个 model 类 , 在里面创建一个 Dog 类 , 有他的编号、姓名、年龄

package model;
    
    public class Dog {
        
        private int id;
        private String name;
        private int age;
    
        public int getId() {
        
            return id;
        }
    
        public void setId(int id) {
        
            this.id = id;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "Dog{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

然后我们在 Controller 包底下去创建一个类 : DogBean  
这个类就是张三开发出的公共模块 , 用来给李四和王五使用的

package controller;
    
    import model.Dog;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Component;
    
    @Component
    public class DogBean {
        
        @Bean
        public Dog dog() {
        
            Dog dog = new Dog();
            dog.setId(1);
            dog.setName("大黑");
            dog.setAge(1);
            return dog;
        }
    }

李四和王五就可以调用这段代码  
这时候李四就去使用他了  
创建一个类 : ScopeController.java

package controller;
    
    import model.Dog;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class ScopeController {
        
    
        @Autowired
        private Dog dog;//这里我们为什么去使用属性注入呢?因为方便
    
        public void doScope() {
        
            System.out.println("Do scope controller.");
            System.out.println("原数据:" + dog);
            // 这是李四写的代码
            // 但是他进行了一些修改
            Dog dog2 = dog;// 他为了不影响之前的dog,自己新建一个dog
            dog2.setName("旺旺");
            System.out.println("修改之后的数据" + dog2);
        }
    }

李四是这样想的 , 我自己新创建一个 dog , 然后针对自己的 dog 去修改 , 不改变张三的 dog  
然后王五开始写代码了 : ScopeController2.java

package controller;
    
    import model.Dog;
    import org.springframework.stereotype.Controller;
    
    import javax.annotation.Resource;
    
    @Controller
    public class ScopeController2 {
        
        @Resource
        private Dog dog;
    
        public void doSCope() {
        
            System.out.println("Do SCope controller 2.");
            System.out.println(dog);
        }
    }

然后我们在启动类运行一下

import com.ethan.controller.ScopeController;
    import com.ethan.controller.ScopeController2;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class App {
        
        public static void main(String[] args) {
        
            ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
    
            ScopeController scopeController = context.getBean("scopeController", ScopeController.class);
            scopeController.doScope();
    
            System.out.println("----------------------------------------------------------------");
    
            ScopeController2 scopeController2 = context.getBean("scopeController2", ScopeController2.class);
            scopeController2.doScope2();
        }
    }

![image.png][]  
这是为什么呢 ?  
这要追溯到我们之前学习的基础类型和引用类型的知识了  
![image.png][image.png 1]  
这是因为我们 Spring 是单例模式 , 默认情况下 , dog 只有一份 , 我们会先去 Spring 里面拿 dog , 所以拿到的都是一个 dog , 获取到的也就是一个对象 , 就导致了这个问题 .  
![image.png][image.png 2]

## 二 . 作用域定义 ##

Bean 的作用域是指 Bean 对象在整个 Spring 中的某种行为模式  
比如单例作用域，就表示 Bean 在整个 Spring 框架中只有⼀份，它是全局共享的，那么当其他⼈修改了这个值之后，那么另⼀个人读取到的就是被修改的值。

### 2.1 Bean 的 6 种作用域 ###

1.  singleton : 单例作用域(默认作用域)

> Spring 默认的是单例作用域 , 因为它只存在一份 , 性能比较高 , 消耗的资源比较少 , 糟糕的问题就是当有一个人修改之后 , 其他人拿到的也就是被修改的作用域

1.  prototype : 原型作用域(多例作用域)

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

1.  request : 请求作用域
2.  session : 会话作用域
3.  application : 全局作用域
4.  websocket : HTTP WebSocket 作用域

ps. 下面这 4 个是 Spring MVC 里面的作用域 , 在普通的 Spring 项目 (Spring FrameWork Core) 里面只有前两种

#### sigleton : 单例模式\[默认的作用域\] ####

官方说明 : (Default) Scopes a single bean definition to a single object instance for each Spring IoC container.  
描述 : 该作用域下的 Bean 在 IoC 容器中只存在⼀个实例：获取 Bean(即通过applicationContext.getBean等方法获取) 及装配 Bean (即通过 @Autowired 注入) 都是同⼀个对象。  
场景 : 通常无状态的 Bean 使用该作用域。无状态表示 Bean 对象的属性状态不需要更新(不需要进行修改的 Bean)  
备注 : Spring 默认选择该作用域

#### prototype : 原型模式 ####

> 原来的形状的模式 , 原来是什么样我们就给你什么样 , 那怎么才能保证原型模式呢 ?  
> 那就每一次使用都复制一份 , 他的模板是不变的 , 然后有人需要的话就复制一份一模一样的给你

描述 : 每次对该作用域下的 Bean 的请求都会创建新的实例 : 获取 Bean (即通过applicationContext.getBean 等方法获取) 及装配 Bean (即通过 @Autowired 注入) 都是新的对象实例。

> 这里怎么没说可以去从 @Resource 获取呢 ?  
> 这是因为我们的 Spring 公司是不会去推销别人家的东西的 , @Resource 是 Java 的 , 我为什么要帮他打广告 , 但是其实 @Resource 是可以使用的

场景 : 通常有状态的 Bean 使用该作用域(有状态 : 总去修改的 Bean)

#### request : 请求作用域\[只能在 Spring MVC 里面使用\] ####

> 在这里 , request 表示 请求作用域 , 而不是在 Servlet 里面的请求对象

官方说明 : Scopes a single bean definition to the lifecycle of a single HTTP request. That is,each HTTP request has its own instance of a bean created off the back of a single beandefinition. Only valid in the context of a web-aware Spring ApplicationContext.  
描述 : 每次 http 请求会创建新的 Bean 实例 , 类似于 prototype

> prototype 每次访问都会创建一个新对象 , 比如 : 每次类里面添加了 @Autowired , 就会新建一个对象  
> Request 而是每一次 HTTP 请求 , 就会创建一个 Bean 对象

场景 : ⼀次 HTTP 的请求和响应的共享 Bean  
备注 : 限定 SpringMVC 中使用

#### session : 会话作用域\[只能在 Spring MVC 里面使用\] ####

官方说明 : Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid inthe context of a web-aware Spring ApplicationContext.  
描述 : 在⼀个 HTTP session 中，定义⼀个 Bean 实例

> 登陆成功 , 是一次会话 , 在这一次会话里面 , 任何地方使用了这个对象 , 都是一个 Bean 对象  
> 退出登录再登陆之后 , 又是一个新的 session 了  
> 每次 (session) 会话使用一个 bean 对象

场景 : 用户会话的共享 Bean, 比如 : 记录⼀个用户的登陆信息  
备注 : 限定 SpringMVC 中使用

#### application : 全局作用域\[只能在 Spring MVC 里面使用\] ####

一个 HTTP Servlet context 中共享一个对象

#### websocket : HTTP WebSocket 作用域\[只能在 WebSocket 程序中使用\] ####

> WebSocket 是什么 ?  
> 现在其实这个技术有点不常见了 , 但是在日常生活中应用还是比较广泛的 , 比如网页聊天室 , 比如 : 某个网站上有在线客服 , 你们可以在线解决问题 . 还比如网页游戏等等  
> 它的底层协议是 TCP/UDP  
> 他是和 HTTP 协议同一级别的应用层的协议

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

我们只需要重点记住前四个即可

#### 单例作用域 (singleton) VS 全局作用域 (application) ####

singleton 是 Spring Core 的作用域 ; application 是 Spring Web 中的作用域 ；  
singleton 作用于 IoC 的容器，而 application 作用于 Servlet 容器。

### 2.2 设置作用域 ###

使用 @Scope 标签就可以用来声明 Bean 的作用域，比如设置 Bean 的作用域

> 把它放到你要存储的对象的上边

@Scope 标签既可以修饰方法也可以修饰类，@Scope 有两种设置方式：

1.  直接设置值：@Scope(“prototype”)
2.  使用枚举设置：@Scope(ConfigurableBeanFactory.SCOPE\_PROTOTYPE)

来看之前的例子  
![image.png][image.png 3]

package controller;
    
    import model.Dog;
    import org.springframework.beans.factory.config.ConfigurableBeanFactory;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Scope;
    import org.springframework.stereotype.Component;
    
    @Component
    public class DogBean {
        
        // 写法一
        @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
        // @Scope(ConfigurableListableBeanFactory.SCOPE_PROTOTYPE) //这种写法也是可以的
        // 写法二
        // @Scope("prototype")
        @Bean
        public Dog dog() {
        
            Dog dog = new Dog();
            dog.setId(1);
            dog.setName("大黑");
            dog.setAge(1);
            return dog;
        }
    }

然后运行一下  
![image.png][image.png 4]  
说明现在就是多例的模式  
那我们再使用写法二来看一下  
![image.png][image.png 5]  
也成功了  
但是我们还是推荐 写法1 这种方法 , 因为它可以进行代码提示 , 我们不容易出错

## 三 . Spring 执行流程与生命周期 ##

### 3.1 Spring 主要的执行流程 ###

![image.png][image.png 6]

### 3.2 Bean 生命周期 ###

1.  实例化 Bean (为 Bean 分配内存空间)

> 不等于初始化  
> 实例化就是分配内存空间  
> 比如 : 我们想要在一个城市安身立业 , 咱们的传统就是得先有个家才算安身了 , 那么实例化就是在这个地方买个房子 , 但是现在这个叫家吗 ? 显然不是 , 我们还需要装修买家具等等

1.  设置属性 (Bean 注入和装配)
2.  Bean 初始化
    
    1.  实现了各种 Aware 通知的方法，如 BeanNameAware、BeanFactoryAware、ApplicationContextAware 的接口方法；

> 加入我们现在有个 Bean , Bean 是有自己的名称的 , 我给这个 Bean 起名 , 这是一个事件 , 然后我给这个 Bean 设置好名字之后就会有一个通知 , 叫做 BeanNameAware

1.  设置属性\[依赖注入-DI\]
2.  初始化
    
    1.  执行各种通知
    2.  初始化的前置方法

> 通过 spring-config.xml 里面定义 init-mtehod  
> 也可以通过 @PostConstruct 注解

3. 初始化方法
      4. 初始化的后置方法

1.  使用 Bean
2.  销毁 Bean

> 销毁容器的各种方法，如 @PreDestroy、DisposableBean 接口方法、destroy-method

大致步骤也在图片里面画了  
![image.png][image.png 7]

#### 生命周期的演示 ####

我们在 Controller 里面创建一个类 , 叫做 BeanLifeComponent (Bean 的一生)  
然后先把注解加上

package controller;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class BeanLifeComponent {
        
        
    }

接下来 , 先写通知 , 我们就需要实现 BeanNameAware , 然后重写他的通知方法

package controller;
    
    import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.stereotype.Component;
    
    @Component
    public class BeanLifeComponent implements BeanNameAware {
        
        @Override
        public void setBeanName(String s) {
        
            System.out.println("执行了 Bean Name 的通知:" + s);
        }
    }

然后我们在写一个方法  
(我们为了测试 xml 时代的写法 , 就先把 @Component 注解去掉)

package controller;
    
    import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.stereotype.Component;
    
    //@Component
    public class BeanLifeComponent implements BeanNameAware {
        
        @Override
        public void setBeanName(String s) {
        
            System.out.println("执行了 Bean Name 的通知:" + s);
        }
    
        /**
         * 方法名随便定义
         * 在 xml 中 init-method 指定的方法
         */
        public void initMethod() {
        
            System.out.println("执行了 init method 方法");
        }
    }

接下来我们在 xml 里面去定义它

<?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:content="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
        <content:component-scan base-package="controller"></content:component-scan>
        
        <bean id="beanlife" class="controller.BeanLifeComponent" init-method="initMethod"></bean>
    </beans>

![image.png][image.png 8]  
然后接下来 , 我们编写初始化的代码 , 在上面加一个注解 : @PostConstruct

package controller;
    
    import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;
    
    //@Component
    public class BeanLifeComponent implements BeanNameAware {
        
        @Override
        public void setBeanName(String s) {
        
            System.out.println("执行了 Bean Name 的通知:" + s);
        }
    
        /**
         * 方法名随便定义
         * 在 xml 中 init-method 指定的方法
         */
        public void initMethod() {
        
            System.out.println("执行了 init method 方法");
        }
    
        /**
         * 方法名随便定义
         * 尽量要符合规范
         */
        @PostConstruct
        public void myPostConstruct() {
        
            System.out.println("执行了 PostConstruct 方法");
        }
    }

然后执行销毁方法

package controller;
    
    import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    
    //@Component
    public class BeanLifeComponent implements BeanNameAware {
        
        @Override
        public void setBeanName(String s) {
        
            System.out.println("执行了 Bean Name 的通知:" + s);
        }
    
        /**
         * 方法名随便定义
         * 在 xml 中 init-method 指定的方法
         */
        public void initMethod() {
        
            System.out.println("执行了 init method 方法");
        }
    
        /**
         * 方法名随便定义
         * 尽量要符合规范
         */
        @PostConstruct
        public void myPostConstruct() {
        
            System.out.println("执行了 PostConstruct 方法");
        }
    
        @PreDestroy
        public void myPreDestroy() {
        
            System.out.println("执行了 PreDestroy 方法");
        }
    }

最后我们再写一个普通方法来进行测试

package controller;
    
    import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.stereotype.Component;
    
    import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    
    //@Component
    public class BeanLifeComponent implements BeanNameAware {
        
        @Override
        public void setBeanName(String s) {
        
            System.out.println("执行了 Bean Name 的通知:" + s);
        }
    
        /**
         * 方法名随便定义
         * 在 xml 中 init-method 指定的方法
         */
        public void initMethod() {
        
            System.out.println("执行了 init method 方法");
        }
    
        /**
         * 方法名随便定义
         * 尽量要符合规范
         */
        @PostConstruct
        public void myPostConstruct() {
        
            System.out.println("执行了 PostConstruct 方法");
        }
    
        /**
         * 销毁前执行方法
         */
        @PreDestroy
        public void myPreDestroy() {
        
            System.out.println("执行了 PreDestroy 方法");
        }
    
        public void use() {
        
            System.out.println("执行了 use 方法");
        }
    
    }

但是这个写法和之前的写法就不太一样了  
如果我们要去销毁他 , 就必须调用他的 myPreDestroy 方法 , 但是我们还不能使用 ApplicationContext , 因为 ApplicationContext 没有销毁方法 , 所以咱们就使用 ClassPathXmlApplicationContext 方法定义上下文对象 , 才有 myPreDestroy 方法

import controller.BeanLifeComponent;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class App {
        
        public static void main(String[] args) {
        
            ClassPathXmlApplicationContext context =
                    new ClassPathXmlApplicationContext("spring-config.xml");
            BeanLifeComponent component = context.getBean("beanlife",BeanLifeComponent.class);
            component.use();
            // 关闭容器
            context.destroy();
        }
    }

运行一下  
![image.png][image.png 9]  
我们来分析一下  
![image.png][image.png 10]  
接下来 , 我再实现一个构造方法 , 来看一下效果

package com.ethan.controller;
    
    import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.beans.factory.annotation.Autowired;
    import com.ethan.service.UserService;
    
    import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    
    //@Component
    public class BeanLifeComponent implements BeanNameAware {
        
    
        @Override
        public void setBeanName(String s) {
        
            System.out.println("执行了 Bean Name 的通知:" + s);
        }
    
        /**
         * 方法名随便定义
         * 在 xml 中 init-method 指定的方法
         */
        public void initMethod() {
        
            System.out.println("执行了 init method 方法");
        }
    
        /**
         * 方法名随便定义
         * 尽量要符合规范
         */
        @PostConstruct
        public void myPostConstruct() {
        
            System.out.println("执行了 PostConstruct 方法");
        }
    
        /**
         * 销毁前执行方法
         */
        @PreDestroy
        public void myPreDestroy() {
        
            System.out.println("执行了 PreDestroy 方法");
        }
    
        public void use() {
        
            System.out.println("执行了 use 方法");
        }
    
        public BeanLifeComponent() {
        
            System.out.println("BeanLifeComponent 的构造方法");
        }
    
    }

![image.png][image.png 11]  
构造方法是最先执行的 , 这是因为构造方法是我们 JDK 的 , 在 JDK 中构造方法优先执行 , 我们的 Spring 也是要遵循 JDK 的  
接下来我们新建一个 service 包 , 底下新建一个类 , 叫做 UserService  
然后编写以下代码

package com.ethan.service;
    
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
        
        public UserService() {
        
            System.out.println("UserService 的构造方法");
        }
        public void doService() {
        
            System.out.println("doService()");
        }
    }

接下来在我们的 BeanLifeComponent 类里面添加 @Autowired 注解

package com.ethan.controller;
    
    import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.beans.factory.annotation.Autowired;
    import com.ethan.service.UserService;
    
    import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    
    //@Component
    public class BeanLifeComponent implements BeanNameAware {
        
    
        @Autowired
        private UserService userService;
        
        @Override
        public void setBeanName(String s) {
        
            System.out.println("执行了 Bean Name 的通知:" + s);
        }
    
        /**
         * 方法名随便定义
         * 在 xml 中 init-method 指定的方法
         */
        public void initMethod() {
        
            System.out.println("执行了 init method 方法");
        }
    
        /**
         * 方法名随便定义
         * 尽量要符合规范
         */
        @PostConstruct
        public void myPostConstruct() {
        
            System.out.println("执行了 PostConstruct 方法");
        }
    
        /**
         * 销毁前执行方法
         */
        @PreDestroy
        public void myPreDestroy() {
        
            System.out.println("执行了 PreDestroy 方法");
        }
    
        public void use() {
        
            System.out.println("执行了 use 方法");
        }
    
        public BeanLifeComponent() {
        
            System.out.println("BeanLifeComponent 的构造方法");
        }
    
    }

![image.png][image.png 12]  
运行一下  
![image.png][image.png 13]  
为什么会执行我们的 UserService 的构造方法呢 ?  
这是因为我们引入了 Userservice 对象 , 里面有他的构造方法 .  
那么这两个构造方法的先后顺序都比较特殊 , 他们都来自于 JDK , 先加载那个类是不一定的 , 所以先打印谁后打印谁都是不一定的 .

#### 生命周期的故事 ####

1.  先买房 (实例化 , 从无到有)
2.  装修 (设置属性)
3.  买家电 (\[各种\]初始化)
4.  入住 (使用 Bean)
5.  不想住然后卖出去 (Bean 销毁)

#### 思考：为什么要先设置属性在进行初始化呢？ ####

在初始化的过程中 , 有很多个方法 , 在这些方法中 , 有可能会调用属性里面的某个对象里面的某个方法 , 而如果先初始化再设置属性的话 , 调用的时候就会报空指针异常  
举个栗子 :  
![image.png][image.png 14]  
所以我们会先进行对象注入 , 防止以后需要使用对象的时候会报错

[JavaEE]: https://blog.csdn.net/m0_53117341/category_12149596.html
[Link 1]: https://blog.csdn.net/m0_53117341/article/details/128753263
[81d4cbe2664c4deb8bdd90ecd189a2ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/1ea43d3fed554266b784b44e219f430a.png
[image.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/4f61f00bf04949a7a4ec567fa80ce62c.png
[image.png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ba1b2ff86fd24a55a2b3c881b107426f.png
[image.png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/f2c758c5e68d4028802800dd44ab4b8e.png
[image.png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/10feddd2b364416eb36c26ef78c93a66.png
[image.png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/d915a8918b7f4d038bd0aab2271042c2.png
[image.png 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/48efc0e826bb4f34abfd5af122f1bfd7.png
[image.png 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/4cea3ab634004807a5971b66d131b413.png
[image.png 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/2073157d12464c1195a0add381ec0876.png
[image.png 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/fdf3fec6b1154c478637f5993c983f70.png
[image.png 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/52524cc1a7c84c1eb7de3a530ab68980.png
[image.png 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/70a4c99b11644b3e93a04a042174c1e0.png
[image.png 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/4b9d839c1dc0425c91c07ceeb3f7683f.png
[image.png 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/081f10183be24036b9f2d5b441444222.png
[image.png 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/141fe51ea74d4ad893479d7d0968b624.png
[image.png 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/1683ed23290f45c4bb81458bae1d4169.png