Spring之依赖注入（IOC、DI）详解---配置Bean

r囧r小猫 2022-07-11 04:18 210阅读 0赞

# Spring是什么 #

*  轻量级：Spring 是非侵入性的 - 基于 Spring 开发的应用中的对象可以不依赖于 Spring 的 API
 *  依赖注入(DI — dependency injection、IOC)
 *  面向切面编程(AOP — aspect oriented programming)
 *  容器: Spring 是一个容器, 因为它包含并且管理应用对象的生命周期
 *  框架: Spring 实现了使用简单的组件配置组合成一个复杂的应用. 在 Spring 中可以使用 XML 和 Java 注解组合这些对象
 *  一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 （实际上 Spring 自身也提供了展现层的 SpringMVC 和 持久层的 Spring JDBC）

# IOC & DI 概述 #

推荐一个知乎帖子，从概念上形象的说明了IOC的思想：[https://www.zhihu.com/question/23277575][https_www.zhihu.com_question_23277575]

**IOC(Inversion of Control)**：其思想是反转资源获取的方向. 传统的资源查找方式要求组件向容器发起请求查找资源. 作为回应, 容器适时的返回资源. 而应用了 IOC 之后, 则是容器主动地将资源推送给它所管理的组件, 组件所要做的仅是选择一种合适的方式来接受资源. 这种行为也被称为查找的被动形式

\*\*DI(Dependency Injection) \*\*：IOC 的另一种表述方式：即组件以一些预先定义好的方式(例如: setter 方法)接受来自如容器的资源注入. 相对于 IOC 而言，这种表述更直接

**需求：从容器中获取 B 对象，并使 B 对象的 a 属性被赋值为容器中 A 对象的引用**

**传统方式：**

![这里写图片描述][SouthEast]

class A{}
    
    class B{
    
    	private A a;
    	public void setA(A a){
    		this.a = a;
    	}
    }

**IOC**：

![这里写图片描述][SouthEast 1]

B b = getB();

**注：本篇博客中使用的类，出于简洁，大部分不提供其实现，都是最基本的bean**

### Spring容器 ###

在 Spring IOC 容器读取 Bean 配置创建 Bean 实例之前, 必须对它进行实例化. 只有在**容器实例化后, 才可以从 IOC 容器里获取 Bean 实例并使用**.

Spring 提供了两种类型的 IOC 容器实现：

*  BeanFactory: IOC 容器的基本实现
 *  ApplicationContext: 提供了更多的高级特性. 是 BeanFactory 的子接口.

BeanFactory 是 Spring 框架的基础设施，面向 Spring 本身；ApplicationContext 面向使用 Spring 框架的开发者，几乎所有的应用场合都**直接使用 ApplicationContext 而非底层的 BeanFactory**.无论使用何种方式, 配置文件时相同的.

**ApplicationContext 的主要实现类：**

*  ClassPathXmlApplicationContext：从 类路径下加载配置文件
 *  FileSystemXmlApplicationContext: 从文件系统中加载配置文件

**ApplicationContext 在初始化上下文时就实例化所有单例的 Bean。通过ApplicationContext中的getBean()方法来从IOC容器中获取Bean。**

# 依赖注入的方式 （Bean 的配置方式） #

## 基于 XML 文件的方式 ##

### 通过全类名（反射） ###

#### 属性注入 ####

*  属性注入即通过 setter 方法（**即对应的属性在类中要有对应的set方法**）注入Bean 的属性值或依赖的对象
 *  属性注入使用`<property>`元素, 使用 name 属性指定 Bean 的属性名称，value 属性或 `<value>`子节点指定属性值
 *  属性注入是实际应用中最常用的注入方式

#### 构造器注入 ####

\*\*分为按索引匹配入参和按类型匹配入参两种：\*\* \`\`\`

<bean id="car" class="com.atguigu.spring.helloworld.Car">
    	
    	
    	<constructor-arg value="KUGA" index="1"></constructor-arg>
    	<constructor-arg value="ChangAnFord" index="0"></constructor-arg>
    	<constructor-arg value="250000" type="float"></constructor-arg>
    </bean>
    
    <bean id="car2" class="com.atguigu.spring.helloworld.Car">
    	<constructor-arg value="ChangAnMazda" type="java.lang.String"></constructor-arg>
    	
    	<constructor-arg>
    		<value><![CDATA[<ATARZA>]]></value>
    	</constructor-arg>
    	
    	<constructor-arg  type="int">
    		<value>250</value>
    	</constructor-arg>
    </bean>

#### 引用其它Bean ####

组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能. 要使 Bean 能够相互访问, 就必须在 Bean 配置文件中指定对 Bean 的引用。在 Bean 的配置文件中, 可以通过 `<ref>` 元素或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用，也可以在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为内部 Bean。

![这里写图片描述][SouthEast 2]

**内部Bean：**

<bean id="service2" class="com.atguigu.spring.ref.Service">
    		<property name="dao">
    			
    			<bean class="com.atguigu.spring.ref.Dao">
    				<property name="dataSource" value="c3p0"></property>
    			</bean>
    		</property>
    	</bean>

#### 集合属性等复合形式 ####

在 Spring中可以通过一组内置的 xml 标签(例如: `<list>`, `<set>` 或 `<map>`) 来配置集合属性.配置 java.util.List 类型的属性, 需要指定 `<list>` 标签, 在标签里包含一些元素. 这些标签可以通过`<value>` 指定简单的常量值, 通过`<ref>` 指定对其他 Bean 的引用. 通过`<bean>` 指定内置 Bean 定义. 通过`<null/>` 指定空元素. 甚至可以内嵌其他集合.

<bean id="user" class="com.atguigu.spring.helloworld.User">
    		<property name="userName" value="Jack"></property>
    		<property name="cars">
    			
    			<list>
    				<ref bean="car"/>
    				<ref bean="car2"/>
    			</list>
    		</property>
    	</bean>

**注：如上通过ref引用的car和car2是在之前都已经配置好的Bean**

<util:list id="cars">
    		<ref bean="car"/>
    		<ref bean="car2"/>
    	</util:list>
    	
    	<bean id="user2" class="com.atguigu.spring.helloworld.User">
    		<property name="userName" value="Rose"></property>
    		
    		<property name="cars" ref="cars"></property>
    	</bean>

#### 使用p命名空间与继承、依赖关系的配置 ####

**p命名空间**  
为了简化 XML 文件的配置，越来越多的 XML 文件采用属性而非子元素配置信息。Spring 从 2.5 版本开始引入了一个新的 p 命名空间，可以通过 元素属性的方式配置 Bean 的属性。使用 p 命名空间后，基于 XML 的配置方式将进一步简化（使用p命名空间，则不必再使用`<property>`标签）：

**继承Bean配置**

*  Spring 允许继承 bean 的配置, 被继承的 bean 称为父 bean. 继承这个父 Bean 的 Bean 称为子 Bean
 *  子 Bean 从父 Bean 中继承配置, 包括 Bean 的属性配置
 *  子 Bean 也可以覆盖从父 Bean 继承过来的配置
 *  父 Bean 可以作为配置模板, 也可以作为 Bean 实例. 若只想把父 Bean 作为模板, 可以设置`<bean>`的abstract 属性为 true, 这样 Spring 将不会实例化这个 Bean，只能被继承
 *  并不是 `<bean>`元素里的所有属性都会被继承. 比如: autowire, abstract 等.
 *  若一个bean的class属性没有指定，则该bean必须是一个抽象bean
 *  也可以忽略父 Bean 的 class 属性, 让子 Bean 指定自己的类, 而共享相同的属性配置. 但此时 abstract 必须设为 true

<bean id="user4" parent="user" p:userName="Bob"></bean>
    	
    	<bean id="user6" parent="user" p:userName="维多利亚"></bean>

**依赖Bean配置**

**依赖Bean配置**：Spring 允许用户通过 depends-on 属性设定 Bean 前置依赖的Bean，前置依赖的 Bean 会在本 Bean 实例化之前创建好。如果前置依赖于多个 Bean，则可以通过逗号，空格或的方式配置 Bean 的名称。

<bean id="user5" parent="user" p:userName="Backham" depends-on="user6"></bean>

#### XML配置里的自动装配 ####

Spring IOC 容器可以自动装配 Bean. 需要做的仅仅是在`<bean>`的 autowire 属性里指定自动装配的模式：

*  byType(根据类型自动装配): 若 IOC 容器中有多个与目标 Bean 类型一致的 Bean. 在这种情况下, Spring 将无法判定哪个 Bean 最合适该属性, 所以不能执行自动装配.
 *  byName(根据名称自动装配): 必须将目标 Bean 的名称和属性名设置的完全相同.
 *  constructor(通过构造器自动装配): 当 Bean 中存在多个构造器时, 此种自动装配方式将会很复杂. 不推荐使用

<bean id="dao2" class="com.atguigu.spring.ref.Dao" scope="prototype"></bean>
    	
    	<bean id="service" class="com.atguigu.spring.ref.Service" autowire="byName"></bean>
    	
    	<bean id="action" class="com.atguigu.spring.ref.Action" autowire="byType"></bean>

在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配 Bean 的所有属性. 然而, 若只希望装配个别属性时, autowire 属性就不够灵活了. autowire 属性要么根据类型自动装配, 要么根据名称自动装配, 不能两者兼而有之.一般情况下，在实际的项目中很少使用自动装配功能，因为和自动装配功能所带来的好处比起来，明确清晰的配置文档更有说服力一些.

#### SpEL：字面量 ####

Spring 表达式语言（简称SpEL）：是一个支持运行时查询和操作对象图的强大的表达式语言。语法类似于 EL：SpEL 使用 \#\{…\} 作为定界符，所有在大框号中的字符都将被认为是 SpEL。SpEL 为 bean 的属性进行动态赋值提供了便利，其实现了：

*  通过 bean 的 id 对 bean 进行引用
 *  调用方法以及引用对象中的属性
 *  计算表达式的值
 *  正则表达式的匹配

<bean id="girl" class="com.atguigu.spring.helloworld.User">
    		<property name="userName" value="周迅"></property>
    	</bean>
    	<bean id="car" class="com.atguigu.spring.helloworld.Car">
    		<constructor-arg value="Aodi"></constructor-arg>
    		<constructor-arg value="Ford"></constructor-arg>
    		
    		<constructor-arg value="#{(java.lang.Math).PI*80}" ></constructor-arg>
    	</bean>
    	<bean id="boy" class="com.atguigu.spring.helloworld.User" init-method="init" destroy-method="destroy">
    		
    		<property name="userName" value="#{'LiMing'}"></property>
    		
    		<property name="wifeName" value="#{girl.userName}"></property>
    		
    		<property name="info" value="#{car.price > 20000 ? '金领' ：‘白领’}"></property>
    	</bean>

#### 使用外部属性文件 ####

在配置文件里配置 Bean 时, 有时需要在 Bean 的配置里混入系统部署的细节信息(例如: 文件路径, 数据源配置信息等). 而这些部署细节实际上需要和 Bean 配置相分离.

Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器, 这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中. 可以在 Bean 配置文件里使用形式为 $\{var\} 的变量, PropertyPlaceholderConfigurer 从属性文件里加载属性, 并使用这些属性来替换变量.

![这里写图片描述][SouthEast 3]

Spring 2.5 之后: 可通过`<context:property-placeholder>`元素简化:

<context:property-placeholder location="classpath:db.properties"/>

### 通过工厂方法（静态工厂方法 & 实例工厂方法） ###

*  调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节.
 *  要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用 `<constrctor-arg>` 元素为该方法传递方法参数.

#### 静态工厂方法 ####

/**
     * 静态工厂方法：直接调用某一个类的静态方法就可以返回Bean的实例
     */
    public class StaticCarFactory {
    	private static Map<String,Car> cars = new HashMap<String,Car>();
    	
    	static{
    		cars.put("audi",new Car("audi","Tom",300000));
    		cars.put("ford",new Car("ford","Jerry",343444));
    	}
    	
    	//静态工厂方法
    	public static Car getCar(String name){
    		return cars.get(name);
    	}
    }

配置Bean：

<bean id="car1"
    	class="com.atguigu.spring.beans.factory.StaticCarFactory" factory-method="getCar">
    	<constructor-arg value="audi"></constructor-arg>
    	</bean>

#### 实例工厂方法 ####

*  实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节.
 *  要声明通过实例工厂方法创建的 Bean：  
    在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean  
    在 factory-method 属性里指定该工厂方法的名称  
    使用 construtor-arg 元素为工厂方法传递方法参数

/**
     * 实例工厂方法：实例工厂的方法，即先需要创建工厂本身，再调用工厂的实例方法来返回bean的实例
     * 
     *
     */
    public class InstanceCarFactory {
    	
    	private static Map<String,Car> cars = null;
    	
    	public InstanceCarFactory(){
    		cars = new HashMap<String,Car>();
    		cars.put("audi",new Car("audi","audi",300000));
    		cars.put("ford",new Car("ford","ford",343444));
    	}
    	
    	public static Car getCar(String brand){
    		return cars.get(brand);
    	}
    	
    }

配置Bean：

<bean id="carFactory" class="com.atguigu.spring.beans.factory.InstanceCarFactory"></bean>
    	
    	
    	<bean id="car2" factory-bean="carFactory" factory-method="getCar">
    		<constructor-arg value="ford"></constructor-arg>
    	</bean>

#### 两种方法的调用 ####

public class Main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans-factory.xml");
    		Car car1 = (Car) ctx.getBean("car1");
    		System.out.println(car1);
    		Car car2 = (Car) ctx.getBean("car2");
    		System.out.println(car2);
    	}
    
    }

### FactoryBean ###

*  Spring 中有两种类型的 Bean, 一种是普通Bean, 另一种是工厂Bean, 即FactoryBean.
 *  工厂 Bean 跟普通Bean不同, 其返回的对象不是指定类的一个实例, 其返回的是该工厂 Bean 的 getObject 方法所返回的对象

![这里写图片描述][SouthEast 4]

**如下实例，最终返回一个brand属性值为BMW的Car对象**：

FacrotyBean：

//自定义FactoryBean需要实现FactoryBean 接口
    public class CarFactoryBean implements FactoryBean<Car>{
    	
    	
    	private String brand;
    	
    	public void setBrand(String brand){
    		this.brand = brand;
    	}
    	//返回bean对象
    	@Override
    	public Car getObject() throws Exception {
    		// TODO Auto-generated method stub
    		return new Car("brand",345456);
    	}
    	
    	/**
    	 * 返回bean的类型
    	 */
    	@Override
    	public Class<?> getObjectType() {
    		// TODO Auto-generated method stub
    		return Car.class;
    	}
    	//是否是单实例的
    	@Override
    	public boolean isSingleton() {
    		// TODO Auto-generated method stub
    		return true;
    	}
    
    }

<bean id="car" class="com.atguigu.spring.beans.factorybean.CarFactoryBean">
    		<property name="brand" value="BMW"></property>
    	</bean>

## 基于注解的方式 ##

*  组件扫描(component scanning): Spring 能够从 classpath 下自动扫描, 侦测和实例化具有特定注解的组件.
 *  特定组件包括:  
    @Component: 基本注解, 标识了一个受 Spring 管理的组件  
    @Respository: 标识持久层组件  
    @Service: 标识服务层(业务层)组件  
    @Controller: 标识表现层组件
 *  对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称
 *  当在组件类上使用了特定的注解之后, 还需要在 Spring 的配置文件中声明 `<context:component-scan>`：  
    ·base-package 属性指定一个需要扫描的基类包，Spring 容器将会扫描这个·基类包里及其子包中的所有类.  
    ·当需要扫描多个包时, 可以使用逗号分隔.  
    ·如果仅希望扫描特定的类而非基包下的所有类，可使用 resource-pattern 属性过滤特定的类，示例：`<context:component-scan base-package="com.spring.beans" resource-pattern="autowire/*.class">`  
    \-`<context:include-filter>` 子节点表示要包含的目标类
 *  `<context:exclude-filter>` 子节点表示要排除在外的目标类
 *  `<context:component-scan>`下可以拥有若干个 `<context:include-filter>` 和 `<context:exclude-filter>`子节点
 *  使用@Autowired进行自动装配

为了模拟持久层、业务层与表现层，实例的结构如下：

![这里写图片描述][SouthEast 5]

import org.springframework.stereotype.Component;
    
    @Component
    public class TestObject {
    
    }

/**
     * 模拟表现层
     * @author Megustas
     *
     */
    @Controller
    public class UserController {
    	
    	//建立关联关系
    	@Autowired 
    	private UserService userService;
    	
    	public void execute(){
    		System.out.println("UserController execute...");
    		//调用方法
    		userService.add();
    	}
    }

public interface UserRepository {
    	
    	void save();
    }

/**
     * 模拟持久层
     * @author Megustas
     *
     */
    @Repository("userRepository")
    public class UserRepositoryImpl implements UserRepository {
    
    	@Override
    	public void save() {
    		// TODO Auto-generated method stub
    		System.out.println("UserRepository Save ...");
    	}
    
    }

/**
     * 模拟业务层
     * @author Megustas
     *
     */
    @Service
    public class UserService {
    	
    	//建立关联关系
    	@Autowired 
    	public UserRepository userRepository;
    
    	public void add(){
    		System.out.println("UserService add...");
    		userRepository.save();
    	}
    }

Bean配置：

<context:component-scan base-package="com.atguigu.spring.annotation"></context:component-scan>

主函数Main（获取各个目标Bean）：

public class Main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-annotation.xml");
    		
    		TestObject to = (TestObject) ctx.getBean("testObject");
    		System.out.println(to);
    		
    		UserController uesrController = (UserController) ctx.getBean("userController");
    		System.out.println(uesrController);
    			
    		UserRepository userRepository = (UserRepository) ctx.getBean("userRepository");
    		System.out.println(userRepository);
    		
    		UserService userService = (UserService) ctx.getBean("userService");
    		System.out.println(userRepository);
    		
    	}
    
    }

# IOC容器中bean的生命周期 #

## IOC 容器中 Bean 的生命周期方法 ##

Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务.

Spring IOC 容器对 Bean 的生命周期进行管理的过程:

*  通过构造器或工厂方法创建 Bean 实例
 *  为 Bean 的属性设置值和对其他 Bean 的引用
 *  调用 Bean 的初始化方法
 *  Bean 可以使用了
 *  当容器关闭时, 调用 Bean 的销毁方法

在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法.

在进行Bean的配置时：

<bean id="Car" class="com.atguigu.spring.beans.cycle.Car"
    		init-method="initcar"
    		destroy-method="destroycar">
    		<property name="brand" value="Audi"></property>
    	</bean>

### 创建 Bean 后置处理器 ###

其实我们可以更细腻的定制初始化方法：

*  Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.
 *  Bean 后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例. 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.
 *  对Bean 后置处理器而言, 需要实现Interface BeanPostProcessor接口. 在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口的以下两个方法:（在IOC容器中进行配置时，不需要加上id，IOC容器会自动识别）
 *  Object postProcessAfterInitialization(Object bean,String beanName)
 *  Object postProcessBeforeInitialization(Object bean,String beanName)

**接下来是一个演示完整的Bean生命周期的实例**：

Bean的定义，定义一个Car：

public class Car {
    
    	private String brand;
    
    	public void setBrand(String brand) {
    		System.out.println("setBrand...");
    		this.brand = brand;
    	}
    
    	public Car(){
    		System.out.println("Car's Contructor...");
    	}
    
    	public void initcar(){
    		System.out.println("init method...");
    	}
    	
    	public void destroycar(){
    		System.out.println("destroy method...");
    	}
    }

**处理器**：

public class MyBeanPostProcessor implements BeanPostProcessor {
    
    	@Override
    	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    		System.out.println("postProcessBeforeInitialization"+beanName+","+beanName);
    		return bean;
    	}
    	
    	@Override
    	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    		System.out.println("postProcessAfterInitialization"+beanName+","+beanName);
    		return bean;
    	}
    
    }

**配置**：

<bean id="car" class="com.atguigu.spring.beans.cycle.Car" 
    	init-method="initcar" destroy-method="destroycar">
    		<property name="brand" value="Audi"></property>
    	</bean>
    	
    	
    	<bean class="com.atguigu.spring.beans.cycle.MyBeanPostProcessor"></bean>

**Main方法**：

public class Main {
    	
    	public static void main(String[] args) {
    		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans-cycle.xml");
    		Car car = (Car) ctx.getBean("car");
    		System.out.println(car);
    		
    		//关闭IOC容器
    		ctx.close();
    	}
    	
    }

**结果**：

![这里写图片描述][SouthEast 6]

**添加 Bean 后置处理器后 Bean 的生命周期：**

*  通过构造器或工厂方法创建 Bean 实例
 *  为 Bean 的属性设置值和对其他 Bean 的引用
 *  将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
 *  调用 Bean 的初始化方法
 *  将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法
 *  Bean 可以使用了
 *  当容器关闭时, 调用 Bean 的销毁方法

**通过后置处理器还可以实现“偷梁换柱”与过滤等功能，只需要在后置处理器中加入对应语句就可以。例如：**

public class MyBeanPostProcessor implements BeanPostProcessor {
    
    	@Override
    	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    		System.out.println("postProcessBeforeInitialization"+beanName+","+beanName);
    		//对beanName是car的bean进行如下操作，实现过滤操作
    		if("car".equals(beanName)){
    			
    		}		
    		return bean;		
    	}
    	
    	@Override
    	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    		System.out.println("postProcessAfterInitialization"+beanName+","+beanName);
    		Car car = new Car();
    		car.setBrand("Ford");
    		return bean;
    	}
    
    }

# 泛型依赖注入 #

Spring 4.x 中可以为子类注入子类对应的泛型类型的成员变量的引用，如图：

![这里写图片描述][SouthEast 7]

整合多个配置文件：

*  Spring 允许通过 `<import>`将多个配置文件引入到一个文件中，进行配置文件的集成。这样在启动 Spring 容器时，仅需要指定这个合并好的配置文件就可以。
 *  import 元素的 resource 属性支持 Spring 的标准的路径资源

![这里写图片描述][SouthEast 8]

[https_www.zhihu.com_question_23277575]: https://www.zhihu.com/question/23277575
[SouthEast]: /images/20220711/252304c5b6fd4663bb7148d55c6ef6bf.png
[SouthEast 1]: /images/20220711/d6809f1b5df34debae13f97f63f4a9c0.png
[SouthEast 2]: /images/20220711/66eb6837896a49198319c9aa4d14ff5f.png
[SouthEast 3]: /images/20220711/64f728d55c1c4d76917b9f07aa7b7b43.png
[SouthEast 4]: /images/20220711/c748399dfdc84c3e9b133d869df4d967.png
[SouthEast 5]: /images/20220711/fe160d31c42949d483129660aaaac5aa.png
[SouthEast 6]: /images/20220711/523c175996404443954f75aa0352c9c1.png
[SouthEast 7]: /images/20220711/0002b1a24df448fe886759e1fe2fd429.png
[SouthEast 8]: /images/20220711/de7991a33a914e4ba21df430471c9082.png