struts2.1.6教程二、struts.xml配置及例程

1.配置文件的优先级

在struts2中一些配置（比如常量）可以同时在struts-default.xml（只读性），strtus-plguin.xml（只读性），struts.xml，struts.properties和web.xml文件中配置，它们的优先级逐步升高，即是说后面的配置会覆盖掉前面相同的配置。

2.配置形式

下面以对struts.i18n.encoding=UTF-8的配置为例进行说明：

在struts.xml配置形式如下：

   <constant name="struts.i18n.encoding" value="gbk"></constant>

在struts.properties的配置形式如下：

struts.i18n.encoding=UTF-8

在web.xml中配置如下：

<filter>

<filter-name>struts2</filter-name>
<filter-class>    org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
    </filter-class>
    <init-param>
       <param-name>struts.i18n.encoding</param-name>
       <param-value>UTF-8</param-value>
    </init-param>
</filter>

说明：官方声称配置了此常量可以解决中文乱码问题，但实事上并不能达到目的，在前面的三个项目中，如果我们在表单中输入中文，其结果是会出现乱码。解决此问题参看[一.7的注意]。这是struts2.1.6中的一bug,它的下一版2.1.8已解决此问题。

3.package配置相关

属性名	是否必须	说明
Name	是	Package的唯一标识，不允许同名
Extends	否	指定要继承的包
Namespace	否	指定名称空间
Abstract	否	声明包为抽象否

aaarticlea/png;base64,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" alt="" />

说明：在上面的配置文件中所用到的Test1Action和Test2Action这两个Action都只是继承了com.opensymphony.xwork2.ActionSupport类，而ActionSupport默认返回的就是“success”,所以当点击上面的链接分别转到了forward目录下的test1.jsp和test2.jsp。下面重点来看这个package元素的namespace属性及action的name属性，它们共同定义了action所映射到的实质文件。上图展示了链接地址和action的对应关系，所以当我们要想访问一个action所关联到的jsp文件时，应该用namespace+action的name 关于它的内容测试可以参考struts2package项目。

补充：通常情况下，action元素的name是属性值是不能出现“/”的，所以希望通过action中name属性来实现多级映射，需要在sturts.xml中增加如下属性：

<constant name="struts.enable.SlashesInActionNames" value="true"/> 

这样配置后就可以再action的name元素中使用“/”了。比如：

<package name="tt3" extends="struts-default">
        <action name="test3/test3" class="com.asm.Test3Action">
            <result name="success">/forward/test3.jsp</result>
        </action>
</package>

然后输入<a href="<%=path%>/test3/test3.action">test3</a><br>链接地址就可以访问了

强调：namespace默认值“”，即不配置namespace属性。它的意思是：如果action不能进行完整路径匹配，则会来此namespace下进行匹配，比如：.../test/test/test.action，如果参照namespace及action的name不能找到也之完全对应的action，它会再到依次追溯到上级目录中查找，即是说它会以…/test/test.action这样的路径来对应namespace和action的name进行查找。如果返回到最终的目录仍找不到，它就会到namespace="/"对应的包下查找名为test的action,如果仍找不到，它就会去默认的namespace下查找名为test的action，如果找到则执行此action。另外，namespace也可以配置成namespace="/"。它代表配置为项目的根。 总结action的名称探索顺序：完全对应、逐步追溯到上级目录查找、"/"下查找、默认namespace下查找。

为什么要提出namespace，主要是避免多人共同开发项目出现名字冲突。如果不使用namespace，多个人所写的action中可能出现重名的现象，这样当项目合并时就会出现冲突。而有了namespace可以在项目开发时由项目经理给每一个人分不同的namespace，这样每个开发人员只需要保证自己所写的action不同名即可。

namespace引发的链接问题：当我们为action配置了namespace时，访问此action的形式总会是如下形式：.../webappname/xxx/yyy/ActionName.action 而当此action成功执行跳转到某个jsp页面时，如想在此jsp页面写链接，一定要写绝对路径，因为相对路径是相对.../webappname/xxx/yyy/，而如果以后我们修改了action的namespace时，相对路径又要变，所以链接不能写成相对路径。 以下介绍

1.绝对路径的写法：通常用myeclipse开发时建立一个jsp文件，默认总会有如下内容：

<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

我们写绝对路径可以参此内容。还可以参<head>下的<base href="<%=basePath%>"> 来完成绝对路径的书写。

4.分工合作include:指定多个配置文件

比如让jack来单独开发一个action，在jack.xml中的配置文件为：

<struts>
    <package name="jack" namespace="/jack" extends="struts-default">
        <action name="test4" class="com.asm.Test4Action">
            <result name="success">/forward/test4.jsp</result>
        </action>
    </package>
</struts>

然后在struts.xml文件中增加如下内容：<include file="jack.xml"></include> 它实质就是把jack.xml中的<package>及其内容写进struts.xml中的<struts>根元素下。

链接：<a href="<%=path %>/jack/test4.action">test4</a> 这样便可以访问到了forward目录下的test4.jsp了。

5.tomcat认证访问

接上例：namespce的作用除了在前面提到的避免协同开发名字冲突外，还为认证提供一个条件。比如jack开发的东西所关联到的页面需要权限才能被访问。由于多为tomcat中的内容，下面只列出步骤。
步骤一，tomcat的conf目录下tomcat-users.xml内容如下：

<?xml version='1.0' encoding='utf-8'?>
<tomcat-users>
  <role rolename="manager"/>
  <role rolename="admin"/>
  <user username="jack" password="jack" roles="admin,manager"/>
  <user username="tom" password="tom" roles="manager"/>
</tomcat-users>

步骤二，在web.xml中增加如下内容：

<security-constraint>
        <web-resource-collection>
            <web-resource-name>jack</web-resource-name>
            <url-pattern>/jack/*</url-pattern>
            <http-method>POST</http-method>
            <http-method>GET</http-method>
        </web-resource-collection>
        <auth-constraint>
            <role-name>admin</role-name>
        </auth-constraint>
    </security-constraint>
    <security-role>
        <role-name>admin</role-name>
    </security-role>

    <login-config>
        <auth-method>BASIC</auth-method>
        <realm-name>input authentication message</realm-name>
    </login-config>

这样配置完成后，当我们访问.../jack中的任何内容都会要求输入密码认证信息，认证时输入tomcat-users.xml配置的admin权限的用户名和密码即可访问（这里就只有jack用户名可以访问）

6.初识拦截器

拦截器能在action被调用之前和被调用之后执行一些“代码”。Struts2框架的大部分核心功能都是通过拦截器来实现的，如防止重复提交、类型转换、对象封装、校验、文件上传、页面预装载等等，都是在拦截器的帮助下实现的。每一个拦截器都是独立装载的(pluggable)，我们可以根据实际的需要为每一个action配置它所需要的拦截器。

在myStruts2项目下，重新对配置文件作如下修改：

<package name="myFirst" namespace="/" extends="struts-default">
<interceptors>
 <interceptor name="timer" class="com.opensymphony.xwork2.interceptor.TimerInterceptor" />
 <interceptor name="params" class="com.opensymphony.xwork2.interceptor.ParametersInterceptor" />
</interceptors>

        <action name="login" class="com.asm.LoginAction">
            <interceptor-ref name="timer"></interceptor-ref>
<interceptor-ref name="params"></interceptor-ref>
            <result name="loginSuccess">/success.jsp</result>
            <result name="loginFailure">/failure.jsp</result>
        </action>
    </package>

首先在package中定义了两个拦截器，然后在login action中引用了这两个拦截器，需要说明的是这里使用的拦截器都是系统自带的拦截器。其实在extends所继承的struts-default中就包含了很多拦截器，也包括我们这里所用的拦截器，但如果在此action中不使用params拦截器，将会报空指针错，因为params拦截器的作用是传递表单参数，如果不使用此拦截器就不能在action中得到表单参数，所以引用时会报空指针错。虽然extends继承的strust-default自带有params拦截器，但是当我们自己引用了拦截器时，继承struts-default将不会再为我们分配默认的拦截器（有点类似构造器），但是我们仍然可以通过<interceptor-ref name="defaultStack"/>来继续使用struts-defalut的拦截器。补充：由于上面的package继承于struts-default，而我们这里所用到的timer和params都是在struts-defalut中定义过，所以即使我们在<interceptors>中没有定义过这两个拦截器，也可以直接在action中引用。

使用<interceptor-stack>组合多个拦截器：比如我们想把上面的params和timer这两个拦截器组合：

    <interceptor-stack name="timer_param">
                <interceptor-ref name="timer" />
                <interceptor-ref name="params" />
    </interceptor-stack>

然后再在action引用<interceptor-ref name="timer_param"/>”，效果和分别引用两个是一样的。其实我们使用strtus-default中的<interceptor-ref name="defaultStack"/>也是使用interceptor-stack方式。

7.Action中的method属性

在struts1.x中我们知道通过继承DispatchAction可以实现把多个Action进行统一操作，在struts2中实现action的统一操作也很简单。我们以crud操作为例，把crud集中到一个Action中。
步骤一、建立CRUDAction，内容如下：

package com.asm;
import com.opensymphony.xwork2.ActionSupport;
public class CRUDAction extends ActionSupport {
    public String add() {
        return "success";
    }
    public String del() {
        return "success";
    }
    public String update() {
        return "success";
    }
    public String query() {
        return "success";
    }
}

步骤二、配置此Action,为了清晰明了，专为此Action，建立一个配置文件crud.xml，主要内容如下：

<struts>
    <package name="crud" extends="struts-default" namespace="/crud">
        <action name="add" class="com.asm.CRUDAction" method="add">
            <result name="success">/crud/addSuccess.jsp</result>
        </action>
        <action name="del" class="com.asm.CRUDAction" method="del">
            <result name="success">/crud/delSuccess.jsp</result>
        </action>
        <action name="update" class="com.asm.CRUDAction" method="update">
            <result name="success">/crud/updateSuccess.jsp</result>
        </action>
        <action name="query" class="com.asm.CRUDAction" method="query">
            <result name="success">/crud/querySuccess.jsp</result>
        </action>
    </package>
</struts>

分析：上面的method方法的值来源于CRUDAction中方法的名字，这样当我们访问上面的每一个Action时，它实质是和method指定的方法关联上。

步骤三、把crud.xml配置文件并入struts.xml中，只需增加如下代码：

<include file="crud.xml"></include>

步骤四、编写相应的jsp页面，在此略去crud文件夹下的四个跳转jsp页面（addSuccess.jsp等），重点是crud.jsp页面。内容如下：

<html>
<%
    String path=request.getContextPath();
%>
    <body>
        <a href="<%=path %>/crud/add.action">添加数据</a><br>
        <a href="<%=path %>/crud/del.action">删除数据</a><br>
        <a href="<%=path %>/crud/query.action">查询数据</a><br>
        <a href="<%=path %>/crud/update.action">修改数据</a><br>
    </body>
</html>

补充扩展，动态调用DMI：不使用method实现统一.我们在crud.xml中增加如下内容：

<action name="op" class="com.asm.CRUDAction">
            <result name="success">/crud/op.jsp</result>
</action>

然后再在crud.jsp中定义如下链接：

<a href="<%=path %>/crud/op!add.action">添加数据</a><br>
<a href="<%=path %>/crud/op!del.action">删除数据</a><br>
<a href="<%=path %>/crud/op!query.action">查询数据</a><br>
<a href="<%=path %>/crud/op!update.action">修改数据</a><br>

注意查看上面的链接地址，它们都是针对op action，然后再加地上“！+CRUDAction中相应的方法名”，最后再写上.action即可以访问到统一页面op.jsp。这样做虽然能减少页面，但是由于它们实质用到的是同一个Action，所以这就意味着我们要使用的拦截器相同，相同的跳转result。实际中这种方式很少使用，在此略作了解。如果不想使用动态方法调用，我们可以通过常量来关闭，即在struts.xml中增加如下配置：

<constant name="struts.enable.DynamicMethodInvocation" value="false"/>

扩展2：在CRUDAction中使用do。举例：我们在CRUDAction中增加一个新的方法，内容如下：

    public String doMain(){
       return "success";
    }

然后再在在crud.xml中增加如下内容：

<action name="main" class="com.asm.CRUDAction" method="main">
           <result name="success">/crud/main.jsp</result>
</action>

注意：配置中method属性值是doMain中去掉do后M小写。然后再在crud.jsp中增加如下链接：

<a href="<%=path %>/crud/main.action">main页面</a><br>

随后便可以访问到.../crud/main.jsp页面了。

8.使用ForwardAction实现页面屏蔽。

我们在jsp页面之间写链接总会是.../xxx.jsp，而如果我们想屏蔽掉具体的jsp,只需要所jsp页面配置成一个ForwardAction即可实现。示例如下：在根目录下有一个index.jsp主页，我们strtus.xml中作如下配置：

<package name="def" extends="struts-default">
        <action name="forward">
            <result >/index.jsp</result>
        </action>
</package>

说明：如果没有未action指定class，默认就是ActionSupport类，如果没有为action指定method属性，则默认执行execute方法，如果没有指定result的name属性，默认值为success。知道了这些再结合ActionSupport的源码就不难理解实现转发的原理了。

随后再在前面第7点扩展中用到的op.jsp中增加如下代码：

<a href="<%=request.getContextPath()%>/forward.action">forward</a>

最后再测试访问op.jsp，在op.jsp中页面中直接点链接便可以跳到index.jsp，观察地址栏发现此时跳到index页面是进行的服务器跳转，如果我们在上面的配置中的result增加type属性变成

<result type="redirect">/index.jsp</result>

，实现的跳转就是客户端跳转。

补充：像这种forward形式的action实质是执行的ActionSupport 这个Action。因此配置它的result可以参看此类的api文档，比如它常用的result name有：success、login、input等。

9.使用default-Action配置统一访问

default-action-ref,当访问没有找到对应的action时,默认就会调用default-action-ref指定的action.同样在上面的package中增加如下内容

<default-action-ref name="error"></default-action-ref>
        <action name="error">
            <result>/other/error.jsp</result>
        </action>

上面一段内容就是说当我们访问的action不能被找到时便指向名为error的action中去，接着我们在下面配置了这个error Action。但是要注意,一个package内只配置一个<default-action-ref>,如果配置多个,就无法预测结果了. 此时我们只要输入.../myStruts2/luanFangWen.action这样的形式，它就会去访问这个默认的<default-action-ref>，通常我们会为它配置一个错误页面，以提示用户访问的页面不存在。

在web开发中，我们还可以把这个默认的action访问配置成主页，这样当用户访问一些不存在的action时，总会跳到主页上去。

通过此配置，只要是访问一个不存在的action便会转向到.../other目录下的error.jsp页面。但是如果访问是其它的不存在资源则仍是报tomcat所标识的404错误，我们可以在web.xml中作如下配置：

<error-page>
        <error-code>404</error-code>
        <location>/other/404error.jsp</location>
</error-page>

这样配置后，访问错误页面将跳到.../other/404error.jsp页面中去。

补充说明：如果我们用ie访问时，如果选中了[工具][IE选项][高级][浏览][显示友好的http错误信息]，则配置的错误页面将失效，因为找不到资源时会报HTTP404错误，而ie截取到此错误进行了它自身的友好处理，所以我们设置<error-page>就失效。

10.使用通配符

建立struts2wildcard项目，此实例基本仿照前面前面第7点的实例改写而成。为了使用通配符，只需要改写配置文件即可。此实例未使用通配时的配置文件如下：

<action name="addUser" class="com.asm.UserAction" method="addUser">
            <result name="success">/user/addUser.jsp</result>
</action>
<action name="delUser" class="com.asm.UserAction" method="delUser">
            <result name="success">/user/delUser.jsp</result>
</action>
<action name="queryUser" class="com.asm.UserAction" method="queryUser">
            <result name="success">/user/queryUser.jsp</result>
</action>
<action name="updateUser" class="com.asm.UserAction" method="updateUser">
            <result name="success">/user/updateUser.jsp</result>
</action>

我们注释掉上面的配置，使用通配符只需如下内容即可达到相同的效果：

<action name="*User" class="com.asm.UserAction" method="{1}User">
            <result name="success">/user/{1}User.jsp</result>
</action>

原理：当有.../addUser.action请求时，如果不能在当前应用中找到完全相同的addUser名字的Action时，通配符配置这时就起作用了，按通配原则，它便和上面的name="*User"相配成功，这里不难明了*此时代指的内容是add，再来看method恰恰是引用第一个*的内容，所以它的method此时的完整名为addUser，它刚好和com.asmUserAction中的addUser方法相对，所以它会去addUser方法，再来看下面的result配置所指代的页面，它也用到了{1}，所以它的完整页面是/addUser.jsp。其实如果我们有良好的编程命名习惯，所有的Action我们都只需要进行一次配置。

举例：规定所有的Action类都用XXXAction来命名，类中所有的CRUD方法都用add/del/update/query。Jsp页面也用add/del/update/query_XXX.jsp这样的形式。即配置文件可以写成如下形式：

<action name="*_*" class="com.asm.{2}Action" method="{1}">
            <result name="success">.../{1}_{2}.jsp</result>
</action>

Name中第一个*代表CRUD操作的名字，第二个*代表类的名字。所以访问链接地址举例如下：

.../del_User.action将访问到User类的del方法，成功后跳到del_User.jsp页面。补充说明{0}是代表name中所有的*组合。

11.使用0配置：ZERO Annotation

略

12.Result配置详解

说明：在前面的许多案例中我们所用到的Action基本都继承自ActionSupport这个类，而在这个类中我们定义了五个字段：SUCCESS，NONE，ERROR，INPUT，LOGING。我们可以直接返回这些字段值，这些字段值实质是被定义成：String SUCCESS=”success”这样的形式，所以我们只要在Result元素中用它们的小写即可。
<result>标准完整形式如下：

<result name="success" type="dispatcher">
        <param name="location">/default.jsp</param>
</result>

如果我们都采用默认的形式，最终可以简写成：<result>/default.jsp</result>

探讨type类型：

Type类型值	作用说明	对应类
chain	用来处理Action链	com.opensymphony.xwork2.ActionChainResult
dispatcher	用来转向页面，通常处理JSP	org.apache.struts2.dispatcher.ServletDispatcherResult
redirect	重定向到一个URL	org.apache.struts2.dispatcher.ServletRedirectResult
redirectAction	重定向到一个Action	org.apache.struts2.dispatcher.ServletActionRedirectResult
plainText	显示源文件内容，如文件源码	org.apache.struts2.dispatcher.PlainTextResult
freemarker	处理FreeMarker模板	org.apache.struts2.views.freemarker.FreemarkerResult
httpheader	控制特殊http行为的结果类型	org.apache.struts2.dispatcher.HttpHeaderResult
stream	向浏览器发送InputSream对象，通常用来处理文件下载，还可用于返回AJAX数据。	org.apache.struts2.dispatcher.StreamResult
velocity	处理Velocity模板	org.apache.struts2.dispatcher.VelocityResult
xslt	处理XML/XLST模板	org.apache.struts2.views.xslt.XSLTResult

以上对type类型作简要的说明，下面来看实例：当一个Action处理后要返回的Result是另一个Action时，作如何配置，关键就是配置type类型。下面建立struts2result项目说明
步骤一：建立两个Action:TestAction、Test2Action
步骤二：web.xml配置省略。struts.xml主要配置内容如下：

<struts>
    <package name="resultTest" extends="struts-default">
        <action name="test" class="com.asm.TestAction">
            <result name="success" type="chain">
                <param name="actionName">test2</param>
            </result>
        </action>

        <action name="test2" class="com.asm.Test2Action">
            <result name="success">/test2Suc.jsp</result>
        </action>
    </package>
</struts>

说明：在名为“test”的action中，我们配置result元素的type类型值为chain，意为将继续把Action传递到下一个名为test2的Action中去，在test2.action中会把页面转向到test2Suc.jsp中去。

在type类型为chain时，它的param有4个值可配，除了这里用到的name=”actionName”外（必须配置，否则报错），还有name=namespace|method|skipActions。其中namespace指定要转向到action的名字空间，由于此处是转到Action位于同一个namespace下，而namesapace的默认值the current namespace，所以可以省略不写(需要说明的是如果要跳到别的名称空间的action中去，除了使用namespace指定外，还可以用：/要跳去action所在名称空间的值/要跳去的action的name值)。Method用于指定转向到一个目标action所调用的方法，默认是调用下一个action的execute方法，所以此处仍可以省略。SkipActions是一个可选的属性，一般不用。具体可以参看chain所对应类的api帮助

在本实例中，我们还在TestAction中设定一个username字段，并在execute方法执行为它赋了值，并在test2Suc.jsp中引用了此值。其实这种做法在web开发中还是很有用处，比如可以代替隐藏域。需要注意的是之所以在action的传递中能把设定的这个值保存下去，主要是因为转向都是服务器跳转。如果我们跳转时采取了客户端跳转，比如在test2 action的result中指定type类型为redirect，要想传递参数可以在result指向的jsp页面中附加参数即可，我们可以在test2 action的result中写成：

<result name="success" type="redirect">
/test2Suc.jsp?username=${username}
</result>  

随后在test2Suc.jsp页面中引用时会出现三个问题：

1.EL表达式引用失效，（EL表达式应该使用${param.username}形式）。我们也可以使用<%=request.getParameter("username")%>获取参数值。

2.由于在前面的TestAction中设定的值为中文，而附加到这里的uri请求的参数后面时会出现乱码问题。（可以使用URI编码再解码解决此问题）

3.值栈取值失效：因为每一次request共享同一个值栈，所以服务器端的forward跳转也是能共享同一值栈得。但是着当test action执行后把请求交由test2 action时，test2 action采取的是redirect重定向到test2Suc.jsp页面，这时其实就是重发的一次request,所以在test action保存的值栈内容全部失效。这也就是为什么我们要附加参数的原因。而参数是保存在actionContext中，所以采用了#的方式来取出值。图示说明：

aaarticlea/png;base64,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" alt="" />

步骤三，编写链接页面index.jsp。发布测试：

全局result：

如果我们所有的action均有可能跳到相同的页面，则不防使用全局result。为了方便引用我们专门建立一个package来存放公共的result。在会用到个全局的跳转时，只需要把继承自这个公共的package即可。

建立公共包，代码如下：

<package name="pubResult" extends="struts-default" abstract="true">
        <global-results>
            <result name="error">/error.jsp</result>
        </global-results>
</package> 

由于它下面没的action配置，所以我们可以像默认的struts-default包一样，声明abstract=true，这样声明表示此packgage下不会有action，它一般是用来让别的package继承。随后再在要用到全局result中引用这个公共的package。代码如下：

<package name="testGlobal" extends="pubResult" >
    <action name="error" class="com.asm.ErrorAction"></action>
    <action name="error2" class="com.asm.Error2Action"></action>
</package>

这样操作相当于把全局的result加到了此package下的所有action中去。

动态Result:了解

步骤一：建立DynaAction，主要代码如下：

package com.asm;
public class DynaAction extends ActionSupport {
    private String username;
    private String nextAction;

    public String execute() throws Exception {
        if (username.equals("admin")) {
            nextAction = "admin";
        } else if (username.equals("user")) {
            nextAction = "user";
        } else {
            nextAction = ERROR;
        }
        return SUCCESS;
    }
    ...省略get/set方法
}

步骤二、建立jsp页面dyna.jsp，主要是为了向DynaAction中传递username参数。

步骤三、相关配置如下：

<package name="dynaTest" extends="pubResult">
        <action name="dyna" class="com.asm.DynaAction">
            <result name="success" type="chain">${nextAction}</result>
        </action>

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

        <action name="user">
            <result>/user.jsp</result>
        </action>
</package>

分析：当dyna.jsp把参数传递到DynaAction中去时，如果传递的值为admin，我们便设定了nextAction的值admin，在配置文件中我们通过${nextAction}（用在struts配置文件中的ognl，其实nextAction的值是存在值栈中，我们通过${}这样的形式取出。在此只作了解）来获取值便为admin，随后再继续把请求传递到下一个Action中去（此时也即admin.action），为了方便我们设定了两个ForwardAction：admin.action和user.action。这样便可以跳到指定的jsp页面。 原理：dyna.action执行后会继续把请求传递给下一个Action，而下一个Action的到底是哪一个Action，是通过DynaAction中动态指定的，比如这里是根据传递的username的值指定。

13.异常处理

步骤一、建立struts2exception项目下，在该项目下建立登录页面login.jsp。主要代码如下：

<form action="<%=request.getContextPath() %>/login.action">
        username:<input type="username" name="username"><br>
        <input type="submit" value="login">
</form>    

步骤二、建立LoginAction，代码如下：

package com.asm;
public class LoginAction extends ActionSupport {
    private String username;
    public String execute() throws Exception {
        if (username.equals("exception")) {
            throw new ClassNotFoundException("类未被找到");
        } else if (username.equals("global")) {
            throw new Exception("全局异常");
        } else {
            return SUCCESS;
        }
    }
    ...省力get/set方法
}

步骤三、struts.xml配置文件如下：

<struts>
    <package name="ex" extends="def">
        <action name="login" class="com.asm.LoginAction">
            <exception-mapping result="myException"
                exception="java.lang.ClassNotFoundException">
            </exception-mapping>
            <result name="myException">/exception.jsp</result>
            <result name="success">/main.jsp</result>
        </action>
    </package>

    <package name="def" extends="struts-default" abstract="true">
        <global-results>
            <result name="myGlobal">/globalException.jsp</result>
        </global-results>

        <global-exception-mappings>
            <exception-mapping result="myGlobal"
                exception="java.lang.Exception">
            </exception-mapping>
        </global-exception-mappings>
    </package>
</struts>

分析：

1.异常处理机制较为简单，所以在此只略作说明。当登录时输入“exception”时，在LoginAction中会抛出会一个ClassNotFoundException异常，此异常我们采取的局部异常处理的方式，如果登录时输入“globla”,则会抛出Exception异常，此异常我们采取的是全局异常的处理方式，

2.在ex包中我们继承了全局异常所在的包。提示：<exception-mapping>中的result属性的值来源于<result>元素中的name属性的值。从实例可以看出，我们一般把这种全局性的异常放在一个抽象包*其实包继承。

小结Action

在struts2中一个普通的java类只要有public String execute()这样的方法都可以配置成一个Action,另外我们可以实现Action接口来使java类成为一个Action，但通常的做法是继承ActionSupport类，这也是以后的项目中惯用的方法，也是推荐的首选方法。 与struts1.x不同的是：在struts2中每一个Action被请求访问时都会new出这个Action对象，所以Action本身不存在线程安全的问题。

项目代码：http://pan.baidu.com/s/1pJkfxnt