Xml代码

1. <dependency>  
2.   <groupId>org.apache.struts</groupId>  
3.   <artifactId>struts2-convention-plugin</artifactId>  
4.   <version>2.1.6</version>  
5. </dependency>  

<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-convention-plugin</artifactId>
<version>2.1.6</version>
</dependency>

零配置并不是没有配置，而是通过约定大于配置的方式，大量通过约定来调度页面的跳转而使得配置大大减少。所以，首先应该了解下convention-plugin的约定：
1. 默认所有的结果页面都存储在WEB-INF/content下，你可以通过设置struts.convention.result.path这个属性的值来改变到其他路径。如：

Xml代码

1. <constant name="struts.convention.result.path" value="/WEB-INF/page" />  

<constant name="struts.convention.result.path" value="/WEB-INF/page" />

则将路径配置到了WEB-INF/page 下。
2. 默认包路径包含action,actions,struts,struts2的所有包都会被struts作为含有Action类的路径来搜索。你可以通过设置struts.convention.package.locators属性来修改这个配置。如：

Xml代码

1. <constant name="struts.convention.package.locators" value="web,action" />  

<constant name="struts.convention.package.locators" value="web,action" />

则定义了在项目中，包路径包含web和action的将被视为Action存在的路径来进行搜索。
Com.ustb.web.*/com.ustb.action.*都将被视为含有Action的包路径而被搜索。
3. 接着，Convention从前一步找到的package以及其子package中寻找 com.opensymphony.xwork2.Action 的实现以及以Action结尾的类：

Java代码

1. com.example.actions.MainAction   
2. com.example.actions.products.Display (implements com.opensymphony.xwork2.Action)   
3. com.example.struts.company.details.ShowCompanyDetailsAction  

com.example.actions.MainAction
com.example.actions.products.Display (implements com.opensymphony.xwork2.Action)
com.example.struts.company.details.ShowCompanyDetailsAction

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 如

Xml代码

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

<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和结果模版的映射关系：

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

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

Java代码

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

package com.example.web;
import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionSupport;
public class HelloAction extends ActionSupport {
@Action("action1")
public String method1() {
return SUCCESS;
}
@Action("/user/action2")
public String method2() {
return SUCCESS;
}
}

通过@Action注释后

通过@Actions注释

Java代码

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

package com.example.web;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Actions;
public class HelloAction extends ActionSupport {
@Actions({
@Action("/different/url"),
@Action("/another/url")
})
public String method1() {
return “error”;
}

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

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

Java代码

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

package com.example.web;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Actions;
public class HelloAction extends ActionSupport {
@Action("/another/url")
public String method1() {
return “error”;
}

我们调用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 注释

Java代码

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

package com.example.web;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Actions;
@Namespace("/other")
public class HelloWorld extends ActionSupport {
public String method1() {
return “error”;
}
@Action("url")
public String method2() {
return “error”;
}
@Action("/different/url")
public String method3() {
return “error”;
}
}

通过 /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类上使用注解进行声明。

Java代码

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

package com.example.actions;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Actions;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
@Results({
@Result(name="failure", location="/WEB-INF/fail.jsp")
})
public class HelloWorld extends ActionSupport {
public String method1() {
return “failure”;
}
@Action("/different/url")
public String method2() {
return “failure”;
}
}

当我们访问 /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方法上进行声明。

Java代码

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

package com.example.actions;
import com.opensymphony.xwork2.ActionSupport;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Actions;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
public class HelloWorld extends ActionSupport {
@Action(value="/other/bar",results={@Result(name = "error", location = "www.baidu.com",type="redirect")})
public String method1() {
return “error”;
}
}

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

首先我们来看看如何搭建最简单的J2EE项目的开发环境。

1. 我们需要建立的一个空的J2EE项目的目录结构



在这里，我简单解释一下这些目录的作用：

src(source folder)：存放所有的Java源代码。
conf(source folder)：存放所有的配置文件。
test(source folder)：存放所有的Java测试代码和调试代码。
web：web项目的根目录，下面有WEB-INF目录以及在此之下的classes和lib目录。classes目录将会成为所有的source folder的编译对象目录，而lib目录则存放项目所依赖的jar包。
lib：也存放jar包，这些jar包可能仅仅在开发调试时依赖，项目本身则不依赖这些jar文件。

2. 编写IDE相关的文件

在这里，你还能看到classpath文件和project文件。这两个文件是导入到eclipse中所必须的文件，是我为eclipse工程而写的文件。如果你使用其他IDE，可能需要自行编辑与其他IDE相关的项目文件。

在建立了这些目录结构后，你就可以将其导入到eclipse中作为eclipse的工程了。



3. 加入相关调试所需要的jar包，并指定classpath

接下来，我们把Jetty所需要的jar包copy到lib目录下，并在IDE中指定classpath。



4. 添加Jetty启动类

在test下建一个runtime的目录，并添加Jetty启动类。

Java代码

1. package runtime;  
2.   
3. import org.mortbay.jetty.Connector;  
4. import org.mortbay.jetty.Server;  
5. import org.mortbay.jetty.nio.SelectChannelConnector;  
6. import org.mortbay.jetty.webapp.WebAppContext;  
7.   
8. /** 
9.  * Jetty Server starter. Use embedded mode. 
10.  *  
11.  * @author Downpour 
12.  */  
13. public class JettyStarter {  
14.   
15.     /** 
16.      * @param args 
17.      * @throws Exception 
18.      */  
19.     public static void main(String[] args) throws Exception {  
20.         long begin = System.currentTimeMillis();  
21.         Connector connector = new SelectChannelConnector();  
22.         connector.setPort(Integer.getInteger("jetty.port", 8080).intValue());  
23.   
24.         WebAppContext webapp = new WebAppContext("web", "/struts-sample");  
25.         webapp.setDefaultsDescriptor("./test/runtime/webdefault.xml");  
26.           
27.         Server server = new Server();  
28.         server.setConnectors(new Connector[] { connector });  
29.         server.setHandler(webapp);  
30.         server.start();  
31.         System.out.println("Jetty Server started, use " + (System.currentTimeMillis() - begin) + " ms");  
32.     }  
33. }  

package runtime;
import org.mortbay.jetty.Connector;
import org.mortbay.jetty.Server;
import org.mortbay.jetty.nio.SelectChannelConnector;
import org.mortbay.jetty.webapp.WebAppContext;
/**
* Jetty Server starter. Use embedded mode.
*
* @author Downpour
*/
public class JettyStarter {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
long begin = System.currentTimeMillis();
Connector connector = new SelectChannelConnector();
connector.setPort(Integer.getInteger("jetty.port", 8080).intValue());
WebAppContext webapp = new WebAppContext("web", "/struts-sample");
webapp.setDefaultsDescriptor("./test/runtime/webdefault.xml");
Server server = new Server();
server.setConnectors(new Connector[] { connector });
server.setHandler(webapp);
server.start();
System.out.println("Jetty Server started, use " + (System.currentTimeMillis() - begin) + " ms");
}
}

如果此时，你在WEB-INF下有web.xml，那么你就可以执行上面这个Jetty的启动类。



5. 启动、调试、测试

执行了Jetty的启动类后，可以看到启动界面的日志：

Java代码

1. 15 [main] INFO org.mortbay.log - Logging to org.slf4j.impl.SimpleLogger(org.mortbay.log) via org.mortbay.log.Slf4jLog  
2. 15 [main] INFO org.mortbay.log - jetty-6.1.7  
3. 1109 [main] INFO org.mortbay.log - Started SelectChannelConnector@0.0.0.0:8080  
4. Jetty Server started, use 1547 ms  

15 [main] INFO org.mortbay.log - Logging to org.slf4j.impl.SimpleLogger(org.mortbay.log) via org.mortbay.log.Slf4jLog
15 [main] INFO org.mortbay.log - jetty-6.1.7
1109 [main] INFO org.mortbay.log - Started SelectChannelConnector@0.0.0.0:8080
Jetty Server started, use 1547 ms

这表示你已经成功启动了Jetty作为你的Web服务器。当然，你可以使用Debug模式来执行Jetty类，这样就进入了调试模式，你可以在代码中设置断点进行调试。

在这里，还有一点需要简单提一下，默认情况下，Jetty会在windows上使用缓存，所以会把js，css等文件进行锁定，使你无法编辑。为了解决这个问题，需要设置一些默认参数。这里，我们可以使用google大法，已经有朋友为我们解决了这个问题：

http://www.blogjava.net/alwayscy/archive/2007/05/27/120305.html

所以，我在runtime的同级目录建立了一个webdefault.xml文件，并且指定Jetty使用该文件作为默认的参数设定。

【小结】
在上面我介绍了我个人的开发调试环境，这种开发环境的好处可能有一下这些：

1. 开发环境不依赖于任何IDE或者相关的插件，只需要运行Java文件即可进行调试。（当然，你可能需要编写IDE相关的project文件来获取IDE的工程支持）

2. 开发环境不依赖于任何外部的Web服务器，与环境无关，所以无论将项目迁移到哪里，都可以直接运行。

3. 不需要开发人员额外学习如何搭建开发环境，开发环境已经内置，降低了开发人员的学习成本。

完善Library的管理方式

在上面搭建环境的过程中，我们发现，Library的管理存在着一定问题。这个问题主要表现为：

1. 不容易做Library的版本管理。如果Library的版本需要升级，那么我们不得不重新copy一份新的jar包，并且借助IDE重新指定项目的 classpath。这种劳动，对于一个项目还可以接受，如果你有10多个项目，那么jar包的复制工作会让你很头疼。

2. 每个项目都会有Library的副本。这一点让人非常恼火。实际上，对于一个公司或者一个项目组而言，使用的技术体系基本不变。然而，每个项目的 Library却是分开的。不仅如此，每个项目都要从svn中下载大量的相同的Library文件，给我们的硬盘造成极大的空间浪费。对于那些频繁使用 Branch的项目来说，这些Library的下载简直就是噩梦。

所以，我们需要一个集中式的Library管理方式。而这一点曾经在Javaeye的海阔天空版激烈得讨论过使用maven来进行管理还是自行管理。

Readonly 写道

共享类库可以用IDE reference project解决，公司内部项目给常用的lib建立一个project，从CVS上check out，其他工程项目都依赖这个project就可以了，ant build也直接引用这个项目的jar就可以，项目体积照样只有几百K。

——一个讨厌ant，更加讨厌maven的人

我比较赞同Readonly老大的说法而倾向于自行管理。maven这样的高级货，偶实在是用不来啊。那么我们就来看看如何使用共享类库来进行Library管理。


1. 首先建立一个共享类库

建立一个共享类库，将项目中需要共享的Library进行恰当的分类。同时，为每个加入到Library中的jar包进行统一的格式化的命名方 式。例如：spring/spring-2.5.5.jar等等。这样的好处在于，一旦jar包的版本有更新，可以加入新的jar包而保留原来的。在项目 中，就可以通过引用不同版本的jar包来对Library进行版本管理。

以下就是我个人建立的一个共享类库，大家可以参考：

svn://www.demo2do.com/library

2. checkout共享类库，并将其导入到IDE中作为一个Library工程



3. 为你的项目指定classpath，引用的jar包存在于Library工程中



在这里，我们可以看到，原来项目中的lib目录被删除，jar包也被删除。在项目中所引用的jar包是Library项目中的jar包。

【小结】
完成了上述所有的步骤之后，Library就被集中管理起来，而每个项目也不会再变得那么庞大。当然，开发环境的搭建完全取决于个人的习惯，所以使用各自喜欢的方式吧，不要让环境问题束缚你们的手脚。

转自：http://www.javaeye.com/wiki/struts2/1321-struts2-development-environment-to-build

Java代码

1.        
2.     <!-- Struts Filter -->   
3. <filter>   
4.     <filter-name>struts</filter-name>   
5.     <filter-class>com.demo2do.lighturl.LightURLFilter</filter-class>   
6. </filter>   
7.   
8. <!-- Struts URL Definition -->   
9. <filter-mapping>   
10.     <filter-name>struts</filter-name>   
11.     <url-pattern>/*</url-pattern>   
12. </filter-mapping>      

<!-- Struts Filter -->
<filter>
<filter-name>struts</filter-name>
<filter-class>com.demo2do.lighturl.LightURLFilter</filter-class>
</filter>
<!-- Struts URL Definition -->
<filter-mapping>
<filter-name>struts</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

Java代码

1. ## action package config   
2. lighturl.action.packages=com.demo2do.lighturl.action   
3.   
4. ## action mapping implementation class  
5. struts.mapper.class=com.demo2do.lighturl.LightURLActionMapper   
6.   
7. ## default parent package  
8. lighturl.action.default.parent.package=struts-config   
9.   
10. ## define your entity package (optional)   
11. # lighturl.entity.package=com.demo2do.lighturl.entity  

## action package config
lighturl.action.packages=com.demo2do.lighturl.action
## action mapping implementation class
struts.mapper.class=com.demo2do.lighturl.LightURLActionMapper
## default parent package
lighturl.action.default.parent.package=struts-config
## define your entity package (optional)
# lighturl.entity.package=com.demo2do.lighturl.entity

Java代码

1. lighturl.action.packages=com.demo2do.lighturl.action  

lighturl.action.packages=com.demo2do.lighturl.action

• com.demo2do.lighturl.action.Index  ----> /
• com.demo2do.lighturl.action.user.Search ----> /user
• com.demo2do.lighturl.action.blog.category.Index ----> /blog/category
• com.demo2do.lighturl.action.accoutDetail.View ----> /account-detail

• com.demo2do.lighturl.action.Index ----> index
• com.demo2do.lighturl.action.user.SearchAction ----> search
• com.demo2do.lighturl.action.blog.CategoryBlog ----> category-blog

• http://host:port/app/user/index ---> com.demo2do.lighturl.action.user.Index
• http://host:port/app/blog/category-blog ---> com.demo2do.lighturl.action.blog.CategoryBlog

• com.demo2do.lighturl.action.Index ---> http://host:port/app/
• com.demo2do.lighturl.action.user.Index ---> http://host:port/app/user
• com.demo2do.lighturl.action.blog.category.Index ---> http://host:port/app/blog/category

• com.demo2do.lighturl.action.user.View ---> http://host:port/app/user/3456
• com.demo2do.lighturl.action.blog.View ---> http://host:port/app/user/1113

Java代码

1. package com.demo2do.lighturl.action.user;   
2.   
3. import com.demo2do.lighturl.annotation.Action;   
4. import com.opensymphony.xwork2.ActionSupport;   
5.   
6. /**  
7.  * @author Downpour  
8.  *  
9.  */  
10. public class Search extends ActionSupport {   
11.        
12.     private static final long serialVersionUID = -1728616675239859226L;   
13.   
14.     /* (non-Javadoc)  
15.      * @see com.opensymphony.xwork2.ActionSupport#execute()  
16.      */  
17.     @Override  
18.     @Action("/all/search-user")   
19.     public String execute() throws Exception {   
20.         return super.execute();   
21.     }   
22.   
23. }  

package com.demo2do.lighturl.action.user;
import com.demo2do.lighturl.annotation.Action;
import com.opensymphony.xwork2.ActionSupport;
/**
* @author Downpour
*
*/
public class Search extends ActionSupport {
private static final long serialVersionUID = -1728616675239859226L;
/* (non-Javadoc)
* @see com.opensymphony.xwork2.ActionSupport#execute()
*/
@Override
@Action("/all/search-user")
public String execute() throws Exception {
return super.execute();
}
}

Java代码

1. package com.demo2do.lighturl.action.blog;   
2.   
3. import com.demo2do.lighturl.annotation.Action;   
4. import com.opensymphony.xwork2.ActionSupport;   
5.   
6. /**  
7.  * @author Downpour  
8.  *  
9.  */  
10. public class Category extends ActionSupport {   
11.   
12.     private static final long serialVersionUID = -1535992103374733252L;   
13.   
14.         private Long id;   
15.        
16.     private int year;   
17.        
18.     private int month;   
19.        
20.     private int day;   
21.   
22.     /* (non-Javadoc)  
23.      * @see com.opensymphony.xwork2.ActionSupport#execute()  
24.      */  
25.     @Override  
26.     @Action("/blogs/${year}/${month}/${day}")   
27.     public String execute() throws Exception {   
28.         return super.execute();   
29.     }   
30.            
31.         @Action("/blog/${id}/edit")   
32.     public String edit() throws Exception {   
33.         return super.execute();   
34.     }   
35.         // setters and getters   
36.        
37. }  

package com.demo2do.lighturl.action.blog;
import com.demo2do.lighturl.annotation.Action;
import com.opensymphony.xwork2.ActionSupport;
/**
* @author Downpour
*
*/
public class Category extends ActionSupport {
private static final long serialVersionUID = -1535992103374733252L;
private Long id;
private int year;
private int month;
private int day;
/* (non-Javadoc)
* @see com.opensymphony.xwork2.ActionSupport#execute()
*/
@Override
@Action("/blogs/${year}/${month}/${day}")
public String execute() throws Exception {
return super.execute();
}
@Action("/blog/${id}/edit")
public String edit() throws Exception {
return super.execute();
}
// setters and getters
}

Java代码

1. package com.demo2do.lighturl.action.user;   
2.   
3. import com.demo2do.lighturl.entity.User;   
4. import com.opensymphony.xwork2.ActionSupport;   
5.   
6. /**  
7.  * @author Downpour  
8.  *  
9.  */  
10. public class Index extends ActionSupport {   
11.   
12.     private static final long serialVersionUID = -5017825114664788765L;   
13.   
14.     private User user;   
15.        
16.     /* (non-Javadoc)  
17.      * @see com.opensymphony.xwork2.ActionSupport#execute()  
18.      */  
19.     @Override  
20.     public String execute() throws Exception {   
21.         return "j:user";   
22.     }   
23.   
24.         // setters and getters   
25. }  

package com.demo2do.lighturl.action.user;
import com.demo2do.lighturl.entity.User;
import com.opensymphony.xwork2.ActionSupport;
/**
* @author Downpour
*
*/
public class Index extends ActionSupport {
private static final long serialVersionUID = -5017825114664788765L;
private User user;
/* (non-Javadoc)
* @see com.opensymphony.xwork2.ActionSupport#execute()
*/
@Override
public String execute() throws Exception {
return "j:user";
}
// setters and getters
}

Java代码

1. package com.demo2do.lighturl.action.user;   
2.   
3. import com.demo2do.lighturl.entity.User;   
4. import com.opensymphony.xwork2.ActionSupport;   
5.   
6. /**  
7.  * @author Downpour  
8.  *  
9.  */  
10. public class Index extends ActionSupport {   
11.   
12.     private static final long serialVersionUID = -5017825114664788765L;   
13.   
14.     private User user;   
15.        
16.     /* (non-Javadoc)  
17.      * @see com.opensymphony.xwork2.ActionSupport#execute()  
18.      */  
19.     @Override  
20.     public String execute() throws Exception {   
21.         return "r:/user/add-user";   
22.     }   
23.   
24.         // setters and getters   
25. }  

package com.demo2do.lighturl.action.user;
import com.demo2do.lighturl.entity.User;
import com.opensymphony.xwork2.ActionSupport;
/**
* @author Downpour
*
*/
public class Index extends ActionSupport {
private static final long serialVersionUID = -5017825114664788765L;
private User user;
/* (non-Javadoc)
* @see com.opensymphony.xwork2.ActionSupport#execute()
*/
@Override
public String execute() throws Exception {
return "r:/user/add-user";
}
// setters and getters
}

Java代码

1. lighturl.result.code.config=yourpackage.ResultCodeConfigImpl1,yourpackage.ResultCodeConfigImpl2  

lighturl.result.code.config=yourpackage.ResultCodeConfigImpl1,yourpackage.ResultCodeConfigImpl2

但是，正所谓“没有最好，只有更好”，Struts1.x自身也有不少的缺点：需要编写的代码过多，容易引起“类爆炸”、单元测试困难。这些缺点随着Web的发展越来越明显。这就促生了Struts 2，它的诞生能很好的解决上述问题。

在本文中，笔者将对Struts2和Struts1.x这两种框架进行详细的比较。比较将涉及到这两种框架的Action、验证、类型转换及如何开发等方面的内容。希望通过这样的比较，让读者了解这两种框架各自的特点，以便于在自己的项目中，根据实际情况，尽快的过渡到Struts2的时代。本文的内容基于Struts2.0.6。

一、       引言

Struts的第一个版本是在2001年5月份发布的。它的最初设想是通过结合JSP和Servlet，使Web应用的视图和业务/应用逻辑得以清晰地分离开来。在Struts之前，最常见的做法是在JSP中加入业务和应用逻辑，或者在Servlet中通过println()来生成视图。

自从第一版发布以来，Struts实际上已成为业界公认的Web应用标准。它的炙手可热也为自己带来了改进和变更，所以不但要跟上对Web应用框架不断变化的需求，而且要与日渐增多竞争激烈的众多框架的特性相融合。

到最后，产生了几个下一代Struts的解决方案。其中两个最受瞩目的方案是Shale和Struts Ti。Shale是一个基于构件的框架，并在最近成为Apache的顶级项目。而Struts Ti则是在Struts的成功经验基础上继续坚持对前端控制器（Front Controller）和MVC（model-view-controller）模式进行改进。

WebWork项目是在2002年3月发布的，它对Struts式框架进行了革命性改进，引进了不少新的思想、概念和功能，但和原Struts代码并不兼容。WebWork是一个成熟的框架，经过了好几次重大的改进与发布。

在2005年12月，WebWork与Struts Ti宣布合并。与此同时，Struts Ti改名为Struts Action Framework 2.0，成为Struts真正的继承者。

最后要注意的是，并不是说Struts或WebWork项目已经停止开发了。由于人们对这两个项目的兴趣仍然很高，而且也有很多开发者仍然愿意使用它们，因此这两个项目还在继续开发中，继续修复Bug，改进功能和继续添加新功能。

二、       Action的区别

对于有着丰富的Struts1.x开发经验的朋友来说，都十分的清楚Action是整个Struts框架的核心内容，当然Struts2也不例外。不过，Struts1.x与Struts2的Action模型很大的区别。

Struts2和Struts1.x的差别，最明显的就是Struts2是一个pull-MVC架构。这是什么意思呢？从开发者角度看，就是说需要显示给用户的数据可以直接从Action中获取，而不像Struts1.x那样，必须把相应的Bean存到Page、Request或者Session中才能获取。Struts1.x 必须继承org.apache.struts.action.Action或者其子类，表单数据封装在FormBean中。Struts 2无须继承任何类型或实现任何接口，表单数据包含在Action中，通过Getter和Setter获取（如下面的ActionForStruts2的代码示例）。

虽然，在理论上Struts2的Action无须实现任何接口或者是继承任何的类，但是，在实际编程过程中，为了更加方便的实现Action，大多数情况下都会继承com.opensymphony.xwork2.ActionSupport类，并且重载（Override）此类里的String execute()方法。如下所示：

package ActionDiffer;

 import java.text.DateFormat;

 import java.util.Date;

 import com.opensymphony.xwork2.ActionSupport;

 public class ActionForStruts2 extends ActionSupport {

     private String message;

     public String getMessage() {

         return message;

    }

    @Override

     public String execute() {

        message = " This is hello from strtuts2. Now is: " + DateFormat.getInstance().format( new Date());

         return SUCCESS;

    }

}

首先，从ActionForStruts2可以看出，返回的对象不是ActionForward，而是String。如果你不喜欢以字符串的形式出现在你的代码中，有个Helper接口Action可以以常量方式提供常见结果，如“success”、“none”、“error”、“input”和“login”。

另外， 按照惯例，在Struts1.x中只有“execute”方法能调用Action,　但在Struts2中并非必要，任何声明为public String methodName() 方法，都能通过配置来调用Action。

最后，和Struts1.x最大的革命性的不同是，Struts2处理Action过程中调用的方法（“execute”方法）是不带参数的。那如何获取所需要的对象呢？答案是使用IoC（反转控制，Inversion of Control)，也叫“依赖注入（Dependency Injection）”的模式（想更多地了解这方面信息请看Martin Fowler的文章http://www.martinfowler.com/articles/injection.html）。Spring框架使得这个模式流行起来，然而Struts2的前身（WebWork）也同时应用上了这个模式。

三、       IoC

IoC(Inversion of Control，以下译为控制反转），随着Java社区中轻量级容器（Lightweight Contianer）的推广而越来越为大家耳熟能详。在此，无需再多费唇舌来解释“什么是控制反转”和“为什么需要控制反转”。因为互联网上已经有非常多的文章对诸如此类的问题作了精彩而准确的回答。读者可以去读一下Rod Johnson和Juergen Hoeller合著的《Expert one-on-one J2EE Development without EJB》或Martin Fowler所写的《Inversion of Control Containers and the Dependency Injection pattern》。

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

为了更好地了解反转控制，下面来看一个例子，如何利用IoC在Action处理过程中可以访问到当前请求HttpServerRequest对象。

在例子中，使用的依赖注入机制是接口注入。就如其名称一样，接口注入需要的是已经被实现了的接口。这个接口包含了相应属性的setter，为Action提供值。例子中使用了ServletRequestAware接口，如下：

public interface ServletRequestAware {
    public void setServletRequest(HttpServletRequest request);
}

当继承这个接口后，原本简单的Action看起来有点复杂了，但是这时可以获取HttpServerRequest对象来使用了。

public class IoCForStruts2 implements ServletRequestAware {
   private HttpServletRequest request;
   public void setServletRequest(HttpServletRequest request) {
        this.request = request;
   }
   public String execute() throws Exception {
        // 可以开始使用request对象进行工作了
        return Action.SUCCESS;
   }
}

看起来现在这些属性是类级别的，并不是线程安全的，会出现问题。其实在Struts2里并没有问题，因为每个请求过来的时候都会产生一个新的Action对象实例，它并没有和其他请求共享一个对象，所以不需要考虑线程安全问题。

四、       拦截器

Interceptor（以下译为拦截器），在AOP（Aspect-Oriented Programming）中用于在某个方法或字段被访问之前，进行拦截然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。

在Webwork的中文文档的解释为——拦截器是动态拦截Action调用的对象。它提供了一种机制可以使开发者定义在一个action执行的前后执行的代码，也可以在一个action执行前阻止其执行。同时也提供了一种可以提取action中可重用的部分的方式。

Struts1.x的标准框架中不提供任何形式的拦截器，虽一个名为SAIF的附加项目则实现了这样的功能，但它的适用的范围还很有限。

拦截器是Struts2的一个强有力的工具，有许多功能（feature）都是构建于它之上，如国际化、转换器，校验等。谈到拦截器，还有一个流行的词——拦截器链（Interceptor Chain，在Struts2中称为拦截器栈Interceptor Stack）。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。

Struts 2的拦截器实现相对比较简单。当请求到达Struts2的ServletDispatcher时，Struts 2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后串成一个列表（list），最后一一地调用列表中的拦截器，如图1所示。

拦截器调用序列器

Struts 2已经提供丰富多样功能齐全的拦截器实现。读者可以到struts2-all-2.0.6.jar或struts2-core-2.0.6.jar包的struts-default.xml查看关于默认的拦截器与拦截器链的配置。

作为“框架（framework）”，可扩展性是不可缺少的，因为世上没有放之四海而皆准的东西。虽然，Struts 2为我们提供如此丰富的拦截器实现，但是这并不意味我们失去创建自定义拦截器的能力，恰恰相反，在Struts 2自定义拦截器是相当容易的一件事。

五、       Struts2和Struts1.x的全面比较

为了对Struts2和Strtus1.x进行全面的比较，让读者了解这两种框架各自的优缺点，以便于在自己的项目中，根据实际情况，选择合适的框架，对它们两者进行比较，总结了如下表分析比较。

六、       结论

前面已经简要介绍了Struts2的起源，并详细对比了Struts2和Struts1.x的差异，读者应该对Struts2的基础有所了解了——包括高层的框架概念和基础的请求流程，并理解Struts1.x和Struts2两者之间在Action方面的差别，Struts2加强了对拦截器与IoC的支持，而在Struts1.x中，这些特性是很难想象的。

同时，读者应该明白：Struts2是WebWork的升级，而不是Struts 1.x的升级。虽然Struts 2提供了与Struts1.x的兼容，但已经不是Struts1.x的升级。对于已有Struts1.x开发经验的开发者而言，Struts1.x的开发经验对于Struts2并没有太大的帮助；相反，对于已经有WebWork开发经验的开发者而言，WebWork的开发经验对Struts2的开发将有很好的借鉴意义。

这一招在一些特殊的场合下非常管用．比如说，用户在第一个页面，选择了某个实体其中要显示出来的几个属性，那个这个时候用反射是非常不错的选择，少了大量 if 语句：

Java代码

1. package com.leo.util;   
2.   
3. import java.lang.reflect.Method;   
4.   
5. public class HelloWorldBean {   
6.   
7.     private String word;   
8.   
9.     private String name;   
10.   
11.     public String getName() {   
12.         return name;   
13.     }   
14.   
15.     public void setName(String name) {   
16.         this.name = name;   
17.     }   
18.   
19.     public String getWord() {   
20.         return word;   
21.     }   
22.   
23.     public void setWord(String word) {   
24.         this.word = word;   
25.     }   
26.   
27.     public HelloWorldBean() {   
28.         name = "superleo";   
29.         word = "Hello World!!!";   
30.     }   
31.   
32.     public String getProperty(String name) throws Exception {   
33.         if (name != null && !name.equals("")) {   
34.             Character ch = name.charAt(0);   
35.             name = Character.toUpperCase(ch) + name.substring(1, name.length());   
36.             Class cls = Class.forName("com.leo.util.HelloWorldBean");   
37.             Method meth = cls.getMethod("get" + name, null);   
38.             Object retobj = meth.invoke(this, null);   
39.             return (String) retobj;   
40.   
41.         }   
42.         throw new RuntimeException();   
43.     }   
44.   
45.     public static void main(String[] args) throws Exception {   
46.         HelloWorldBean bean = new HelloWorldBean();   
47.         bean.setName("superleo");   
48.         bean.setWord("name");   
49.         System.out.println(bean.getProperty("name"));   
50.         System.out.println(bean.getProperty("word"));   
51.     }   
52.   
53. }  

package com.leo.util;
import java.lang.reflect.Method;
public class HelloWorldBean {
private String word;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getWord() {
return word;
}
public void setWord(String word) {
this.word = word;
}
public HelloWorldBean() {
name = "superleo";
word = "Hello World!!!";
}
public String getProperty(String name) throws Exception {
if (name != null && !name.equals("")) {
Character ch = name.charAt(0);
name = Character.toUpperCase(ch) + name.substring(1, name.length());
Class cls = Class.forName("com.leo.util.HelloWorldBean");
Method meth = cls.getMethod("get" + name, null);
Object retobj = meth.invoke(this, null);
return (String) retobj;
}
throw new RuntimeException();
}
public static void main(String[] args) throws Exception {
HelloWorldBean bean = new HelloWorldBean();
bean.setName("superleo");
bean.setWord("name");
System.out.println(bean.getProperty("name"));
System.out.println(bean.getProperty("word"));
}
}

OK ，假设我们在 HelloAction 使用了这个 HelloWorldBean ，并且运行后，跳转到相应页面，你可以这样去取 HelloWorldBean 的 word 和 name 属性了：

Html代码

1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
2. <%@ taglib prefix="s" uri="/struts-tags"%>  
3. <html>  
4.     <body>  
5.         <h3>  
6.             正常方法：<s:property value="helloWorld.name" /> <br />  
7.             <s:property value="helloWorld.word" /> <br />  
8.             反射方法：<s:property value="helloWorld.getProperty('name')" /> <br />  
9.             <s:property value="helloWorld.getProperty('word')" />  
10.         </h3>  
11.     </body>  
12. </html>  

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<html>
<body>
<h3>
正常方法：<s:property value="helloWorld.name" /> <br />
<s:property value="helloWorld.word" /> <br />
反射方法：<s:property value="helloWorld.getProperty('name')" /> <br />
<s:property value="helloWorld.getProperty('word')" />
</h3>
</body>
</html>

对于公共属性，还可以将此方法移到父类。

用 iterator 迭代 Map 对象

这对显示 Hibernate 多表连接的查询结果非常管用。

以前，在使用 Hibernate 的时候，因为涉及到多个表查询是很普遍的，每个表取一些字段，想显示在页面，比较好的办法是新建一个 VO 对象，专门用来显示查询的结果．但缺点就是，如果这样的查询很多， VO 类会越来越多（如果不断的往一个 VO 增加字段的话，那么这个 VO 也越来越大，构造函数会特别夸张），咱们来看一个例子：

Java代码

1. List list = session.createQuery("select new MyVO(a.name, b.name, c.id) from .....").list();  

这样返回的 List 直接就可以在页面上用 iterator 标签迭代了，但假如现在要取 10 呢？不仅 HQL 语句要修改，而且 MyVO 也要修改．下面是一种更好的做法：

Java代码

1. List list = session.createQuery("select new Map(a.name as fristName, b.name as secondName, c.id as id from .....").list();  

这里改用 Map 了，注意每个属性都用“ as ”重新启了一个别名，这个非常重要，否则在页面显示时，很费劲．

现在来看页面调用代码：

Html代码

1. <s:iterator value="list" id="maps">  
2.       <tr class="row1">  
3.       <input type="checkbox" name="ids" value="<s:property value="#maps.get('id')" />" />  
4.       <td align="center"><s:property value="#maps.get('fristName')" /></td>  
5.       <td align="center"><s:property value="#maps.get('secondName')" /></td>  
6.     </tr>  
7.     </s:iterator>  

<s:iterator value="list" id="maps">
<tr class="row1">
<input type="checkbox" name="ids" value="<s:property value="#maps.get('id')" />" />
<td align="center"><s:property value="#maps.get('fristName')" /></td>
<td align="center"><s:property value="#maps.get('secondName')" /></td>
</tr>
</s:iterator>

注意上面的页面中 Map 的取值就是当时 hql 语句中“ as ”后的别名．

虽然相对于以往的 JSTL 来说，要写的标签代码更多了，但强大的 OGNL 表达式也让你在视图层拥有更强大的灵活性与扩展性．

顺序无关，如果你使用了 select new List(...) 也能达到类似效果，但因为 List 是有序的，所以在页面显示非常不灵活，不推荐使用．

用 if 标签判断汉字问题

这个问题具体原因不明，先看下面一段代码：

Java代码

1. <s:if test="user.name == '程序'">   
2. ...  

<s:if test="user.name == '程序'">
...

这样就算 user.name 等于“程序”也是无法通过的，需要修改成以下代码：

Html代码

1. <s:if test="user.name == "'程序"'">  
2. ...  

<s:if test="user.name == "'程序"'">
...

如果“程序”是你系统的一个常量，更推荐的作法是：

Html代码

1. <s:if test="user.name == @com.leo.util.Constants@TYPE ">  
2. ...  

<s:if test="user.name == @com.leo.util.Constants@TYPE ">
...

我不知道原因是不是因为版本问题？希望有知道的，回复一下．

用 iterator 双重循环

这个也很常用，相信很多人都轻车熟路，那我们来回顾一下。假设 lists 装的都是 Group 对象， Group 持有一个 List<User> 那个我们接下来可以：

Html代码

1. <ww:iterator value="lists" id="top">  
2. <ww:iterator value="users" id="sub">  
3. 组名：<s:property value="#top.name" />，成员名：<s:property value="#sub.name" />  
4. </ww:iterator>  
5.   应该组总数：<s:property value="users.size" />  
6. </ww:iterator>  

<ww:iterator value="lists" id="top">
<ww:iterator value="users" id="sub">
组名：<s:property value="#top.name" />，成员名：<s:property value="#sub.name" />
</ww:iterator>
应该组总数：<s:property value="users.size" />
</ww:iterator>

上面的写法有很多种，但效果都是一样的，有兴趣可以多看看 OGNL 。

还有一些没有及时整理好，下次统一再给大家分享一下．

    <constant name="struts.i18n.encoding" value="UTF-8"/>

    <package name="demo" extends="struts-default">
        <action name="excel" method="execute" class="demo.ExcelAction">
                <result name="excel" type="stream">
                    <param name="contentType">application/vnd.ms-excel</param>    <!-- 注意这里的ContentType -->
                    <param name="inputName">excelStream</param>                   <!-- 这里需要和Action里的变量名一致 -->
                    <param name="contentDisposition">filename="standard.xls"</param>
                    <param name="bufferSize">1024</param>
                </result>
        </action>
    </package>
</struts>

二、Struts2的 Action

package demo;
public class ExcelAction {
    private InputStream excelStream; // 需要生成getter和setter

    public String execute() throws Exception {
        StringBuffer excelBuf = new StringBuffer();
        excelBuf.append("BookName").append("\t").append("Year").append("\t").append("author").append("\n");
        excelBuf.append("Thinking in Java").append("\t").append("2001").append("\t").append("Eckel").append("\n");
        excelBuf.append("Spring in action").append("\t").append("2005").append("\t").append("Rod").append("\n");
        String excelString = excelBuf.toString();
        logger.debug("result excel String: " + excelString);
        excelStream = new ByteArrayInputStream(excelString.getBytes(), 0, excelString.length());
        return "excel";
    }

    // getter and setter
    ...
}

三、Jsp页面

<%@ taglib prefix="s" uri="/struts-tags"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
 <head>
  <s:head />
 </head>

 <body>

    <s:form action="" method="post">
       <s:submit key="button.submit"/>
    </s:form>
 </body>
</html>