工具：MyEclipse 6.0.1 GA、Tomcat 5.5、MySql 5.0 、MySql GUI Tools 5.0（便于管理MySql数据库，不是必须）

2. Struts 部分

3. Spring 部分

4. Hibernate 部分

1．坚果壳中的apache struts2 体系

不知道为什么struts2的官方文档中为什么要使用nutshell这个词语来表述，我只好直译了，也许是要表达一个框架的意思吧，整个struts2框架体系如下图所示：

它的具体流程如下：

a． 首先浏览器发出请求，请求一个服务器端资源，这也许是一个action，也许是别的   什么东西

b． FilterDispatcher会对每个请求进行检查，然后选择合适的action

c． 拦截器会自动对客户端的亲求进行一些一般化的操作，例如工作流(workflow)、确认(validation)以及文件上传的处理

d． Action中的方法被执行，它通常都是向数据库中存储数据或者检索数据

e． Result会将输出返回到浏览器，这通常是一个html文件或者图片等等

2．坚果壳中的struts标签

Struts中的标签库确实为我们程序的编写提供了很大的方便，使用struts标签之后，程序代码的数量确实减少了很多。除了减少代码量之外，struts标签相对于普通的html标签而言功能更加强大，例如有的标签还支持国际化、本地化等等，总之呢，struts标签就是好，^_^，而且容易理解。不过说实话，我在项目中还是很不习惯又这个struts标签，我一般都是采用的普通html标签再加上jstl标签。

3．坚果壳中的struts配置

一个web应用程序通常使用一个部署描述符来初始化诸如过滤器、监听器之类的支援，这个部署描述符通常都是以xml文件的形式存在，并且命名为web.xml。在struts2中你可以通过生命在web.xml中的java类来初始化资源，你还可以通过一个叫struts.xml的文件来完全控制这些配置。下面展示了一个典型的struts.xml配置文件：

 <struts>

    <package name="default"extends="struts-default">

        <action name="Logon" class="mailreader2.Logon">

            <result name="input">/pages/Logon.jsp</result>

            <result name="cancel" type="redirect-action">Welcome</result>

            <result type="redirect-action">MainMenu</result>

            <result name="expired" type="chain">ChangePassword</result>

        </action>

        <action name="Logoff" class="mailreader2.Logoff">

            <result type="redirect-action">Welcome</result>

        </action>

    </package>

 </struts>

3．坚果壳中的Struts MVC

Struts2是一个MVC框架，它提供了控制器(controller)和视图(viewer)组件，并且和其它技术相结合来提供Model组件。框架的控制器可以看作是应用程序的Model和Web的view之间的一个桥梁。

为了使动态显示数据更加方便，struts框架还提供了一个标记库。这些标签能够同框架的验证(validation)、国际化(internationalization)特征相互作用，确保输入的正确性和输出的本土化。标签库能同JSP、FreeMarker等一起使用，而且不影响其它的标签库如JSTL等的使用，它还支持JSF组件。

当一个请求达到的时候，控制器(Controller)会调用一个Action类。这个Action类会在“咨询”Model组件(代表业务逻辑)后检查或者更新应用程序的状态，为了在Model层和View层之间传输数据，我们可以在Action类中放置属性，或者在一个POJO中放置。

绝大多数时候，Model看起来就像一个JavaBean对象。Model承担了大多数的工作，而Action就像一个交通警察或者适配器一样，只是负责一下监管。框架还提供了非常成熟且自动化的类型转换器，藉此来简化丰富的域对象与纯文本的http请求之间的数据传输工作。

Struts的扩展性非常好，它部署的每一个类都是面向借口的，它提供了一个应用程序可能用到的所有基础类，如果应用还需要别的类，你可以自己去主动的添加，这就是面向接口的好处。尽管struts提供了很多了功能，但是开发人员还是可以以他们自己的方式来开发。

4．总结

    基于已有的行业标准和设计模式，struts2可以帮助我们为企业级开发创建一个可扩展的开发环境，如果我们只是要开发一个小的系统的话，我们完全可以采用JSP Model1开发模式；如果我们要开发的是一个更加复杂的系统，包含很多的页面，并且可能要运行很久的话，使用Struts是一个不错的选择，^_^。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1768562

通常相对路径的写法有两种，一种就是以“/”开头，一种就是不以“/”开头，这两种写法有什么区别呢，下面举例阐述一下。

现在的Web环境是一个Struts2的应用，我的应用名是Struts，应用程序所在的目录名也是Struts。这样我的url基本是以http://localhost/Struts开头的啦。现在做如下测试：

1．在Struts目录下面有一个文件叫sayHello.jsp，它里面的form的action的值是HelloWorld.action，那么提交之后匹配的路径是http://localhost/Struts/HelloWorld.action。

2．如果action的值是test/HelloWorld.action，那么提交之后匹配的路径是http://localhost/Struts/test/HelloWorld.action。

3．假设在Struts目录下面有一个子目录add，它里面有一个文件叫sayHello.jsp，它里面的form的action的值是HelloWorld.action，那么提交之后匹配的路径是http://localhost/Struts/add/HelloWorld.action。

4．在测试3下将action的值改为test/HelloWorld.action，那么提交之后匹配的路径是http://localhost/Struts/add/test/HelloWorld.action。

5．在测试3下将action的值改为/HelloWorld.action，那么提交之后匹配的路径是http://localhost/Struts/ HelloWorld.action。

6．在测试3下将action的值改为/test/HelloWorld.action，那么提交之后匹配的路径是http://localhost/Struts/ test/HelloWorld.action。

总结：在页面文件中，所请求的相对路径为path，那么它的路径匹配是从文件当前所在的目录开始的，假设页面文件当前所在目录为curr，那么匹配后的完整路径就是http://localhost/Sturts/curr/path；如果相对路径为/aa/bb/cc，那么匹配后的路径就是http://localhost/Sturts/path。也就是说，如果以“/”开头，就从当前应用的根目录开始匹配，如果不以“/”开头就从当前文件所在的目录开始匹配。这样的话，如果文件本来就在根目录下面，那么加“/”和不加“/”就没啥区别了。

在Struts2还一个要匹配路径的地方就是在处理完请求之后对页面进行分发的时候，也就是result元素里面的内容。测试记录如下：

1．<result>/HelloWorld.jsp</result>。匹配的路径是http://localhost/Struts/HelloWorld.jsp。

2．<result>HelloWorld.jsp</result>。这个时候就和调用这个action的路径相关了。可以这样进行匹配，首先得到请求这个action的url，然后去掉最后一个“/”后面的内容，再把HelloWorld.jsp接上去即可。例如，我们是通过http://localhost/Struts/aa//bb/cc/HelloWorld.action调用的action，那么匹配出来的url就是http://localhost/Struts/aa//bb/cc/HelloWorld.jsp。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1728547

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1721226

publicvoid setName(String name) {

       System.out.println("name:"+name);     

this.name = name;

}

OK，在浏览器中输入http://localhost:8888/Struts/sayHello.jsp，这时我们发现后台打印出了name:CMTobby，CMTobby是我输入的name的值，这说明setName方法被执行了，奇怪啊，我们根本没有显式的调用这个方法啊，它是什么时候调用的呢？现在我们在setName方法里面设置一个断点，然后再在execute方法里面设置一个断点，再次运行我们的程序，结果显示setName方法在execute方法前面执行。

接着，无聊的我又做了一些测试：

1．把setName改为setName1，结果页面输出：Hello null，并且setName1为执行

2．在sayHello.jsp的form之外加了一个文本框，取名address，在HelloWorld中增加相应的域address、setAddress方法和getAddress方法，通过断点测试发现，setAddress方法不会执行。

基于以上测试，我认为在执行action的操作之前，首先会根据请求页面的form表当中所包含的参数来调用action中相应的set****方法，比如说，本例中，form中有name属性，因此会在执行execute之情调用setName方法，而address因为不在form中所以不会调用setAddress方法.

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1710368

我现在把struts.xml文件修改如下：

<!DOCTYPE struts PUBLIC   

     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"   

     "http://struts.apache.org/dtds/struts-2.0.dtd">  

<struts>

  <package name="tutorial" extends="struts-default" namespace="/test">

      <action name="HelloWorld" class="tutorial.HelloWorld">

        <result>HelloWorld.jsp</result>

      </action>

   </package>

</struts>  

其它文件的内容都不变，和上一篇文章中一样，这是我在sayHello.jsp文件中点击提交，页面报错：The requested resource (/Struts/HelloWorld) is not available。下面做如下一些尝试：

1．将sayHello.jsp中form的action改为test/HelloWorld

   报错：The requested resource (/Struts/test/HelloWorld) is not available

2．将sayHello.jsp中form的action改为test/HelloWorld.action

   报错：The requested resource (/Struts/test/HelloWorld.jsp) is not available，这表明action已经找到，只是执行action之后找不到所转向的页面HelloWorld.jsp

3．将struts.xml中result标签改为<result>/HelloWorld.jsp</result>

   OK,测试通过！

因此，在设置了package的namespace属性之后，标准的访问url应该是：

http://webserver/webPrefix/namespace/actionname.action。

实际上FilterDispatcher对url进行映射的方式非常复杂，我在上篇文章里面所做的推测

针对的只是一种最简单的情况而已，因为我做了很多BT的测试，得到了一些让我吃惊的结果。比如说我再加一个package：

    <package name="tutorial1" extends="struts-default">

        <action name="HelloWorld" class="tutorial.HelloWorld">

           <result>/HelloWorld.jsp</result>

        </action>

</package>

这个包和之前那个唯一的差别就是没有namespace属性，当然包名肯定是不同的咯，现在我将sayHello.jsp的action进行修改，我发现无论怎么改，只要它是以HelloWorld.action结尾，测试都是通过的，例如111/222/HelloWorld.action，aaa/bbb/HelloWorld.action，这些都能得到正确的答案。看来FilterDispatcher到底是怎么映射url的只能到源码里面去找答案了。但是在具体的开发中，我们只要严格按照http://webserver/webPrefix/namespace/actionname.action这个规则来配置url肯定是不是错的咯。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1708634

sayHello.jsp：

<%@ page language="java" contentType="text/html; charset=utf-8"%>

<%@ taglib prefix="s" uri="/struts-tags" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=utf-8">

<title>Say Hello</title>

</head>

<body>

    <h3>Say "Hello" to: </h3>

    Address:<input type="text" name="address"/>

    <s:form action="HelloWorld">

        Name: <s:textfield name="name"/>

        <s:submit></s:submit>

    </s:form>

</body>

</html>

HelloWorld.jsp:

<%@ page language="java" contentType="text/html; charset=utf-8"%>

<%@ taglib prefix="s" uri="/struts-tags" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

    <head>

        <title>Hello</title>

    </head>

    <body>

        <h3><s:property value="name" /></h3>

    </body>

</html>

HelloWorld.java

package tutorial;

import com.opensymphony.xwork2.ActionSupport;

publicclass HelloWorld extends ActionSupport {

    private String name;

    public String getName() {

       returnname;

    }

    publicvoid setName(String name) {

       this.name = name;

    }

    public String execute(){

    name="Hello "+name+"!";

    //System.out.println(name);

    returnSUCCESS; 

    }

}

这几个文件之间的流程如下图所示：

首先sayHello.jsp向服务器发送请求，然后根据我们web.xml文件的配置，这个请求被交给了FilterDispatcher这个类来进行处理，FilterDispatcher会根据我们struts.xml文件的中的配置信息来对这个请求分流，让它进入某个指定的action(本例中是HelloWorld.java)，在处理完请求之后，再将页面转向HelloWorld.jsp(这个也是在struts.xml中指定的)。为了保证上述流程的顺利执行，现在struts.xml文件的内容修改如下：

<!DOCTYPE struts PUBLIC   

     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"   

     "http://struts.apache.org/dtds/struts-2.0.dtd">  

<struts>

    <!-- this is a test

    <include file="struts-default.xml"></include>-->

    <package name="tutorial" extends="struts-default">

       <action name="HelloWorld" class="tutorial.HelloWorld">

           <result>HelloWorld.jsp</result>

       </action>

    </package>

</struts>  

注意，这里action的name属性和sayHello.jsp中的action属性的值是一样的，实际上在FilterDispatcher中就是根据这两个值对request进行分流的，具体过程如下：

1． 我们写出这个处理这个请求的url，本例是http://localhost:8888/Struts/HelloWorld，

2． 取出http://localhost:8888/Struts/之后的字符串得到了HelloWorld

3． 在struts.xml文件中查找name属性为HelloWorld的action，把request交给它处理，默认情况下首先执行它里面的execute()方法

4． 请求处理完毕之后进入HelloWorld.jsp页面，配置在<result>标签里面

当然上述流程是最简单的一个过程，还没有涉及到命名空间、请求处理完毕之后要根据执

行结果跳转到不同的页面等一些复杂的问题，后面我会把我的学习心得贴出来。

    注：上述request的分流流程是我根据struts1里面的机制推测的，在struts1里面这个过程由ActionServlet负责，它会调用RequestProcessor里面的一个方法对访问路径进行处理，这个在我博客里面的《Struts工作流程》中可以找到，至于这个FilterDispatcher，因为看不到源码只能推测一下了，^_^。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1707777

Struts1.*都还没有怎么玩，Struts2的时代就已经来临了，在网上查了很多资料，结果显示Struts2和Struts1相关性不高，即使没有用过Struts1，也可以直接使用Struts2框架，实际上Struts2可以说是WebWork的翻版。于是俺就在网上down了一个Struts2中文文档，是一个网友自己做的chm文件，他的blog地址是http://www.blogjava.net/max/，^_^。

下面简单说下我的实践经历吧，我用的开发工具是MyEclipse_5.5.1。首先当然是去Apache上下一个Struts的发布包咯，然后创建一个Web工程，我的工程名字叫Struts，这个过程在Max的教程上都有详细的描述，接下来的三个步骤就比较重要了：

1．配置web.xml文件

我的web.xml文件内如如下，

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "web-app_2_3.dtd" >

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

    <welcome-file-list>

        <welcome-file>index.html</welcome-file>

    </welcome-file-list>

</web-app>

红色突出显示的部分是使用Struts2的关键，它表明所有的请求都将交给FilterDispatcher这个控制器来进行“分流”，这个原理和Struts1中的一样，只不过Struts1中使用的servlet映射而不是filter映射，至于servlet和filter是如何对url进行映射的请参考这篇文章http://blog.csdn.net/delez/archive/2007/05/05/1596936.aspx。

2．Struts.xml

这个文件的作用就和Struts1中的Struts-config.xml文件的作用一样了，我们对所请求的url进行映射时都需要这个文件的帮助，它里面详细指定了一个路径经过映射后进入哪个action里面去。我的Struts.xml文件的内容如下：

<!DOCTYPE struts PUBLIC   

     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"   

     "http://struts.apache.org/dtds/struts-2.0.dtd">  

<struts>

</struts>  

因为我目前还没有配置任何action，所以我的struts.xml文件的内容是空的。

3．把Struts发布包中lib目录下的jar文件全部都拷贝到web工程的WEB-INF/lib目录下面去;

现在我们启动Tomcat，，这个时候如果不出意外的话Tomcat启动会报如下的错误：

unable to load bean: type:com.opensymphony.xwork2.ObjectFactory

class:org.apache.struts2.spring.StrutsSpringObjectFactory - bean - jar:file:/E:/workspace/Struts/WEB-INF/lib/struts2-spring-plugin-2.0.8.jar!/struts-plugin.xml:8:132。

很莫名奇妙的一个错误，因为我根本没有使用Spring啊！我后来尝试放了一个spring.jar到WEB-INF/lib下面去，上面的错误虽然没有了但是又出现了一个新的错误，并且还提示我在web.xml中加上这句：

<listener>

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

总之Struts应用就是加载不了，Tomcat显示如下的错误信息：Context [/Struts] startup failed due to previous errors。

后来我根据错误提示在网上进行搜索，发现导致这些错误的原因可能是因为Struts发布包中lib目录下面的jar文件中很多都是插件，并不是构建Struts应用所必须的，于是我试着把所有名字中包含有plugin的jar文件从WEB-INF/lib中删掉，然后再次重新启动Tomcat，OK，一切正常了，原来那些被删除的jar文件才是真正的“元凶“啊！在搭建好Struts2的运行环境之后就可以开始Struts应用的开发了，^_^。

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1707171

参考文档：
    http://struts.apache.org/2.0.9/docs/ajax-client-side-validation.html
    http://struts.apache.org/2.0.9/docs/pure-javascript-client-side-validation.html
    http://struts.apache.org/2.0.9/docs/client-validation.html

参考示例：
    http://struts.apache.org/2.0.9/docs/ajax-validation.html

基本说明：

Struts校验可以分为两种类型：Annotation型，XML配置型

Annotation型主要使用Annotation来配置Action中的属性，这里我们做过多的介绍，需要看的请参看我的其他相关文章。

XML配置型主要是指，使用XML来描述配置信息，之后提供给Struts框架做校验。

使用Struts2，XML配置型的校验可以使用三种方式：普通的服务器端校验方式，客户纯JavaScript方式端校验，和Ajax方式的校验。

普通的服务器端校验方式：

     客户端提交信息到服务器，在服务器上使用XML配置信息，校验客户端提交的信息，错误的情况下，返回input页面，显示校验错误信息。

客户端纯JavaScript校验方式：

     在输入画面上，根据XML文件中的配置内容生成对应的JavaScript校验脚本，在提交数据的时候首先使用这些生成的JavaScript校验输入信息，错误情况下在画面上显示错误信息，不需要向服务器提交内容，只有输入数据校验正确的情况下才向服务器提交请求。这种方式的校验不支持所有Struts2内置的校验，只支持一部分校验：

    required validator 
    requiredstring validator 
    stringlength validator 
    regex validator 
    email validator 
    url validator 
    int validator 
    double validator

Ajax方式校验

     在提交请求的时候，首先使用AJAX的方式将数据提交到服务器，在校验出错的情况下在页面显示错误信息，但是不刷新页面，在校验成功的情况下，才向服务器提交请求。

三种方式比较

说明：struts-dojo-plugin在2.1.0的时候可能会Release。现在使用需要从Subversion中去除2.1.0SNAPSHOT代码：

svn http://svn.apache.org/repos/asf/struts/struts2/trunk

代码示例

// QuizAction 类

package example;

import com.opensymphony.xwork2.ActionSupport;

/**
 * Created by IntelliJ IDEA.
 * User: ma.zhao@dl.cn
 * Date: 2007-9-8
 * Time: 13:58:16
 * To change this template use File | Settings | File Templates.
 */
public class QuizAction extends ActionSupport {
    private static final long serialVersionUID = -7505437345373234225L;

    private String name;
    private int age;
    private String answer;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAnswer() {
        return answer;
    }

    public void setAnswer(String answer) {
        this.answer = answer;
    }

    public String execute() {
        return SUCCESS;
    }
}

// QuizValidation.xml 校验配置文件

<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.2//EN"
        "http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">
<validators>
    <field name="name">
        <field-validator type="requiredstring">
            <message>You must enter a name</message>
        </field-validator>
    </field>
    <field name="age">
        <field-validator type="int">
            <param name="min">13</param>
            <param name="max">19</param>
            <message>Only people ages 13 to 19 may take this quiz</message>
        </field-validator>
    </field>
</validators>

// 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="example" namespace="/example" extends="struts-default">

        <action name="quizAction" class="example.QuizAction">
            <result name="input">/example/quiz-ajax.jsp</result>
            <result>/example/quiz-success.jsp</result>
        </action>
    </package>
</struts>

// JSP 文件

<%--
  Created by IntelliJ IDEA.
  User: ma.zhao@dl.cn
  Date: 2007-9-8
  Time: 14:02:17
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="s" uri="/struts-tags" %>

<html>
<head><title>Quiz Action Validation</title></head>
<body>

<s:form action="quizAction" namespace="/example" validate="true">

    <s:textfield label="Name" name="name"/>
    <s:textfield label="Age" name="age"/>
    <s:textfield label="Favorite color" name="answer"/>
    <s:submit/>

</s:form>

</body>
</html>
 

特别说明（Ajax Validation）：

为什么使用AJAX 校验？

纯的JavaScript校验不刷新页面，但是也不能使用所有的Struts2校验方法；服务端校验可以使用所有Struts2的校验方法，但是需要刷新页面。

Struts2 Ajax校验，既不需要刷新页面，又可以使用Struts2内置的所有的校验方法，所以我们比较倾向于使用Ajax校验。

现在（2007/09/08）Struts2的最新版本为2.0.9，还不支持dojo-plugin，所以还没有办法使用Ajax校验。所以要想使用Ajax Validation必须使用Struts2.1.0 SNAPSHOT版本。

下载：

使用Subversion可以从以下位置下载最新的Struts2的源代码：

http://svn.apache.org/repos/asf/struts/struts2/trunk 

构造：

在下载的apps目录下blank子目录下可以使用如下命令

mvn compile jar：jar

可以在target目录中看到：struts2-blank.war

在plugins目录dojo子目录下使用如下命令

mvn compile jar:jar

可以在target目录中看到dojo-plugin：struts2-dojo-plugin-2.1.0-SNAPSHOT.jar

按照上述的说明构造AJAX校验

一些变化：

Struts 配置文件：

<action name="quizAjax" class="example.QuizAction">
    <interceptor-ref name="jsonValidationWorkflowStack"/>
    <result name="input">/example/quiz-ajax.jsp</result>
    <result>/example/quiz-success.jsp</result>
</action>

这个interceptor是在Struts 2.1.0 才有的。

JSP文件：

<%--
  Created by IntelliJ IDEA.
  User: ma.zhao@dl.cn
  Date: 2007-9-8
  Time: 17:29:43
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<%@ taglib prefix="sx" uri="/struts-dojo-tags" %>

<html>
<head>
    <title>Validation - AJAX</title>
    <sx:head />
</head>

<s:url id="url" namespace="/example" action="quizAjax"/>

<body>
<s:form method="post" theme="xhtml" namespace="/example" action="quizAjax" id="form">
    <s:textfield label="Name" name="name" />
    <s:textfield label="Age" name="age" />
    <s:textfield label="Favorite color" name="answer"/>
    <sx:submit validate="true" />
</s:form>
</body>
</html> 

需要注意

<s:url id="url" namespace="/example" action="quizAjax"/>

提供了Dojo校验的URL，一定要注意。

 
Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1777417

　　未使用AJAX之前

　　目前大多数的Struts应用都是标准的“如同一个平面文档的web页面”的结构。如果你想模仿一些桌面应用程序(比如那些使用Java Swing，Visual Basic，或者Delphi建立的应用程序)，那么你有两个选择:你可以发送所有的可能作为页面的一部分被请求的信息，使用大量的JavaScript来操作其动态的显示(一个很慢并且非企业级Java的方法);或者你可以不改变形式地提交到后台服务器(一种有效的方法) 。AJAX提高给你了融合前面的最佳解决方案:动态的页面，但是大多数的应用是在你的web服务器的Java程序来处理的。

　　AJAX 101

　　AJAX和现有的动态HTML技术非常相似，并在其上增加了一个发送到“后台”服务器的请求来获取需要的新的或者更新的信息。AJAX的机制在其他地方已经有详细的说明――请查看本文后的Resources来获取更多。但是你至少需要知道:

• 　　1. XMLHttpRequest (如果你使用的是IE浏览器的话，则是Microsoft.XMLHTTP的ActiveX的对象)。这些对象，你可以在web页面中使用JavaScript调用。他们允许你作为后台的调用方式来请求web服务器的内容(例如，在表单提交后，屏幕并不像平时一样显示“空白”)。
• 　　2. XMLHttpRequest 和Microsoft.XMLHTTP 返回的内容可以作为XML或者文本来处理。JavaScript(在你页面上的)可以使用请求的新内容来更新页面。
• 　　3. 整个处理过程可以由普通的JavaScript事件来触发:onclick，onchange，onblur，等。

　　在你的Struts应用中使用AJAX

　　你阅读了本文，然后你会对使用AJAX来创建动态的web页面感兴趣，并且想知道如何将它加入到你的Struts应用中。这只是选择之一。那么你会如何选择呢?

• 　　· 等待，知道Struts的下一个版本融合了AJAX技术。如果Struts开发者准备开发一个新的应用，这或许会是一个好的选择。再后面，可能会是要求JSF也这样做――对其本身并不一件坏事，但是对于已经存在的系统这将会带来最根本的改变。
• 　　· 你也可以直接采用新的方法，比如Direct Web Remoting (DWR) 和Ruby on Rails，这些都是专为建立AJAX应用的。如果你考虑不使用Struts来开发web的话，那么这些都是很又用的框架，并且值得一试。但是，这也同时意味着你必须要重写你的应用。
• 　　· 在你已经存在的Struts应用中增加AJAX。既然AJAX只是一项技术而并非框架，那么它就很容易融入到Struts中。作为现有的系统，其稳定性(如，保持现有的库文件)是相当重要的。所以这个方法被推荐，并且我们将在后面详细介绍。

　　我们选择在Struts应用中增加AJAX的优势是:

• 　　1. 它并不需要任何新的库文件或者服务器代码;只需要使用现有的Struts库文件和action。
• 　　2. 解决方案中所有部分――JavaScript，XML，Java和Struts――早已为广泛所知。
• 　　3. 此应用可以一块一块地移植到AJAX;我们可以确定哪些部分对用户有益，并首先将它们更新到动态AJAX显示。

　　实现方案

　　我们如何真正的贯彻我们的选择呢?我们首先应该注意一个“标准的”(没有AJAX)Struts应用是如何工作的。在此应用中，一个一般的事件流程如下:

• 　　1. 使用点击超链接或者表单的提交按钮，用户发送请求。
• 　　2. web服务器运行处理请求的Struts Action来生成一个web页面。
• 　　3. 浏览器显示web页面。
• 　　4. 当用户点击保存的时候，信息由Struts框架中一个ActionForm类来转换并发送到服务器。
• 　　5. 然后，Struts框架调用Struts Action来出来请求(如，保存数据到数据库中)。
• 　　6. 页面再一次回传，处理流程继续。

　　现有的Struts应用

　　一个演示事件流程的简单Struts应用可以在以下地址下载: struts-non-ajax.zip。此基于Struts的应用，是基于用户的输入显示或者隐藏蓝色和绿色的表格。图1显示了载入初始页面的画面。图2显示了用户输入值并点击了提交后的画面。虽然简单，但它已经足以表示一个Struts的工作流程。

　　图 1. 没有AJAX的例子:初始屏幕

　　服务器端的代码是:一个Struts Action使用struts-config.xml 中定义的值转发到(相同的)JSP。这个例子代码中一些需要注意的地方是:

• 　　·struts-config.xml文件将所有的请求重定向到http://localhost:8080/struts-non-ajax/(或者和你自己的服务器相同)的index.jsp。
• 　　· index.jsp 包含了一个两个文本框的Struts form(showBlue和showGreen)。该页面同样包含了标签，但是如同两个文本框被初始化为空，标签之间的内容并不显示。
• 　　· 用户输入值(true或者false)并点击提交按钮，处理控制(经过Struts框架，读取struts-config.xml)提交到SampleAction类中。
• 　　·SampleAction记录下值，然后转发到index.jsp。一个成熟的Struts应用可能会处理更多的事情，不如保存或者查询数据库等。
• 　　· index.jsp 现在重新处理请求;如果ShowBlue或者ShowGreen的值是true，这些表格就显示出来。

　　该应用并没有任何“错误”。类似的Struts项目好多年都是这样做的。但是，我们如何在不添加复杂的JavaScript或者频繁的表单提交的前提下，为此应用增加动态的元素呢?

　　我们的第一个Struts AJAX应用

　　观察下下面的图3和图4。第一眼看上去，它们和前面的例子没有说明区别。它们的不同之处在于，页面载入后(图3)然后文本框中的值改变了，窗体自动提交而不显示空白的，然后在图4中显示结果。普通的提交按钮仍然在，你也可以选择使用它。

　　图 3. 页面载入后的AJAX例子

　　图 4. AJAX调用后的AJAX例子

　　添加AJAX是出奇的容易。服务器端的代码和前面的例子是一样的: 一个Struts的ActionForm来后去数据，一个Struts的Action来执行需要的任务(例如，存储数据库)然后转发到适当的JSP页面来显示结果。

　　继续

　　如果你希望就此停止阅读(跳过这个例子的工作说明)，但是这里的是和你需要转换你的Struts应用到一个Struts-AJAX应用同样的风格:

• 　　1. 在你的web页面中引入一个Ajax.js (该文件是struts-ajax.zip 例文件中的一部分)。Ajax.js 包含了所有需要发送和接收AJAX调用的JavaScript方法。
• 　　2. 确保你希望在AJAX调用中更新的web页面的部分包含在标签中，并且给每个标签一个id。
• 　　3. 当一些事件触发的时候就更新页面(例如，文本框的the onchange()方法)，调用retrieveURL()方法，通过URL传递到需要执行服务器端处理的Struts Action。
• 　　4. 为了页面的显示/更新，最简单的方法是Struts Action转发回同样的页面。在本例中，showGreen/showBlue 文本框中的onchange()方法来触发AJAX调用。

　　JavaScript方法retrieveURL()调用服务器的Struts(通过URL)，获取JSP响应，然后更新显示页面中的 标签中的部分。就是这么简单!

　　AJAX解决方案的细节

　　我们将例子变为AJAX-Struts应用的时候，需要三个变化:

• 　　1. 增加一个JavaScript方法来完成到服务器的“背后的”AJAX调用。
• 　　2. 增加JavaScript代码来接收服务器的响应并更新页面。
• 　　3. 在JSP页面增加标签标签，这个标签中内容将在AJAX调用中更新。

　　有两个方法(在下面列出)用于发送请求到服务器。

　　· retrieveURL()方法获得服务器的URL和Struts form。URL用于使用AJAX，form的值用于传递到服务器。

　　· getFormAsString()方法用于将retrieveURL()中form命名的值组装成查询字符串，并发送到服务器。

　　使用方法很简单，使用onclick()/onChange()事件来触发retrieveURL()更新显示。

　　在这两个方法中有一些有趣的东西。

　　在retrieveURL()方法中，req.onreadystatechange = processStateChange (注意，没有括号)这一行来告诉浏览器在服务器响应到达的时候调用processStateChange()方法(该方法将在后面介绍)。retrieveURL()方法中(现在已经是AJAX的标准了)同样决定是使用IE浏览器(ActiveX)还是使用Netscape/Mozilla (XmlHttpRequest) 来实现跨浏览器兼容。

　　getFormAsString()方法将HTML form转换成字符串连接在URL后面(这样就允许我们发送HTTP GET请求)。这个字符串是经过转换的(比如，空格转换成%20等)，并且是一个Struts能将其组装成ActionForm的格式(并不需要Struts清楚的明白这个是来之AJAX的请求)。注意，在本例中我们使用HTTP GET，使用HTTP POST的方法也是类似的。

function retrieveURL(url,nameOfFormToPost) {

//将url转换成字符串
url=url+getFormAsString(nameOfFormToPost);

//调用AJAX
if (window.XMLHttpRequest) {

// 非IE浏览器
req = new XMLHttpRequest();
req.onreadystatechange = processStateChange;
try {
req.open("GET", url, true);
} catch (e) {
alert("Server Communication Problem\n"+e);
}
req.send(null);
} else if (window.ActiveXObject) {
// IE

req = new ActiveXObject("Microsoft.XMLHTTP");
if (req) {
req.onreadystatechange=processStateChange;
req.open("GET", url, true);
req.send();
}
}
}

getFormAsString() 是一个“私有” 方法，在retrieveURL()中使用。

function getFormAsString(formName){

//设置返回字符串
returnString ="";

//取得表单的值
formElements=document.forms[formName].elements;

//循环数组，组装url
//像'/strutsaction.do&name=value'这样的格式

for(var i=formElements.length-1;i>=0; --i ){
//转化每一个值
returnString+="&"
+escape(formElements[i].name)+"="
+escape(formElements[i].value);
}

表单标志使用小技巧

Struts 2的表单标志在输出（render）HTML时，使用了模板的概念，增加了复杂性（因为它不像Struts 1.x的表单标志，它通常都是一个标志对应HTML的一个元素），因此大家在使用时，需要一些技巧：

1. Struts 2的UI标志的表单标志默认是以表格布局，按钮是右对齐的。如果你不喜欢此风格，你可以简单地将<s:form />标志的“theme”属性设为“simple”，然后用以往的做法自已布局表单元素（注意：此法有利有弊，弊就是当你将“theme”属性设为“simple”时，表单标志以最简单方式输出HTML，所以你可能失去一些默认输出提供的便利，如：友好的错误信息的显示，或客户端的表单验证等）。当然更好的做法是通过CSS或自定义主题（theme）然后应用到整个应用程序，这样可以获得一致的页面风格，加强用户体验（我会在以后的文章对此进行讲解）；
2. 当你在页面上加入某些标志（如：<s:doubleselect />等）时，应该通过action来访问页面，而不是通过*.jsp的URL直接访问。

下面我将分别对这些标志进行讲述：

1、<s:checkboxlist />

大家对<s:checkboxlist />的最大的疑问可能是：“如何在默认情况下，选中某些checkbox？”

答案其实很简单，只需要将其“value”属性设为你的要选中的值，如以代码所示：

分布运行应用程序，在浏览器中键入：http://localhost:8080/Struts2_CoolTags/checkboxlist.jsp，出现如下图所示页面：

清单2 checkboxlist.jsp页面

2、<s:doubleselect />

大家看Struts 2的showcase的例子，<s:doubleselect />的用法如下所示：

很多朋友问：“上面的‘list’属性只有两个值，如果我有三个或更多的值，‘doublelist’属性应该如何设定呢？”

我建议的做法是先定义一个Map类型的对象，键为“list”的集合，值则为“doubleList”的集合，然后“doubleList”的OGNL写成“#myMap[top]”，如以下代码所示：

分布运行应用程序，在浏览器中键入：http://localhost:8080/Struts2_CoolTags/doubleselect.action，出现如下图所示页面：

清单5 doubleselect.jsp页面

3、<s: token />

这个标志可能大家不常用，不过本人认为它还是挺有用的。在使用Struts 1.x时，因为跳转通常是用Forward（而不是Redirect）实现的，所以当用户完成请求后，按“F5”刷新页面时，就会重新提交上次的请求，这样经常会出错。要解决这个问题，<s:token />可以帮你忙。

实现原理

在页面加载时，<s: token />产生一个GUID（Globally Unique Identifier，全局唯一标识符）值的隐藏输入框如：

同时，将GUID放到会话（session）中；在执行action之前，“token”拦截器将会话token与请求token比较，如果两者相同，则将会话中的token删除并往下执行，否则向actionErrors加入错误信息。如此一来，如果用户通过某种手段提交了两次相同的请求，两个token就会不同。

具体实现

首先看一下Action的代码：

package tutorial;

import com.opensymphony.xwork2.ActionSupport;

public class CoolTagAction extends ActionSupport {    
   private static final long serialVersionUID = 6820659617470261780L;
   
   private String message;
       
   public String getMessage() {
       return message;
   }

   public void setMessage(String message) {
       this.message = message;
   }
   
   @Override
   public String execute() {
       System.out.println("Executing action, your message is " + message);
       return SUCCESS;
   }    
}

以上代码一目了然，再看看JSP的写法：

JSP也很简单，就是加入<s:token />标志。接下来是Actoin配置的XML片段：

以上XML片段值注意的是加入了“token”拦截器和“invalid.token”结果，因为“token”拦截器在会话token与请求token不一致时，将会直接返回“invalid.token”结果。

发布运行应用程序，在浏览器中键入：http://localhost:8080/Struts2_CoolTags/token.jsp，出现如下图所示页面：

清单10 正常显示的token.jsp页面

随便填点东西并提交页面，一切正常返回以上页面，然后按“F5”刷新页面，在弹出的对话框中点击“Retry”，出现如下图所示页面：

清单11 重复提交出错显示

4、<s:datetimepicker />、<s:optiontransferselect />和<s:updownselect />

这几个标志的使用相对简单，所以我想小举一例即可，以下是JSP的代码：

发布运行应用程序，在浏览器中键入：http://localhost:8080/Struts2_CoolTags/others.jsp，出现如下图所示页面：

清单13 其它表单标志页面

总结

Struts 2在标志上的确比Struts 1.x丰富了许多，同时模板机制也给程序员带来不少方便（如果你不太喜欢个性化的风格）。另外，Struts 2还有一些AJAX（如<s: autocompleter />等）的标志和非表单的UI标志（如<s: tree />等），我会在以后的文章中讲述其使用。

言归正传，本文的目的主要是介绍在Struts 2中实现控制反转。

历史背景

众所周知，Struts 2是以Webwork 2作为基础发展出来。而在Webwork 2.2之前的Webwork版本，其自身有一套控制反转的实现，Webwork 2.2在Spring 框架的如火如荼发展的背景下，决定放弃控制反转功能的开发，转由Spring实现。值得一提的是，Spring确实是一个值得学习的框架，因为有越来越多的开源组件（如iBATIS等）都放弃与Spring重叠的功能的开发。因此，Struts 2推荐大家通过Spring实现控制反转。

具体实现

首先，在开发环境中配置好Struts 2的工程。对这部分仍然有问题的朋友，请参考我的早前的文章。

然后，将所需的Spring的jar包加入到工程的构建环境（Build Path）中，如下图1所示：

图1 所依赖的Spring的jar包

本文使用的是Spring 2.0，Spring强烈建议大家在使用其jar包时，只引用需要的包，原因是Spring是一个功能非常强大的框架，其中有些功能是您不需要的；而且Spring提倡的是“按需所取”，而不是EJB的“爱我就要爱我的一切”。当然，如果你怕麻烦或者是不清楚每个包的作用，引用一个Spring的总包也未尝不可。

接下来，就要修改WEB-INF\web.xml文件了，内容为：

大家一看便知道，主要是加入Spring的ContextLoaderListener监听器，方便Spring与Web容器交互。

紧接着，修改Struts.properties文件，告知Struts 2运行时使用Spring来创建对象（如Action等），内容如下：

再下来，遵循Spring的原则——面向接口编程，创建接口ChatService，代码如下：

package tutorial;

import java.util.Set;

public interface ChatService {
   Set < String > getUserNames();
}

然后，再创建一个默认实现ChatServiceImpl，代码如下：

package tutorial;

import java.util.HashSet;
import java.util.Set;

public class ChatServiceImpl implements ChatService {

    public Set < String > getUserNames() {
       Set < String > users = new HashSet < String > ();
       users.add( " Max " );
       users.add( " Scott " );
       users.add( " Bob " );
        return users;
   }

}

接下来，就该新建Action了。tutorial.ChatAction.java的代码如下：

package tutorial;

import java.util.Set;

import com.opensymphony.xwork2.ActionSupport;

public class ChatAction extends ActionSupport {
    private static final long serialVersionUID = 8445871212065L ; 
   
    private ChatService chatService;
    private Set < String > userNames;

    public void setChatService(ChatService chatService) {
        this .chatService = chatService;
   }
   
    public Set < String > getUserNames() {
        return userNames;
   }
   
   @Override
    public String execute() {
       userNames = chatService.getUserNames();
        return SUCCESS;
   }
   
}

ChatAction类使用属性（Getter/Setter）注入法取得ChatService对象。

然后，配置Spring的applicationContext.xml（位于WEB-INF下）文件，内容如下：

上述代码有二点值得大家注意的：

1. Struts 2会为每一个请求创建一个Action对象，所以在定义chatAction时，使用scope="prototype"。这样Spring就会每次都返回一个新的ChatAction对象了；
2. 因为ChatServiceImpl被配置为默认的scope（也即是singleton，唯一的），所以在实现时应保证其线程安全（关于编写线程安全的代码的讨论已经超出本文的范围，更超出了本人的能力范围，大家可以参考Addison Wesley Professional出版的《Java Concurrency in Practice》）。

接下来，在classes/struts.xml中配置Action，内容如下：

这里的Action和平常不同的就是class属性，它对应于Spring所定义的bean的id，而不是它的类全名。

最后，让我们看看/UserList.jsp，内容如下：

大功告成，分布运行应用程序，在浏览器中键入http://localhost:8080/Struts2_IoC/Chat.action，出现如图2所示页面：

图2 /ListUser.jsp

总结

通过Spring在Struts 2上实现控制反转是强烈推荐的做法，当然您也可以组合其它的实现（如Pico等）。

其实，Struts 1.x在此部分已经做得相当不错了。它极大地简化了我们程序员在做国际化时所需的工作，例如，如果您要输出一条国际化的信息，只需在代码包中加入FILE-NAME_xx_XX.properties（其中FILE-NAME为默认资源文件的文件名），然后在struts-config.xml中指明其路径，再在页面用<bean:message>标志输出即可。

不过，所谓“没有最好，只有更好”。Struts 2.0并没有在这部分止步，而是在原有的简单易用的基础上，将其做得更灵活、更强大。

国际化Hello World

下面让我们看一个例子——HelloWorld。这个例子演示如何根据用户浏览器的设置输出相应的HelloWorld。

1. 在Eclipse创建工程配置开发和运行环境（如果对这个步骤有问题，可以参考我早前的文章《为Struts 2.0做好准备》）。
   
2. 在src文件夹中加入struts.properties文件，内容如下：
   
   struts.custom.i18n.resources=globalMessages

   Struts 2.0有两个配置文件，struts.xml和struts.properties都是放在WEB-INF/classes/下。 struts.xml用于应用程序相关的配置 struts.properties用于Struts 2.0的运行时（Runtime）的配置

3. 在src文件夹中加入globalMessages_en_US.properties文件，内容如下：
   
   HelloWorld=Hello World!
4. 在src文件夹中加入globalMessages_zh_CN.properties文件，内容如下：
   
   HelloWorld=你好，世界！

   在此想和大家分享一个不错的编写properties文件的Eclipse插件（plugin），有了它我们在编辑一些简体中文、繁体中文等Unicode文本时，就不必再使用native2ascii编码了。您可以通过Eclipse中的软件升级（Software Update）安装此插件，步骤如下： 1、展开Eclipse的Help菜单，将鼠标移到Software Update子项，在出现的子菜单中点击Find and Install； 2、在Install/Update对话框中选择Search for new features to install，点击Next； 3、在Install对话框中点击New Remote Site； 4、在New Update Site对话框的Name填入“PropEdit”或其它任意非空字符串，在URL中填入http://propedit.sourceforge.jp/eclipse/updates/； 5、在Site to include to search列表中，除上一步加入的site外的其它选项去掉，点击Finsih； 6、在弹出的Updates对话框中的Select the features to install列表中将所有结尾为“3.1.x”的选项去掉（适用于Eclipse 3.2版本的朋友）； 7、点击Finish关闭对话框； 8、在下载后，同意安装，再按提示重启Eclipse，在工具条看到形似vi的按钮表示安装成功，插件可用。此时，Eclpise中所有properties文件的文件名前有绿色的P的图标作为标识。

5. 在WebContent文件夹下加入HelloWorl.jsp文件，内容如下：
   
   <%@ page  contentType="text/html; charset=UTF-8"%>
   <%@taglib prefix="s" uri="/struts-tags"%>
   <html>
   <head>
       <title>Hello World</title>
   </head>
   <body>
       <h2><s:text name="HelloWorld"/></h2>
       <h2><s:property value="%{getText('HelloWorld')}"/></h2>
   </body>
   </html>
6. 发布运行应用程序，在浏览器地址栏中输入http://localhost:8080/Struts2_i18n/HelloWorld.jsp ，出现图1所示页面。
   
   图1 中文输出
7. 将浏览器的默认语言改为“英语（美国）”，刷新页面，出现图2所示页面。
   
   图2 英文输出

资源文件查找顺序

之所以说Struts 2.0的国际化更灵活是因为它可以能根据不同需要配置和获取资源（properties）文件。在Struts 2.0中有下面几种方法：

1. 使用全局的资源文件，方法如上例所示。这适用于遍布于整个应用程序的国际化字符串，它们在不同的包（package）中被引用，如一些比较共用的出错提示；
2. 使用包范围内的资源文件。做法是在包的根目录下新建名的package.properties和package_xx_XX.properties文件。这就适用于在包中不同类访问的资源；
3. 使用Action范围的资源文件。做法为Action的包下新建文件名（除文件扩展名外）与Action类名同样的资源文件。它只能在该Action中访问。如此一来，我们就可以在不同的Action里使用相同的properties名表示不同的值。例如，在ActonOne中title为“动作一”，而同样用title在ActionTwo表示“动作二”，节省一些命名工夫；
4. 使用<s:i18n>标志访问特定路径的properties文件。使用方法请参考我早前的文章《常用的Struts 2.0的标志（Tag）介绍》。在您使用这一方法时，请注意<s:i18n>标志的范围。在<s:i18n name="xxxxx">到</s:i18n>之间，所有的国际化字符串都会在名为xxxxx资源文件查找，如果找不到，Struts 2.0就会输出默认值（国际化字符串的名字）。

上面我列举了四种配置和访问资源的方法，它们的范围分别是从大到小，而Struts 2.0在查找国际化字符串所遵循的是特定的顺序，如图3所示：

假设我们在某个ChildAction中调用了getText("user.title")，Struts 2.0的将会执行以下的操作：

1. 查找ChildAction_xx_XX.properties文件或ChildAction.properties；
2. 查找ChildAction实现的接口，查找与接口同名的资源文件MyInterface.properties；
3. 查找ChildAction的父类ParentAction的properties文件，文件名为ParentAction.properties；
4. 判断当前ChildAction是否实现接口ModelDriven。如果是，调用getModel()获得对象，查找与其同名的资源文件；
5. 查找当前包下的package.properties文件；
6. 查找当前包的父包，直到最顶层包；
7. 在值栈（Value Stack）中，查找名为user的属性，转到user类型同名的资源文件，查找键为title的资源;
8. 查找在struts.properties配置的默认的资源文件，参考例1;
9. 输出user.title。

参数化国际化字符串

许多情况下，我们都需要在动行时（runtime）为国际化字符插入一些参数，例如在输入验证提示信息的时候。在Struts 2.0中，我们通过以下两种方法做到这点：

1. 在资源文件的国际化字符串中使用OGNL，格式为${表达式}，例如：
   
   validation.require=${getText(fileName)} is required
2. 使用java.text.MessageFormat中的字符串格式，格式为{ 参数序号（从0开始）, 格式类形（number | date | time | choice）, 格式样式}，例如：
   
   validation.between=Date must between {0, date, short} and {1, date, short}

1. 使用标志的value0、value1...valueN的属性，如：
   
   <s:text name="validation.required" value0="User Name"/>
2. 使用param子元素，这些param将按先后顺序，代入到国际化字符串的参数中，例如：
   
   <s:text name="validation.required">
      <s:param value="User Name"/>
   </s:text>

让用户方便地选择语言

开发国际化的应用程序时，有一个功能是必不可少的——让用户快捷地选择或切换语言。在Struts 2.0中，通过ActionContext.getContext().setLocale(Locale arg)可以设置用户的默认语言。不过，由于这是一个比较普遍的应用场景（Scenario），所以Struts 2.0为您提供了一个名i18n的拦截器（Interceptor），并在默认情况下将其注册到拦截器链（Interceptor chain）中。它的原理为在执行Action方法前，i18n拦截器查找请求中的一个名为"request_locale"的参数。如果其存在，拦截器就将其作为参数实例化Locale对象，并将其设为用户默认的区域（Locale），最后，将此Locale对象保存在session的名为“WW_TRANS_I18N_LOCALE”的属性中。

下面，我将提供一完整示例演示它的使用方法。

package tutorial;

import java.util.Hashtable;
import java.util.Locale;
import java.util.Map;

publicclass Locales {
   public Map<String, Locale> getLocales() {
       Map<String, Locale> locales =new Hashtable<String, Locale>(2);
       locales.put("American English", Locale.US);
       locales.put("Simplified Chinese", Locale.CHINA);
       return locales;
   }
}

上述代码的原理为，LangSelector.jsp先实例化一个Locales对象，并把对象的Map类型的属性locales赋予下拉列表（select） 。如此一来，下拉列表就获得可用语言的列表。大家看到LangSelector有<s:form>标志和一段Javascript脚本，它们的作用就是在用户在下拉列表中选择了后，提交包含“reqeust_locale”变量的表单到Action。在打开页面时，为了下拉列表的选中的当前区域，我们需要到session取得当前区域（键为“WW_TRANS_I18N_LOCALE”的属性），而该属性在没有设置语言前是为空的，所以通过值栈中locale属性来取得当前区域（用户浏览器所设置的语言）。

可能大家会问为什么一定要通过Action来访问页面呢？ 你可以试一下不用Action而直接用JSP的地址来访问页面，结果会是无论你在下拉列表中选择什么，语言都不会改变。这表示不能正常运行的。其原因为如果直接使用JSP访问页面，Struts 2.0在web.xml的配置的过滤器（Filter）就不会工作，所以拦截器链也不会工作。