常用框架学习(一)——Struts2

Love The Way You Lie 2022-05-22 04:08 166阅读 0赞

##  ##

# 1.1  Struts2概述 #

### 1.1.1  什么是Struts2 ###

Struts2是由Apache社区的Struts1和Opensysmphony的Webwork整合而来，Struts负责对http请求的处理，Webwork负责业务逻辑处理。

### 1.1.2 运行环境搭建 ###

1.导入13个jar包（在Struts2自带的demo中可以找到最少所需包）

![70][]

2.需要在web.xml文件中配置StrutsPrepareAndExecuteFilter（ctrl+shif+t查找）

3.创建一个struts.xml文件,它的位置是可以放置在src下。(如果没有联网，需要配置约束，DTD映射类型为URL)

![70 1][]

### 1.1.3  Struts执行流程 ###

![70 2][]

**大致流程:**

（1）  客户端（Client）向Action发用一个请求（Request）

（2）  Container通过web.xml映射请求，并获得控制器（Controller）的名字

（3）  容器（Container）调用控制器（StrutsPrepareAndExecuteFilter）。在Struts2.1以前调用FilterDispatcher，Struts2.1以后调用StrutsPrepareAndExecuteFilter

（4）  控制器（Controller）通过ActionMapper获得Action的信息

（5）  控制器（Controller）调用ActionProxy

（6）  ActionProxy读取struts.xml文件获取action和interceptor stack的信息。

（7）  ActionProxy把request请求传递给ActionInvocation

（8）  ActionInvocation根据配置文件加载相关的所有Interceptor拦截器,通过代理模式调用Action和interceptor

（9）  根据action的配置信息，产生result

（10） Result信息返回给ActionInvocation根据struts.xml中配置的result，决定进行下一步输出

（11） 产生一个HttpServletResponse响应

（12） 产生的响应行为发送给客服端。

**详细流程:**

1.启动服务器(tomcat),StrutsPrepareAndExecuteFilter的init方法执行将会自动加载配置文件

default.properties 在 struts2-core-2.3.7.jar 中 org.apache.struts2包里面（常量的默认值）

struts-default.xml 在 struts2-core-2.3.7.jar（Bean、273行18个默认拦截器、结果类型 ）

struts-plugin.xml 在struts-Xxx-2.3.7.jar（在插件包中存在 ，配置插件信息 ）  struts-config-browser-plugin-2.3.7.jar里面有

struts.xml 该文件是web应用默认的struts配置文件 （实际开发中，通常写struts.xml ）

struts.properties 该文件是Struts的默认配置文件  (配置常量 )

web.xml 该文件是Web应用的配置文件 (配置常量 )

2.请求经过一系列的过滤器（Filter）,StrutsPrepareAndExecuteFilter被调用doFilter方法被执行

HttpServletRequestrequest = (HttpServletRequest) req;
    
          HttpServletResponse response =(HttpServletResponse) res;
    
    prepare.setEncodingAndLocale(request,response);//设置编码格式：默认utf-8,根据    
    
    default.properties
    
       prepare.createActionContext(request, response);//创建actionContext
    
       prepare.assignDispatcherToThread();//整个的过程都在当前线程中执行
    
    request =prepare.wrapRequest(request);//对request进行了包装
    
    ActionMapping mapping = prepare.findActionMappin(request, response,true);//询问     ActionMapper来决定这个请求是否需要调用某个Action。如果是.action:   dispatcher.serviceAction()

3.createAcitonContext()\{

//利用容器创建值栈
    
    ValueStack stack =                              dispatcher.getContainer().getInstance(ValueStackFactory.class).createValueStack();
    
       //构建值栈的结构,把request,session,application等封装成一些map,再把这些map放入到       大map中
    
        stack.getContext().putAll(dispatcher.createContextMap(request, response,null,        servletContext));
    
        //把大map的引用指向了ActionContext中的Map<String,Object> context;
    
        ctx = new ActionContext(stack.getContext());
    
        //把整个actionContext放入到了当前线程中，因为actionContext中有valueStack,所以       valueStack也在当前线程中，
    
        //这样就保证了数据的安全性并且在一个线程范围内可以共享数据
    
        ActionContext.setContext(ctx);
    
    }

**说明：**

1、创建actionContext对象

2、创建ValueStack(实现类OnglValueStack)

3、把整个的actionContext放入到了ThreadLocal中

serviceAction(){
    
        ValueStack stack = (ValueStack)request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
    
       /**
    
          *  因为在struts2容器中有太多的参数request,response,valueStack,session,application,paramters
    
             所以struts2容器对当前的请求中用到所有的数据封装在了ActionContext中的map中
    
         */
    
       extraContext.put(ActionContext.VALUE_STACK,valueStackFactory.createValueStack(stack));
    
       String namespace = mapping.getNamespace();
    
       String name = mapping.getName();
    
       String method = mapping.getMethod();
    
       //创建actionProxy
    
        ActionProxy proxy =config.getContainer().getInstance(ActionProxyFactory.class).createActionProxy(
    
           namespace,name, method, extraContext, true, false);
    
       proxy.execute()方法
    
       prepare.cleanupRequest(request);//把struts2过程中的数据全部清空了
    
    }

5.在createActionProxy中执行了如下的内容：

重点：

执行了DefaultActionInvocation中的init方法
    
            createAction(contextMap)调用ObjectFactory中buildAction 创建了action
    
            stack.push(action);  把action放入到了对象的栈顶
    
            contextMap.put("action", action);把action放入到map中
    
            List<InterceptorMapping> interceptorList = new ArrayList<InterceptorMapping>(proxy.getConfig().getInterceptors());
    
           interceptors = interceptorList.iterator();
    
            获取所有的拦截器，并且返回了迭代器的形式

6.DefaultActionInvocation中的invoke方法

1、按照顺序的方式执行所有的拦截器

2、执行action中的方法

3、执行结果集

4、按照倒序的方式执行拦截器

invoke(){
    
           //调用了拦截器
    
           if (interceptors.hasNext()) {
    
                    final InterceptorMappinginterceptor = (InterceptorMapping) interceptors.next();
    
                    String interceptorMsg ="interceptor: " + interceptor.getName();
    
                   UtilTimerStack.push(interceptorMsg);
    
                    try {resultCode =interceptor.getInterceptor().intercept(DefaultActionInvocation.this);
    
                     }
    
                    finally{UtilTimerStack.pop(interceptorMsg);
    
                    }
    
               }
    
            resultCode = invokeActionOnly();//执行action
    
           //在执行结果集之前执行PreResultListener
    
            if (preResultListeners != null) {
    
                       for (ObjectpreResultListener : preResultListeners) {
    
                            PreResultListenerlistener = (PreResultListener) preResultListener;
    
                            String _profileKey ="preResultListener: ";
    
                            try {UtilTimerStack.push(_profileKey);
    
                               listener.beforeResult(this, resultCode);
    
                            }
    
                            finally{UtilTimerStack.pop(_profileKey);
    
                            }
    
                        }
    
                    }
    
           executeResult();//执行结果集   
    
          }

**总结:**

在执行过滤器filter的过程中

1、创建ActionContext

1、创建actionContext

2、创建值栈

3、把actionContext加入到当前线程中

2、创建actionProxy

执行DefaultActionInvocation的init方法

1、创建action

2、把action放入到栈顶

3、创建所有的拦截器，并且产生拦截器的迭代器

3、执行Proxy的execute方法

proxy.execute()---->invocaction.invoke方法

1、执行所有的拦截器

2、执行当前请求的action

3、执行RreResultListener

4、执行结果集

4、清除数据  在finally中，这样即便出错，也能清除

### 1.1.4  Struts2的优缺点 ###

优点：是一款功能强大，成熟而稳定的开源框架，它良好的实现了业务隔离，数据封装等功能，并具有可扩展性。

缺点：a:核心流程写死，无法动态添加内容

b:所有的错误处理采用try方法，使框架显得臃肿

c:与Ajax结合使用过，没有内置错误码，任何错误需要手动设置

## 1.2  Struts2配置文件详解 ##

### 1.2.1 内置配置文件加载 ###

**第一个加载的是default.properties文件**

位置:struts2-core.jar包   org.apache.struts2包下

作用:主要是声明了struts2框架的常量

示例：struts.i18n.encoding=UTF-8（设置post请求字符编码）

struts.multipart.maxSize=2097152（约束文件上传大小）

struts.devMode = false

**第二个加载的是一批配置文件**

**struts-default.xml**

位置:struts2-core.jar

作用:声明了interceptor  result bean

示例：result 的type种类

dispatcher ：Action 转发给 JSP

chain ：Action转发到另一个Action （同一次请求）

redirect ： Action重定向到 JSP

redirectAction ：Action重定向到另一个Action

stream：下载用的（文件上传和下载时再议）

plainText：以纯文本的形式展现内容

**struts-plugin.xml**

位置:在strtus2的插件包中

作用:主要用于插件的配置声明

struts.xml

位置:在我们自己的工程中

作用:用于我们自己工程使用struts2框架的配置

第三个加载的是自定义的struts.properties

位置:都是在自己工程的src下

作用:定制常量

第四自定义配置提供

第五加载的是web.xml配置文件

主要是加载struts2框架在web.xml文件中的相关配置.

第六 bean相关配置

### 1.2.2 Struts2配置文件解析 ###

**package配置**

1.name属性  作用:定义一个包的名称，它必须唯一。

2.namespace属性 作用:主要是与action标签的name属性联合使用来确定一个action       的访问路径

3.extends属性 作用:指定继承自哪个包。一般值是struts-default  
              strtus-default包是在struts-default.xml文件中声明的。

4.abstruct属性 它代表当前包是一个抽象的，主要是用于被继承

**action配置**

1.name属性 作用:主要是与package的namespace联合使用来确定一个action的访问路       径

2.class属性  作用:用于指示当前的action类

3.method属性  作用:用于指示当前的action类中的哪个方法执行(默认execute，并默认返回success)

**result配置**

它主要是用于指示结果视图

1.name属性 作用是与action类的method方法的返回值进行匹配，来确定跳转路径

2.type属性 作用是用于指定跳转方式（默认dispatcher）

**常量配置**

struts.xml （推举）

格式 ： <constant name="struts.devMode" value="true"/>

struts.properties（要求）

格式 ： struts.devMode = true

web.xml               <init-param>

<param-name>struts.devMode</param-name>

<param-value>true</param-value>

</init-param>

\*<constantname="struts.i18n.encoding" value="UTF-8"/> 可以帮助我们解决post请求乱码问题

<constant name="struts.action.extension"value="action"/> 指定访问struts2框架路径的扩展名>

配置这项后，它会提供更加详细报错信息，以及在struts.xml文件修改后不在需要重启服务器

**拦截器配置**

在要拦截的action所在的package里面声明拦截器

在要拦截的action里面使用拦截器

如果使用自定义的拦截器，默认的拦截器不会执行的，手动使用默认的拦截器

<package name="demo2" namespace="/" extends="struts-default">
    <interceptors>
    		<interceptor name="pre"class="cn.itcast.demo2.Invacaton"></interceptor>
    		</interceptors>
    		<action name="demo2" class="cn.itcast.demo2.DemoAction" >
    			result>/index.jsp</result>	
    			<result name="login">/demo100.jsp</result>
    			<interceptor-ref name="pre"></interceptor-ref>
    			<interceptor-ref name="defaultStack"></interceptor-ref>
    	</action>
    /package>

**\*指定拦截方法**

我们可以使用Interceptor接口的一个实现类来完成操作

![70 3][]

在配置时，就可以指定哪些方法拦截，哪些方法不拦截

![70 4][]

**\*过滤器和拦截器的区别**

过滤器：在目标资源之前进行的操作

过滤所有的内容，比如action、servlet、jsp、html

拦截器：在目标资源之前进行的操作

不能拦截所有的内容，拦截action，不能拦截jsp，不能拦截html

拦截器和过滤器之间有很多相同之处，但是两者之间存在根本的差别。其主要区别为以下几点：  
       1）拦截器是基于JAVA反射机制的，而过滤器是基于函数回调的。  
       2）拦截器不依赖于Servlet容器，而过滤器依赖于Servlet容器  
       3）拦截器只能对Action请求起作用，而过滤器可以对几乎所有的请求起作用。  
       4）拦截器可以访问Action上下文、值栈里的对象，而过滤器不能  
       5）在Action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次

### 1.2.3 验证器配置 ###

对指定的方法校验

1格式：Action类名\-validation.xml 针对动作类中的指定方法进行校验,使用@SkipValidation注解

2格式 ： Action类名\-ActionName(<action>元素name属性)-validation.xml

<validators>
    
    <validator type=”requiredstring”>
    
    <param name=”fileName”>password</param>
    
    <validator>
    
    </validators>

## 1.3  Struts标签库 ##

引入标签库：<%@ taglib uri="/struts-tags" prefix="s"%>

**常见标签**

格式                                                               作用

<s:propertyvalue=”ognl表达式”/>                   获取数据并输入页面

<s:set scope=””var=”” value=””/>              令var=value存入scope中

<s:pushvalue=””/>                                          将value压入值栈

<s:if><s:elseif><s:else>                                   等同if()\{\}elseif()\{\}else\{\}

<s:iteratorvar=”” value=””......>                        遍历集合或数组、域对象

<s:表单标签>                                                 与HTML标签友好交互

<s:actionerror><s:filederror>                            获取错误信息

<s:debug>                                                       查看值栈信息

\*addFieldError、addActionError有何区别？

都是com.opensymphony.xwork2.ActionSupport类下的方法.

addActionError (String  anErrorMessage)

添加一个Action级别的错误消息到Action

anErrorMessage:错误消息,被存放在List列表中

显示消息的标签是（如放在jsp页面中）:

<s:actionerror/>  显示全部的 Action级别的错误消息,可以加CSS代码

addFieldError (String  fieldName, String  errorMessage)

给一个字段(属性) 添加错误消息

fieldName:字段(属性)名

errorMessage:错误消息,被存放在一个Map<key, value>中（其中key存放的是        fieldName，value存放的是errorMessage）。

显示消息的标签是（如放在jsp页面中）:

<s:fielderror/>   显示全部的错误消息(用addFieldError方法添加的 )

## 1.4 Action类解析 ##

### 1.4.1 Action类创建 ###

**1.     创建一个pojo类**

Pojo(plani Ordinary java object)简单的java对象

Pojo类就是没有实现任何接口没有继承任何类

优点:无耦合

缺点:所有的功能都要自己完成

**2.     创建一个类实现一个Action接口**

com.opensymphony.xwork2.Action

![70 5][]

在Action接口中定义了五个常量，一个execute方法

五个常量:它们是默认的五个结果视图<result name=””>:

ERROR : 错误视图

INPUT: 它是struts2框架中interceptor中发现问题后会访问的一个视图

NONE:它代表的是null,什么都不做（也不会做跳转操作）

SUCCESS:这是一个成功视图

优点：耦合度低

缺点:还是需要自己来完成功能

**3.创建一个类继承ActionSupport类（推举）**

com.opensymphony.xwork2.ActionSupport

ActionSupport类也实现了Action接口。

### 1.4.2 数据封装 ###

主要有两种方式:

**1.属性驱动**

a.直接在action类中提供与请求参数匹配属性，提供get/set方法

b.在action类中创始一个javaBean,对其提供get/set ，在请求时页面上要进行修改，         例如 user.username  user.password ,要使用ognl表达式

以上两种方式的优缺点:

第一种比较简单，在实际操作我们需要将action的属性在赋值给模型(javaBean)       去操作  
       第二种:不需要在直接将值给javaBean过程，因为直接将数据封装到了javaBean       中。它要求在页面上必须使用ognl表达式，就存在页面不通用问题。

**2.模型驱动（推举）**

步骤:

1.让Action类要实现一个指定接口ModelDriven

2.实例化模型对象(就是要new出来javaBean)

3.重写getModel方法将实例化的模型返回。

![70 6][]

对于模型驱动它与属性驱动对比，在实际开发中使用比较多，模型驱动缺点，它只能对 一个模型数据进行封装。

### 1.4.3 调用Servlet API ###

**ServletActionContext获取（推举）**

![70 7][]

![70 8][]

**采用注入方式**

Struts2框架在运行时，请求会被StrutsPrepareAndExecuteFilter拦截，会根据请求，去       strtus.xml文件中查找到匹配的action，在action执行前，会走一些interceptor

默认执行的拦截器是struts-default.xml文件中定义的。

在默认执行的拦截器中有一个

![70 9][]

![70 10][]

查看一下ServletConfigInterceptor源代码

以下是部分源代码

![70 11][]

ServletRequestAware, 实现这个接口可以获取HttpServletRequest

ServletResponseAware ,实现这个接口可以获取HttpServletResponse

ServletContextAware 实现这个接口可以获取ServletContext

## 1.5 值栈valueStack和对象图导航语言OGNL ##

### 1.5.1 什么是值栈 ###

依赖于request请求的一种数据容器，每次request请求都会创建一个action实例，而每一个action实例都对应一个valueStack(它保存在request中，是request的一个属性),valueStack存储action对象以及其他对象内容。

### 1.5.2 值栈结构 ###

值栈由两部分组成

root:compoundRoot其实就是一个ArrayList.

context   :OgnlContext其实就是一个Map。context中有root的引用,request、 session、application、 attr、 parameters等对象引用

\* 操作值栈默认指 操作 root 元素

![70 12][]

### 1.5.3 值栈操作 ###

**获取值栈**

![70 13][]

**值的存取**

ActionContext.getContext().getValueStack().push(Object) ,

将对象注入到栈顶对象栈                            JSP页面通过 javabean 属性名获取

ActionContext.getContext().getValueStack().set(k ,v )  ，

把一个对象变成map存入到对象栈中           JSP页面 “key” 获得

ActionContext.getContext().put(k ,v )

把一个数据直接放入到map栈中 ,               JSP页面“\#key”

**\*如何在JSP页面获取数据**

访问root中数据 不需要\#

访问 其它对象数据 加 \#

通过下标获取root中对象

<s:property value="\[0\].top"/> //取值栈顶对象

直接在root中查找对象属性 （自上而下自动查找）

valueStack:<s:propertyvalue="username"/>

（1）对象保存到值栈

<s:propertyvalue="user.username"/>

（2）  集合保存到值栈

<s:propertyvalue="list\[0\].username"/>

在OgnlContext中获取数据

request:<s:propertyvalue="\#request.username"/>

session:<s:propertyvalue="\#session.username"/>

application:<s:propertyvalue="\#application.username"/>

attr:<s:propertyvalue="\#attr.username"/>

parameters:<s:propertyvalue="\#parameters.cid"/>

**struts内置存储过程**

每次请求，访问action，这个对象会存储到valueStack中。

在DefaultActionInvocation的init方法内

![70 14][]

在ModelDrivernInterceptor中

![70 15][]

以上代码会将模型对象存储到valueStack中。

**EL表达式取值**

由于在struts2中重写了request的getAttribute方法，如果在request域对象中获取不到值就会在valueStack中查找。

### 1.5.4 OGNL的特殊符号使用 ###

**\#号:它是从非root中获取数据**

![70 16][]

**%用于强制是否要解析ognl表达式**

![70 17][]

**$它主要是从配置文件中来获取valueStack中数据**

![70 18][]

## 1.6 文件上传 ##

### 1.6.1 实现文件上传 ###

**单文件上传**

浏览器端注意事项:

表单提交方式method=post

表单中必须有一个<input type=”file” name=””>组件

表单中必须设置enctype=”multipart/form-data”

服务器端

导入 Commons-fileupoad.jar包

Struts2框架本身支持文件上传

Struts2框架使用一个fileupload的interceptor来完成文件上传，而我们要使用它

在action中我们可以提供类似以下的操作就能完成文件上传操作(必须有对应set方法)

![70 19][]

在execute方法中将文件copy就可以完成文件上传。

**多文件上传**

**   ** 页面

![70 20][]

对象

![70 21][]

方法

![70 22][]

### 1.6.2 文件上传注意事项 ###

文件上传时出现了问题

![70 23][]

现在的问题是我们的action中没有设置input视图

![70 24][]

在页面上可以通过

![70 25][]

在default.properties中

struts.multipart.maxSize=2097152  (2m)

它是描述文件上传时允许的最大值

只需要在struts.xml文件中

![70 26][]

我们还可以查看FileuploadInterceptor

![70 27][]

## 1.7 Struts2框架Ajax开发 ##

**用HttpServletRuqest处理**

在浏览器端

![70 28][]

![70 29][]

在服务器端

![70 30][]

**使用自带的json插件**

首先要导入插件包：struts2-json-pligin-2.3.24.jar

然后在struts.xml中进行如下操作

1.      将我们自己配置文件中的<packageextends=”json-default”>.

2.      Action的返回视图<result name=”” type=”json”>

浏览器端

![70 31][]

服务器端

![70 32][]

## 1.8 注释开发 ##

注意:要想使用struts2的注解，我们必须单独在导入一个jar包。

![70 33][]

![70 34][]

@Namespace来代替<package  namespace=””>

@ParentPackage来代替<packageextends=””>

@Action来描述关于<action>配置

value属性<action name=””>

使用@Action的results来描述关于结果类型的配置<result>

@Action(value=””,results=\{@Result(name=””,type=””,location=””)\})

@Actions

作用:可以通过多个映射来访问同一个action

![70 35][]

@Results 类似于全局的结果视图

![70 36][]

@InterceptorRef  它是用于处理拦截器的

问题:我们在action类中定义了注解，strtus2框架怎样识别它们?

原因:我们必须查看插件包中的配置

![70 37][]

是在action,actions,struts,struts2这样的包下扫描注解

[70]: /images/20220522/c2b9b7fe871b4681a083c9d342257287.png
[70 1]: /images/20220522/ea055e35641d4bf182783b3bdbfe0790.png
[70 2]: /images/20220522/9b09b3b479c34c6bb9afbdc7ea37f0b0.png
[70 3]: /images/20220522/8c7a56c4dd5c44a8bd4dd8070075dd1b.png
[70 4]: /images/20220522/de870f6e438145a3b131b47f37a3f2c6.png
[70 5]: /images/20220522/75e66468e01f40598e245217d398e134.png
[70 6]: /images/20220522/48c1ed9b67dc460a81eb0a71568f4dff.png
[70 7]: /images/20220522/257c0e450e2c46a5bd28e3aa26b65360.png
[70 8]: /images/20220522/495faeed27fa4c1081410c98137cf97c.png
[70 9]: /images/20220522/2dffb0b6d5194e09a8a6bc6924439fec.png
[70 10]: /images/20220522/be57240c889b401a8a5140be65326aad.png
[70 11]: /images/20220522/902ef36ee58c4ebea489ffb304cc0f4b.png
[70 12]: /images/20220522/e2d13e6d95a143038e8e1db1dbe3b67f.png
[70 13]: /images/20220522/55e725db694947f5ac8f54f307553c59.png
[70 14]: /images/20220522/8e57a4254a044d0e9e8f697ddfc53bff.png
[70 15]: /images/20220522/72f44a4b4bb84246aebfa36bb3f913fb.png
[70 16]: /images/20220522/28ae6c0ba61f47b9a25f6cbf57e5012e.png
[70 17]: /images/20220522/c40bf6f68a86416786ef7356a6c4606c.png
[70 18]: /images/20220522/f2b34f2ff848453380d23ddba9a834ec.png
[70 19]: /images/20220522/921fbf9fbf8f4a1c9607b971718bd8fb.png
[70 20]: /images/20220522/3b3a381222414e25b88787e6868c9533.png
[70 21]: /images/20220522/d4c531231bbe4d9c91d3099a4984b458.png
[70 22]: /images/20220522/a31bafa1b8244c399519d751da407a5a.png
[70 23]: /images/20220522/78574e2eae754e5797ff5bdb9582e364.png
[70 24]: /images/20220522/fe5e63beabf044c6ad30d73f1801c2a6.png
[70 25]: /images/20220522/2febd8b37f5c474fac9c85663362d5b1.png
[70 26]: /images/20220522/c70d4fce0ceb402d9c0b15ec0d6e0b73.png
[70 27]: /images/20220522/aa2b5f380d894f709b3a8420bf26783e.png
[70 28]: /images/20220522/a9dc3de032f240938123d5738bd8f915.png
[70 29]: /images/20220522/e775fcf3b4604541b434de9ddfc10311.png
[70 30]: /images/20220522/9a47fa59920446c3983152ef3e8b4699.png
[70 31]: /images/20220522/5b53848706314e2ba506031bc1caa8fb.png
[70 32]: /images/20220522/c5c5a6c28de44b118cebeaa121159fc1.png
[70 33]: /images/20220522/17b542caf89a4535bba74d5f88705408.png
[70 34]: /images/20220522/0c4c035889df49b6abef423f47351855.png
[70 35]: /images/20220522/800d05165abb43f2a2d7afae49d21aed.png
[70 36]: /images/20220522/e1c57b8bc5b5434f96d8d959bc390be5.png
[70 37]: /images/20220522/48174770f7d1419d96d337b25ce60309.png