【Spring篇】IOC相关内容

悠悠 2024-04-20 07:52 74阅读 0赞

> ?系列专栏:[Spring系列专栏][Spring]
> 
> ?个人主页:[个人主页][Link 1]

**目录**

一、bean基础配置

1.bean基础配置(id与class)

2.bean的name属性

3.bean作用范围scope配置

二、bean实例化

1.构造方法实例化

2.分析Spring的错误信息

3.静态工厂实例化

4.实例工厂

5.FactoryBean

三、bean的生命周期

1.环境准备

2.生命周期设置

3.close关闭容器

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

通过前面两个案例，我们已经学习了 bean 如何定义配置 ， DI 如何定义配置 以及 容器对象如何获取 的内容，接下来主要是把这三块内容展开进行详细的讲解，深入的学习下这三部分的内容，首先是bean 基础配置。

## 一、**bean基础配置**  ##

对于 bean 的配置中，主要会讲解 bean 基础配置 ,  bean 的别名配置 ,  **bean的作用范围配置(重点)** , 这三部分内容：

#### **1.bean****基础配置****(id****与****class)**  ####

对于 bean 的基础配置，在前面的案例中已经使用过 :

其中， bean 标签的功能、使用方式以及 id 和 class 属性的作用，我们通过一张图来描述下

![238ac3aca6c84db5ace9d398801431b2.png][]

这其中需要大家重点掌握的是:**bean****标签的****id****和****class****属性的使用**。

**思考：**

class属性能不能写接口如BookDao的类全名呢?

*  答案肯定是不行，因为接口是没办法创建对象的。

#### 2.**bean****的****name****属性** ####

首先来看下别名的配置说

![0166a244970249c9b6e6193f90dae116.png][]

**步骤****1****：配置别名**

打开 spring 的配置文件 applicationContext.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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        
        <bean id="bookService" name="service service4 bookEbi" class="com.itheima.service.impl.BookServiceImpl">
            <property name="bookDao" ref="bookDao"/>
        </bean>
    
        
        <bean id="bookDao" name="dao" class="com.itheima.dao.impl.BookDaoImpl" scope="prototype"/>
    </beans>

**说明** **:Ebi** **全称** **Enterprise Business Interface** **，翻译为企业业务接口**

**步骤** **2:** **根据名称容器中获取** **bean** **对象**

public class AppForName {
        public static void main(String[] args) {
    
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    
            BookService bookService = (BookService) ctx.getBean("service4");
    
            bookService.save();
        }
    }

**运行：**

![b01acaf2cf2245d2a6b4f2e1bed17eaf.png][]

**注意事项****:**

![1ca0b7a57e4548c887c0c39875e315a3.png][]

**如果不存在,则会报错，如下:**

![bd4c36158a56401c8a2f2e9ac9b9043a.png][]

获取bean无论是通过id还是name获取，如果无法获取到，将抛出异常 **NoSuchBeanDefinitionException**

#### 3.**bean****作用范围****scope****配置** ####

**关于bean的作用范围是bean属性配置的一个重点****内容。**

看到这个作用范围，我们就得思考bean的作用范围是来控制bean哪块内容的? 我们先来看下bean作用范围的配置属性:

![c9914bf02af643cb8928dc3b6a008ea7.png][]

**验证****IOC****容器中对象是否为单例**

**验证思路**

同一个 bean 获取两次，将对象打印到控制台，看打印出的地址值是否一致。

**具体实现**

创建一个 AppForScope 的类，在其 main 方法中来验证

![61a658c619014ece86e8f4a6654be782.png][]

结论:默认情况下，Spring创建的bean对象都是单例的

**配置****bean****为非单例**

在Spring配置文件中，配置scope属性来实现bean的非单例创建

*  在Spring的配置文件中，修改<bean>的scope属性

将 scope 设置为 singleton

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        
        <bean id="bookService" name="service service2 bookEbi" class="com.itheima.service.impl.BookServiceImpl">
            <property name="bookDao" ref="bookDao"/>
        </bean>
    
        
        <bean id="bookDao" name="dao" class="com.itheima.dao.impl.BookDaoImpl"  scope="singleton"/>
    </beans>

运行AppForScope，打印看结果：

![55370e052f224fc281e04e193818327c.png][]

将scope设置为prototype ：

![fba74ecad018460c91bdb53fe5542a84.png][]

**结论，使用bean的scope属性可以控制bean的创建是否为单例：**

*  **singleton默认为单例** 
 *  **prototype为非单例**

**scope** **使用后续思考**

为什么 bean 默认为单例 ?

*  bean为单例的意思是在Spring的IOC容器中只会有该类的一个对象 
 *  bean对象只有一个就避免了对象的频繁创建与销毁，达到了bean对象的复用，性能高

bean 在容器中是单例的，会不会产生线程安全问题 ?

*  如果对象是有状态对象，即该对象有成员变量可以用来存储数据的， 
 *  因为所有请求线程共用一个bean对象，所以会存在线程安全问题。 
 *  如果对象是无状态对象，即该对象没有成员变量没有进行数据存储的， 
 *  因方法中的局部变量在方法调用完成后会被销毁，所以不会存在线程安全问题。

哪些 bean 对象适合交给容器进行管理 ?

*  表现层对象 
 *  业务层对象 
 *  数据层对象 
 *  工具对象

哪些bean对象不适合交给容器进行管理?

*  封装实例的域对象，因为会引发线程安全问题，所以不适合。

## 二、**bean实例化** ##

对象已经能交给 Spring 的 IOC 容器来创建了，但是容器是如何来创建对象的呢 ?

就需要研究下 bean 的实例化过程 ，在这块内容中主要解决两部分内容，分别是

*  bean是如何创建的 
 *  实例化bean的三种方式，**构造方法**,**静态工厂和实例工厂**

在讲解这三种创建方式之前，我们需要先确认一件事 :

bean 本质上就是对象，对象在 new 的时候会使用构造方法完成，那创建 bean 也是使用构造方法完成的。

基于这个知识点出发，我们来验证 spring 中 bean 的三种创建方式

#### 1.**构造方法实例化**  ####

**步骤** **1:** **准备需要被创建的类**

准备一个 BookDao 和 BookDaoImpl 类

public interface BookDao {
        public void save();
    }

public class BookDaoImpl implements BookDao {
    
        public void save() {
            System.out.println("book dao save ...");
        }
    
    }

**步骤** **2:** **将类配置到** **Spring** **容器**

**步骤** **3:** **编写运行程序**

public class AppForInstanceBook {
        public static void main(String[] args) {
    
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    
            BookDao bookDao = (BookDao) ctx.getBean("bookDao");
    
            bookDao.save();
    
        }
    }

**步骤** **4:** **类中提供构造函数测试**

在 BookDaoImpl 类中添加一个无参构造函数，并打印一句话，方便观察结果。

public class BookDaoImpl implements BookDao {
    
        public BookDaoImpl() {
            System.out.println("book dao constructor is running ....");
        }
    
        public void save() {
            System.out.println("book dao save ...");
        }
    
    }

运行程序，如果控制台有打印构造函数中的输出，说明 Spring 容器在创建对象的时候也走的是构造函数

![06d5ceacda1042329b44ee076846a7d8.png][]

**步骤** **5:** **将构造函数改成** **private** **测试**

![a4351a3458bb4969b53fbf70a64934ea.png][]

运行程序，能执行成功 , 说明内部走的依然是构造函数 , 能访问到类中的私有构造方法 , 显而易见

Spring 底层用的是反射

**步骤** **6:** **构造函数中添加一个参数测试**

public class BookDaoImpl implements BookDao {
    
        private BookDaoImpl(int i) {
            System.out.println("book dao constructor is running ....");
        }
    
        public void save() {
            System.out.println("book dao save ...");
        }
    
    }

运行程序，

程序会报错，说明 Spring 底层使用的是类的无参构造方法。

![632ee75b1d634117b038c05eb8b1a153.png][]

#### **2.分析****Spring****的错误信息** ####

接下来，我们主要研究下Spring的报错信息来学一学如阅读。

错误信息从下往上依次查看，因为上面的错误大都是对下面错误的一个包装，最核心错误是在最下面

Caused by: java.lang.NoSuchMethodException:

com.itheima.dao.impl.BookDaoImpl.  <init>  ()

*  Caused by 翻译为引起，即出现错误的原因 
 *  java.lang.NoSuchMethodException:抛出的异常为 没有这样的方法异常 
 *  com.itheima.dao.impl.BookDaoImpl. <init> ():哪个类的哪个方法没有被找到导致的异常，<init> ()指定是类的构造方法，即该类的无参构造方法

如果最后一行错误获取不到错误信息，接下来查看第二层:

Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'bookDao' defined in class path resource \[applicationContext.xml\]: Instantiation of bean failed; **nested** exception is org.springframework.beans.**BeanInstantiationException**: Failed to instantiate \[com.itheima.dao.impl.BookDaoImpl\]: **No default constructor found**; nested exception is java.lang.NoSuchMethodException: com.itheima.dao.impl.BookDaoImpl.<init>()

*  nested:嵌套的意思，后面的异常内容和最底层的异常是一致的
 *  BeanInstantiationException:翻译为bean实例化异常
 *  No default constructor found:没有一个默认的构造函数被发现

#### 3.**静态工厂实例化**  ####

接下来研究Spring中的第二种bean的创建方式静态工厂实例化:

**工厂方式创建****bean**

在讲这种方式之前，我们需要先回顾一个知识点是使用工厂来创建对象的方式 :

(1) 准备一个 OrderDao 和 OrderDaoImpl 类

public class OrderDaoImpl implements OrderDao {
    
        public void save() {
            System.out.println("order dao save ...");
        }
    }

public interface OrderDao {
        public void save();
    }

(2) 创建一个工厂类 OrderDaoFactory 并提供一个 **静态方法**

//静态工厂创建对象
    public class OrderDaoFactory {
        public static OrderDao getOrderDao(){
            System.out.println("factory setup....");
            return new OrderDaoImpl();
        }
    }

(3) 编写 AppForInstanceOrder 运行类，在类中通过工厂获取对象

public class AppForInstanceOrder {
        public static void main(String[] args) {
            //通过静态工厂创建对象
            OrderDao orderDao = OrderDaoFactory.getOrderDao();
            orderDao.save();
    
    
    
        }
    }

![a4df9c61e6e64af78ba41ac3b7a26263.png][]

如果代码中对象是通过上面的这种方式来创建的，如何将其交给Spring来管理呢?

**静态工厂实例化**

这就要用到 Spring 中的静态工厂实例化的知识了，具体实现步骤为 :

(1) 在 spring 的配置文件 application.properties 中添加以下内容 :

class: 工厂类的类全名

factory-mehod: 具体工厂类中创建对象的方法名

对应关系如下图

![f837e5f10d1341e18f378da09869d316.png][]

(2)在AppForInstanceOrder运行类，使用从IOC容器中获取bean的方法进行运行测试

public class AppForInstanceOrder {
        public static void main(String[] args) {
            //通过静态工厂创建对象
    //        OrderDao orderDao = OrderDaoFactory.getOrderDao();
    //        orderDao.save();
    
    
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    
            OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");
    
            orderDao.save();
    
        }
    }

![37203fe80412458e9795c0a34cb584b3.png][]

#### 4.**实例工厂** ####

接下来继续来研究Spring的第三种bean的创建方式实例工厂实例化:

**环境准备**

(1) 准备一个 UserDao 和 UserDaoImpl 类

public interface UserDao {
        public void save();
    }

public class UserDaoImpl implements UserDao {
    
        public void save() {
            System.out.println("user dao save ...");
        }
    }

(2) 创建一个工厂类 OrderDaoFactory 并提供一个普通方法，注意此处和静态工厂的工厂类不一样的

地方是方法不是静态方法

//实例工厂创建对象
    public class UserDaoFactory {
        public UserDao getUserDao(){
            return new UserDaoImpl();
        }
    }

(3) 编写 AppForInstanceUser 运行类，在类中通过工厂获取对象

public class AppForInstanceUser {
        public static void main(String[] args) {
            //创建实例工厂对象
            UserDaoFactory userDaoFactory = new UserDaoFactory();
            //通过实例工厂对象创建对象
            UserDao userDao = userDaoFactory.getUserDao();
            userDao.save();
    
    
        }
    }

运行后，可以查看到结果

![cdb76bd5fe6f44a98081114956623fa6.png][]

对于上面这种实例工厂的方式如何交给Spring管理呢?

**实例工厂实例化**

具体实现步骤为 :

(1) 在 spring 的配置文件中添加以下内容 :

实例化工厂运行的顺序是 :

*  创建实例化工厂对象,对应的是第一行配置 
 *  调用对象中的方法来创建bean，对应的是第二行配置
 *  factory-bean: 工厂的实例对象 
 *  factory-method:工厂对象中的具体创建对象的方法名 , 对应关系如下 :

![93e5090bed3145a3b7044389a632ad92.png][]

factory-mehod:具体工厂类中创建对象的方法名

(2)在AppForInstanceUser运行类，使用从IOC容器中获取bean的方法进行运行测试

![34eca4b68b944b36b436a089477a1a74.png][]

实例工厂实例化的方式就已经介绍完了，配置的过程还是比较复杂，所以Spring为了简化这种配置方式就提供了一种叫FactoryBean的方式来简化开发。

#### 5.**FactoryBean** ####

具体的使用步骤为 :

(1) 创建一个 UserDaoFactoryBean 的类，实现 FactoryBean 接口，重写接口的方法

//FactoryBean创建对象
    public class UserDaoFactoryBean implements FactoryBean<UserDao> {
        //代替原始实例工厂中创建对象的方法
        public UserDao getObject() throws Exception {
            return new UserDaoImpl();
        }
    
        public Class<?> getObjectType() {
            return UserDao.class;
        }
    
    }

(2) 在 Spring 的配置文件中进行配置

(3)AppForInstanceUser 运行类不用做任何修改，直接运行

![4468ef2f3a394feb967786917e07e69e.png][]

这种方式在 Spring 去整合其他框架的时候会被用到，所以这种方式需要大家理解掌握。

查看源码会发现， FactoryBean 接口其实会有三个方法，分别是 :

getObject() throws Exception;
    
     Class<?> getObjectType();
    
     default boolean isSingleton() {
     return true;
     }

方法一 :getObject() ，被重写后，在方法中进行对象的创建并返回

方法二 :getObjectType(), 被重写后，主要返回的是被创建类的 Class 对象

方法三 : 没有被重写，因为它已经给了默认值，从方法名中可以看出其作用是设置对象是否为单例，默认true ，从意思上来看，我们猜想默认应该是单例，如何来验证呢 ?

思路很简单，就是从容器中获取该对象的多个值，打印到控制台，查看是否为同一个对象。

public class AppForInstanceUser {
        public static void main(String[] args) {
    
    
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    
            UserDao userDao1 = (UserDao) ctx.getBean("userDao");
            UserDao userDao2 = (UserDao) ctx.getBean("userDao");
            System.out.println(userDao1);
            System.out.println(userDao2);
    //        userDao.save();
    
        }
    }

打印结果，如下 :

![ec17872b05fd45239c4945aa2b3615eb.png][]

通过验证，会发现默认是单例，那如果想改成单例具体如何实现?

只需要将 isSingleton() 方法进行重写，修改返回为 false ，即可

public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    
    
        public UserDao getObject() throws Exception {
            return new UserDaoImpl();
        }
    
        public Class<?> getObjectType() {
            return UserDao.class;
        }
    
        public boolean isSingleton() {
            return false;
        }
     
    
    
    }

重新运行 AppForInstanceUser ，查看结果

![7e4b1f8f02884a47b7e6e30eadf08346.png][]

从结果中可以看出现在已经是非单例了，但是一般情况下我们都会采用单例，也就是采用默认即可。所以isSingleton() 方法一般不需要进行重写。

## 三、**bean的生命周期**  ##

关于 bean 的相关知识还有最后一个是 bean 的生命周期 , 对于生命周期，我们主要围绕着 bean 生命周期控制来讲解 :

首先理解下什么是生命周期 ?

*  从创建到消亡的完整过程,例如人从出生到死亡的整个过程就是一个生命周期。

bean 生命周期是什么 ?

*  bean对象从创建到销毁的整体过程。

构造方法 bean 生命周期控制是什么 ?

*  在bean创建后到销毁前做一些事情。

现在我们面临的问题是如何在 bean 的创建之后和销毁之前把我们需要添加的内容添加进去。

#### 1.**环境准备** ####

项目结构：

![a263bc90e2234275a1f30d2a22187221.png][]

(1)项目中添加BookDao、BookDaoImpl、BookService和BookServiceImpl类

public interface BookDao {
        public void save();
    }

public class BookDaoImpl implements BookDao {
    public void save() {
    System.out.println("book dao save ...");
    }
    }

public class BookServiceImpl implements BookService{
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
    this.bookDao = bookDao;
    }
    public void save() {
    System.out.println("book service save ...");
    bookDao.save();
    }
    }

(2)resources 下提供 spring 的配置文件

(3) 编写 AppForLifeCycle 运行类，加载 Spring 的 IOC 容器，并从中获取对应的 bean 对象

#### **2.生命周期设置**  ####

接下来，在上面这个环境中来为 BookDao 添加生命周期的控制方法，具体的控制有两个阶段 :

*  bean创建之后，想要添加内容，比如用来初始化需要用到资源 
 *  bean销毁之前，想要添加内容，比如用来释放用到的资源

**步骤****1:****添加初始化和销毁方法**

针对这两个阶段，我们在 BookDaoImpl 类中分别添加两个方法， **方法名任意**

public class BookDaoImpl implements BookDao {
        public void save() {
            System.out.println("book dao save ...");
        }
        //表示bean初始化对应的操作
        public void init(){
            System.out.println("init...");
        }
        //表示bean销毁前对应的操作
        public void destory(){
            System.out.println("destory...");
        }
    
    }

**步骤****2:****配置生命周期**

在配置文件添加配置，如下 :

**运行程序**

![5813ee7d87944b7a855e91da7b4c2495.png][]

从结果中可以看出， init 方法执行了，但是 destroy 方法却未执行，这是为什么呢 ?

*  Spring的IOC容器是运行在JVM中 
 *  运行main方法后,JVM启动,Spring加载配置文件生成IOC容器,从容器获取bean对象，然后调方 法执行 
 *  main方法执行完后，JVM退出，这个时候IOC容器中的bean还没有来得及销毁就已经结束了 所以没有调用对应的destroy方法

知道了出现问题的原因，具体该如何解决呢 ?

#### 3.**close****关闭容器**  ####

调用ctx的close()方法

public class AppForLifeCycle {
        public static void main( String[] args ) {
            ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    
            BookDao bookDao = (BookDao) ctx.getBean("bookDao");
            bookDao.save();
            ctx.close();
        }
    }

运行程序，就能执行 destroy 方法的内容：

![d9397f41f923428bb32942126fc0d471.png][]

**注册钩子关闭容器**

*  在容器未关闭之前，提前设置好回调函数，让JVM在退出之前回调此函数来关闭容器 
 *  调用ctx的registerShutdownHook()方法

![4c3a93aab1424c35b80ab1b07e7387f5.png][]

两种方式介绍完后， close 和 registerShutdownHook 选哪个 ?

**相同点** : 这两种都能用来关闭容器

**不同点** :close() 是在调用的时候关闭， registerShutdownHook() 是在 JVM 退出前调用关闭。

分析上面的实现过程，会发现添加初始化和销毁方法，即需要编码也需要配置，实现起来步骤比较多也比较乱。

Spring 提供了两个接口来完成生命周期的控制，好处是可以不用再进行配置 init \- method 和destroy- method

接下来在 BookServiceImpl 完成这两个接口的使用 :

修改BookServiceImpl 类，添加两个接口 InitializingBean ，  DisposableBean 并实现接口中的

两个方法 afterPropertiesSet 和 destroy

public class BookServiceImpl implements BookService,InitializingBean,DisposableBean
    {
        private BookDao bookDao;
    
        public void setBookDao(BookDao bookDao) {
            System.out.println("set .....");
            this.bookDao = bookDao;
        }
    
        public void save() {
            System.out.println("book service save ...");
            bookDao.save();
        }
    
        public void destroy() throws Exception {
            System.out.println("service destroy");
        }
    
        public void afterPropertiesSet() throws Exception {
            System.out.println("service init");
        }
    }

pox.xml:

重新运行 AppForLifeCycle 类

![5d9ac25a7f7d40bb9e8ee8c63444ea32.png][]

**bean** **生命周期小结**

(1) 关于 Spring 中对 bean 生命周期控制提供了两种方式 :

*  在配置文件中的bean标签中添加init\-method和destroy\-method属性 
 *  类实现InitializingBean与DisposableBean接口，这种方式了解下即可。

(2) 对于 bean 的生命周期控制在 bean 的整个生命周期中所处的位置如下 :

初始化容器

*  1.创建对象(内存分配) 
 *  2.执行构造方法 
 *  3.执行属性注入(set操作) 
 *  **4.****执行****bean****初始化方法**

使用 bean

*  1.执行业务操作

关闭 / 销毁容器

*  **1.****执行****bean****销毁方法**

(3) 关闭容器的两种方式 :

ConfigurableApplicationContext 是 ApplicationContext 的子类

*  close()方法 
 *  registerShutdownHook()方法

[Spring]: https://blog.csdn.net/javascript_tsj/category_11957185.html?spm=1001.2014.3001.5482
[Link 1]: https://blog.csdn.net/Javascript_tsj?type=blog
[238ac3aca6c84db5ace9d398801431b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/505c7d1e20694bea845537bb131e5e15.png
[0166a244970249c9b6e6193f90dae116.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/a961f3322744456583a42768892d4c0c.png
[b01acaf2cf2245d2a6b4f2e1bed17eaf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/b707341b536d4a518b2026fa1df53b2c.png
[1ca0b7a57e4548c887c0c39875e315a3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/bfe3384e560b4df7a6a5b61959f00543.png
[bd4c36158a56401c8a2f2e9ac9b9043a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/1e09fe38674347eba12928b05561441c.png
[c9914bf02af643cb8928dc3b6a008ea7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/4063925da6b94904b2645194191877e0.png
[61a658c619014ece86e8f4a6654be782.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/fc51734683ff4cb9a08fb67e8a8c9fe1.png
[55370e052f224fc281e04e193818327c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/b33fe027fa284c99b3a4aa6fd8f29851.png
[fba74ecad018460c91bdb53fe5542a84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/06ea5c1cc23344328b4deaf4032ad0bb.png
[06d5ceacda1042329b44ee076846a7d8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/f96ec087a1fa4d3e9dc859e4a3f7c57c.png
[a4351a3458bb4969b53fbf70a64934ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/115eb4f805c04d72a1cf8433781f1b6b.png
[632ee75b1d634117b038c05eb8b1a153.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/9267943c503c443ba91d03e83c72009f.png
[a4df9c61e6e64af78ba41ac3b7a26263.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/772e7de1698c4ae1bedfd551b615cac0.png
[f837e5f10d1341e18f378da09869d316.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/d32aec6fe28940ecb6499cf41088d5f6.png
[37203fe80412458e9795c0a34cb584b3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/a8eec4c84fd044cba200e3b511198232.png
[cdb76bd5fe6f44a98081114956623fa6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/ecc4f711f6114a5190f0435e62848748.png
[93e5090bed3145a3b7044389a632ad92.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/efec270b31a84c55a0e5f5c65492849a.png
[34eca4b68b944b36b436a089477a1a74.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/6e97927ec66b4a23a2828db29c2cfe93.png
[4468ef2f3a394feb967786917e07e69e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/3eb3eaeb4fd84c9eb2f030fc485a53a4.png
[ec17872b05fd45239c4945aa2b3615eb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/ebf282f1fd434e3785d65f8139be67d7.png
[7e4b1f8f02884a47b7e6e30eadf08346.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/399c0ffead6941aeb2b386d171c13003.png
[a263bc90e2234275a1f30d2a22187221.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/0a67022274fb4690a26d8e0c31f9f7e8.png
[5813ee7d87944b7a855e91da7b4c2495.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/d4d2bf302db548e6a59cb377815bcc82.png
[d9397f41f923428bb32942126fc0d471.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/7eb8c4e1d399407682e3d1ed8952e861.png
[4c3a93aab1424c35b80ab1b07e7387f5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/7fd53b08fa1e45f3b90d125bdf886425.png
[5d9ac25a7f7d40bb9e8ee8c63444ea32.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/4db94a5b654d42de9b8d2886fd1fc663.png