sturts2.2-annotation

从struts2.1开始，struts2不再推荐使用Codebehind作为零配置插件，而是改为使用Convention插件来支持零配置，和Codebehind相比，Convention插件更彻底，该插件完全抛弃配置信息，不仅不需要是使用struts.xml文件进行配置，甚至不需要使用Annotation进行配置，而是由struts2根据约定自动配置。

 

将[struts2-convention-plugin-2.2.3.jar]导入lib

struts.xml如下配置（Com.ustb.test.*/com.ustb.leo.*都将被视为含有Action的包路径而被搜索。）
----------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
       "-//Apache Software Foundation//DTD Struts Configuration2.0//EN"
       "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
 <constantname="struts.convention.package.locators" value="test,leo"/>
 <constantname="struts.convention.classes.reload" value="true"/>

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

 </package>
</struts>
----------------------------------

package leo.test;

import org.apache.struts2.convention.annotation.Namespace;
importorg.apache.struts2.convention.annotation.ParentPackage;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import com.opensymphony.xwork2.ActionSupport;

@Namespace("/")
@ParentPackage("default")
@Results({ @Result(name = "tagSelect", location ="/JSP/TagSelect.jsp"),
    @Result(name= "sshTest", location = "/JSP/SSHTestResult.jsp"),
})
public class MenuAction extends ActionSupport {

    privatestatic final long serialVersionUID = 6164665898354735604L;

    publicString execute() throws Exception {
       return SUCCESS;
    }

    publicString sshTest() throws Exception {
       return "sshTest";
    }
}

--------------------------------------------------------------------------------------------------

Strtus2 Convention Plugin 配置规则

 

1.官方介绍的地址：

http://struts.apache.org/2.1.6/docs/convention-plugin.html


2.struts.xml文件配置

只挑选几个重要的常量说明：

(1) <constant name="struts.locale"value="zh_CN"/>
     <constant name="struts.i18n.encoding"value="UTF-8"/>

     struts2.1.6现在只需要一个struts.xml文件就可以了。以前配struts.locale=zh_CN，struts.i18n.encoding＝UTF-8，应用起动时会报一个警告，说没有配置locale，必须要在struts.properties里面配置才不会报错，现在这个问题已经解决了，所有配置都可以在xml文件中指定了。


(2) <constant name="struts.action.extension"value="action,do,,"/>

     扩展名可以指定为空。这样地址栏比较好看。但也会有个问题，就是一些其他servlet映射，如cxf，我们会映射地址为/services/*，现在这个地址也变成struts2控制范围的地址了，如果按默认的配置会报找不到action的错误。解决办法是修改mapper类。这在以后文章中会提到。


(3) <constantname="struts.enable.DynamicMethodInvocation"value="true"/>
      <constant name="struts.enable.SlashesInActionNames"value="true"/>

     开启动态方法。要实现零配置，就是需要动态方法调用。开启action名称可以有“/”，一个请求地址有多个“/”，struts2就不会再使用类路径扫描的命名空间，只会使用配置的名称。所以既想action名称里使用“/”，又想用struts2默认搜索的命名空间，只能自己修改一下convention插件的实现类了。


(4) <constant name="struts.ui.theme"value="simple"/>

     不用dojo的及struts2复杂标签样式的就把主题设置为simple，这样可以不加载多余的模板。


(5) <constant name="struts.devMode"value="true"/>
     <constant name="struts.i18n.reload"value="true"/>
     <constant name="struts.configuration.xml.reload"value="true"/>
     <constant name="struts.convention.classes.reload"value="true" />

      开启开发者模式，在平时开发时修改action的annotation配置可以不重启，但是修改struts.xml文件还是要重启。修改类的具体内容，debug模式下可以不重启，或是使用javarebel，这个不在讨论范围。


(6) <constant name="struts.convention.result.path"value="/WEB-INF/pages/"/>

     指定结果页面路径。convention插件会自动在此路径中寻找文件。放到WEB-INF的目的的保护文件资源，只能通过程序内部跳转才能访问，我们的权限拦截器或其他权限处理只要加到action上就可以了。


(7) <constant name="struts.convention.action.suffix"value="Action"/>
    <constantname="struts.convention.action.name.lowercase"value="true"/>
    <constantname="struts.convention.action.name.separator"value="_"/>

    一个action名字的获取。比如为HelloWorldAction。按照配置，actionName为hello_world。


(8)<constantname="struts.convention.action.disableScanning"value="false"/>

    是否不扫描类。一定要设为false，否则convention插件不起作用，零配置也没有意义。


(9)<constantname="struts.convention.default.parent.package"value="default"/>

    设置默认的父包，一般我们都设置一个default包继承自struts-default。大部分类再继承default。如果有特殊的类需要特殊的包，只能在action中再指定父包了。


(10) <constantname="struts.convention.package.locators"value="action"/>
      <constantname="struts.convention.package.locators.disable"value="false"/>
      <constantname="struts.convention.package.locators.basePackage"value=""/>

　　　确定搜索包的路径。只要是结尾为action的包都要搜索。basePackage按照默认不用配置，如果配置，只会找以此配置开头的包。locators及locators.basePackage都是一组以逗号分割的字符串。


(11) <constantname="struts.convention.exclude.packages"value="org.apache.struts.*,org.apache.struts2.*,org.springframework.web.struts.*,org.springframework.web.struts2.*,org.hibernate."/>

　　　排除哪些包不搜索。按默认配置即可。逗号分割字符串。


(12) <constantname="struts.convention.action.includeJars" value=""/>

　　　包括哪些jar包中的action。逗号分割字符串。


(13)<constantname="struts.convention.relative.result.types"value="dispatcher,freemarker,velocity"/>

　　　默认返回的结果类型搜索。按顺序先找相关的dispatcher的jsp文件是否存在。然后再找freemarker，再找velocity。


(14)<constantname="struts.convention.result.flatLayout"value="true"/>

     如果此值设为true，如果一个action的命名空间为/login，名称为HelloWorldAction。result返回值是success，默认会找到/WEB-INF/pages/login/hello_world.jsp（如果有hello_world_success.jsp就找这个文件，连接符“_”是在<constantname="struts.convention.action.name.separator"value="_"/>中配置的）。如果有一个action的result返回值是“error”，就会找/WEB-INF/pages/login/hello_world_error.jsp。

     如果此值设为false，如果一个action的命名空间为/login，名称为HelloWorldAction。result返回值是success，默认会找到/WEB-INF/pages/login/hello_world/index.jsp（如果有success.jsp就找这个文件）。如果有一个action的result返回值是“error”，就会找/WEB-INF/pages/login/hello_world/error.jsp。


(15) <constantname="struts.convention.action.mapAllMatches"value="false"/>
      <constantname="struts.convention.action.checkImplementsAction"value="false"/>
　   <constantname="struts.mapper.alwaysSelectFullNamespace"value="false"/>
　   <constantname="struts.convention.redirect.to.slash"value="true"/>

     这几个配置没有太多的实际意义，本着最小检查的原则就可以。


(16)默认拦截器配置，已经简化了许多，一般不需要chain和fileupload。modelDriven也没什么用，如果我们要使用restfull插件会有用。其实最简单只要一个params就可以了。我加入exception是为了开发时的异常。servletConfig是为了包装一下request,reponse等对象，staticParams是为了可以配置${}形式参数。actionMappingParams是struts2.1新增的，我初步认为是可以在action配置中传参数，这个还有些疑问。


1.action配置

  按照第一篇中的配置，设置locator为action，则默认一个类的命名空间为：

              类路径                                            命名空间
com.example.action.MainAction        ->   /
com.example.action.products.Display->   /products

   完整url为：

               类路径                                                                                     完整url
com.example.action.MainAction                                      -> /main
com.example.action.products.Display                              -> /products/display
com.example.action.company.ShowCompanyDetailsAction-> /company/details/show_company_details



3.action类写法
   如果要实现基本零配置，命名空间和action名称按照默认的类路径搜索。默认执行方法是execute。方法返回值是success，就会找。

Java代码

1. package com.example.action;  
2.   
3. importcom.opensymphony.xwork2.ActionSupport;  
4.   
5. public class HelloWorldextendsActionSupport {  
6.   
7.     privateString message;  
8.   
9.     publicString getMessage() {  
10.         returnmessage;   
11.     }   
12.   
13.     publicString execute() {  
14.         message = "Hello World! excute";  
15.         returnSUCCESS;   
16.     }   
17.   
18.     publicString edit() {  
19.             message ="Hello World! edit";  
20.         return"xyz";  
21.     }   
22.   
23.     publicString delete() {  
24.         message = "Hello World! delete";  
25.         return"depp";  
26.     }   
27.   
28. }  

   返回结果对应：

              类路径                                  实际url(WEB-INF/pages)
/hello_world                                    /hello_world.jsp或/hello_world_success.jsp
/hello_world!edit                              /hello_world_xyz.jsp
/hello_world!delete                           /hello_world_depp.jsp

   基本的零配置就是这样，如果要有redirect、chain等跳转方式，interceptor的配置，就要加入annotation。


2.action类中的annotation

convention插件的annotation都在annotation这个包中，基本和xml配置相对应。

   annotation          意义                                                                       作用域
ParentPackage  指定继承的包(struts2)名                                             包，类
Namespaces     给一个action指定多个命名空间(一般不用)                     包，类
Namespace      指定一个命名空间(一般不用，按默认的类路径即可)        包，类，Namespaces注解中
actions             给一个action指定多个名称                                           方法
action              指定一个action名称                                                     类，方法，actions注解中
InterceptorRefs 一组拦截器集合(只能是名称，必须先在xml文件中配置好) 类，action注解中
InterceptorRef  一个拦截器                                                                 类，InterceptorRefs注解中
ResultPath       结果映射的路径(已经在struts.xml文件中指定)                包，类
Results            多个结果集合                                                              类，action注解中
Result             一个结果定义                                                               类，Results注解中

    需要注意：

1）包(java)级别是在package-info.java这个文件中配置，可以配置整个包的定义，但是命名空间就不能按默认的类路径扫描了，必须也要显式的配置。所以这个文件最好不要使用。

2）不在包(java)级别配置就要在类(java)级别配置，可能每个类都要写一句ParentPackage，指定继承的包(struts2)，以获得父包中的拦截器配置及其他公用配置。如果没有特殊的拦截器配置则不用配置ParentPackage。

3）最好把annotation配到类级别，因为这样action名称及命名空间都可用默认的类路径扫描，不用我们显式的配置。只要配置特殊的result和拦截器即可。类中的其他方法使用动态方法调用的方式使用同一个配置。我们知道struts2所有配置都是启动加载到map中的，减少配置，会提高一定性能。而动态方法这种模式是零配置必不可少的，但我很不喜欢叹号出现在地址栏中，所以在后面的文章中我会结合restful插件及自己修改源代码实现意义上的动态方法调用，但形式上是别的方式，地址栏会比较美观。

Java代码

1. package com.example.action;  
2.   
3. importcom.opensymphony.xwork2.ActionSupport;  
4. importorg.apache.struts2.convention.annotation.Result;  
5. importorg.apache.struts2.convention.annotation.Results;  
6. importorg.apache.struts2.convention.annotation.InterceptorRef;  
7. importorg.apache.struts2.convention.annotation.InterceptorRefs;  
8.   
9. @InterceptorRefs({  
10.     @InterceptorRef("interceptor-1"),  
11.     @InterceptorRef("defaultStack")  
12. })   
13. @Results({  
14.     @Result(name="reload",location="hello_world",type="redirectAction",params={key1,value1,key2,value2}),  
15.     @Result(name="chainact",location="hello_world!edit",type="chain")  
16. })   
17. public class HelloWorldextendsMyBaseAction {  
18.   
19.     privateString message;  
20.   
21.     publicString getMessage() {  
22.         returnmessage;   
23.     }   
24.   
25.     publicString execute() {  
26.         message = "Hello World! excute";  
27.         returnSUCCESS;   
28.     }   
29.   
30.     publicString edit() {  
31.             message ="Hello World! edit";  
32.         returnRELOAD;   
33.     }   
34.           
35.     publicString delete() {  
36.             message ="Hello World! delete";  
37.         returnCHAINACT;   
38.     }   
39. }  

4）如果有极其特殊的情况需要为action的每个方法单独配置，这时就不能用默认的类扫描了，必须是先配置action，指定名称，再在action中配置result和interceptor。这就会使配置增多，违背的零配置的初衷。有时我们为了性能原因想把拦截器细化到具体的action上，我想如果真是这样，我们还不如再写一个action类。还有struts2.1.6原有的配置是如果action名称中有“/”，会认为这是一个命名空间，不会再按照类扫描的默认值。例如：

Java代码

1. package com.example.action;  
2.   
3. importcom.opensymphony.xwork2.ActionSupport;  
4. importorg.apache.struts2.convention.annotation.Action;  
5.   
6. public class HelloWorldextendsActionSupport {  
7.   
8.     @Action("/different/url")  
9.     publicString execute() {  
10.         returnSUCCESS;   
11.     }   
12.   
13.     @Action("url")  
14.     publicString doSomething() {  
15.         returnSUCCESS;   
16.     }   
17. }  

   调用方法execute的url为:      /different/url (命名空间已经更换)
   调用方法doSomething的url为 :  /url

5）比较别扭的地方就是拦截器的配置，必须用名称，而名称和实际拦截器类的对应关系是在struts.xml文件中声明的，如果用struts2以前的annotation是可以直接配置拦截器类的，但是我没有和convention插件结合使用，这个问题我正在研究，看看有没有好的办法。

6）还有一种默认的chain跳转，实际是在struts2.1.6中新增的unknownHandleder中设定的，没有什么太大作用，我们可以不使用。而unknownHandleder我们可以自定义为其他，这在后面的文章中会有说明。

1.Convention插件的主要实现浅析

1.1 PackageBasedActionConfigBuilder 这个类最重要，是整个程序的入口。
    1.1.1buildActionConfigs方法进行初始化配置，其中findActions扫描类路径，我没有深入研究这个方法具体是怎么找到所有类的。只是找到全部类后，和我们的配置文件中限定的范围匹配、过滤，存入一个set中。然后buildConfiguration(set)循环分析这些类。

    1.1.2buildConfiguration方法，首先创建一个map类型的packageConfigs。键为包（struts2）名，值为PackageConfig.Builder对象，这个对象可以创建PackageConfig对象。
     然后循环找到的类，分析包名（java），determineActionNamespace方法分析命名空间，得到一个list对象。
     再循环所有命名空间，determineActionName方法分析类名称、类的默认方法（这个是写死在程序中的，就是execute方法）。
     getPackageConfig方法分析得到PackageConfig.Builder对象。
     getActionAnnotations方法分析得到action类方法的annotation配置。
     循环每个方法的配置，调用createActionConfig方法分析，把results，interceptors，exceptionMappings等配置放入ActionConfig.Builder对象，再把ActionConfig对象（由ActionConfig.Builder生成）放入PackageConfig.Builder中。
     buildIndexActions创建默认索引action。这个好像用处不大。
     最后把PackageConfig对象放入Configuration对象中，这是最顶级的配置。我们在任何时间和地点都可以得到Configuration对象，并对其进行分析。

    1.1.3  determineActionNamespace方法是确定一个action类在web应用中的命名空间，先找这个类的Namespace注解，找到后放入一个存储命名空间的list。再找Namespaces注解，一个action可以有多个命名空间。如果有注解则按照注解来确定一个action的命名空间，如果没有，则分析这个action所在包（java）的路径，按照struts2.xml中配置的规则来确定。这个规则就是截取到定义的locator，在这个locator之后的包（java）全部作为命名空间，类名作为action名称。

    1.1.4  determineActionName方法是确定一个action类在web应用中的名称。由ActionNameBuilder（接口）的方法来实现，这个接口的具体实现类，插件默认为SEOActionNameBuilder。被称为搜索引擎友好的名称。会把action类的name按单词分解，然后用连接符连起来。默认连接符是"-"，我们可以设置为"_"。

    1.1.5  getPackageConfig方法是确定一个action类在web应用中的继承的包（struts2）。先找这个类的ParentPackage注解，如果有注解则按照注解来确定一个action的父包（struts2），如果没有，按照struts.xml中配置的规则来确定。这个规则就是defaultParentPackage。得到父包（struts2）后要拼成：actionPackage + "#" + parentPkg.getName() + "#" + actionNamespace的形式，这是xwork里的规定。

    1.1.6  getActionAnnotations方法是确定一个action类的方法上的annotation配置。先找方法的Actions注解，一个方法可以有多个action映射。再找Action注解，放入一个map中，键是方法名，值是存储一组acton映射的list对象。
    
     1.1.7  createActionConfig方法构造ActionConfig.Builder对象，逐一判断interceptors，results，exceptionMappings，都是从类一级开始判断是否有此注解，再从方法的action注解中寻找。InterceptorMapBuilder，ResultMapBuilder是两个接口，提供通过注解构造Interceptor和Result的方法，插件分别提供了默认的实现DefaultInterceptorMapBuilder和DefaultResultMapBuilder。而buildExceptionMappings只是本类中的一个方法。

1.2 DefaultInterceptorMapBuilder
    先找action类是否存在InterceptorRefs注解，再看是否存在InterceptorRef注解，再看action注解中是否定义了InterceptorRefs。
    还用到了StringTools的createParameterMap方法把注解中的params（形式为{key1,value1,key2,value2,......}）转化成一个map。
     buildInterceptorList方法利用了xwork中的InterceptorBuilder的一个静态方法constructInterceptorReference把拦截器注入到配置中。
     而一个action所继承的父包中的拦截器，或是默认拦截器，并不在这个类中构造。而是由xwork根据包（struts2）的继承关系加载（actionPackage+ "#" + parentPkg.getName() + "#" + actionNamespace这是xwork里规定的形式，已经由PackageBasedActionConfigBuilder 配置）。

1.3 DefaultResultMapBuilder
    1.3.1build方法，确定defaultResultPath，构造包含ResultConfig的map对象，再通过扩展名获得一个包含ResultTypeConfig的map对象。createFromResources方法获得默认返回结果页面，然后查找action注解中的results配置，再找类级别的Results注解，再找类级别的Result注解，相同的肯定会覆盖。createFromAnnotations。

    1.3.2createFromResources方法中使用servletContext.getResourcePaths方法寻找页面。如果struts.xml中配置flatLayout为true则直接找到以命名空间为名称的文件夹，在此文件夹中寻找页面，如果flatLayout为false，则会找到以命名空间为名称的文件夹，再找到此文件夹中的以action名称命名的子文件夹，在这个文件夹中寻找页面。

    1.3.3makeResults方法找默认的返回页面，如果没有路径没有包含resultcode（定义的字符串）的页面，则按默认顺序寻找success，input，error。比如hello_world.jsp文件（flatLayout为true，连接符为"_"），如果没有hello_world_success.jsp，hello_world_input.jsp，hello_world_error.jsp文件，同时"success"，"input"，"error"，又没有显式的配置，只是作为结果字符串返回，则程序默认会用hello_world.jsp来匹配三种结果。如果结果字符串resultcode是"edit"，同时又没有显式的配置，则必会找hello_world_edit.jsp。

    1.3.4createFromAnnotations这个方法就是把注解转换成ResultConfig配置。

1.4 ConventionsServiceImpl
   是result配置的辅助类。determineResultPath方法先判断struts.xml文件中的配置，再判断action类的注解中是否有ResultPath，如果有将覆盖struts.xml中配置。
    getResultTypesByExtension方法提供一个map对象，默认的result结果返回。

     其实通过看这些方法，我们也基本了解了struts2的整个配置过程，非常繁琐，很多的判断确实很耗费资源，使用xml配置也一样。我们也知道所有配置信息都是应用启动时加载，存入map中常驻内存。所以我们应该尽可能减少配置，多使用动态方法调用。

1.5 ConventionUnknownHandler是UnknownHandler接口的一个实现，用来处理找不到相应配置的情况。在struts2.1的dtd中新增了一个<unknown-handler-stack>元素，可以配置一组handler。
      handleUnknownAction方法处理找不到action的情况。这个我感觉用处不大。
      handleUnknownResult方法处理找不到result的情况。这个方法可以有很多扩展。比如我想定义一种返回值形式：redirect->xxx.do?ad=12或chain->xxx.do。用这种形式比写注解要方便的多。
      handleUnknownActionMethod方法处理找不到action中方法的情况。这个默认没有实现。

  

--------------------------------------------------------------------------------------------------

 

4. 命名空间。从定义的.package.locators标示开始到包结束的部分，就是命名空间。举个例子：
Com.ustb.web.user.userAction的命名空间是：”/user”。Com.ustb.web.user.detail.UserAction的命名空间是：”/user/detail”
5.Convention通过如下规则确定URL的具体资源部分:去掉类名的Action部分。然后将将每个分部的首字母转为小写，用’-’分割，你可以设置struts.convention.action.name.separator如:

<constant name="struts.convention.action.name.separator" value="-" />

还是举个例子：
UserAction->user  UserDetailAction->user-detail。结合上面的。对于com.ustb.web.user.detail.UserDetailAction，映射的url就是/WEB-INF/content/user/detail/user-detail.jsp
6. struts支持.jsp .html .htm .vm格式的文件。
下面是actiong和结果模版的映射关系：
URLResult
File that could matchResult Type/hellosuccess/WEB-INF/content/hello.jspDispatcher/hellosuccess/WEB-INF/content/hello-success.htmDispatcher/hellosuccess/WEB-INF/content/hello.ftlFreeMarker/hello-worldinput/WEB-INF/content/hello-world-input.vmVelocity/test1/test2/helloerror/WEB-INF/content/test/test2/hello-error.htmlDispatcher

 

 

 

 

 

 

 

 

以上的内容来自struts2的文档http://struts.apache.org/2.1.6/docs/convention-plugin.html

 

当然，简单的通过默认的方式来进行配置不能完全满足实际项目的需要。所幸，convention的零配置是非常灵活的。
通过@Action注释
对如下例子：

   1. package com.example.web;  
   2.   
   3. import com.opensymphony.xwork2.Action;  
   4. import com.opensymphony.xwork2.ActionSupport;   
   5.   
   6. public class HelloAction extends ActionSupport {  
   7.     @Action("action1")  
   8.     public String method1() {  
   9.         return SUCCESS;  
  10.     }  
  11.   
  12.     @Action("/user/action2")  
  13.     public String method2() {  
  14.         return SUCCESS;  
  15. }  
  16. } 

方法名默认调用路径默认映射路径method1/hello!method1.action ./WEB-INF/content/hello.jspmethod2/hello!method2.action./WEB-INF/content/hello.jsp

通过@Action注释后

方法名@Action注释后调用路径@Action注释 后映射路径method1/action1!method1.action./WEB-INF/content/action1.jspmethod1/user/action2!method2.action/WEB-INF/content/user/action2.jsp

通过@Actions注释

   1. package com.example.web;  
   2.   
   3. import com.opensymphony.xwork2.ActionSupport;   
   4. import org.apache.struts2.convention.annotation.Action;  
   5. import org.apache.struts2.convention.annotation.Actions;  
   6.   
   7. public class HelloAction extends ActionSupport {  
   8.   @Actions({  
   9.     @Action("/different/url"),  
  10.     @Action("/another/url")  
  11.   })  
  12.   public String method1() {  
  13.     return “error”;  
  14.   }   

我们可以通过：/different/url!method1.action或/another/url!method1.action来调用method1 方法。
对应的映射路径分别是/WEB-INF/content/different/url-error.jsp;/WEB-INF/content/another/url-error.jsp

可能误导了大家，一个方法被@Action注释后，只是多了一种调用方式，而不是说覆盖了原来的调用方式。比如对于如下例子：

   1. package com.example.web;  
   2.   
   3. import com.opensymphony.xwork2.ActionSupport;   
   4. import org.apache.struts2.convention.annotation.Action;  
   5. import org.apache.struts2.convention.annotation.Actions;  
   6.   
   7. public class HelloAction extends ActionSupport {  
   8.   @Action("/another/url")  
   9.   public String method1() {  
  10.     return “error”;  
  11.   } 

我们调用method1方法可以通过两种方式：
1  /hello!method1.action映射url：/WEB-INF/content/hello-error.jsp
2 /another/url!method1.action映射url：/WEB-INF/content/another/url-error.jsp
可见，两种方式均可对method1方法进行调用，唯一的区别就是，两种调用的映射是不一样的，所以，想跳转到不同的界面，这是一个非常好的选择。

 

通过@Namespace 注释

   1. package com.example.web;  
   2.   
   3. import com.opensymphony.xwork2.ActionSupport;   
   4. import org.apache.struts2.convention.annotation.Action;  
   5. import org.apache.struts2.convention.annotation.Actions;  
   6. @Namespace("/other")  
   7. public class HelloWorld extends ActionSupport {  
   8.   
   9.   public String method1() {  
  10.     return “error”;  
  11.   }  
  12.     @Action("url")  
  13.   public String method2() {  
  14. return “error”;  
  15.   }  
  16.   
  17.     @Action("/different/url")  
  18.   public String method3() {  
  19. return “error”;  
  20.   }  
  21. } 

通过/other/hello-world!method1.action访问method1 方法。
通过 /other/url!method2.action访问method2方法
通过 /different/url!method3.action访问method3方法
与@Action 注释不同的是，该注释覆盖了默认的namespace(这里是’/’)，此时再用hello!method1.action已经不能访问method1 了.
@Results和@Result
1 全局的（global）。
全局results可以被action类中所有的action分享，这种results在action类上使用注解进行声明。

   1. package com.example.actions;  
   2.   
   3. import com.opensymphony.xwork2.ActionSupport;   
   4. import org.apache.struts2.convention.annotation.Action;  
   5. import org.apache.struts2.convention.annotation.Actions;  
   6. import org.apache.struts2.convention.annotation.Result;  
   7. import org.apache.struts2.convention.annotation.Results;  
   8.   
   9. @Results({  
  10.   @Result(name="failure", location="/WEB-INF/fail.jsp")  
  11. })  
  12. public class HelloWorld extends ActionSupport {  
  13.   public String method1() {  
  14.     return “failure”;  
  15.   }  
  16.     @Action("/different/url")  
  17.   public String method2() {  
  18.     return “failure”;  
  19.   }  
  20.   
  21. } 

当我们访问/hello-world!method1.action时，返回/WEB-INF/fail.jsp
当我们访问 /hello-world!method2.action时，返回/WEB-INF/fail.jsp
当我们访问 /different/url!method2.action时，返回/WEB-INF/fail.jsp

2 本地的（local）。
本地results只能在action方法上进行声明。

   1. package com.example.actions;  
   2.   
   3. import com.opensymphony.xwork2.ActionSupport;   
   4. import org.apache.struts2.convention.annotation.Action;  
   5. import org.apache.struts2.convention.annotation.Actions;  
   6. import org.apache.struts2.convention.annotation.Result;  
   7. import org.apache.struts2.convention.annotation.Results;  
   8.   
   9. public class HelloWorld extends ActionSupport {  
  10.     @Action(value="/other/bar",results={@Result(name = "error", location = "www.baidu.com",type="redirect")})  
  11.   public String method1() {  
  12.     return “error”;  
  13.   }  
  14. }   

当我们调用/hello-world!method1.action时，返回/WEB-INF/content/hello-error.jsp
当我们调用/other/bar!method1.action时，返回 www.baidu.com