Spring入门这一篇就够了

亦凉 2021-09-30 18:44 366阅读 0赞

# 前言 #

前面已经学习了Struts2和Hibernate框架了。接下来学习的是Spring框架…本博文主要是引入Spring框架…

# Spring介绍 #

Spring诞生：

## 侵入式概念 ##

**Spring是一种非侵入式的框架**…

**侵入式**

**非侵入式**

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

## 松耦合 ##

前面我们在写程序的时候，都是**面向接口编程，通过DaoFactroy等方法来实现松耦合**

private CategoryDao categoryDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.CategoryDAOImpl", CategoryDao.class);    private BookDao bookDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.BookDaoImpl", BookDao.class);    private UserDao userDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.UserDaoImpl", UserDao.class);    private OrderDao orderDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.OrderDaoImpl", OrderDao.class);"zhongfucheng.dao.impl.CategoryDAOImpl", CategoryDao.class);
    
        private BookDao bookDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.BookDaoImpl", BookDao.class);
    
        private UserDao userDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.UserDaoImpl", UserDao.class);
    
        private OrderDao orderDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.OrderDaoImpl", OrderDao.class);

![640?wx\_fmt=png][640_wx_fmt_png] 这里写图片描述

**DAO层和Service层通过DaoFactory来实现松耦合**

**而Spring给我们更加合适的方法来实现松耦合，并且更加灵活、功能更加强大！---->IOC控制反转**

## 切面编程 ##

切面编程也就是AOP编程，其实我们在之前也接触过…**动态代理就是一种切面编程了**…

当时我们使用**动态代理+注解的方式给Service层的方法添加权限**.

@Override    @permission("添加分类")    /*添加分类*/    public void addCategory(Category category) {        categoryDao.addCategory(category);    }    /*查找分类*/    @Override    public void findCategory(String id) {        categoryDao.findCategory(id);    }    @Override    @permission("查找分类")    /*查看分类*/    public List<Category> getAllCategory() {        return categoryDao.getAllCategory();    }    /*添加图书*/    @Override    public void addBook(Book book) {        bookDao.addBook(book);    }
        @permission("添加分类")
        /*添加分类*/
        public void addCategory(Category category) {
        
            categoryDao.addCategory(category);
        }
    
    
        /*查找分类*/
        @Override
        public void findCategory(String id) {
        
            categoryDao.findCategory(id);
        }
    
        @Override
        @permission("查找分类")
        /*查看分类*/
        public List<Category> getAllCategory() {
        
            return categoryDao.getAllCategory();
        }
    
        /*添加图书*/
        @Override
        public void addBook(Book book) {
        
            bookDao.addBook(book);
    
        }

AOP编程可以简单理解成：**在执行某些代码前，执行另外的代码**

Spring也为我们**提供更好地方式来实现面向切面编程**！

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

# 引出Spring #

我们试着回顾一下没学Spring的时候，是怎么开发Web项目的

**用户访问：**

我们来思考几个问题：

对于第一个问题和第三个问题，**我们可以通过DaoFactory解决掉(虽然不是比较好的解决方法)**

对于第二个问题，我们要**控制对象的数量和创建事件就有点麻烦了**….

而**Spring框架通过IOC就很好地可以解决上面的问题**….

## IOC控制反转 ##

Spring的核心思想之一：**Inversion of Control , 控制反转 IOC**

那么控制反转是什么意思呢？？？**对象的创建交给外部容器完成，这个就做控制反转。**

那么对象的对象之间的依赖关系Spring是怎么做的呢？？**依赖注入，dependency injection.**

上面已经说了，控制反转是通过外部容器完成的，**而Spring又为我们提供了这么一个容器，我们一般将这个容器叫做：IOC容器.**

**无论是创建对象、处理对象之间的依赖关系、对象创建的时间还是对象的数量，我们都是在Spring为我们提供的IOC容器上配置对象的信息就好了。**

那么使用IOC控制反转这一思想有什么作用呢？？？我们来看看一些优秀的回答…

来自知乎：https://www.zhihu.com/question/23277575/answer/24259844

我摘取一下核心的部分：

> ioc的思想最核心的地方在于，资源不由使用资源的双方管理，而由不使用资源的第三方管理，这可以带来很多好处。**第一，资源集中管理，实现资源的可配置和易管理**。**第二，降低了使用资源双方的依赖程度，也就是我们说的耦合度**。
> 
> 也就是说，甲方要达成某种目的不需要直接依赖乙方，它只需要达到的目的告诉第三方机构就可以了，比如甲方需要一双袜子，而乙方它卖一双袜子，它要把袜子卖出去，并不需要自己去直接找到一个卖家来完成袜子的卖出。它也只需要找第三方，告诉别人我要卖一双袜子。这下好了，甲乙双方进行交易活动，都不需要自己直接去找卖家，相当于程序内部开放接口，卖家由第三方作为参数传入。甲乙互相不依赖，而且只有在进行交易活动的时候，甲才和乙产生联系。反之亦然。这样做什么好处么呢，甲乙可以在对方不真实存在的情况下独立存在，而且保证不交易时候无联系，想交易的时候可以很容易的产生联系。甲乙交易活动不需要双方见面，避免了双方的互不信任造成交易失败的问题。**因为交易由第三方来负责联系，而且甲乙都认为第三方可靠。那么交易就能很可靠很灵活的产生和进行了**。这就是ioc的核心思想。生活中这种例子比比皆是，支付宝在整个淘宝体系里就是庞大的ioc容器，交易双方之外的第三方，提供可靠性可依赖可灵活变更交易方的资源管理中心。另外人事代理也是，雇佣机构和个人之外的第三方。  
> ==========================update===========================
> 
> 在以上的描述中，诞生了两个专业词汇，依赖注入和控制反转所谓的依赖注入，则是，甲方开放接口，在它需要的时候，能够讲乙方传递进来(注入)所谓的控制反转，甲乙双方不相互依赖，交易活动的进行不依赖于甲乙任何一方，整个活动的进行由第三方负责管理。

参考优秀的博文①：https://www.tianmaying.com/tutorial/spring-ioc

参考优秀的博文②：[这里写链接内容][Link 1]

**知乎@Intopass的回答：**

1.  不用自己组装，拿来就用。
2.  享受单例的好处，效率高，不浪费空间。
3.  便于单元测试，方便切换mock组件。
4.  便于进行AOP操作，对于使用者是透明的。
5.  统一配置，便于修改。

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

## Spring模块 ##

**Spring可以分为6大模块：**

![640?wx\_fmt=png][640_wx_fmt_png 1] 这里写图片描述

上面文主要引出了为啥我们需要使用Spring框架，以及大致了解了Spring是分为六大模块的….**下面主要讲解Spring的core模块！**

# Core模块快速入门 #

## 搭建配置环境 ##

**引入jar包:**

本博文主要是core模块的内容，**涉及到Spring core的开发jar包有五个**：

我主要**使用的是Spring3.2版本**…

**编写配置文件:**

Spring核心的配置文件`applicationContext.xml`或者叫`bean.xml`

那这个配置文件怎么写呢？？一般地，我们都知道框架的配置文件都是有约束的…**我们可以在`spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html`找到XML配置文件的约束**

我是使用Intellij Idea集成开发工具的，可以选择自带的Spring配置文件,它长的是这样：

<?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"></beans>
    <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">
    
    </beans>

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

前面在介绍Spring模块的时候已经说了，**Core模块是：IOC容器，解决对象创建和之间的依赖关系**。

因此**Core模块主要是学习如何得到IOC容器，通过IOC容器来创建对象、解决对象之间的依赖关系、IOC细节。**

## 得到Spring容器对象【IOC容器】 ##

Spring容器不单单只有一个，可以归为两种类型

### **通过Resource获取BeanFactory** ###

//加载Spring的资源文件        Resource resource = new ClassPathResource("applicationContext.xml");        //创建IOC容器对象【IOC容器=工厂类+applicationContext.xml】        BeanFactory beanFactory = new XmlBeanFactory(resource);
            Resource resource = new ClassPathResource("applicationContext.xml");
    
            //创建IOC容器对象【IOC容器=工厂类+applicationContext.xml】
            BeanFactory beanFactory = new XmlBeanFactory(resource);

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

### **类路径下XML获取ApplicationContext** ###

// 得到IOC容器对象        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");        System.out.println(ac);
            ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    
            System.out.println(ac);

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

在Spring中总体来看可以通过三种方式来配置对象:

## XML配置方式 ##

在上面我们已经可以得到IOC容器对象了。**接下来就是在applicationContext.xml文件中配置信息【让IOC容器根据applicationContext.xml文件来创建对象】**

/** * Created by ozc on 2017/5/10. */public class User {    private String id;    private String username;    public String getId() {        return id;    }    public void setId(String id) {        this.id = id;    }    public String getUsername() {        return username;    }    public void setUsername(String username) {        this.username = username;    }}
    public class User {
        
    
        private String id;
        private String username;
    
    
        public String getId() {
        
            return id;
        }
    
        public void setId(String id) {
        
            this.id = id;
        }
    
        public String getUsername() {
        
            return username;
        }
    
        public void setUsername(String username) {
        
            this.username = username;
        }
    }

User user = new User();

<bean id="user" class="User"/>
        <bean id="user" class="User"/>

**通过IOC容器对象获取对象:**

// 得到IOC容器对象        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");        User user = (User) ac.getBean("user");        System.out.println(user);
            ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    
            User user = (User) ac.getBean("user");
    
            System.out.println(user);

![640?wx\_fmt=png][640_wx_fmt_png 2] 这里写图片描述

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

上面我们使用的是IOC通过无参构造函数来创建对象，我们来回顾一下一般有几种创建对象的方式：

使用无参的构造函数创建对象我们已经会了，接下来我们看看使用剩下的IOC容器是怎么创建对象的。

### 带参数的构造函数创建对象 ###

首先，**JavaBean就要提供带参数的构造函数：**

public User(String id, String username) {        this.id = id;        this.username = username;    }
            this.id = id;
            this.username = username;
        }

接下来，关键是怎么配置applicationContext.xml文件了。

![640?wx\_fmt=png][640_wx_fmt_png 3] 这里写图片描述

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

在constructor上**如果构造函数的值是一个对象，而不是一个普通类型的值，我们就需要用到ref属性了，而不是value属性**

比如说：**我在User对象上维护了Person对象的值，想要在构造函数中初始化它**。因此，就需要用到ref属性了

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

### 工厂静态方法创建对象 ###

首先，**使用一个工厂的静态方法返回一个对象**

public class Factory {    public static User getBean() {        return new User();    }}class Factory {
        
    
        public static User getBean() {
        
    
            return new User();
        }
    
    }

**配置文件中使用工厂的静态方法返回对象**

<bean id="user" class="Factory" factory-method="getBean" >    </bean>
        <bean id="user" class="Factory" factory-method="getBean" >
    
        </bean>

![640?wx\_fmt=png][640_wx_fmt_png 4] 这里写图片描述

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

### 工厂非静态方法创建对象 ###

首先，也是通过工厂的非非静态方法来得到一个对象

public class Factory {    public User getBean() {        return new User();    }}class Factory {
        
    
    
        public User getBean() {
        
    
            return new User();
        }
    
    
    }

**配置文件中使用工厂的非静态方法返回对象**

<bean id="factory" class="Factory"/>        <bean id="user" class="User" factory-bean="factory" factory-method="getBean"/>
        <bean id="factory" class="Factory"/>
    
        
        <bean id="user" class="User" factory-bean="factory" factory-method="getBean"/>

![640?wx\_fmt=png][640_wx_fmt_png 4] 这里写图片描述

### c名称空间 ###

我们在使用XML配置创建Bean的时候，如果该Bean有构造器，那么我们使用`<constructor-arg>`这个节点来对构造器的参数进行赋值…

`<constructor-arg>`未免有点太长了，为了简化配置，Spring来提供了c名称空间…

**要想c名称空间是需要导入`xmlns:c="http://www.springframework.org/schema/c"`的**

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

c名称空间有个**缺点：不能装配集合，**当我们要装配集合的时候还是需要`<constructor-arg>`这个节点

### 装载集合 ###

如果对象上的属性或者构造函数拥有集合的时候，而我们又需要为集合赋值，那么怎么办？

## 注解方式 ##

自从jdk5有了注解这个新特性，我们可以看到Struts2框架、Hibernate框架都支持使用注解来配置信息…

**通过注解来配置信息就是为了简化IOC容器的配置，注解可以把对象添加到IOC容器中、处理对象依赖关系**，我们来看看怎么用吧：

使用注解步骤：

//表明该类是配置类@Configuration//启动扫描器，扫描bb包下的    //也可以指定多个基础包    //也可以指定类型@ComponentScan("bb")public class AnnotationScan {}
    @Configuration
    
    //启动扫描器，扫描bb包下的
        //也可以指定多个基础包
        //也可以指定类型
    @ComponentScan("bb")
    public class AnnotationScan {
        
    
    }

**在使用@ComponentScan()这个注解的时候，在测试类上需要@ContextConfiguration这个注解来加载配置类…**

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

创建对象以及处理对象依赖关系，相关的注解：

**测试代码:**

package aa;import org.springframework.stereotype.Repository;/** * Created by ozc on 2017/5/10. *///把对象添加到容器中,首字母会小写@Repositorypublic class UserDao {    public void save() {        System.out.println("DB:保存用户");    }}
    
    import org.springframework.stereotype.Repository;
    
    /** * Created by ozc on 2017/5/10. */
    
    //把对象添加到容器中,首字母会小写
    @Repository
    public class UserDao {
        
    
        public void save() {
        
            System.out.println("DB:保存用户");
        }
    
    
    }

package aa;import org.springframework.stereotype.Service;import javax.annotation.Resource;//把UserService对象添加到IOC容器中,首字母会小写@Servicepublic class UserService {    //如果@Resource不指定值，那么就根据类型来找--->UserDao....当然了，IOC容器不能有两个UserDao类型的对象    //@Resource    //如果指定了值，那么Spring就在IOC容器找有没有id为userDao的对象。    @Resource(name = "userDao")    private UserDao userDao;    public void save() {        userDao.save();    }}
    
    
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    
    
    //把UserService对象添加到IOC容器中,首字母会小写
    @Service
    public class UserService {
        
    
        //如果@Resource不指定值，那么就根据类型来找--->UserDao....当然了，IOC容器不能有两个UserDao类型的对象
        //@Resource
    
        //如果指定了值，那么Spring就在IOC容器找有没有id为userDao的对象。
        @Resource(name = "userDao")
        private UserDao userDao;
    
        public void save() {
        
            userDao.save();
        }
    }

package aa;import org.springframework.stereotype.Controller;import javax.annotation.Resource;/** * Created by ozc on 2017/5/10. *///把对象添加到IOC容器中,首字母会小写@Controllerpublic class UserAction {    @Resource(name = "userService")    private UserService userService;    public String execute() {        userService.save();        return null;    }}
    
    import org.springframework.stereotype.Controller;
    
    import javax.annotation.Resource;
    
    /** * Created by ozc on 2017/5/10. */
    
    //把对象添加到IOC容器中,首字母会小写
    @Controller
    public class UserAction {
        
    
        @Resource(name = "userService")
        private UserService userService;
    
        public String execute() {
        
            userService.save();
            return null;
        }
    }

package aa;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;/** * Created by ozc on 2017/5/10. */public class App {    public static void main(String[] args) {        // 创建容器对象        ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");        UserAction userAction = (UserAction) ac.getBean("userAction");        userAction.execute();    }}
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /** * Created by ozc on 2017/5/10. */
    public class App {
        
    
        public static void main(String[] args) {
        
    
            // 创建容器对象
            ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");
    
            UserAction userAction = (UserAction) ac.getBean("userAction");
    
            userAction.execute();
        }
    }

![640?wx\_fmt=png][640_wx_fmt_png 5] 这里写图片描述

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

## 通过Java方式 ##

由于Spring的**自动装配并不能将第三方库组件装配到应用中，于是需要显式装配配置**。显示装配有两种方式

**Spring In Action作者首推使用自动装配的功能，而后是通过java代码配置bean，最后才用XML文件配置的方式**..

那么怎么通过java代码来配置Bean呢？？

**编写配置类:**

@org.springframework.context.annotation.Configuration    public class Configuration {    }
        public class Configuration {
        
    
        }

**使用配置类创建bean:**

@org.springframework.context.annotation.Configurationpublic class Configuration {    @Bean    public UserDao userDao() {        UserDao userDao = new UserDao();        System.out.println("我是在configuration中的"+userDao);        return userDao;    }}
    public class Configuration {
        
    
        @Bean
        public UserDao userDao() {
        
    
            UserDao userDao = new UserDao();
            System.out.println("我是在configuration中的"+userDao);
            return userDao;
        }
    
    }

package bb;import org.junit.Test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import org.springframework.test.context.ContextConfiguration;/** * Created by ozc on 2017/5/11. *///加载配置类的信息@ContextConfiguration(classes = Configuration.class)public class Test2 {    @Test    public void test33() {        ApplicationContext ac =                new ClassPathXmlApplicationContext("bb/bean.xml");        UserDao userDao = (UserDao) ac.getBean("userDao");        System.out.println(userDao);    }}
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.test.context.ContextConfiguration;
    
    /** * Created by ozc on 2017/5/11. */
    //加载配置类的信息
    @ContextConfiguration(classes = Configuration.class)
    public class Test2 {
        
    
        @Test
        public void test33() {
        
    
            ApplicationContext ac =
                    new ClassPathXmlApplicationContext("bb/bean.xml");
    
            UserDao userDao = (UserDao) ac.getBean("userDao");
    
            System.out.println(userDao);
        }
    }

![640?wx\_fmt=png][640_wx_fmt_png 6] 这里写图片描述

## 三种方式混合使用 ##

**注解和XML配置是可以混合使用的，JavaConfig和XML也是可以混合使用的…**

如果JavaConfig的配置类是分散的，我们一般再创建一个更高级的配置类（root），然后使用**@Import来将配置类进行组合**  
如果XML的配置文件是分散的，我们也是创建一个更高级的配置文件（root），然后**使用来将配置文件组合**

**在JavaConfig引用XML**

**在XML引用JavaConfig**

## bean对象创建细节 ##

在Spring第一篇中，我们为什么要引入Spring提出了这么一些问题：

![640?wx\_fmt=png][640_wx_fmt_png 7] 这里写图片描述

既然我们现在已经初步了解IOC容器了，那么这些问题我们都是可以解决的。并且是十分简单【对象写死问题已经解决了，IOC容器就是控制反转创建对象】

### **scope属性** ###

**指定scope属性，IOC容器就知道创建对象的时候是单例还是多例的了。**

**属性的值就只有两个：单例/多例**

![640?wx\_fmt=png][640_wx_fmt_png 8] 这里写图片描述![640?wx\_fmt=png][640_wx_fmt_png 9] 这里写图片描述![640?wx\_fmt=png][640_wx_fmt_png 10] 这里写图片描述

scope属性除了控制对象是单例还是多例的，**还控制着对象创建的时间**！

public User() {        System.out.println("我是User，我被创建了");    }
    
            System.out.println("我是User，我被创建了");
        }

### **lazy-init属性** ###

lazy-init属性**只对singleton【单例】的对象有效**…..lazy-init默认为false….

有的时候，可能我们**想要对象在使用的时候才创建，那么将lazy-init设置为ture就行了**

![640?wx\_fmt=png][640_wx_fmt_png 11] 这里写图片描述

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

### init-method和destroy-method ###

如果我们想要**对象在创建后，执行某个方法**，我们指定为init-method属性就行了。。

如果我们想要**IOC容器销毁后，执行某个方法**，我们指定destroy-method属性就行了。

### Bean创建细节总结 ###

/**     * 1) 对象创建： 单例/多例     *  scope="singleton", 默认值， 即 默认是单例 【service/dao/工具类】     *  scope="prototype", 多例；              【Action对象】     *      * 2) 什么时候创建?     *    scope="prototype"  在用到对象的时候，才创建对象。     *    scope="singleton"  在启动(容器初始化之前)， 就已经创建了bean，且整个应用只有一个。     * 3)是否延迟创建     *    lazy-init="false"  默认为false,  不延迟创建，即在启动时候就创建对象     *    lazy-init="true"   延迟初始化， 在用到对象的时候才创建对象     *    （只对单例有效）     * 4) 创建对象之后，初始化/销毁     *    init-method="init_user"       【对应对象的init_user方法，在对象创建之后执行 】     *    destroy-method="destroy_user"  【在调用容器对象的destroy方法时候执行，(容器用实现类)】     */

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

> 如果文章有错的地方欢迎指正，大家互相交流。**习惯在微信看技术文章，想要获取更多的Java资源的同学，可以关注微信公众号:Java3y**

[640_wx_fmt_png]: /images/20210827/4c75178cd1024235826ceea0b786c230.png?wx_fmt=png
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzAxOTc0NzExNg==&mid=2665513179&idx=1&sn=772226a5be436a0d08197c335ddb52b8&scene=21#wechat_redirect
[640_wx_fmt_png 1]: /images/20210827/bce09c5bf6b149eeb544d532eaac2a9e.png?wx_fmt=png
[640_wx_fmt_png 2]: /images/20210827/b86268b0540746a78e767cc0ae7274e8.png?wx_fmt=png
[640_wx_fmt_png 3]: /images/20210827/de1367f3b4874e98918753148d230d5f.png?wx_fmt=png
[640_wx_fmt_png 4]: /images/20210827/f322a787610b412fab40aadde03ef774.png?wx_fmt=png
[640_wx_fmt_png 5]: /images/20210827/48f7a4914af4496290ba6b960a17b1c2.png?wx_fmt=png
[640_wx_fmt_png 6]: /images/20210827/5d43ace78dfd47a58a3a0ea592d92393.png?wx_fmt=png
[640_wx_fmt_png 7]: /images/20210827/19a29cd3aee040d4a1a6d04a916a7fe9.png?wx_fmt=png
[640_wx_fmt_png 8]: https://ss.csdn.net/p?https://mmbiz.qpic.cn/mmbiz_png/2BGWl1qPxib3XWs28nV4SUx3eOG2TSdzHzN213ou0r4r2OsvHwSCPOH55fxDL68ak7ibbiajpAtsgicmJk6rQ4SdWg/640?wx_fmt=png
[640_wx_fmt_png 9]: https://ss.csdn.net/p?https://mmbiz.qpic.cn/mmbiz_png/2BGWl1qPxib3XWs28nV4SUx3eOG2TSdzHVMvEvlNLcfaCmb1RQbFF8AyFticeSFbVEteibiabma9RBz5zPg2w93mxQ/640?wx_fmt=png
[640_wx_fmt_png 10]: /images/20210827/c2f687690c6d45fdab04b0f93ccbd83c.png?wx_fmt=png
[640_wx_fmt_png 11]: /images/20210827/fdfb45d4fbbe4c87b4e1b16f6c6f5539.png?wx_fmt=png