1.建立一个webproject –>struts2
2.导入相应的jar包（可以参考blank项目）
3.配置web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5"
xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<welcome-file-list>
<welcome-file>login.jsp</welcome-file>
</welcome-file-list>
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
4.创建struts.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="default" extends="struts-default">
<action name="login" class="org.action.LoginAction">
<result name="success">/welcome.jsp</result>
</action>
</package>
</struts>
5.编写loginaction.java
package org.action;
public class LoginAction{
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String execute() throws Exception{
return "success";
}
}
然后与请求映射关联起来
stuts.xml
<action name="login" class="org.action.LoginAction">
<result name="success">/welcome.jsp</result>
</action>
6.创建视图login.jsp
<%@ page language="java" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>登录页面</title>
</head>
<body>
<form action="login.action" method="post">
<table align="center" border=1 width="300" bgcolor=#F5FFE1>
<tr><td colspan="2" align="center" width="250" bgcolor="#CCCCFF">用户登录界面</td></tr>
<tr><td width="50">姓名：</td><td><input type="text" name="username"/></td></tr>
<tr><td width="50">密码：</td><td><input type="password" name="password" size=22/></td></tr>
<tr><td align="center" colspan=2><input type="submit" value="登录"/><input type="reset" value="重置" /></td></tr>
</table>
</form>
</body>
</html>
7.创建成功视图
<%@ page language="java" pageEncoding="UTF-8"%>
<%@ taglib uri="/struts-tags" prefix="s" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>欢迎界面</title>
</head>
<body bgcolor=#F5FFE1>
欢迎您！${username}
</body>
</html>
2. Struts 2中各种文件详解
（1）web.xml文件
在上例开发过程中，首先配置了web.xml，看看其中到底配置了什么
最上面是普通的xml文件头，然后是一些引用文件。后面的webapp标签中配置了下面这样一段：
…
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
…
所有过滤器必须实现java.Serlvet.Filter接口，这个接口中含有3个过滤器类必须实现的方法：
linit(FilterConfig)：Servlet过滤器的初始化方法，Servlet容器创建Servlet过滤器实例后将调用这个方法。
ldoFilter(ServletRequest,ServletResponse,FilterChain)：完成实际的过滤操作，当用户请求与过滤器关联的URL时，Servlet容器将先调用过滤器的doFilter方法，返回响应之前也会调用此方法。FilterChain参数用于访问过滤器链上的下一个过滤器。
destroy()：Servlet容器在销毁过滤器实例前调用该方法，这个方法可以释放Servlet过滤器占用的资源
过滤器类编写完成后，必须要在web.xml中进行配置，格式如下：
<filter>
<!--自定义的名称-->
<filter-name>过滤器名</filter-name>
<!--自定义的过滤器类，注意，这里要在包下，要加包名-->
<filter-class>过滤器对应类</filter-class>
<init-param>
<!--类中参数名称-->
<param-name>参数名称</param-name>
<!--对应参数的值-->
<param-value>参数值</param-value>
</init-param>
</filter>
过滤器必须和特定的URL关联才能发挥作用，过滤器的关联方式有3种：与一个URL资源关联、与一个URL目录下的所有资源关联、与一个Servlet关联。
① 与一个URL资源关联：
<filter-mapping>
<!- -这里与上面配置的名称要相同-->
<filter-name>过滤器名</filter-name>
<!- -与该URL资源关联-->
<url-pattern>xxx.jsp</url-pattern>
</filter-mapping>
② 与一个URL目录下的所有资源关联：
<filter-mapping>
<filter-name>过滤器名</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
③ 与一个Servlet关联：
<filter-mapping>
<filter-name>过滤器名</filter-name>
<url-pattern>Servlet名称</url-pattern>
</filter-mapping>
（2）struts.xml文件
struts.xml是一个XML文件，前部是XML的头，然后是<struts>标签，位于Struts 2配置的最外层，其他标签都是包含在它里面的，如下：
<?xml version="1.0" encoding="UTF-8" ?> //XML头
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts> //<struts>标签
……
</struts>
（3）package元素
package有以下几个常用属性：
name（必选）：指定包名，这个名字将作为引用该包的键。注意，包的名字必须是唯一的，在一个struts.xml文件中不能出现两个同名的包。
extends（可选）：允许一个包继承一个或多个先前定义的包。
abstract（可选）：将其设置为true，可以把一个包定义为抽象的。抽象包不能有action定义，只能作为“父”包被其他包所继承。
namespace（可选）：将保存的action配置为不同的名称空间。
看下面这个例子：
<package name="default">
<action name="foo" class="mypackage.simpleAction">
<result name="success">/foo.jsp</result>
</action>
<action name="bar" class="mypackage.simpleAction">
<result name="success">/bar.jsp</result>
</action>
</package>
<package name="mypackage1" namespace="/">
<action name="moo" class="mypackage.simpleAction">
<result name="success">/moo.jsp</result>
</action>
</package>
<package name="mypackage2" namespace="/barspace">
<action name="bar" class="mypackage.simpleAction">
<result name="success">/bar.jsp</result>
</action>
</package>
（4）Action元素
当一个请求匹配到某个Action名字时，框架就使用这个映射来确定如何处理请求。
<action name="struts" class="org.action.StrutsAction">
<result name="success">/welcome.jsp</result>
<result name="error">/hello.jsp</result>
</action>
在上面代码中，当一个请求映射到struts时，就会执行该Action配置的class属性对应的Action类，然后根据Action类的返回值决定跳转的方向。其实一个Action类中不一定只能有execute()方法。如果一个请求要调用Action类中的其他方法，就需要在Action配置中加以配置。例如，如果在org.action.StrutsAction中有另外一个方法为：
public String find() throws Exception{return SUCCESS;}
那么如果想要调用这个方法，就必须在Action中配置method属性，配置方法为：
<! - - name值是用来和请求匹配的- - >
<action name="find" class="org.action.StrutsAction" method="find">
<result name="success">/welcome.jsp</result>
<result name="error">/hello.jsp</result>
</action>
使用ActionSupport
继承ActionSupport类能够帮助程序员更好地完成一些工作，它实现了5个接口并包含了一组默认的实现。如果编程中想要用到该类提供的某些功能，只要重写它提供的方法就可以了，例如，要实现验证功能，只需在自定义Action类中重写validate()方法即可。
public class ActionSupport implements Action, Validateable, ValidationAware,
TextProvider, LocaleProvider,Serializable{
}
从上面的代码中可以看出ActionSupport实现了5个接口。下面简要介绍这5个接口。
（1）Action接口：该接口提供了5个常量及一个execute()方法。代码如下：
public interface Action {
public static final String SUCCESS = "success";
public static final String NONE = "none";
public static final String ERROR = "error";
public static final String INPUT = "input";
public static final String LOGIN = "login";
public String execute() throws Exception;
}
如果Action类继承了ActionSupport类，就可以直接应用这几个常量，比如在2.3节例子中的Action的代码：
package org.action;
public class LoginAction {
...
public String execute(){
return "success"; //不做任何判断直接返回“success”
}
}
就可以改为：
package org.action;
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction extends ActionSupport{
...
public String execute(){
return SUCCESS; //不做任何判断直接返回“success”
}
}
2）Validateable接口：该接口提供了一个validate()方法用于校验表单数据，在实际应用中只要在Action类中重写该方法即可。例如2.3节例子中，并没有对填入的数据进行任何判断，即使用户未输入任何内容，提交后也会跳转到欢迎界面，在一般情况下是不会允许的。这时就可以在Action类中重写validate()方法，然后在该方法中对取得的数据进行判断，如果为空或其他不允许的情况就可以保存错误信息。该方法是在执行execute()方法之前执行的。
（3）ValidationAware接口：该接口定义了一些方法用来对Action执行过程中产生的信息进行处理。例如，该接口中提供了addFieldError（String fieldname，String errorMessage）方法用来在验证出错时保存错误信息。
（4）TextProvider接口：该接口中提供了一系列getText()方法，用于获得对应的国际化信息资源。在Struts 2中的国际化信息资源都是以key-value对出现的，通过使用该接口中的getText()方法可以用key来获得相应的value值（国际化内容会在国际化部分讲解）。
（5）LocaleProvider接口：该接口提供了一个getLocale()方法，用于国际化时获得语言/地区信息
2.Action传值
在Action类中，username属性可以不叫username，可以叫“name”或其他，但是里面必须有页面的文本框名“username”对应的setUsername()方法
前面这种传值方式称为字段传值方式，如果一个表单中字段比较多，而在Action中就要写很多字段，若在不同的Action中都要用到就要重复写，这样就会很麻烦，也不利于维护，所以Struts 2框架提供了另一种传值方式即模型传值方式。使用该传值方式首先要把字段封装成一个类，并生成其get和set方法，就是通常说的JavaBean了。如上例可把“username”和“password”封装成一个“User”类，代码。
然后在Action中就可以改变写法：
package org.action;
public class LoginAction {
private User user;
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public String execute(){
return SUCCESS;
}
}
可以发现，这样简单了很多。还要注意的是，传值页面也就是JSP页面（这里就是login.jsp页面）的“属性名”也要做小小的修改，要把以前的“属性名”改为“模型对象名.属性名”，例如这里要把以前的“<input type="text" name="username"/>”中的“username”及“<input type="password" name="password"/>”中的name值“password”修改为“user.username”和“user.passoword”，而欢迎界面的取值也要相应地修改为“user.username”。这样修改后，再重新启动Tomcat服务器，运行项目会得到相同的结果。
3．在Action类中访问Servlet API
学过Struts 1.x的都知道，Struts 1.x的Action类中的方法有4个参数，其中有两个是“request”及“response”，而Struts 2中却没有与任何的Servlet API关联，这样大大降低了程序的耦合性，但是有时候在写程序时需要用到Servlet的一些API，例如“request”、“response”、“application”、“session”等。Struts 2提供了两种方式来访问Servlet API：一种是通过ActionContext访问Servlet API，另一种是通过实现*Aware()接口来获得。
1）通过ActionContext访问：ActionContext类提供了一个静态的getContext()方法来获得ActionContext对象，然后根据其对象来获得一些Servlet API的对象。例如：
ActionContext ac=ActionContext.getContext(); //获得ActionContext对象
Map session=ac.getSession(); //获得session对象
Map application=ac.getApplication(); //获得application对象
Map request=ac.get()； //获得request对象
大家可能有些奇怪，这些方法得到的都是Map类型，而不是要求的“HttpSession”或“Application”，其实Struts 2把Map对象模拟成了“HttpSession”等对象，从而将Servlet从Action中分离出来。
由于“request”和“response”比较特殊，也是在开发中经常会用到的，所以Struts 2提供了专门的类来获取，即“ServletActionContext”。
HttpServletRequest request=ServletActionContext.getRequest(); //获得HttpServletRequest对象
HttpServletResponse response =ServletActionContext.getResponse(); //获得HttpServletResponse对象
HttpSession session=request.getSession(); //获得HttpSession对象
除了这种方法外，还可以用如下方法得到：
ActionContext ac=ActionContext.getContext();
//获得HttpServletRequest对象
HttpServletRequestrequest=(HttpServletRequest)ac.get(ServletActionContext.HTTP_REQUEST);
//获得HttpServletResponse对象
HttpServletResponseresponse(HttpServletResponse)ac.get(ServletActionContext.HTTP_RESPONSE);
//获得HttpSession对象
HttpSession session=request.getSession();
2）通过实现*Aware接口获得：Struts 2中提过了一系列的*Aware接口，如表2.1所示。
表2.1 *Aware接口及获得对象方法
例如要获得Application对象，Action类就可以如下编写：
import java.util.Map;
import org.apache.struts2.interceptor.ApplicationAware;
public class TestApplication implements ApplicationAware{
private Map application;
public void setApplication(Map application) {
this.application=application;
}
public String execute() throws Exception{
//...其他内容，这里可以直接应用application
}
}
4．Action类中返回多个结果
在一个Action类中，有时会返回多个结果，例如判断一件事情，如果为真就返回SUCCESS，否则就返回ERROR（或"error"）。在2.4节的例子中，没有对输入的“username”和“password”做任何判断，现在对其进行判断，然后返回不同结果。
public String execute(){
if(user.getUsername().equals("李方方")&&user.getPassword().equals("123456")){
return SUCCESS;
}else{
return ERROR;
}
}
这里判断如果输入的姓名为“李方方”且密码为“123456”就返回成功，然后根据配置文件的返回跳转到欢迎界面，如果两者有一个不符合就返回错误页面，所以还要在“struts.xml”配置文件中配置返回错误时跳转的页面，比如：
<action name="login" class="org.action.LoginAction">
<result name="success">/welcome.jsp</result>
<result name="error">/login.jsp</result>
</action>
5．Action类中定义多个方法
例如，在TestAction类中定义两个方法：
import com.opensymphony.xwork2.ActionSupport;
public class TestAction extends ActionSupport{
private String username;
private String password;
public String login()throws Exception{
if(username.equals("程明")){
return "login";
}
else{
return ERROR;
}
}
public String regist() throws Exception{
return "regist";
}
2<action>配置详解
Struts 2的核心功能是Action。对于开发人员来说，使用Struts 2框架，主要的编码工作就是编写Action类。当开发好Action类后，就需要配置Action 映射，以告诉Struts 2框架，针对某个URL的请求应该交由哪一个Action进行处理。这就是struts.xml中action配置要起的作用。在2.3节例子中：
<action name="login" class="org.action.LoginAction">
<result name="success">/welcome.jsp</result>
</action>
上例表示请求名为“login”的请求，交由“org.action.LoginAction”这个类来处理，返回结果为“success”时就跳转到“welcome.jsp”页面。
1．<action>属性
<action>有以下属性：
name：该属性是必需的，对应请求的Action的名称。
class：该属性不是必需的，指明处理类的具体路径，例如“org.action.LoginAction”。
method：该属性不是必需的，若Action类中有不同的方法，该属性指定请求对应应用哪个方法。
converter：该属性不是必需的，指定Action使用的类型转换器（类型转换内容会在类型转换部分讲解）。
在一般情况下，都会为<action>设置name和class属性，如果没有设置method属性，系统会默认调用Action类中的execute方法。若在Action中存在多个方法，请求其某个方法的时候就要通过这里的method属性来指定所请求的方法名。例如在2.5.1节中的第5点的Action类中有login和regist两个方法，如果要在请求中应用login方法，就要在相应的action中配置method属性：
<action name="login" class="org.action.LoginAction" method="login">
...
</action>
黑体部分就是要配置的指定的方法，表示应用LoginAction类中的login方法，如果是：
<action name="login" class="org.action.LoginAction" method="regist">
...
</action>
就应用LoginAction类中的regist方法。
2．在<action>中应用通配符
前面讲过，可以在<action>中指定method属性来决定应用Action类中的哪个方法，但这样有些麻烦，应用两个不同的方法就要配置两个<action>，Struts 2中提供了通配符的使用，可以应用通配符只配置一个Action就可以根据通配符来识别应用Action类中的哪个方法。
<action>配置要修改为：
<action name="*" class="org.action.LoginAction" method="{1}">
...
</action>
其中“{1}”就是取前面的“*”的值。例如，如果要应用 Action类中的login方法，请求就为：
<form action="login.action" method="post">
...
</form>
这样用请求中“login”与action配置中的“*”匹配，得出“*”为“login”，<action>中method的值就为“login”，也就是应用Action类中的login方法。如果要应用regist方法，请求为：
<form action="regist.action" method="post">
...
</form>
“regist”就会与“*”匹配，得出“*”为“regist”，则<action>中method属性的值就为“regist”，就会应用Action类中的regist方法。
不仅方法可以使用通配符这样匹配，返回的值也可以。例如，如果应用login方法返回“error”时就让其跳转到“login.jsp”界面，而应用regist方法返回“error”时就跳转到“regist.jsp”界面。<action>配置修改为：
<action name="*" class="org.action.LoginAction" method="{1}">
...
<result name="error">/{1}.jsp</result>
</action>
3．访问Action类中方法的其他实现方式
仍以前面的LoginAction为例，该例中有两个方法“login”和“regist”。首先访问login方法，<action>配置可以用正常情况，只需配置name和class：
<action name="login" class="org.action.LoginAction">
...
</action>
在<action>配置中完全不知道要访问LoginAction类中的哪个方法，但是需要在请求中指明，请求的form表单要改为：
<form action="login!login.action" method="post">
...
</form>
其中，“login!login.action”中“！”前面的“login”对应<action>中name属性值，“！”后面的“login”对应要使用的LoginAction类中的方法名。例如，如果要使用该类中的regist方法，只需将请求改为：
<form action="login!regist.action" method="post">
...
</form>
该方法是在请求中指定应用Action类中的哪个方法，还有一种方法是在提交按钮中设置的，<action>不用做任何改变，不过提交按钮需要用Struts 2的标签来实现，并且要指定method：
<form action="login.action" method="post">
...
<s:submit value="登录" method="login"></s:submit>
<s:submit value="注册" method="regist"></s:submit>
</form>
4．使用默认类
如果未指明class属性，则系统将会自动引用<default-class-ref>标签中所指定的类，即默认类。在Struts 2中，系统默认类为ActionSupport，当然也可以自己定义默认类，例如：
<package name="default" extends="struts-default">
<default-class-ref class="org.action.LoginAction"></default-class-ref>
<action name="login">
...
</action>
<action name="regist">
...
</action>
</package>
3 <result>配置详解
下面简要介绍这些类型的作用范围。
l chain：用来处理Action链。
l chart：用于整合JFreeChart的结果类型。
l dispatcher：用来转向页面，通常处理JSP，该类型也为默认类型。
l freemaker：处理FreeMarker模板。
l httpheader：控制特殊http行为的结果类型。
l jasper：用于JasperReports整合的结果类型。
l jsf：JSF整合的结果类型。
l redirect：重定向到一个URL。
l redirect-action：重定向到一个Action。
l stream：向浏览器发送InputStream对象，通常用来处理文件下载，还可用于返回AJAX数据。
l tiles：与Tiles整合的结果类型。
l velocity：处理Velocity模板。
l xslt：处理XML/XSLT模板。
l plaintext：显示原始文件内容，例如文件源代码等。
1．dispatcher类型
该结果类型是默认的结果类型，从“struts-default.xml”中也可以看出，其定义为“default="true"”。定义该类型时，物理视图为JSP页面，并且该JSP页面必须和请求信息处于同一个Web应用中。还有一点值得注意的是，请求转发时地址栏不会改变，也就是说，属于同一请求，所以请求参数及请求属性等数据不会丢失，该跳转类似于JSP中的“forward”。从前面的例子中也可以看出，跳转到“welcome.jsp”页面后，仍可以取出“username”的值。在应用该类型时，一般都会省略不写。配置该类型后，<result>可以指定以下两个参数。
l location：指定请求处理完成后跳转的地址，例如“/welcome.jsp”。
l parse：指定是否允许在location参数值中使用表达式，例如“/welcome.jsp?username=
${username}”，在实际运行时，这个结果信息会替换为用户输入的“username”值，该参数默认值是true。
2．redirect类型
该结果类型可以重定向到JSP页面，也可以重定向到另一个Action。该类型是与dispatcher类型相对的，当Action处理用户请求结束后，将重新生成一个请求，转入另一个界面。例如在2.3节的例子中，当用默认值“dispatcher”时，请求完成，转向“welcome.jsp”界面，如图2.12所示。
可以发现，请求没变，还是“login.action”，但页面已经跳转到“welcome.jsp”，并且可以取出“username”的值。如果把<result>中的内容改为：
<result name="success" type="redirect">/welcome.jsp</result>
则请求完成，转向“welcome.jsp”界面，如图2.13所示。
3．redirect-action类型
该结果类型与redirect类似，都是重定向而不是转发，该类型一般都为了重定向到一个新的action请求，而非JSP页面。配置该类型时，<result>可以配置如下两个参数。
l actionName：该参数指定重定向的action名。
l namespace：该参数指定需要重定向的action所在的命名空间（命名空间会在后面讲解）。
看下面一段代码。
上面代码就是redirect-action类型应用的体现。首先对“test1”包中的“regist”进行请求，通过LoginAction类中的regist方法来处理请求，完成后用redirect-action结果类型来重新定向到“test2”包中的“login”，然后用LoginAction类中的login方法处理，完成后跳转到“welcome.jsp”页面，由于“test2”包指定了命名空间“namespace”，所以必须配置参数指定：
<param name="actionName">login</param>
<param name="namespace">/test2</param>
4．chain类型
前面的redirect及redirect-action虽然都可以重定向到另外的action，但是它们都不能实现数据的传递，在重定向过程中，请求属性等都会丢失，这样有的时候就不利于编程了。所以，Struts 2又提供了另一种结果类型“chain”，用来实现action之间的跳转，而非重定向，意思就是可以跳转到另外的action而且数据不丢失，通过设置chain类型，可以组成一条action链，不用担心数据的丢失，这样就大大方便了编程。action跳转可以共享数据的原理是处于同一个action链的action都共享同一个值栈，每个action执行完毕后都会把数据压入值栈，如果需要就可以直接到值栈中取出。
5．全局结果
从前面的例子中可以看出，<result>都是包含在<action>...</action>中的，这配置的是局部结果，只对当前action请求返回的结果起作用。假如都返回到同一页面，而且在不同的action请求中都会用到，那么配置局部结果就显得 唆了。所以，Struts 2提供了全局结果的配置，例如，如果返回“error”，都跳转到错误页面。
4 <package>配置详解
1．name
该属性必须指定，代表包的名称，由于struts.xml中可以定义不同的<package>，而且它们之间还可以互相引用，所以必须指定名称。
2．extends
该属性是可选的，表示当前定义的包继承其他的包，继承了其他包，就可以继承其他包中的action、拦截器等。由于包信息的获取是按照配置文件中的先后顺序进行的，所以父包必须在子包之前被定义。
在一般情况下，定义包时都会继承一个名为“struts-default”的包，该包是Struts 2内置的，定义在struts-default.xml这个文件中。这个文件的位置在前面讲解<result>结果类型的时候已经说过，打开该文件找到这个包，可以发现该包下定义了一些结果类型、拦截器及拦截器栈，结果类型在前面已经讲解，拦截器会在后面详细讲解。
3．namespace
该属性是可选的，用来指定一个命名空间，例如在前面讲redirect-action类型时已经用到了，定义命名空间非常简单，只要指定“namespace="/*"”就行了，其中“*”是我们自定的，如果直接指定“"/"”，表示设置命名空间为根命名空间。如果不指定任何namespace，则使用默认的命名空间，默认的命名空间为“" "”。
当指定了命名空间后，相应的请求也要改变，例如：
<action name="login" class="org.action.LoginAction" namespace="/user">
...
</action>
请求就不能是“login.action”，而必须改为“user/login.action”。当Struts 2接收到请求后，会将请求信息解析为namespace名和action名两部分，然后根据namespace名在struts.xml中查找指定命名空间的包，并且在该包中寻找与action名相同的配置，如果没有找到，就到默认的命名空间中寻找与action名称相同的配置，如果再没找到，就给出错误信息。看下面的代码。
如果页面中请求为barspace/bar.action，框架将首先在命名空间为/barspace的包中查找bar这个action配置，如果找到了，则执行bar.action；如果没有找到，则到默认的命名空间中继续查找。在本例中，/barspace命名空间中有名为bar的Action，因此它会被执行。
如果页面中请求为barspace/foo.action，框架会在命名空间为/barspace的包中查找foo这个action配置。如果找不到，框架会到默认命名空间中去查找。在本例中，/barspace名称空间中没有foo这个action，因此默认的命名空间中的/foo.action将会被找到并执行。
如果页面中请求为moo.action，框架会在根命名空间“/”中查找moo.action，如果没有找到，再到默认命名空间中查找
4．abstract
该属性是可选的，如果定义该包是一个抽象包，则该包不能包含<action>配置信息，但可以被继承。
<package>主要包含以上4个属性，<package>下面还可配置以下几个标签。
l <action>：action标签，其作用前面已经详细讲解。
l <default-action-ref>：配置默认action，如果配置了默认action，则若请求的action名在包中找不到与之匹配的名称就会应用默认action。
l <default-class-ref>：配置默认类。
l <default-interceptor-ref>：配置默认拦截器。
l <global-exception-mappings>：配置发生异常时对应的视图信息，为全局信息，与之对应还有局部异常配置，局部异常配置要配置在<action>标签中，局部异常配置用<exception-mapping>进行配置。配置异常信息格式如下：
<package name="default" extends="struts-default">
<global-exception-mappings>
<exception-mapping result="逻辑视图" exception="异常类型"/>
</global-exception-mappings>
<action name="action名称">
<exception-mapping result="逻辑视图" exception="异常类型"></exception-mapping>
</action>
</package>
<exception-mapping>中可以指定3个属性，分别为name：可选属性，用来标识该异常配置信息；result：该属性必须指定，指定发生异常时显示的视图信息，必须配置为逻辑视图；exception：该属性必须指定，用来指定异常类型。
l <global-results>：配置全局结果，前面已经讲述。
l <interceptors>：配置拦截器。
l <result-types>：配置结果类型
5 struts.xml文件
Struts 2.0.14版本下的struts.xml的大体格式如下：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
...
</struts>
在该版本下，这个格式是不变的，前面是编码格式及一些头文件信息，接着是<struts>…</struts>，该文件中的其他配置都包含在其中。该标签下可以编写下面几个标签。
l include：用于导入其他xml配置文件。
l constant：配置一些常量信息。
l bean：由容器创建并注入的组件。
l package：配置包信息。
1．<include>
例如在学生信息系统中，把学生信息的配置、课程信息的配置、成绩信息的配置分别放入各自的配置文件xs.xml、kc.xml和cj.xml中，然后再用Struts 2提供的<include>标签把它们导入到struts.xml中。
例如xs.xml为：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<package name="xs" extends="struts-default">
<action name="addXs" class="org.action.XsAction">
...
</action>
</package>
</struts>
在struts.xml中导入应为：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<include file="xs.xml"></include>
...
</struts>
注意：这里xs.xml也是放在classes文件夹下的，即在MyEclipse中直接放在src下即可，如果xs.xml放在其他包中，例如放在“xs”包中，那么struts.xml中引入的时候就要加上包名：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<include file="/xs/xs.xml"></include>
...
</struts>
2．<constant>
<constant>是用来在struts.xml中定义属性的，例如设置编码形式、设置开发模式等。该标签里面有两个属性：name和value。例如，可以做下面的设置：
<struts>
<!-- 设置开发模式 -->
<constant name="struts.devMode" value="true"></constant>
<!-- 设置编码格式GB2312 -->
<constant name="struts.il8n.encoding" value="GB2312"></constant>
...
</struts>
struts.prope
6 struts.properties文件
rties文件是一个标准的properties文件，该文件中存放一系列的key-value 对，每个key 就是一个Struts 2属性，而其对应的value值就是一个Struts 2的属性值。struts.properties文件和struts.xml一样，要放在项目的classes文件夹下，Struts 2框架会自动加载该文件。
下面介绍Struts 2中常量配置信息：
l struts.action.extension：该属性指定需要Struts 2处理的请求后缀，该属性的默认值是action，即所有匹配*.action的请求都由Struts 2处理。如果用户需要指定多个请求后缀，则多个后缀之间以英文逗号（,）隔开。
l struts.configuration：该属性指定加载Struts 2配置文件的配置文件管理器。该属性的默认值是org.apache.Struts2.config.DefaultConfiguration，这是Struts 2默认的配置文件管理器。如果需要实现自己的配置管理器，可以编写一个实现Configuration接口的类，该类可以自己加载Struts 2配置文件。
l struts.configuration.files：该属性指定Struts 2框架默认加载的配置文件，如果需要指定默认加载多个配置文件，则多个配置文件的文件名之间以英文逗号（，）隔开。该属性的默认值为struts-default.xml，struts-plugin.xml，struts.xml。前面说过，Struts 2会自动加载struts.xml文件，这里就是最好的解释。
l struts.configuration.xml.reload：该属性设置当struts.xml 文件改变后，系统是否自动重新加载该文件。该属性的默认值是false。
l struts.custom.i18n.resources：该属性指定Struts 2应用所需要的国际化资源文件，如果有多份国际化资源文件，则多个资源文件的文件名以英文逗号（，）隔开。
l struts.custom.properties：该属性指定Struts 2应用加载用户自定义的属性文件，该自定义属性文件指定的属性不会覆盖struts.properties文件中指定的属性。如果需要加载多个自定义属性文件，多个自定义属性文件的文件名以英文逗号（，）隔开。
l struts.devMode：该属性设置Struts 2应用是否使用开发模式。如果设置该属性为true，则可以在应用出错时显示更多、更友好的出错提示。该属性只接受true和flase两个值，该属性的默认值是false。通常，应用在开发阶段，将该属性设置为true，当进入产品发布阶段后，则该属性设置为false。
l struts.dispatcher.parametersWorkaround：对于某些Java EE 服务器，不支持HttpServlet Request调用getParameterMap()方法，此时可以设置该属性值为true来解决该问题。该属性的默认值是false。对于WebLogic、Orion和OC4J服务器，通常应该设置该属性为true。
l struts.enable.DynamicMethodInvocation：该属性设置Struts 2是否支持动态方法调用，该属性的默认值是true。如果需要关闭动态方法调用，则可设置该属性为false。
l struts.enable.SlashesInActionNames：该属性设置Struts 2是否允许在Action名中使用斜线，该属性的默认值是false。如果开发者希望允许在Action名中使用斜线，则可设置该属性为true。
l struts.freemarker.manager.classname：该属性指定Struts 2使用的FreeMarker 管理器。该属性的默认值是org.apache.struts2.views.freemarker.FreemarkerManager，这是Struts 2内建的FreeMarker 管理器。
l struts.freemarker.wrapper.altMap：该属性只支持true和false两个属性值，默认值是true。通常无须修改该属性值。
l struts.i18n.encoding：指定Web应用的默认编码集。一般当获取中文请求参数值时会将该属性值设置为GBK或者GB 2312。该属性默认值为UTF-8。
l struts.i18n.reload：该属性设置是否每次HTTP请求到达时，系统都重新加载资源文件（允许国际化文件重载）。该属性默认值是false。在开发阶段将该属性设置为true会更有利于开发，但在产品发布阶段应将该属性设置为false。开发阶段将该属性设置了true，将可以在每次请求时都重新加载国际化资源文件，从而可以看到实时开发效果。产品发布阶段将该属性设置为false，是为了提高响应性能，每次请求都重新加载资源文件会大大降低应用的性能
struts.locale：指定Web应用的默认Locale。
l struts.multipart.parser：该属性指定处理multipart/form-data的MIME类型（文件上传）请求的框架，该属性支持cos、pell和jakarta等属性值, 即分别对应使用cos的文件上传框架、pell上传及common-fileupload 文件上传框架。该属性的默认值为jakarta。
注意：如果需要使用cos 或者pell 的文件上传方式，则应该将对应的JAR文件复制到Web应用中。例如，使用cos 上传方式，则需要自己下载cos 框架的JAR文件，并将该文件放在WEB-INF/lib 路径下。
l struts.multipart.saveDir：该属性指定上传文件的临时保存路径，该属性的默认值是javax.servlet.context.tempdir。
l struts.multipart.maxSize：该属性指定Struts 2文件上传中整个请求内容允许的最大字节数。
l struts.mapper.class：指定将HTTP请求映射到指定Action的映射器，Struts 2提供了默认的映射器org.apache.struts2.dispatcher.mapper.DefaultActionMapper。默认映射器根据请求的前缀与<action>配置的name 属性完成映射。
l struts.objectFactory：指定Struts 2默认的ObjectFactoryBean，该属性默认值是spring。
l struts.objectFactory.spring.autoWire：指定Spring框架的自动装配模式, 该属性的默认值是name，即默认根据Bean的name属性自动装配。
l struts.objectFactory.spring.useClassCache：该属性指定整合Spring框架时，是否缓存Bean实例，该属性只允许使用true和false两个属性值，它的默认值是true。通常不建议修改该属性值。
l struts.objectTypeDeterminer：该属性指定Struts 2的类型检测机制，支持tiger和notiger两个属性值。
l struts.serve.static：该属性设置是否通过JAR文件提供静态内容服务，该属性只支持true和false属性值，该属性的默认属性值是true。
l struts.serve.static.browserCache：该属性设置浏览器是否缓存静态内容。当应用处于开发阶段时，如果希望每次请求都获得服务器的最新响应，则可设置该属性为false。
l struts.tag.altSyntax：该属性指定是否允许在Struts 2标签中使用表达式语法，因为通常都需要在标签中使用表达式语法，故此属性应该设置为true，该属性的默认值是true。
l struts.url.http.port：该属性指定Web应用所在的监听端口。该属性通常没有太大的用户，只是当Struts 2 需要生成URL时（例如Url标签），该属性才提供Web应用的默认端口。
l struts.ui.theme：该属性指定视图标签默认的视图主题，该属性的默认值是xhtml。
l struts.ui.templateDir：该属性指定视图主题所需要模板文件的位置，该属性的默认值是template，即默认加载template 路径下的模板文件。
l struts.url.https.port：该属性类似于struts.url.http.port属性的作用，区别是该属性指定的是Web应用的加密服务端口。
l struts.url.includeParams：该属性指定Struts 2生成URL时是否包含请求参数。该属性接受none、get和all三个属性值，分别对应于不包含、仅包含GET类型请求参数和包含全部请求参数。
l struts.ui.templateSuffix：该属性指定模板文件的后缀，该属性的默认属性值是ftl。该属性允许使用ftl、vm或jsp，分别对应FreeMarker、Velocity和JSP模板。
l struts.velocity.configfile：该属性指定Velocity框架所需的velocity.properties文件的位置。该属性的默认值为velocity.properties。
l struts.velocity.contexts：该属性指定Velocity框架的Context位置，如果该框架有多个Context，则多个Context 之间以英文逗号（，）隔开。
l struts.velocity.toolboxlocation：该属性指定Velocity框架的toolbox的位置。
l struts.xslt.nocache：该属性指定XSLT Result是否使用样式表缓存。当应用处于开发阶段时，该属性通常被设置为true。当应用处于产品使用阶段时，该属性通常被设置为false。
7 web.xml文件
前面开发例子的过程中，首先就配置了web.xml，它是一个正规的xml文件，包括版本及编码信息，然后就是<web-app>标签。这里具体讲解在<web-app>里面配置的信息。
…
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
Servlet过滤器是在Java Servlet规范中定义的，它能够对过滤器关联的URL请求和响应进行检查和修改。Servlet过滤器能够在Servlet被调用之后检查response对象，修改response Header对象和response内容。Servlet过滤器过滤的URL资源可以是Servlet、JSP、HTML文件，或者是整个路径下的任何资源。多个过滤器可以构成一个过滤器链，当请求过滤器关联的URL的时候，过滤器就会逐个发生作用。
所有过滤器必须实现java.Serlvet.Filter接口，这个接口中含有3个过滤器类必须实现的方法：
l init(FilterConfig)：这是Servlet过滤器的初始化方法。Servlet容器创建Servlet过滤器实例后将调用这个方法。
l doFilter(ServletRequest,ServletResponse,FilterChain)：这个方法完成实际的过滤操作。当用户请求与过滤器关联的URL时，Servlet容器将先调用过滤器的doFilter方法，返回响应之前也会调用此方法。FilterChain参数用于访问过滤器链上的下一个过滤器。
l destroy()：Servlet容器在销毁过滤器实例前调用该方法。这个方法可以释放Servlet过滤器占用的资源
过滤器类编写完成后，必须要在web.xml中进行配置，格式如下：
<filter>
<!-- 自定义的名称 -->
<filter-name>过滤器名</filter-name>
<!-- 自定义的过滤器类，注意，如果类放在指定包下，要加完整包名 -->
<filter-class>过滤器对应类</filter-class>
<init-param>
<!-- 类中参数名称 -->
<param-name>参数名称</param-name>
<!-- 对应参数的值 -->
<param-value>参数值</param-value>
</init-param>
</filter>
过滤器必须和特定的URL关联才能发挥作用，过滤器的关联方式有3种：与一个URL关联、与一个URL目录下的所有资源关联、与一个Servlet关联。
与一个URL资源关联：
<filter-mapping>
<!-- 这里与上面配置所起的名称要相同 -->
<filter-name>过滤器名</filter-name>
<!-- 与该url资源关联-->
<url-pattern>xxx.jsp</url-pattern>
</filter-mapping>
与一个URL目录下的所有资源关联：
<filter-mapping>
<filter-name>过滤器名</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
与一个Servlet关联：
<filter-mapping>
<filter-name>过滤器名</filter-name>
<url-pattern>Servlet名称</url-pattern>
</filter-mapping>