一文读懂 Spring Bean 的生命周期

以你之姓@ 2022-10-13 01:59 178阅读 0赞

> 欢迎大家关注我的微信公众号【老周聊架构】，Java后端主流技术栈的原理、源码分析、架构以及各种互联网高并发、高性能、高可用的解决方案。

## 一、前言 ##

今天我们来说一说 Spring Bean 的生命周期，小伙伴们应该在面试中经常遇到，这是正常现象。因为 Spring Bean 的生命周期是除了 IoC、AOP 几个核心概念之外最重要概念，大家务必拿下。可 Spring 源代码又比较复杂，跟着跟着就不知道跟到哪里去了，不太好拿下呀。这倒是真的，而且网上一上来就各种贴流程源码，对初学者来说是真的一脸懵逼，就像字都看的懂，但连在一块就不知道意思了，太绕了。

本文老周试着讲的通俗易懂些，让更多的小伙伴们轻松的读懂 Spring Bean 的生命周期，并有对它有继续研究学习的想法，那我写此文的目的也就达到了。

我们讲 Spring Bean 的生命周期之前先来了解两个概念：

**1.1 什么是 Bean**

我们来看下 Spring Framework 的官方文档：

> In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC container are called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. Otherwise, a bean is simply one of many objects in your application. Beans, and the dependencies among them, are reflected in the configuration metadata used by a container.

简而言之，bean 是由 Spring IoC 容器实例化、组装和管理的对象。

**1.2 什么是 Spring Bean 的生命周期**

对于普通的 Java 对象，当 new 的时候创建对象，然后该对象就能够使用了。一旦该对象不再被使用，则由 Java 自动进行垃圾回收。

而 Spring 中的对象是 bean，bean 和普通的 Java 对象没啥大的区别，只不过 Spring 不再自己去 new 对象了，而是由 IoC 容器去帮助我们实例化对象并且管理它，我们需要哪个对象，去问 IoC 容器要即可。IoC 其实就是解决对象之间的耦合问题，Spring Bean 的生命周期完全由容器控制。

## 二、Spring Bean 的生命周期 ##

这里老周必须要提一下，这里我们说的 Spring Bean 的生命周期主要指的是 singleton bean，对于 prototype 的 bean ，Spring 在创建好交给使用者之后则不会再管理后续的生命周期。

我们也来复习下 Spring 中的 bean 的作用域有哪些?

*  `singleton` : 唯一 bean 实例，Spring 中的 bean 默认都是单例的。
 *  `prototype` : 每次请求都会创建一个新的 bean 实例。
 *  `request` : 每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP request 内有效。
 *  `session` : 每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP session 内有效。
 *  `global-session`： 全局 session 作用域，仅仅在基于 Portlet 的 web 应用中才有意义，Spring5 已经没有了。Portlet 是能够生成语义代码（例如：HTML）片段的小型 Java Web 插件。它们基于 portlet 容器，可以像 servlet 一样处理 HTTP 请求。但是，与 servlet 不同，每个 portlet 都有不同的会话。

我们知道对于普通的 Java 对象来说，它们的生命周期就是：

*  实例化
 *  该对象不再被使用时通过垃圾回收机制进行回收

而对于 Spring Bean 的生命周期来说：

*  实例化 Instantiation
 *  属性赋值 Populate
 *  初始化 Initialization
 *  销毁 Destruction

实例化 -> 属性赋值 -> 初始化 -> 销毁

只有四个步骤，这样拆解的话是不是感觉也不难？不像其他人写的那样直接一上来就各种 BeanPostProcessor、BeanFactoryPostProcessor 全部怼进流程里去，别说读者看着头大，自己写的可能短时间内还记得流程，隔个一段时间，你可能都不知道自己写了个啥。

本来老周想通过 Bean 创建流程入口  
AbstractApplicationContext\#refresh() 方法的 finishBeanFactoryInitialization(beanFactory) 处带大家跟一下源码，想了想还是不带入过多的代码进来，直接给到最终的主要逻辑。

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { 
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) { 
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }
    
        if (instanceWrapper == null) { 
        	// 实例化阶段
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }
    
        ...
    
        Object exposedObject = bean;
    
        try { 
        	// 属性赋值阶段
            this.populateBean(beanName, mbd, instanceWrapper);
            // 初始化阶段
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable var18) { 
            ...
        }
    
        ...
    }

至于销毁，是在容器关闭时调用的，详见 `ConfigurableApplicationContext#close()`

是不是很清爽了？至于 BeanPostProcessor、BeanFactoryPostProcessor 以及其他的类，在老周看来，只不过是对主流程四个步骤的一系列扩展点而已。

## 三、Spring Bean 的生命周期的扩展点 ##

Spring Bean 的生命周期的扩展点超级多，老周这里不可能全部列出来，只说核心的扩展点。这也就是为什么 Spring 的扩展性很好的原因，开了很多的口子，尽可能让某个功能高内聚松耦合，用户需要哪个功能就用哪个，而不是直接来一个大而全的东西。

**3.1 Bean 自身的方法**

比如构造函数、getter/setter 以及 init-method 和 destory-method 所指定的方法等，也就对应着上文说的实例化 -> 属性赋值 -> 初始化 -> 销毁四个阶段。

![在这里插入图片描述][20210707002134280.png]  
**3.2 容器级的方法（BeanPostProcessor 一系列接口）**

主要是后处理器方法，比如下图的 `InstantiationAwareBeanPostProcessor`、`BeanPostProcessor` 接口方法。这些接口的实现类是独立于 Bean 的，并且会注册到 Spring 容器中。在 Spring 容器创建任何 Bean 的时候，这些后处理器都会发生作用。

![在这里插入图片描述][20210707225212729.png]  
**3.2.1 InstantiationAwareBeanPostProcessor 源码分析**

我们翻一下源码发现 InstantiationAwareBeanPostProcessor 是继承了 BeanPostProcessor

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

*  `InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation` 调用点

> Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)  
> 返回值：如果返回的不为null，那么后续的Bean的创建流程【实例化、初始化afterProperties】都不会执行，而是直接使用返回的快捷Bean，此时的正常执行顺序如下：  
> InstantiationAwareBeanPostProcessor接口中的postProcessBeforeInstantiation，在实例化之前调用。  
> BeanPostProcessor接口中的postProcessAfterInitialization，在实例化之后调用。

![在这里插入图片描述][20210707233026943.png]  
![在这里插入图片描述][20210707235533784.png]  
![在这里插入图片描述][20210708000048835.png]  
![在这里插入图片描述][20210708000228655.png]  
总之，postProcessBeforeInstantiation 在 doCreateBean 之前调用，也就是在 bean 实例化之前调用的，英文源码注释解释道该方法的返回值会替换原本的 Bean 作为代理，这也是 AOP 等功能实现的关键点。

*  `InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation` 调用点

> boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException  
> 正常情况下在实例化之后在执行populateBean之前调用  
> 返回值：如果有指定的bean的时候返回false，那么后续的属性填充和属性依赖注入【populateBean】将不会执行，同时后续的postProcessPropertyValues将不会执行,但是初始化和BeanPostProcessor的仍然会执行。

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

> public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor\[\] pds, Object bean, String beanName)  
> 实例化之后调用，在方法applyPropertyValues【属性填充】之前  
> 返回值：如果返回null，那么将不会进行后续的属性填充，比如依赖注入等，如果返回的pvs额外的添加了属性，那么后续会填充到该类对应的属性中。  
> pvs：PropertyValues对象，用于封装指定类的对象，简单来说就是PropertyValue的集合，里面相当于以key-value形式存放类的属性和值。  
> pds：PropertyDescriptor对象数组，PropertyDescriptor相当于存储类的属性，不过可以调用set，get方法设置和获取对应属性的值。

![在这里插入图片描述][20210708010057366.png]  
**3.2.2 BeanPostProcessor 源码分析**

> org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory\#doCreateBean

![在这里插入图片描述][20210708232740951.png]  
进入初始化接口：

![在这里插入图片描述][20210708233139731.png]  
我们先来看

> org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory\#applyBeanPostProcessorsBeforeInitialization

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

*  首先获取到所有的后置处理器 getBeanPostProcessors()
 *  在 for 循环中依次调用后置处理器的方法 `processor.postProcessBeforeInitialization(result, beanName);`
 *  进入 postProcessBeforeInitialization 方法

> org.springframework.context.support.ApplicationContextAwareProcessor\#postProcessBeforeInitialization

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

进入 `invokeAwareInterfaces(bean);` 方法，当前 bean 实现了 ApplicationContextAware 接口。

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

*  `ApplicationContextAwareProcessor#postProcessBeforeInitialization` 首先判断此 bean 是不是各种的Aware，如果是它列举的那几个 Aware 就获取 Bean 工厂的权限，可以向容器中导入相关的上下文环境，目的是为了 Bean 实例能够获取到相关的上下文，如果不是它列举的几个 Aware，那就调用 `invokeAwareInterfaces(bean)`，向容器中添加相关接口的上下文环境。

**3.3 工厂后处理器方法（BeanFactoryProcessor 一系列接口）**

包括 `AspectJWeavingEnabler`、`CustomAutowireConfigurer`、`ConfigurationClassPostProcessor` 等。这些都是 Spring 框架中已经实现好的 BeanFactoryPostProcessor，用来实现某些特定的功能。

我们知道 Spring IoC 容器初始化的关键环节就在 `org.springframework.context.support.AbstractApplicationContext#refresh` 方法中 ，容器创建的主体流程都在这个方法里面，这个方法是真的重要！！！

对于工厂后处理器方法老周这里直接带你看 `invokeBeanFactoryPostProcessors(beanFactory);` 方法，这个方法处理的是 `BeanFactoryPostProcessor` 接口的 Bean。调用方法如下：

![在这里插入图片描述][20210709231013239.png]  
跟到最重要的方法里去，代码虽长，但逻辑中规中矩。

`BeanFactoryPostProcessor`：一切处理 BeanFactory 的父接口  
`BeanDefinitionRegistryPostProcessor`：实现了 BeanFactoryPostProcessor 接口的接口

![在这里插入图片描述][20210709233225102.png]  
流程说明：

*  调用 BeanDefinitionRegistryPostProcessor\#postProcessBeanDefinitionRegistry(registry) 方法。参数 beanFactoryPostProcessors 传入的优先处理掉。然后获取容器注册的，对于这些 Bean 按照 PriorityOrdered 接口、Ordered、没有排序接口的实例分别进行处理。
 *  调用 BeanFactoryPostProcessor\#postProcessBeanFactory(beanFactory) 方法。备注：BeanDefinitionRegistryPostProcessor 属于 BeanFactoryPostProcessor 子接口。先处理属于 BeanDefinitionRegistryPostProcessor 接口实例的 postProcessBeanFactory(beanFactory) 方法，然后获取容器注册的。对于这些 Bean 按照 PriorityOrdered 接口、Ordered、没有排序接口的实例分别进行处理。

**3.4 Bean 级生命周期方法**

可以理解为 Bean 类直接实现接口的方法，比如 `BeanNameAware`、`BeanFactoryAware`、`ApplicationContextAware`、`InitializingBean`、`DisposableBean` 等方法，这些方法只对当前 Bean 生效。

**3.4.1 Aware 类型的接口**

Aware 类型的接口的作用就是让我们能够拿到 Spring 容器中的一些资源。基本都能够见名知意，Aware 之前的名字就是可以拿到什么资源，例如 BeanNameAware 可以拿到 BeanName，以此类推。调用时机需要注意：所有的 Aware 方法都是`在初始化阶段之前调用的`。

Aware 接口众多，这里同样通过分类的方式帮助大家记忆。Aware 接口具体可以分为两组，至于为什么这么分，详见下面的源码分析。如下排列顺序同样也是 Aware 接口的执行顺序，能够见名知意的接口不再解释。

**Aware Group1**

*  `BeanNameAware`
 *  `BeanClassLoaderAware`
 *  `BeanFactoryAware`

**Aware Group2**

*  `EnvironmentAware`
 *  `EmbeddedValueResolverAware`  
    这个知道的人可能不多，实现该接口能够获取 Spring EL 解析器，用户的自定义注解需要支持 SPEL 表达式的时候可以使用，非常方便。
 *  `ApplicationContextAware(ResourceLoaderAware/ApplicationEventPublisherAware/MessageSourceAware)`  
    这几个接口可能让人有点懵，实际上这几个接口可以一起记，其返回值实质上都是当前的 ApplicationContext 对象，因为 ApplicationContext 是一个复合接口，如下：  
    ![在这里插入图片描述][2021071000362926.png]

**Aware 调用时机源码分析**

![在这里插入图片描述][20210710005027150.png]  
可以看到并不是所有的 Aware 接口都使用同样的方式调用。Bean××Aware 都是在代码中直接调用的，而 ApplicationContext 相关的 Aware 都是通过 BeanPostProcessor\#postProcessBeforeInitialization() 实现的。感兴趣的可以自己看一下 ApplicationContextAwareProcessor 这个类的源码，就是判断当前创建的 Bean 是否实现了相关的 Aware 方法，如果实现了会调用回调方法将资源传递给 Bean。

BeanPostProcessor 的调用时机也能在这里体现，包围住 invokeInitMethods 方法，也就说明了在初始化阶段的前后执行。

关于 Aware 接口的执行顺序，其实只需要记住第一组在第二组执行之前就行了。

**3.4.2 生命周期接口**

至于剩下的两个生命周期接口就很简单了，实例化和属性赋值都是 Spring 帮助我们做的，能够自己实现的有初始化和销毁两个生命周期阶段。

*  `InitializingBean` 对应生命周期的初始化阶段，在上面源码的 `invokeInitMethods(beanName, wrappedBean, mbd);`方法中调用。  
    有一点需要注意，因为 Aware 方法都是执行在初始化方法之前，所以可以在初始化方法中放心大胆的使用 Aware 接口获取的资源，这也是我们自定义扩展 Spring 的常用方式。  
    除了实现 InitializingBean 接口之外还能通过注解或者 xml 配置的方式指定初始化方法，至于这几种定义方式的调用顺序其实没有必要记。因为这几个方法对应的都是同一个生命周期，只是实现方式不同，我们一般只采用其中一种方式。
 *  `DisposableBean` 类似于 InitializingBean，对应生命周期的销毁阶段，以`ConfigurableApplicationContext#close()`方法作为入口，实现是通过循环取所有实现了 DisposableBean 接口的 Bean 然后调用其 destroy() 方法，感兴趣的可以自行跟一下源码。

**3.5 Spring Bean 生命周期流程图**

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

## 四、常用接口说明 ##

**4.1 BeanNameAware**

该接口只有一个方法 `setBeanName(String name)`，用来获取 bean 的 `id 或者 name`。

**4.2 BeanFactoryAware**

该接口只有一个方法 `setBeanFactory(BeanFactory beanFactory)`，用来获取`当前环境中的 BeanFactory`。

**4.3 ApplicationContextAware**

该接口只有一个方法 `setApplicationContext(ApplicationContext applicationContext)`，用来获取`当前环境中的 ApplicationContext`。

**4.4 InitializingBean**

该接口只有一个方法 `afterPropertiesSet()`，在`属性注入完成后调用`。

**4.5 DisposableBean**

该接口只有一个方法 `destroy()`，在容器销毁的时候调用，在`用户指定的 destroy-method 之前调用`。

**4.6 BeanPostProcessor**

该接口有两个方法：

*  `postProcessBeforeInitialization(Object bean, String beanName)`：在`初始化之前`调用此方法
 *  `postProcessAfterInitialization(Object bean, String beanName)`：在`初始化之后`调用此方法

通过方法签名我们可以知道，我们可以通过 beanName 来筛选出我们需要进行个性化定制的 bean。

**4.7 InstantiationAwareBeanPostProcessor**

该类是 BeanPostProcessor 的子接口，常用的有如下三个方法：

*  `postProcessBeforeInstantiation(Class beanClass, String beanName)`：在bean`实例化之前`调用
 *  `postProcessProperties(PropertyValues pvs, Object bean, String beanName)`：在bean`实例化之后、设置属性前`调用
 *  `postProcessAfterInstantiation(Class beanClass, String beanName)`：在bean`实例化之后`调用

## 五、代码演示 ##

思路：创建一个类 UserBean ，让其实现几个特殊的接口，并分别在接口实现的构造器、接口方法中断点，观察线程调用栈，分析出 Bean 对象创建和管理关键点的触发时机。

**5.1 UserBean 类**

@Component
    public class UserBean implements InitializingBean, BeanNameAware, DisposableBean, ApplicationContextAware { 
    	private int id;
    
    	private String name;
    
    	public UserBean(int id, String name) { 
    		this.id = id;
    		this.name = name;
    		System.out.println("2. 调用构造函数");
    	}
    
    	public int getId() { 
    		return id;
    	}
    
    	public void setId(int id) { 
    		this.id = id;
    		System.out.println("5. 属性注入 id");
    	}
    
    	public String getName() { 
    		return name;
    	}
    
    	public void setName(String name) { 
    		this.name = name;
    		System.out.println("5. 属性注入 name");
    	}
    
    	@Override
    	public void setBeanName(String name) { 
    		System.out.println("6. 调用 BeanNameAware.setBeanName() 方法");
    	}
    
    	@Override
    	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { 
    		UserBean userBean = (UserBean) applicationContext.getBean("userBean");
    		System.out.println(userBean);
    		System.out.println("7. 调用 BeanNameAware.setBeanName() 方法");
    	}
    
    	@Override
    	public void afterPropertiesSet() throws Exception { 
    		System.out.println("9. 调用 InitializingBean.afterPropertiesSet() 方法");
    	}
    
    	public void myInit() { 
    		System.out.println("10. 调用 init-method 方法");
    	}
    
    	@Override
    	public void destroy() throws Exception { 
    		System.out.println("12. 调用 DisposableBean.destroy() 方法");
    	}
    
    	public void myDestroy() { 
    		System.out.println("13. 调用 destroy-method 方法");
    	}
    
    	@Override
    	public String toString() { 
    		return "UserBean{" +
    				"id=" + id +
    				", name='" + name + '\'' +
    				'}';
    	}
    }

**5.2 InstantiationAwareBeanPostProcessor 接口实现类**

@Component
    public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor { 
    	@Override
    	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException { 
    		if ("userBean".equals(beanName)) { 
    			System.out.println("1. 调用 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation() 方法");
    		}
    		return null;
    	}
    
    	@Override
    	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException { 
    		if ("userBean".equals(beanName)) { 
    			UserBean userBean = (UserBean) bean;
    			System.out.println("3. 调用 InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation() 方法");
    			System.out.println(userBean);
    		}
    		return true;
    	}
    
    	@Override
    	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException { 
    		if ("userBean".equals(beanName)) { 
    			System.out.println("4. 调用 InstantiationAwareBeanPostProcessor.postProcessProperties() 方法");
    		}
    		return null;
    	}
    }

**5.3 BeanPostProcessor 接口实现类**

@Component
    public class MyBeanPostProcessor implements BeanPostProcessor { 
    	@Override
    	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
    		if ("userBean".equals(beanName)) { 
    			System.out.println("8. 调用 BeanPostProcessor.postProcessBeforeInitialization() 方法");
    		}
    		return bean;
    	}
    
    	@Override
    	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
    		if ("userBean".equals(beanName)) { 
    			System.out.println("11. 调用 BeanPostProcessor.postProcessAfterInitialization() 方法");
    		}
    		return bean;
    	}
    }

**5.4 BeanFactoryPostProcessor 接口实现类**

@Component
    public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor { 
    	@Override
    	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { 
    		System.out.println("0. 调用 BeanFactoryPostProcessor.postProcessBeanFactory() 方法");
    	}
    }

**5.5 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 https://www.springframework.org/schema/beans/spring-beans.xsd ">
    
    	<bean class="com.riemann.test.MyInstantiationAwareBeanPostProcessor" />
    
    	<bean id="userBean" class="com.riemann.test.UserBean" init-method="myInit" destroy-method="myDestroy">
    		
    		<constructor-arg index="0" type="int">
    			<value>1</value>
    		</constructor-arg>
    		<constructor-arg index="1" type="java.lang.String">
    			<value>微信公众号【老周聊架构】</value>
    		</constructor-arg>
    
    		
    		<property name="id" value="2"/>
    		<property name="name" value="riemann"/>
    	</bean>
    
    	<bean class="com.riemann.test.MyBeanPostProcessor" />
    
    	<bean class="com.riemann.test.MyBeanFactoryPostProcessor" />
    	
    </beans>

**5.6 测试类**

public class BeanLifeCycleTest { 
    	public static void main(String[] args) { 
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    		UserBean user = (UserBean) applicationContext.getBean("userBean");
    		((AbstractApplicationContext) applicationContext).close();
    	}
    }

**5.7 控制台结果打印**

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

[20210707002134280.png]: /images/20221005/55433bf955414cdba272c8a06509c566.png
[20210707225212729.png]: /images/20221005/d0b2c80e4f844c5b83506170420dfab7.png?
[20210707230505579.png]: /images/20221005/01cfef7abd9a43299928bc64c3ac39d8.png
[20210707230919307.png]: /images/20221005/34e8cdfd81d94934b29577dcb46340a7.png
[20210707233026943.png]: /images/20221005/e9f6d0446d364a9b84d15de14cd2b65c.png
[20210707235533784.png]: /images/20221005/b3aad4f474d448b79a8a6b4c5c714ffe.png
[20210708000048835.png]: /images/20221005/c3ebc13b6c0e49a795d44c6e708caf0e.png
[20210708000228655.png]: /images/20221005/9539c4dd599846fe8adef26db24bc07e.png
[20210708005050274.png]: /images/20221005/ab2cfde0f40f418cbe772c9827d2f47e.png
[20210708010057366.png]: /images/20221005/6c4fa810a6534642b2cb4257caa98d66.png
[20210708232740951.png]: /images/20221005/e264c0a0f5df4d19a501224e5bc8cdd2.png
[20210708233139731.png]: /images/20221005/135ad52f8e5841ff918bbfeabeffdeec.png
[20210708233742525.png]: /images/20221005/035b17920e2b44da991b44aee2910b1e.png
[20210708234443215.png]: /images/20221005/7d44b588a6d5447789da3768eeb39450.png
[20210708234639952.png]: /images/20221005/e538752788714d169f0de8e4560fbf29.png
[20210709231013239.png]: /images/20221005/e52ebadf7e3f4c9eaa5c0c3d0d09e140.png
[20210709233225102.png]: /images/20221005/ebd10e4865d94f07b495b0c8ec205302.png
[2021071000362926.png]: /images/20221005/4e0fa3dceeab49369c251f26ecac8af4.png
[20210710005027150.png]: /images/20221005/7c6075763ba94f6884cfa8bc09670166.png
[20210710134349143.png]: /images/20221005/edb71f5380724659bf422f820790a4fe.png
[20210711212237789.png]: /images/20221005/a38ecca8b99e4af0953bf5b5ed8a3904.png