Struts2框架详解-优快云博客

1.什么是struts2框架？

struts2是一个基于action的MVC框架

2.使用struts2有什么好处？

优点：

1. 实现MVC模式，结构清晰,使开发者只关注业务逻辑的实现.

2.有丰富的tag可以用 ,Struts的标记库(Taglib)，如能灵活动用，则能大大提高开发效率

3. 页面导航

使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。

4. 提供Exception处理机制 .

5. 数据库链接池管理

6. 支持I18N（国际化）

缺点

1. 转到展示层时，需要配置forward，如果有十个展示层的jsp，需要配置十次struts，而且还不包括有时候目录、文件变更，需要重新修改forward，注意，每次修改配置之后，要求重新部署整个项目，而tomcate这样的服务器，还必须重新启动服务器

2.Struts 的Action必需是thread－safe方式，它仅仅允许一个实例去处理所有的请求。所以action用到的所有的资源都必需统一同步，这个就引起了线程安全的问题。

3. 测试不方便.Struts的每个Action都同Web层耦合在一起，这样它的测试依赖于Web容器，单元测试也很难实现。不过有一个Junit的扩展工具Struts TestCase可以实现它的单元测试。

4. 类型的转换.Struts的FormBean把所有的数据都作为String类型，它可以使用工具Commons-Beanutils进行类型转化。但它的转化都是在Class级别，而且转化的类型是不可配置的。类型转化时的错误信息返回给用户也是非常困难的。

5. 对Servlet的依赖性过强.Struts处理Action时必需要依赖ServletRequest和ServletResponse，所有它摆脱不了Servlet容器。

6.前端表达式语言方面.Struts集成了JSTL，所以它主要使用JSTL的表达式语言来获取数据。可是JSTL的表达式语言在Collection和索引属性方面处理显得很弱。

7.对Action执行的控制困难. Struts创建一个Action，如果想控制它的执行顺序将会非常困难。甚至你要重新去写Servlet来实现你的这个功能需求。

8.对Action 执行前和后的处理. Struts处理Action的时候是基于class的hierarchies，很难在action处理前和后进行操作。

9.对事件支持不够. 在struts中，实际是一个表单Form对应一个Action类(或DispatchAction)，换一句话说：在Struts中实际是一个表单只能对应一个事件，struts这种事件方式称为applicationevent，application event和component event相比是一种粗粒度的事件

3.struts2的工作原理

1.客户端通过HttpServletRequest向Servlet容器提交一个请求，这个请求会经过一系列的过滤器，最终被struts核心过滤器StrutsPrepareAndExecuteFilter过滤。

2.核心过滤器过滤以后，调用访问ActionMapping，决定是否调用某一Action，如果用户请求的是jsp页面或者是其他静态资源，不会调用某Action，否则ActionMapping会将控制权委派给ActionProxy，也叫Action代理，此时Action代理会通过一个ConfigurationManager也就是配置管理器对象加载struts核心配置文件,也就是struts.xml。

3.如果在struts.xml找到需要创建的Action，ActionProxy会创建一个Action Invocation实例，Action Invocation包括一系列的拦截器和Action，先顺序执行一些列的拦截器，然后执行Action处理，返回一个结果，通过Result返回一个视图或者调用另外某个Action。

4.当返回这个视图以后，将之前执行过的拦截器反向执行一遍，然后通过response响应客户端的请求。

4.struts2的工作流程

1、客户端浏览器发出HTTP请求.

2、根据web.xml配置，该请求被FilterDispatcher接收

3、根据struts.xml配置，找到需要调用的Action类和方法，并通过IoC方式，将值注入给Aciton

4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。

5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面

6、返回HTTP响应到客户端浏览器

5.strut2的配置

1：导包

Commons-io：io的包；
Commons-lang 语言包
Freemarker ：主要用来处理前台页面；
Log4j：日志
Ognl：导航语言包，跟jstl差不多
Struts2-core：核心包；
Xwork-core：xwork的包

##1、在pom.xml中引入如下依赖
```xml

<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-core</artifactId>
<version>2.3.32</version>
</dependency>
```

##2、配置WEB-INF/web.xml
```xml
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
```

##3、创建一个struts.xml文件，src/main/resources 目录下
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<package name="default" extends="struts-default">

<action name="index">
<result>/index.jsp</result>
</action>



<action name="hello" class="com.mipo.controller.HelloAction" method="execute">
<result name="success" type="dispatcher">/success.jsp</result>
</action>
</package>
</struts>
```

##4、编写一个Action

只有action类中有get（）方法值才可以被接收
```java
package com.mipo.controller;

public class HelloAction {

private String searchKey;

public String execute() throws Exception {
this.searchKey = "百度";

return "success";
}

public String getSearchKey() {
return searchKey;
}

public void setSearchKey(String searchKey) {
this.searchKey = searchKey;
}

}

6.struts2的拦截器

①什么是拦截器？

拦截器

在访问struts2中某个action之后或者之前，会自动调用的类，就是struts2中的拦截器，他具有的最大特点就是实现了AOP（面向切面编程），他是可插拔式的，也就是说它可以在需要使用的时候通过配置xml文件来实现，而在不使用的时候又不会影响整个框架的效果，这让struts2的拦截器具有非常好的扩展性（简单的说，拦截器可以对所有action发起的请求进行拦截，也过滤器不同的是，过滤器是对web请求进行拦截）

拦截器栈

Struts2中拦截器栈就是将拦截器按照一定的顺序连接在一起的链，当满足拦截的要求时，则会按照实现声明的顺序依次执行拦截器

Strut2中的拦截器作用

毫不夸张的说，sturts2本身只是一个空的容器，而是大量的拦截器让struts2拥有非常强大的功能，比如防止表单重复提交，进行输入校验…我们可以打开struts2-core.jar包下的struts-default.xml中看到struts2都实现了哪些拦截器。大家应该也都了解struts-default.xml这个文件是我们写struts.xml时需要继承的xml文件，其中就声明了大量的拦截器和拦截器栈。我们可以找到defaultStack这个拦截器栈，它就是struts2默认加载的拦截器栈，他提供了struts2的基本操作，比如得到参数并将参数赋值给对应的action中的属性……

注：当我们手动为某个action添加一个拦截器的时候，会让defaultStack自动无效，所以需要首先引用defaultStack然后再添加其他的拦截器（详细添加方法后续介绍）

自定义拦截器

Struts2规定用户自定义拦截器必须实现com.opensymphony.xwork2.interceptor.Interceptor接口，该接口声明了三个方法分别为init()、destroy()和iterceptor(ActionInvocation invocation)；

Init()和destroy()方法是在程序启动和结束时各执行一次，无论该拦截器是否使用，只要在struts.xml中注册就会自动调用。

当然，struts2中也提供了几个抽象类来简化

public abstract class AbstractInterceptor implements Interceptor;
public abstract class MethodFilterInterceptor extends AbstractInterceptor;

其中AbstractInterceptor使用时只需要覆盖intercept()方法。

MethodFilterInterceptor额外提供了includeMethod和excludeMethod两个属性，用来执行该过滤器的action的方法。

### 4、如何使用拦截器
```xml
<interceptors>
<interceptor name="拦截器别名" class="拦截器完全类名" />
</interceptors>

### tips:注意事项
如果action内使用了自定义或者内置的拦截器，此时必须加上默认拦截器，否则从前端form提交的数据，丢失。

### 过滤器(Filter)和拦截器(Interceptor)的区别
过滤器，是在java web中，你传入的request,response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者struts的
action进行业务逻辑，比如过滤掉非法url（不是login.do的地址请求，如果用户没有登陆都过滤掉）,或者在传入servlet或者
struts的action前统一设置字符集，或者去除掉一些非法字符.
拦截器，是在面向切面编程的就是在你的service或者一个方法，前调用一个方法，或者在方法后调用一个方法比如动态代理就是拦截器的简单实现，在你调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在你调用方法后打印出字符串，甚至在你抛出异常的时候做业务逻辑的操作。

拦截器与过滤器的区别：
拦截器是基于java的反射机制的，而过滤器是基于函数回调。
拦截器不依赖与servlet容器，过滤器依赖与servlet容器。
拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。
拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。
在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次
执行顺序：过滤前 - 拦截前 - Action处理 - 拦截后 -
过滤后。个人认为过滤是一个横向的过程，首先把客户端提交的内容进行过滤(例如未登录用户不能访问内部页面的处理)；过滤通过后，拦截器将检查用户提交数据的验证，做一些前期的数据处理，接着把处理后的数据发给对应的Action；Action处理完成返回后，拦截器还可以做其他过程(还没想到要做啥)，再向上返回到过滤器的后续操作。

## 6、Ajax
### 6.1、在pom.xml里引入如下依赖
```xml
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-json-plugin</artifactId>
<version>${struts2.version}</version>
<exclusions>
<exclusion>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-core</artifactId>
</exclusion>
</exclusions>
</dependency>
```

### 6.2、编写Java源文件
```java
package com.mipo.controller;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.PrintWriter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts2.ServletActionContext;

import com.mipo.vo.Person;

/**
* Struts2 之 AJAX 示例
*/
public class AjaxAction {

private InputStream is;
private String name;
private Person person;

public String execute() throws Exception {
this.is = new ByteArrayInputStream(("Hello " + this.name).getBytes("UTF-8"));

return "success";
}

/**
* 使用一般方式响应请求
*
* @param request
* @param response
* @return
* @throws Exception
*/
public void greet() throws Exception {
HttpServletRequest request = ServletActionContext.getRequest();
HttpServletResponse response = ServletActionContext.getResponse();
response.setContentType("text/html; charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("Hello " + request.getParameter("name"));
out.flush();
out.close();
}

/**
* 通过struts2-json-plugin 处理 json 数据
*
* @return
* @throws Exception
*/
public String getJSON() throws Exception {
this.person = new Person("Nick", "555");

return "success";
}

public InputStream getIs() {
return is;
}

public void setIs(InputStream is) {
this.is = is;
}

public Person getPerson() {
return person;
}

public void setPerson(Person person) {
this.person = person;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

}
```

### 6.3、配置ajax.xml
```xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<package name="ajax" extends="json-default">

<action name="ajax">
<result>/ajax.jsp</result>
</action>
<action name="ajaxController" class="com.mipo.controller.AjaxAction" method="execute">
<result name="success" type="stream">
<param name="contentType">text/html</param>
<param name="inputName">is</param>
</result>
</action>
<action name="jsonAjaxController" class="com.mipo.controller.AjaxAction" method="getJSON">
<result name="success" type="json">
<param name="encoding">UTF-8</param>
<param name="excludeNullProperties">true</param>
<param name="root">person</param>
</result>
</action>
<action name="originAjaxController" class="com.mipo.controller.AjaxAction" method="greet" />
</package>
</struts>
```

## 7、异常处理
```xml
<global-results>
<result name="securityerror" type="redirect">/error/securityerror.jsp</result>
<result name="error" type="redirect">/error/error.jsp</result>
</global-results>
<global-exception-mappings>
<exception-mapping exception="org.apache.struts.register.exceptions.SecurityBreachException" result="securityerror" />
<exception-mapping exception="java.lang.Exception" result="error" />
</global-exception-mappings>
```

一个action处理多个请求？

3、Action处理多个请求
## 3.1、常规方式配置让一个Action处理多个请求
```xml

<action name="savePersonAction" class="com.mipo.controller.PersonAction" method="savePerson">
<result name="save" type="dispatcher">/person/save.jsp</result>
</action>
<action name="modifyPersonAction" class="com.mipo.controller.PersonAction" method="modifyPerson">
<result name="modify" type="dispatcher">/person/modify.jsp</result>
</action>
<action name="removePersonAction" class="com.mipo.controller.PersonAction" method="removePerson">
<result name="remove" type="dispatcher">/person/remove.jsp</result>
</action>
<action name="triggerExceptionAction" class="com.mipo.controller.PersonAction" method="triggerException" />
```

### 3.2、通配符方式配置让一个Action处理多个请求
```xml

<action name="*PersonAction" class="com.mipo.controller.PersonAction" method="{1}Person">
<result name="{1}" type="dispatcher">/person/{1}.jsp</result>
</action>
```

### 3.3、动态方法(DMI)调用方式配置让一个Action处理多个请求
```xml
……

<constant name="struts.enable.DynamicMethodInvocation" value="true"/>
……
<package strict-method-invocation="true">
……
```
```xml

<action name="personController" class="com.mipo.controller.PersonAction" method="execute">
<result name="success" type="dispatcher">/person/success.jsp</result>
<result name="save" type="dispatcher">/person/save.jsp</result>
<result name="modify" type="dispatcher">/person/modify.jsp</result>
<result name="remove" type="dispatcher">/person/remove.jsp</result>
<allowed-methods>savePerson, modifyPerson, removePerson, triggerException</allowed-methods>
</action>
```

## 4、Result 的几种方式
### 4.1、dispatcher(默认值)
>转发到某具体JSP页面，此处只能是JSP路径，不能是action地址。
```xml
<result>/main.jsp</result>
```

### 4.2、redirect
>重定向到某具体JSP页面，此处可以是JSP页面，也可以是action地址。
```xml
<result type="redirect">/main.jsp</result>
```

### 4.3、chain
>转发到某action
```xml
<result type="chain">
<param name="actionName">savePersonAction</param>
</result>
```

### 4.4、redirectAction
>重定向到某action
```xml
<result type="redirectAction">
<param name="actionName">savePersonAction</param>
</result>
```

===============================值栈==============================

struts2值栈（ValueStack）与Action交互过程：

（1）每个Struts2中的Action实例对象都与一个值栈相关联。此值栈用于将用户请求参数值赋值给Action实例中相应属性。

（2）Struts2收到一个action的请求后，并不会立即去执行一个action方法，而是先将action中的相关属性放入到值栈对象中的顶层节点中，并赋于这些属性初始值。

（3）Struts2去调用拦截器链中的拦截器，根据用户请求参数的值去更新值栈对象中的顶层节点中相应属性中的值。

（4）最后才将值栈顶层节点中的这些相应属性值赋值给action中的相应的属性，并调用action中的相关action方法.

（5）值栈会在请求开始时创建，在请求结束时消亡。

ValueStack对象的查找顺序：

1.从ObjectStack中查找指定名称的属性，找到后返回。

2.如果从ObjectStack中没有找到指定名称的属性，则从ContextMap中查找对应key的值，找到后返回。

##### 1.1.1 request
&emsp;&emsp;假设我们通过原生```javax.servlet.HttpServletRequest#setAttribute```设置了一些值在```request```作用域中，此时，我们在```Action```中要获取这些值或新增一些值到```request```作用域，在Struts2中如下操作

```java
// 获取request Map
Map<String, Object> request = (Map<String, Object>) ActionContext.getContext().get("request");
// 新增值
request.put("requestKey", "requestValue");
// 获取值
request.get("requestKey");
```
那么在前台页面又该如何获取？
(1)、使用s:property 标记

```xml
<s:property value="#request.requestKey" />
```
(2)、使用EL表达式
```plain
${requestScope.requestKey}
```

##### 1.1.2 session
&emsp;&emsp;假设我们通过原生```javax.servlet.HttpSession#setAttribute```设置了一些值在session作用域中，此时，我们在Action中要获取这些值或新增一些值到session，在Struts2中如下操作

```java
// 获取session Map
Map<String, Object> session = (Map<String, Object>) ActionContext.getContext().getSession();
// 新增值
session.put("sessionKey", "sessionValue");
// 获取值
session.get("sessionKey");
```

那么在前台页面又该如何获取session？
(1)、使用s:property 标记

```xml
<s:property value="#session.sessionKey" />
```

(2)、使用EL表达式
```plain
${sessionScope.sessionKey}
```

##### 1.1.3 application
&emsp;&emsp;假设我们通过原生```javax.servlet.ServletContext#setAttribute```设置了一些值在```application```作用域中，此时，我们在Action中要获取这些值或新增一些值到```application```，在Struts2中如下操作:

```java
// 获取application Map
Map<String, Object> application = (Map<String, Object>) ActionContext.getContext().getApplication();
// 新增值
application.put("applicationKey", "applicationValue");
// 获取值
session.get("applicationKey");
```

那么在前台页面又该如何获取```application```？
(1)、使用```s:property```标记

```xml
<s:property value="#application.applicationKey" />
```

(2)、使用EL表达式
```plainText
${applicationScope.applicationKey}
```

##### 1.1.4 parameters
&emsp;&emsp;我们通过表单提交或者通过URL传递请求参数的形式，在Servlet中获取```request.getParameter("")```获取参数值。Struts2中，如下操作

```java
// 获取 parameters Map
Map<String, Object> params = ActionContext.getContext().getParameters();
// 取值
params.get("uname")
// 切记，此处请勿往params对象中存值，因为即使存值，也取不到
```

在JSP页面，取值经有如下方式：
(1)、通过```s:property```标记

```xml
<s:property value="#parameters.uname" />
```

(2)、通过EL表达式
```plainText
${param.uname}
```

##### 1.1.5 attr
&emsp;&emsp;如上述，若不指定具体的范围，那么可以让其自动寻值
(1)、通过s:property 标记
```xml
<s:property value="#attr.uname" />
```

(2)、通过EL表达式
```plain
${uname}
```

##### 1.1.6 非耦合接口
除了从ActionContext中获取上述对象外，还可以通过实现接口来获取。
```java
public class ScopeAware implements ApplicationAware, SessionAware, RequestAware {

private Map<String, Object> request;
private Map<String, Object> session;
private Map<String, Object> application;

@Override
public void setRequest(Map<String, Object> request) {
this.request = request;
}

@Override
public void setSession(Map<String, Object> session) {
this.session = session;
}

@Override
public void setApplication(Map<String, Object> application) {
this.application = application;
}

}
```

##### 1.1.7 耦合接口
Struts2中如何获取Servlet原生对象，方法有二：

###### 1.1.7.1 通过ServletActionContext对象获取

```java
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.struts2.ServletActionContext;

/**
* 从ServletActionContext 对象中获取原生Servlet API
*/
public class ServletScope {

@SuppressWarnings("unused")
void execute() {
HttpServletRequest request = ServletActionContext.getRequest();

HttpServletResponse response = ServletActionContext.getResponse();

HttpSession session = ServletActionContext.getRequest().getSession();

ServletContext servletContext = ServletActionContext.getServletContext();
}

}
```

###### 1.1.7.2 通过接口

```java
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;
import org.apache.struts2.util.ServletContextAware;

/**
* 以实现接口的方式，获取原生Servlet API
*/
public class ServletScopeAware implements ServletRequestAware, ServletContextAware, ServletResponseAware {

private HttpServletRequest request;
private HttpServletResponse response;
private HttpSession session;
private ServletContext context;

@Override
public void setServletResponse(HttpServletResponse response) {
this.response = response;
}

@Override
public void setServletContext(ServletContext context) {
this.context = context;
}

@Override
public void setServletRequest(HttpServletRequest request) {
this.request = request;
this.session = request.getSession();
}

}
```

#### 1.2 狭义值栈（对象栈）
通常指的是实现```com.opensymphony.xwork2.util.ValueStack```接口的对象，目前就是```com.opensymphony.xwork2.ognl.OgnlValueStack```对象。
狭义值栈主要用来存取动态EL（表达式语言）运算需要的值和结果，当然```OgnlValueStack```对象主要是用来支持```OGNL```（对象图导航语言）运算的。狭义值栈里面存放着一些OGNL可以存取访问的数据，典型如：
Action的实例，这样就可以通过```OGNL```来访问```Action```实例中的属性的值了
OGNL表达式运算的值，可以设置到值栈中，可以主动访问值栈对象，强行设置
OGNL表达式产生的中间变量，比如在后面使用Struts2的标签的时候，使用循环标签，自然会有循环的变量，这些都存放在值栈中。
```CompoundRoot```类型，内部存放着与当前Action实例相关的各个对象。如某```Action```类中声明一个Product属性，则在前端JSP页面，可以直接获取该值。

```xml
<s:property value="product" />
```

是否可以不通过添加属性，往值栈中添加值呢？
```java
ValueStack valueStack = ActionContext.getContext().getValueStack();
valueStack.set("student", new Student(9527, "周星星"));
```

前端页面JSP获取值

```xml
<s:property value="student" />
```

### 2、```OGNL```
&emsp;&emsp;对象图导航语言，用于获取值栈中的数据。
（1）获取栈顶数据，可以写成```[0].product.name```，当然也可以省略[0] 因为默认就是取栈顶数据；
（2）获取栈中第二项数据，写成```[1].product.name```，如果不存在，从此处开始查找；
（3）```OGNL```可直接调用类常量或方法

=================================注解=============================

### 1、关于值栈ValueStack
&emsp;&emsp;值栈是对应每一个请求对象的轻量级的内存数据中心。
&emsp;&emsp;简单的说，值栈能够线程安全的为每个请求提供公共的数据存取服务。当有请求到达的时候，Struts2会为每个请求创建一个新的值栈，也就是说，值栈和请求是一一对应的，不同的请求，值栈也不一样，而值栈封装了一次请求所有需要操作的相关的数据。正是因为值栈和请求的对应关系，因而值栈能保证线程安全的为每个请求提供公共的数据存取服务。
&emsp;&emsp;值栈有狭义的值栈和广义的值栈之分。今后在说值栈的时候，没有特别指明的情况下，多数就是指的广义值栈，反正开发的时候都是说从值栈中获取值。当然，有一种情况除外，就是在页面上使用```OGNL```的时候，没有特殊标识的情况下，默认是从```ValueStatck```中取值的。

#### 1.1 广义值栈（Map栈）
&emsp;&emsp;通常指的是```ActionContext```对象，```ActionContext```是```Action```运行的上下文，每个```ActionContext```是一个基本的容器，包含着```Action```运行需要的数据，比如请求参数、会话等。```ActionContext```是线程安全的，每个线程有一个独立的```ActionContext```，这样你就不用担心值栈中值的线程安全问题了。```ActionContext```里面存放有很多的值，典型如：
+ 请求的parameters：请求中的参数，要注意这里的数据是从请求对象里面拷贝出来的，因此这里数据的变化是不会影响到请求对象里面的参数的值的；
+ Request的Attribute：请求中的属性，这里其实就是个Map，存放着请求对象的属性数据，这些数据和请求对象的Attribute是连动的；
+ Session的Attribute：会话中的属性，这里其实就是个Map，存放着会话对象的属性数据，这些数据和会话对象的Attribute是连动的；
+ Application的Attribute：应用中的属性，这里其实就是个Map，存放着应用对象的属性数据，这些数据和应用对象的Attribute是连动的；

ValueStack：也就是狭义值栈，ActionContext以ValueStack作为被OGNL访问的根，简单点说，OGNL在没有特别指明的情况下，访问的就是ValueStack里面的数据
attr：在所有的属性范围中获取值，依次搜索page、request、session和application。
　　我们知道Xwork与Web是无关的，因此Action不用去依赖于任何Web容器，不用和Servlet 的API去交互，但是Action需要能访问到Web应用的数据，不仅仅是取得请求参数的值，往往也需要在Action里直接获取请求或会话的一些数据，对于这些数据，现在都可以通过ActionContext来获取到。

##### 1.1.1 request
&emsp;&emsp;假设我们通过原生```javax.servlet.HttpServletRequest#setAttribute```设置了一些值在```request```作用域中，此时，我们在```Action```中要获取这些值或新增一些值到```request```作用域，在Struts2中如下操作

```java
// 获取request Map
Map<String, Object> request = (Map<String, Object>) ActionContext.getContext().get("request");
// 新增值
request.put("requestKey", "requestValue");
// 获取值
request.get("requestKey");
```
那么在前台页面又该如何获取？
(1)、使用s:property 标记

```xml
<s:property value="#request.requestKey" />
```
(2)、使用EL表达式
```plain
${requestScope.requestKey}
```

##### 1.1.2 session
&emsp;&emsp;假设我们通过原生```javax.servlet.HttpSession#setAttribute```设置了一些值在session作用域中，此时，我们在Action中要获取这些值或新增一些值到session，在Struts2中如下操作

```java
// 获取session Map
Map<String, Object> session = (Map<String, Object>) ActionContext.getContext().getSession();
// 新增值
session.put("sessionKey", "sessionValue");
// 获取值
session.get("sessionKey");
```

那么在前台页面又该如何获取session？
(1)、使用s:property 标记

```xml
<s:property value="#session.sessionKey" />
```

(2)、使用EL表达式
```plain
${sessionScope.sessionKey}
```

##### 1.1.3 application
&emsp;&emsp;假设我们通过原生```javax.servlet.ServletContext#setAttribute```设置了一些值在```application```作用域中，此时，我们在Action中要获取这些值或新增一些值到```application```，在Struts2中如下操作:

```java
// 获取application Map
Map<String, Object> application = (Map<String, Object>) ActionContext.getContext().getApplication();
// 新增值
application.put("applicationKey", "applicationValue");
// 获取值
session.get("applicationKey");
```

那么在前台页面又该如何获取```application```？
(1)、使用```s:property```标记

```xml
<s:property value="#application.applicationKey" />
```

(2)、使用EL表达式
```plainText
${applicationScope.applicationKey}
```

##### 1.1.4 parameters
&emsp;&emsp;我们通过表单提交或者通过URL传递请求参数的形式，在Servlet中获取```request.getParameter("")```获取参数值。Struts2中，如下操作

```java
// 获取 parameters Map
Map<String, Object> params = ActionContext.getContext().getParameters();
// 取值
params.get("uname")
// 切记，此处请勿往params对象中存值，因为即使存值，也取不到
```

在JSP页面，取值经有如下方式：
(1)、通过```s:property```标记

```xml
<s:property value="#parameters.uname" />
```

(2)、通过EL表达式
```plainText
${param.uname}
```

##### 1.1.5 attr
&emsp;&emsp;如上述，若不指定具体的范围，那么可以让其自动寻值
(1)、通过s:property 标记
```xml
<s:property value="#attr.uname" />
```

(2)、通过EL表达式
```plain
${uname}
```

##### 1.1.6 非耦合接口
除了从ActionContext中获取上述对象外，还可以通过实现接口来获取。
```java
public class ScopeAware implements ApplicationAware, SessionAware, RequestAware {

private Map<String, Object> request;
private Map<String, Object> session;
private Map<String, Object> application;

@Override
public void setRequest(Map<String, Object> request) {
this.request = request;
}

@Override
public void setSession(Map<String, Object> session) {
this.session = session;
}

@Override
public void setApplication(Map<String, Object> application) {
this.application = application;
}

}
```

##### 1.1.7 耦合接口
Struts2中如何获取Servlet原生对象，方法有二：

###### 1.1.7.1 通过ServletActionContext对象获取

```java
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.struts2.ServletActionContext;

/**
* 从ServletActionContext 对象中获取原生Servlet API
*/
public class ServletScope {

@SuppressWarnings("unused")
void execute() {
HttpServletRequest request = ServletActionContext.getRequest();

HttpServletResponse response = ServletActionContext.getResponse();

HttpSession session = ServletActionContext.getRequest().getSession();

ServletContext servletContext = ServletActionContext.getServletContext();
}

}
```

###### 1.1.7.2 通过接口

```java
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.ServletResponseAware;
import org.apache.struts2.util.ServletContextAware;

/**
* 以实现接口的方式，获取原生Servlet API
*/
public class ServletScopeAware implements ServletRequestAware, ServletContextAware, ServletResponseAware {

private HttpServletRequest request;
private HttpServletResponse response;
private HttpSession session;
private ServletContext context;

@Override
public void setServletResponse(HttpServletResponse response) {
this.response = response;
}

@Override
public void setServletContext(ServletContext context) {
this.context = context;
}

@Override
public void setServletRequest(HttpServletRequest request) {
this.request = request;
this.session = request.getSession();
}

}
```

#### 1.2 狭义值栈（对象栈）
通常指的是实现```com.opensymphony.xwork2.util.ValueStack```接口的对象，目前就是```com.opensymphony.xwork2.ognl.OgnlValueStack```对象。
狭义值栈主要用来存取动态EL（表达式语言）运算需要的值和结果，当然```OgnlValueStack```对象主要是用来支持```OGNL```（对象图导航语言）运算的。狭义值栈里面存放着一些OGNL可以存取访问的数据，典型如：
Action的实例，这样就可以通过```OGNL```来访问```Action```实例中的属性的值了
OGNL表达式运算的值，可以设置到值栈中，可以主动访问值栈对象，强行设置
OGNL表达式产生的中间变量，比如在后面使用Struts2的标签的时候，使用循环标签，自然会有循环的变量，这些都存放在值栈中。
```CompoundRoot```类型，内部存放着与当前Action实例相关的各个对象。如某```Action```类中声明一个Product属性，则在前端JSP页面，可以直接获取该值。

```xml
<s:property value="product" />
```

是否可以不通过添加属性，往值栈中添加值呢？
```java
ValueStack valueStack = ActionContext.getContext().getValueStack();
valueStack.set("student", new Student(9527, "周星星"));
```

前端页面JSP获取值

```xml
<s:property value="student" />
```

### 2、```OGNL```
&emsp;&emsp;对象图导航语言，用于获取值栈中的数据。
（1）获取栈顶数据，可以写成```[0].product.name```，当然也可以省略[0] 因为默认就是取栈顶数据；
（2）获取栈中第二项数据，写成```[1].product.name```，如果不存在，从此处开始查找；
（3）```OGNL```可直接调用类常量或方法

=============================面试题=============================

struts2有哪些优点？
1）在软件设计上Struts2的应用可以不依赖于Servlet API和struts API。 Struts2的这种设计属于无侵入式设计；
2）拦截器，实现如参数拦截注入等功能；
3）类型转换器，可以把特殊的请求参数转换成需要的类型；
4）多种表现层技术，如：JSP、freeMarker、Velocity等；
5）Struts2的输入校验可以对指定某个方法进行校验；
6）提供了全局范围、包范围和Action范围的国际化资源文件管理实现
struts2是如何启动的？
struts2框架是通过Filter启动的，即StrutsPrepareAndExecuteFilter，此过滤器为struts2的核心过滤器；
StrutsPrepareAndExecuteFilter的init()方法中将会读取类路径下默认的配置文件struts.xml完成初始化操作。struts2读取到struts.xml的内容后，是将内
容封装进javabean对象然后存放在内存中，以后用户的每次请求处理将使用内存中的数据，而不是每次请求都读取struts.xml文件
struts2框架的核心控制器是什么？它有什么作用？
1）Struts2框架的核心控制器是StrutsPrepareAndExecuteFilter。
2）作用：
负责拦截由<url-pattern>/*</url-pattern>指定的所有用户请求，当用户请求到达时，该Filter会过滤用户的请求。默认情况下，如果用户请求的路径
不带后缀或者后缀以.action结尾，这时请求将被转入struts2框架处理，否则struts2框架将略过该请求的处理。
可以通过常量"struts.action.extension"修改action的后缀，如：
<struts><constant name="struts.action.extension" value="do"/></struts>
如果用户需要指定多个请求后缀，则多个后缀之间以英文逗号（,）隔开。如：
<constant name="struts.action.extension" value="do,go"/>
struts2配置文件的加载顺序？
struts.xml ——> struts.properties
常量可以在struts.xml或struts.properties中配置，如果在多个文件中配置了同一个常量，则后一个文件中配置的常量值会覆盖前面文件中配置的常量值.
struts.xml文件的作用：通知Struts2框架加载对应的Action资源
struts2常量的修改方式？
常量可以在struts.xml或struts.properties中配置，两种配置方式如下：
1）在struts.xml文件中配置常量
<struts>
<constant name="struts.action.extension" value="do"/>
</struts>
2）在struts.properties中配置常量（struts.properties文件放置在src下）：
struts.action.extension=do
struts2如何访问HttpServletRequest, HttpSession 和 ServletContext三个域对象？
方案一：
HttpServletRequest request = ServletActionContext.getRequest();
HttpServletResponse response = ServletActionContext.getResponse();
HttpSession session = request.getSession();
ServletContext servletContext = ServletActionContext.getServletContext();
方案二：
类 implements ServletRequestAware,ServletResponseAware，SessionAware，ServletContextAware
注意：框架自动传入对应的域对象
struts2是如何管理action的？这种管理方式有什么好处？
struts2框架中使用包来管理Action，包的作用和java中的类包是非常类似的。
主要用于管理一组业务功能相关的action。在实际应用中，我们应该把一组业务功能相关的Action放在同一个包下。
struts2中的默认包struts-default有什么作用？
1）struts-default包是由struts内置的，它定义了struts2内部的众多拦截器和Result类型，而Struts2很多核心的功能都是通过这些内置的拦截器实现，如：从请求中
把请求参数封装到action、文件上传和数据验证等等都是通过拦截器实现的。当包继承了struts-default包才能使用struts2为我们提供的这些功能。
2）struts-default包是在struts-default.xml中定义，struts-default.xml也是Struts2默认配置文件。 Struts2每次都会自动加载 struts-default.xml文件。
3）通常每个包都应该继承struts-default包，
struts2的工作流程？
用户请求
——> StrutsPrepareAndExecuteFilter
——> Interceptor
——> Action
——> Result
——> Jsp/html
——> 响应
struts2的action的URL访问路径由什么构成？
由两部分组成：包的命名空间+action的名称 [ + action的后缀 ]，即：package.namespace + action.name
在struts.xml中可以不为action指定class属性吗？struts2中有哪些默认的属性？
可以，如果没有为action指定class，默认是com.opensymphony.xwork2.ActionSupport
默认属性：
如果没有为action指定class ActionSupport
如果没有为action指定method execute() 注意：ActionSupport的execute方法里面就一句话return "success";
如果没有指定result的name success
如果没有指定result的type dispatcher
action中默认都有一个拦截器的引用，即：<interceptor-ref name="defaultStack">;
注意：
1）一旦我们为该包中的某个action显式指定了某个拦截器，则默认拦截器不会起作用，所以此时要显式的引进默认的拦截器；
2）每个包只能指定一个默认拦截器，每个默认拦截器只针对当前包下有效。
struts2如何对指定的方法进行验证？
1）validate()方法会校验action中所有与execute方法签名相同的方法；
2）要校验指定的方法通过重写validateXxx()方法实现， validateXxx()只会校验action中方法名为Xxx的方法。其中Xxx的第一个字母要大写；
3）当某个数据校验失败时，调用addFieldError()方法往系统的fieldErrors添加校验失败信息（为了使用addFieldError()方法，action可以继承ActionSupport），
如果系统的fieldErrors包含失败信息，struts2会将请求转发到名为input的result；
4）在input视图中可以通过<s:fielderror/>显示失败信息。
5）先执行validateXxxx()->validate()->如果出错了，会转发<result name="input"/>所指定的页面，如果不出错，会直接进行Action::execute()方法
struts2默认能解决get和post提交方式的乱码问题吗？
不能。struts.i18n.encoding=UTF-8属性值只能解析POST提交下的乱码问题。
struts2如何完成文件的上传？
1、JSP页面：
1）JSP页面的上传文件的组件：<s: file name=”upload” />，如果需要一次上传多个文件, 就必须使用多个 file 标签, 但它们的名字必须是相同的，即：
name=“xxx”的值必须一样；
2）必须把表单的enctype属性设置为：multipart/form-data；
3）表单的方法必须为post，因为post提交的数据在消息体中，而无大小限制。
2、对应的action：
1）在 Action 中新添加 3 个和文件上传相关的属性；
2）如果是上传单个文件, uploadImage属性的类型就是 java.io.File, 它代表被上传的文件, 第二个和第三个属性的类型是 String, 它们分别代表上传文
件的文件名和文件类型，定义方式是分别是：
jsp页面file组件的名称+ContentType,
jsp页面file组件的名称+FileName
3）如果上上传多个文件, 可以使用数组或 List
struts2的拦截器与拦截器栈有什么区别：
1）Struts2 拦截器在访问某个 Action 方法之前或之后实施拦截, Struts2 拦截器是可插拔的。
2）拦截器栈(Interceptor Stack): 将拦截器按一定的顺序联结成一条链，在访问被拦截的方法时, Struts2拦截器链中的拦截器就会按其之前定义的顺序被依次
调用，类似于Filter在web.xml文件中的配置顺序调用。
拦截器的生命周期与工作过程？
1）每个拦截器都是实现了Interceptor接口的 Java 类；
2）init(): 该方法将在拦截器被创建后立即被调用, 它在拦截器的生命周期内只被调用一次. 可以在该方法中对相关资源进行必要的初始化；
3）intercept(ActionInvocation invocation): 每拦截一个动作请求, 该方法就会被调用一次；
4）destroy: 该方法将在拦截器被销毁之前被调用, 它在拦截器的生命周期内也只被调用一次；
5）struts2中有内置了18个拦截器。
拦截器的作用？拦截器与过滤器的区别？
1）拦截器是对调用的Action起作用，它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码。拦截器只能拦截Action,说明白点拦截器其实是Action
的功能块,只在Action前后执行。拦截器可以抽象出一部分代码可以用来完善原来的action。同时可以减轻代码冗余，提高重用率。
2）过滤器是拦截用户请求的,范围明显比拦截器大的多。
请你写出struts2中至少5个的默认拦截器？
fileUpload 提供文件上传功能
i18n 记录用户选择的locale
cookies 使用配置的name,value来是指cookies
checkbox 添加了checkbox自动处理代码，将没有选中的checkbox的内容设定为false，而html默认情况下不提交没有选中的checkbox。
chain 让前一个Action的属性可以被后一个Action访问，现在和chain类型的result（）结合使用。
alias 在不同请求之间将请求参数在不同名字件转换，请求内容不变
result的type属性中有哪几种结果类型？
一共10种：
dispatcher struts默认的结果类型，把控制权转发给应用程序里的某个资源不能把控制权转发给一个外部资源，若需要把控制权重定向到一个外部资源, 应该使用
redirect结果类型
redirect 把响应重定向到另一个资源（包括一个外部资源）
redirectAction 把响应重定向到另一个 Action
freemarker、velocity、chain、httpheader、xslt、plainText、stream
struts2如何完成从html表单到action的类型转换？
1）在 struts2 中, 把请求参数映射到 action 属性的工作由 Params拦截器负责, 它是默认的 defaultStack 拦截器中的一员. Params拦截器可以自动完成字符串
和基本数据类型之间转换.
2）对于引用类型的数据（除String、Collection）转换，需要自定义类型转换器；
3）自定义类型转化器必须实现TypeConverter 接口或对这个接口的某种具体实现做扩展，如：StrutsTypeConverter，重写convertToString和convertFromString方法；
4）两种自定义类型的转换器：
>> 局部：
创建一个属性文件: ActionClassName-conversion.properties, 该文件需和相对应的动作类(Action)放在同一个目录下, ActionClassName是Action的类名，
后面的-conversion.properties 是固定写法。在properties文件中的内容为：属性名称=类型转换器的全类名
>> 全局：
在 WEB-INF/classes/ 目录下创建 xwork-conversion.properties 文件. 在properties文件中的内容为：待转换的类型=类型转换器的全类名
注意：对于转换的是属性，只需要写属性名，如果是对应的是类型，则需要写全类名
值栈ValueStack的原理与生命周期？
1）ValueStack贯穿整个 Action 的生命周期，保存在request域中，所以ValueStack和request的生命周期一样。当Struts2接受一个请求时，会迅速创建ActionContext，
ValueStack，action。然后把action存放进ValueStack，所以action的实例变量可以被OGNL访问。请求来的时候，action、ValueStack的生命开始，请求结束，action、
ValueStack的生命结束；
2）action是多例的，和Servlet不一样，Servelt是单例的；
3）每个action的都有一个对应的值栈，值栈存放的数据类型是该action的实例，以及该action中的实例变量，Action对象默认保存在栈顶；
4）ValueStack本质上就是一个ArrayList；
5）关于ContextMap，Struts 会把下面这些映射压入 ContextMap 中：
parameters : 该 Map 中包含当前请求的请求参数
request : 该 Map 中包含当前 request 对象中的所有属性
session : 该 Map 中包含当前 session 对象中的所有属性
application : 该 Map 中包含当前 application 对象中的所有属性
attr : 该 Map 按如下顺序来检索某个属性: request, session, application
6）使用OGNL访问值栈的内容时，不需要#号，而访问request、session、application、attr时，需要加#号；
7）注意： Struts2中，OGNL表达式需要配合Struts标签才可以使用。如：<s:property value="name"/>
8）在struts2配置文件中引用ognl表达式 ,引用值栈的值，此时使用的"$"，而不是#或者%;
ActionContext、ServletContext、pageContext的区别？
1）ActionContext是当前的Action的上下文环境，通过ActionContext可以获取到request、session、ServletContext等与Action有关的对象的引用；
2）ServletContext是域对象，一个web应用中只有一个ServletContext，生命周期伴随整个web应用；
3）pageContext是JSP中的最重要的一个内置对象，可以通过pageContext获取其他域对象的应用，同时它是一个域对象，作用范围只针对当前页面，当前页面结束时，pageContext销毁，
生命周期是JSP四个域对象中最小的。
struts2如何防止用户表单重复提交？
第一步：在表单中加入<s:token />
第二步，使用token栏截器，定义invalid.token结果集
要使用<s:token /> 必须要在struts.xml的action中引用token的预定义拦截器。
<interceptor name="token" class="org.apache.struts2.interceptor.TokenInterceptor"/>

当然还可以使用tokenSession

<interceptor name="tokenSession" class="org.apache.struts2.interceptor.TokenSessionStoreInterceptor"/>
第二种方法

从Api文档中发现找出里面有一个字段叫做actionName,指定我们需要跳转的Action

配置方法如下：

12）.struts2如何完成文件的上传？

1、JSP页面：
JSP页面的上传文件的组件：<s: file name=”upload” />，如果需要一次上传多个文件, 就必须使用多个 file 标签, 但它们的名字必须是相同的，即：name=“xxx”的值必须一样；

2. 必须把表单的enctype属性设置为：multipart/form-data；

3.表单的方法必须为post，因为post提交的数据在消息体中，而无大小限制。

对应的action：
4.在 Action 中新添加 3 个和文件上传相关的属性

5.如果是上传单个文件, uploadImage属性的类型就是 java.io.File, 它代表被上传的文件, 第二个和第三个属性的类型是 String, 它们分别代表上传文件的文件名和文件类型，定义方式是分别是：jsp页面file组件的名称+ContentType, jsp页面file组件的名称+FileName
6如果上上传多个文件, 可以使用数组或 List

1.描述Struts2的工作原理

答:客户端发送请求--》请求经过一系列过滤器--》FilterDispatcher通过ActionMapper来决定这个Request需要调用哪个Action --》FilterDispatcher把请求的处理交给ActionProxy--》通过ConfigurationManager询问Struts配置文件（Struts.xml），找到需要调用的Action类--》ActionProxy创建一个ActionInvocation的实例 --》调用Action--》执行完毕，返回结果

2.Struts2中的拦截器有什么用？列举框架提供的拦截器名称？（至少3种，可用中文名）

答：拦截器是struts2核心组成部分，它提供了一种机制,使得开发者可以定义一个特定的功能模块,这个模块会在Action执行之前或者之后执行,也可以在Action执行之前阻止Action执行。

常用的拦截器有:chain:在不同请求之间将请求参数在不同名字件转换，请求内容不变fileUpload:提供文件上传。

i18n：记录用户选择的区域环境 logger：输出Action的名字 params：将请求中的参数设置到Action中去。

3.什么是OGNL，有什么用途？如何访问存放在session中叫user的对象的username属性

答：OGNL是Object-Graph Navigation Language的缩写，也叫对象导航语言。它是Struts的一种功能强大的表达式语言

列如：访问session中的user对象的username属性:

注意的是：使用前需要在页面头部导入taglib prefix="s" uri="/struts-tags"

4. 什么是国际化，struts2实现国际化的原理。

答：国际化是根据不同的国家和地区的语言文化的不同，所设计的适用于不同地区的编码格式。

实现方法：

首先在src目录下新建message_en.properties(英文);

页面获取国际化信息:

或者使用

原理：程序得到当前运行环境的国际/区域,语言环境并存放于Locale,ResourceBundle根据Locale中信息自动搜索对应的国际化资源文件并加载。

5.JSON的全称是什么？用JavaScript代码描述一个json数组，并进行解析。

答：JSON的全称是”JavaScript Object Notation”，它是一种独立于语言的轻量级数据交换格式。

比如：

[{

"id":"1",

"text":"所有班级",

"Children":[

{"id":"11",

"text:"Y2T01"

}

]

}]

6. AJAX是什么？描述ajax的原理

答：Ajax又叫异步刷新,（JavaScript和xml）

原理：

使用HttpRequest向服务器发送异步请求,服务器返回处理结果

7. 什么是反射？请用反射动态创建一个类的对象(写关键代码,其它可省略)

答：反射，程序运行时动态获取类型信息,完成对象创建，方法调用等。

例如：

Class myclass=Class.forNama("包名.类名");

Student stu=Factory.createInstance("stu1");

8. 在struts2中如何实现转发和重定向？

答：在struts.xml中配置type="redirect"(重定向)

type="redirectAction"(转发)

9. Struts2中的type类型有哪些？至少写4种

答：chain,redirect,redirectAction,json,dispatcher

10. Struts2有哪些优点？

答：实现MVC模式,结构清晰,使开发者只关注业务逻辑的实现。有丰富的tag可以用,大大提高了开发效率。

struts2是如何管理action的？这种管理方式有什么好处？

struts2框架中使用包来管理Action，包的作用和java中的类包是非常类似的。

主要用于管理一组业务功能相关的action。在实际应用中，我们应该把一组业务功能相关的Action放在同一个包下。

struts2中的默认包struts-default有什么作用？

1）struts-default包是由struts内置的，它定义了struts2内部的众多拦截器和Result类型，而Struts2很多核心的功能都是通过这些内置的拦截器实现，如：从请求中

把请求参数封装到action、文件上传和数据验证等等都是通过拦截器实现的。当包继承了struts-default包才能使用struts2为我们提供的这些功能。

2）struts-default包是在struts-default.xml中定义，struts-default.xml也是Struts2默认配置文件。 Struts2每次都会自动加载 struts-default.xml文件。

3）通常每个包都应该继承struts-default包。

struts2如何对指定的方法进行验证？

1）validate()方法会校验action中所有与execute方法签名相同的方法；

2）要校验指定的方法通过重写validateXxx()方法实现， validateXxx()只会校验action中方法名为Xxx的方法。其中Xxx的第一个字母要大写；

3）当某个数据校验失败时，调用addFieldError()方法往系统的fieldErrors添加校验失败信息（为了使用addFieldError()方法，action可以继承ActionSupport），如果系统的fieldErrors包含失败信息，struts2会将请求转发到名为input的result；

4）在input视图中可以通过<s:fielderror/>显示失败信息。

5）先执行validateXxxx()->validate()->如果出错了，会转发<result name="input"/>所指定的页面，如果不出错，会直接进行Action::execute()方法

struts2默认能解决get和post提交方式的乱码问题吗？

不能。struts.i18n.encoding=UTF-8属性值只能解析POST提交下的乱码问题。

请你写出struts2中至少5个的默认拦截器？

fileUpload 提供文件上传功能

i18n 记录用户选择的locale

cookies 使用配置的name,value来是指cookies

checkbox 添加了checkbox自动处理代码，将没有选中的checkbox的内容设定为false，而html默认情况下不提交没有选中的checkbox。

chain 让前一个Action的属性可以被后一个Action访问，现在和chain类型的result（）结合使用。

alias 在不同请求之间将请求参数在不同名字件转换，请求内容不变

值栈ValueStack的原理与生命周期？

1）ValueStack贯穿整个 Action 的生命周期，保存在request域中，所以ValueStack和request的生命周期一样。当Struts2接受一个请求时，会迅速创建ActionContext，

ValueStack，action。然后把action存放进ValueStack，所以action的实例变量可以被OGNL访问。请求来的时候，action、ValueStack的生命开始，请求结束，action、 ValueStack的生命结束；

2）action是多例的，和Servlet不一样，Servelt是单例的；

3）每个action的都有一个对应的值栈，值栈存放的数据类型是该action的实例，以及该action中的实例变量，Action对象默认保存在栈顶；

4）ValueStack本质上就是一个ArrayList；

5）关于ContextMap，Struts 会把下面这些映射压入 ContextMap 中：

parameters : 该 Map 中包含当前请求的请求参数

request : 该 Map 中包含当前 request 对象中的所有属性 session :该 Map 中包含当前 session 对象中的所有属性

application :该 Map 中包含当前 application 对象中的所有属性

attr:该 Map 按如下顺序来检索某个属性: request, session, application

6）使用OGNL访问值栈的内容时，不需要#号，而访问request、session、application、attr时，需要加#号；

7）注意： Struts2中，OGNL表达式需要配合Struts标签才可以使用。如：<s:property value="name"/>

8）在struts2配置文件中引用ognl表达式 ,引用值栈的值，此时使用的"$"，而不是#或者%;

ActionContext、ServletContext、pageContext的区别？

1）ActionContext是当前的Action的上下文环境，通过ActionContext可以获取到request、session、ServletContext等与Action有关的对象的引用；

2）ServletContext是域对象，一个web应用中只有一个ServletContext，生命周期伴随整个web应用；

3）pageContext是JSP中的最重要的一个内置对象，可以通过pageContext获取其他域对象的应用，同时它是一个域对象，作用范围只针对当前页面，当前页面结束时，pageContext销毁，

生命周期是JSP四个域对象中最小的。

result的type属性中有哪几种结果类型？

一共10种：

dispatcher

struts默认的结果类型，把控制权转发给应用程序里的某个资源不能把控制权转发给一个外部资源，若需要把控制权重定向到一个外部资源, 应该使用

redirect结果类型

redirect 把响应重定向到另一个资源（包括一个外部资源）

redirectAction 把响应重定向到另一个 Action

freemarker、velocity、chain、httpheader、xslt、plainText、stream

拦截器的生命周期与工作过程？

1）每个拦截器都是实现了Interceptor接口的 Java 类；

2）init(): 该方法将在拦截器被创建后立即被调用, 它在拦截器的生命周期内只被调用一次. 可以在该方法中对相关资源进行必要的初始化；

3）intercept(ActionInvocation invocation): 每拦截一个动作请求, 该方法就会被调用一次；

4）destroy: 该方法将在拦截器被销毁之前被调用, 它在拦截器的生命周期内也只被调用一次；

5）struts2中有内置了18个拦截器。

struts2如何完成文件的上传？

1、JSP页面：

1）JSP页面的上传文件的组件：<s: file name=”upload” />，如果需要一次上传多个文件, 就必须使用多个 file 标签, 但它们的名字必须是相同的，即：

name=“xxx”的值必须一样；

2）必须把表单的enctype属性设置为：multipart/form-data；

3）表单的方法必须为post，因为post提交的数据在消息体中，而无大小限制。

2、对应的action：

1）在 Action 中新添加 3 个和文件上传相关的属性；

2）如果是上传单个文件, uploadImage属性的类型就是 java.io.File, 它代表被上传的文件, 第二个和第三个属性的类型是 String, 它们分别代表上传文

件的文件名和文件类型，定义方式是分别是：

jsp页面file组件的名称+ContentType, jsp页面file组件的名称+FileName

3）如果上上传多个文件, 可以使用数组或 List