struts2环境的搭建及工作流程

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>



<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-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>

posted @ 2015-03-15 21:20 elite_2012 阅读(285) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部