moutan http://chenshuang.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 善良的爱心 chenshuang1227 作者: chenshuang1227  链接：http://chenshuang.javaeye.com/blog/193597  发表时间: 2008年05月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一个很小的问题，乘以13亿，都会变成一个大问题；
一个很大的总量，除以13亿，都会变成一个小数目。
现在我们要说：
一点很小的善心，乘以13亿，都会变成爱的海洋；
一个很大的困难，除以13亿，都会变得微不足道。

让我们为所有受灾的人祝福，希望你们平安。


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 16 May 2008 12:39:08 +0800 http://chenshuang.javaeye.com/blog/193597 http://chenshuang.javaeye.com/blog/193597 struts配置 chenshuang1227 作者: chenshuang1227  链接：http://chenshuang.javaeye.com/blog/136575  发表时间: 2007年10月30日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Struts.xml
包含配置
在默认的情况下，Struts2将自动加载放在WEB-INF/classes路径下的struts.xml文件。大部分应用里，随着应用的规模的增加，系统的Action数量大量增加，导致了struts.xml配置文件变得非常臃肿。
       为了避免这种情况，可以将一个struts.xml文件分解成多个配置文件，然后在struts.xml文件中包含其他配置文件。比如说：在struts.xml文件中使用以下配置方式
<include file=”struts-mod1.xml” />
通过这种方式提供了一种模块化的方式来管理struts.xml文件。
另外，在core的根目录下有一个struts-default.xml文件，注意，这个文件是自动加载的，不需要在我们的struts.xml文件中用include导入。
 
Bean的配置
一般这个元素不需要我们进行配置，只是需要重新定义struts2的核心组件的时候才需要使用到这个元素。
Struts2框架是一个可以高度扩展的框架，框架的大部分核心组件，都是通过IOC容器来进行管理的。因此，允许开发者可以很方便的提供自己的组件实现类，并将组件类部署到struts2就OK了。
这个标记很不常用，如果需要可以查看帮助。
不过这里举个例子：
<bean type=”com.opensymphony.xwork2.ObjectFactory” name=”caFactory” class=”cc.dynasoft.MyObject” />
以上代码的作用是使用一个自己定义的ObjectFactory来替换了struts2内置的object。
常量配置
Struts有一个属性文件，struts.properties，实际上这个配置文件是指定struts2的属性。而常量配置就是指定struts2属性的一种方式。例子：
<constant name=”struts.custom.i18n.resources” value=”message” />
以上用于指定国际化资源文件的前缀名是message，当然也可以在struts.properties中配置，如下：
struts.custom.i18n.resources=message
也可以在web.xml中进行配置：
作为FilterDispatcher的init-param
<param-name> struts.custom.i18n.resources</param-name>
<param-value>message</param-value>
以下是加载struts2常量的搜索顺序：
1、  struts-default.xml中
2、  struts-plugin.xml中
3、  struts.xml中
4、  struts.properties
5、  web.xml中


包配置
Struts2使用package来管理Action和拦截器等。配置该包时，必须指定一个name属性，用于指定包名，可以指定一个可选的extends属性，是另一个包的名字，子包可以继承父包的拦截器，拦截器栈、action等配置。除此之外，struts还提供了一个抽象包，抽象包的含义是该包不能有action的定义。设置abstract=”true”说明这是一个抽象包。
以下是一个例子：
<package name=”mod1” extends=”struts-default” /> 其中struts-default是struts-default.xml提供的包。
 
另一个比较重要的概念就是命名空间：
考虑在一个web应用中需要同名的action，struits2以命名空间的方式来管理Action，同一个命名空间不能有同名的Action，不同的命名空间可以有同名的Action。如果不指定命名空间，则默认的命名空间是””，指定了命名空间之后，Action的URL应该是命名空间+Action名。
比如说：
<action name=”register” extends=”struts-default” namespace=”/user” >……</action>
则对应的Action应该是/user/register.action。
如果namespace=”/”，说明这是一个根命名空间。
 
如果指定了命名空间，但是在该命名空间中找不到该Action，struts2将会在默认的命名空间中继续查找，如果还找不到，则出现系统错误。
比如说：
请求/order/save.action，系统首先在命名空间/order中查找，如果找到，使用该action进行处理，否则，系统将到默认的命名空间中查找，如果两个命名空间都找不到，出现系统错误。
 
拦截器配置
       拦截器实际上思想就是AOP，我们可以使用拦截器跟踪日志、跟踪系统性能瓶颈等。
       拦截器的配置无非就是声明拦截器、引用拦截器以及声明拦截器栈。可以认为拦截器栈是由多个拦截器组成的一个大的拦截器。
       定义拦截器和拦截器栈都在<interceptors />这个标记内
       以下是一个例子：
       <interceptors>
              <interceptor name=”log” class=”cc.dynasoft.LogInterceptor” />
<interceptor name=”authority” class=”cc.dynasoft. Authority Interceptor” />
<interceptor name=”timer” class=”cc.dynasoft.TimerInterceptor” />
<interceptor-stack name=”default”>
       <interceptor-ref name=” authority” />
<interceptor-ref name=” timer” />
</interceptor>
 
引用拦截器是在action中引用的：例子：
<action name=”login” class=”cc.dynasoft.LoginAction”>
       ……
       <interceptor-ref name=”log” />
</action>
 
配置Action
实际上配置Action很简单，就使用action标签就OK了，action标签有两个重要属性：name和class，name是必须指定的，他既是action的名字，也是该action需要处理的URL的前半部分。如果class没有指定，默认是ActionSupport。而ActionSupport默认处理就是返回一个SUCCESS字符串。
struts的全局配置文件中有一个属性：struts.enable.SlashesInActionNames如果设置为true，允许struts2框架中使用斜线。
Action中直接访问servlet API有以下两种方法：
1、  如果需要访问ServletContext，Action类需要实现接口ServletContextAware
如果需要访问 HttpServletRequest，Action类需要实现接口ServletRequestAware
如果需要访问 HttpServletResponse，Action类需要实现接口ServletResponseAware
 
以下是例子代码，主要用于访问Reponse对象：
public class LoginAction implements Action,ServletResponseAware
{
        private HttpServletResponse response;
 
        //实现ServletResponseAware接口必须实现的方法
       
        public String execute() throw Exception
        {
               Cookie c = new Cookie(“user”,getUsername());
               c.setMaxAge(60*60);//最大生存时间
               response.addCookie(c);
               return SUCCESS;
        }
}
 
2、  struts2提供了一个ServletActionContext，这个类包含了访问request，response等静态方法。
 
注意：即使我们在struts2的Action中获得了HttpServletResponse对象，也不要尝试直接在Action中生成对客户端的输出。比如：下面代码是没有实际意义的，即
response.getWriter().println(“hello world!”);
 
动态方法调用（类似struts1的DispatchAction）
其实没有什么特别的地方，只是提交表单的时候需要使用如下的格式：
action=”ActionName!MethodName.action”
举个例子：action=”Login!regist.action”,这句话的实质就是交给Login Action的regist方法进行处理
 
使用动态方法调用前必须设置struts2允许动态方法调用。开启系统的动态方法调用是通过设置struts.enable.DynamicMethodInvocation常量完成的，设置该常量的值为true，将开启动态方法调用；否则将关闭动态方法调用。
 
为action元素指定method属性
 
对action进行如下的配置：
<action name=”Login” class=”cc.dynasoft.LoginAction” method=”login” />
              ……
</action>
             
<action name=”Regist” class=”cc.dynasoft.LoginAction” />
              ……
</action>
 
查看以上两个action，默认的情况是Regist，而当Login的时候，将提交到LoginAction的login中。查看上面的两个action，class都是一样的，于是就出现了下面的使用通配符的概念。
 
使用通配符
       在配置action的时候，action的三个属性name、class和method都可以使用通配符。
       以下举例说明：
       例1：<action name=”*Action” class=”cc.dynasoft.LoginAction” method=”{1}”>
              ……
              </action>
解释一下上面代码的含义：上面定义的不是一个普通的action，而是定义了一系列的action，只要URL是*Action.action的模式，都可以通过该Action进行处理。但该Action定义了一个表达式{1}，该表达式的值就是name属性值中的第一个*的值。
例如，如果用户请求的URL是loginAction.action，则调用该action的login方法；如果用户请求的URL是registAction.action，则调用该action的regist方法。
 
例2：<action name=”*Action” class=”cc.dynasoft.{1}Action”>
 
       ……
            
     </action>
 
比如说：如果URL为RegistAction.action，可以匹配上面的action，该action的处理类是cc.dynasoft.RegistAction
 
例3：<action name=”*_*” class=”cc.dynasoft.{1}Action” method=”{2}”>
当一个action为Book_save.action的时候将调用BookAction的save方法来处理用户请求。
 
注意这个时候指定校验文件需要注意，比如说Book_save.action的校验文件应该是
Book_save-validation.xml。
 
例4：<action name=”*”>
             <result>/{1}.jsp</result>
       </action>
 
这个应该不难理解，呵呵。
 
以下需要注意的问题：
如果有URL为abcAction.action的请求，如果struts.xml文件有名为abcAction的Action，则一定由该Action来处理用户请求；如果struts.xml文件没有名为abcAction的Action，则搜索name属性值匹配abcAction的Action，例如name为*Action或*，*Action并不会比*更优先匹配abcAction的请求，而是先找到哪个Action，就先由哪个Action来处理用户的请求。因此，我们应该将名为*的Action配置在最后，否则struts2将使用该Action来处理所有希望使用模式匹配的请求。
处理结果
struts2通过在struts.xml文件中使用<result>元素来配置结果，根据<result>元素所在位置的不同，struts2提供了两种结果。
局部结果：将<result>作为<action>元素的子元素配置
全局结果：将<result>作为<global-result>元素的子元素配置。
以下列出比较标准的配置：
<result name=”success” type=”dispatcher”>
       <param name=”location” >/thank_you.jsp</param>
<param name=”parse” >true</param>
</result>
 
location：用于指定实际视图资源
parse：该参数指定是否允许在实际视图名称中使用ONGL表达式，默认为true。如果设置为false则不允许使用，通常不需要修改。
一般我们比较常用的写法：
<result name=”success” type=”dispatcher”>
/thank_you.jsp
</result>
 
注意如果没有指定name属性：则默认是success；如果没有指定type，则默认就是dispatcher，即JSP。
下面列出struts2内建支持的结果类型如下：
chain：Action链式处理的结果类型，也就是将结果转发到这个action中。
chart：整合JFreeChart的结果类型
dispatcher：用于整合JSP的结果类型
freemarker：用于整合freemarker结果类型。
httpheader：用于控制特殊的HTTP行为的结果类型。
jasper：用于JasperReports整合的结果类型
jsf：用于整合JSF后的结果类型
redirect：实际上dispatcher和redirect的区别就是在于转发和重定向的区别。
redirect-action：用于直接redirect action。
stream：用于向浏览器返回一个Inputstream（用于文件下载）
tiles：用于整合Tiles后的结果类型。
velocity：用于整合Velocity的结果类型。
xslt：用于整合XML/XSLT的结果类型。
plaintext：用于显示某个页面的源代码。
 
plaintext、redirect以及redirect-action的配置分别如下：
<result type=”plaintext”>
       <param name=”location”>/welcome.jsp</param>
       <!—设置字符集编码-->
       <param name=”charset”>gb2312</param>
</result>
 
<result type=”redirect”>
       /welcome.jsp
</result>
 
<result type=” redirect-action”>
       <!—指定action的命名空间-->
       <param name=”namespace”>/ss</param>
<!—指定action的名字-->
       <param name=”actionName”>login </param>
</result>
 
在请求结果中使用ONGL表达式
 
例子：
<result type=”redirect”>edit.action?skillName=${currentSkill.name}</result>
 
对于上面的表达式语法，要求action中必须包含currentSkill属性，并且currentSkill属性必须包含name属性，否则${currentSkill.name}表达式值为null。
 
属性驱动和模型驱动
我不推荐使用模型驱动，属性驱动完全可以实现模型驱动的效果。


异常处理
       异常处理在struts2中采用可配置的方式来处理，主要是为了防止异常代码和action代码耦合。我们比较希望的异常处理模式是这样的，如果出现了异常一，则系统跳转到视图1；如果出现了异常二，则系统转到视图2。
       我们查看execute的声明：public String execute() throws Exception可以发现将异常抛出由struts2框架进行处理，为了处理异常，我们必须使用exception拦截器，由于在struts-default.xml的defaultStack中已经存在这个拦截器的定义，于是我们可以不用做任何事情。
       struts2的异常处理机制是通过在struts.xml文件中配置<exception-mapping />元素完成的，配置该元素的时候，需要指定两个属性：
exception：此属性指定该异常映射所设置的异常类型。
result：出现这个异常的时候，转入result属性所指向的结果。
根据<exception-mapping />元素出现的位置的不同，异常映射又可分为两种：
局部异常映射：将<exception-mapping />作为action的子元素配置
全局异常映射：将<exception-mapping />元素作为<global-exception-mappings>元素的子元素配置。
实际上配置类似result，可以有局部，也可以是全局，局部优先。
 
举个例子：
<global-exception-mappings>
       <exception-mapping exception=”java.sql.SQLException” result=”sql”/>
<exception-mapping exception=”java.lang.Exception” result=”root”/>
</ global-exception-mappings>
 
注意以上的sql和root是全局result。
输出异常信息：
<s:property value=”exception” />:输出异常对象本身，注意这个异常代表Exception的实例，因此可以调用message属性。
<s:property value=”exceptionStack” />：输出异常堆栈信息。
 

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 30 Oct 2007 08:58:18 +0800 http://chenshuang.javaeye.com/blog/136575 http://chenshuang.javaeye.com/blog/136575 struts2入门例子 chenshuang1227 作者: chenshuang1227  链接：http://chenshuang.javaeye.com/blog/136527  发表时间: 2007年10月30日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

 

1、首先下载Struts2GA版本，GA的全称是General Availability。

使用Struts2必须的包：core、xwork、freemarker、ognl。

2、配置web.xml文件

  1. <filter>  
  2.     <filter-name>struts2filter-name>  
  3.     <filter-class>  
  4.         org.apache.struts2.dispatcher.FilterDispatcher   
  5.     filter-class>  
  6. filter>  
  7. <filter-mapping>  
  8.     <filter-name>struts2filter-name>  
  9.     <url-pattern>/*url-pattern>  
  10. filter-mapping>  

 

3、建立JSP

 

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"%>  
  2. <%@taglib prefix="s" uri="/struts-tags" %>  
  3. >  
  4. <html>  
  5.   <head>  
  6.     <title>struts2 testDemotitle>  
  7.   
  8.        
  9.   head>  
  10.      
  11.   <body>  
  12.     <s:form action="login.action" method="post">  
  13.         <s:textfield key="username" name="user.username"/>  
  14.         <s:password key="password" name="user.password" />  
  15.         <s:submit key="submit" />  
  16.     s:form>  
  17.   body>  
  18. html>  

 

 4、建立Action

  1. package cc.dynasoft.action;   
  2.   
  3. import cc.dynasoft.vo.User;   
  4.   
  5. public class LoginAction   
  6. {   
  7.     private User user;   
  8.   
  9.     public User getUser()   
  10.     {   
  11.         return user;   
  12.     }   
  13.   
  14.     public void setUser(User user)   
  15.     {   
  16.         this.user = user;   
  17.     }   
  18.        
  19.     public String execute() throws Exception   
  20.     {   
  21.         if(user.getUsername().equals("chenshuang") && user.getPassword().equals("chenshuang"))   
  22.         {   
  23.             return "success";   
  24.         }   
  25.         else  
  26.         {   
  27.             return "error";   
  28.         }   
  29.     }   
  30. }   
User.java
  1. package cc.dynasoft.vo;   
  2.   
  3. public class User   
  4. {   
  5.     private String username;   
  6.     private String password;   
  7.        
  8.     public String getUsername()   
  9.     {   
  10.         return username;   
  11.     }   
  12.     public void setUsername(String username)   
  13.     {   
  14.         this.username = username;   
  15.     }   
  16.     public String getPassword()   
  17.     {   
  18.         return password;   
  19.     }   
  20.     public void setPassword(String password)   
  21.     {   
  22.         this.password = password;   
  23.     }   
  24. }   
 

5、配置struts.xml

  1. xml version="1.0" encoding="UTF-8" ?>  
  3.     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"   
  4.     "http://struts.apache.org/dtds/struts-2.0.dtd">  
  5.   
  6. <struts>  
  7.     <package name="login" extends="struts-default">  
  8.         <action name="login" class="cc.dynasoft.action.LoginAction">  
  9.             <result name="success">/welcome.jspresult>  
  10.             <result name="error">/login.jspresult>  
  11.         action>  
  12.     package>  
  13. struts>  

 

6、完成国际化

在struts.xml文件中加上配置

  1. <constant name="struts.custom.i18n.resources" value="message" />  

 

建立资源文件message_en_US.properties和message_zh_CN.properties

message_en_US.properties
  1. username=username   
  2. password=password   
  3. welcome=welcom to    
  4. submit=submit   
message_zh_CN.properties
  1. username=\u7528\u6237\u540d   
  2. password=\u5bc6\u7801   
  3. welcome=\u6b22\u8fce   
  4. submit=\u63d0\u4ea4   

 


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 30 Oct 2007 08:33:59 +0800 http://chenshuang.javaeye.com/blog/136527 http://chenshuang.javaeye.com/blog/136527 Struts2概述 chenshuang1227 作者: chenshuang1227  链接：http://chenshuang.javaeye.com/blog/136525  发表时间: 2007年10月30日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

  最近研究了一下srtuts2.0，将一些心得准备以一个系列的方式列一下。

一、MVC思想及其优势

MVC思想将一个应用分成三个部分：Model（模型）、View（视图）、Controller（控制器）。这三个部分以最少的耦合协同工作，从而提高应用的可扩展性及可维护性。

MVC特点：1、多个视图对应一个模型。2、模型返回的数据与显示逻辑分离，模型数据可以应用任何显示技术，例如JSP，Velocity，或者生成Excel。3、应用被分成三层，降低了各层之间的耦合，提高可扩展性。4、MVC更符合软件工程思想，不同的层各司其职。

常用的MVC框架介绍：全世界第一个MVC框架是struts，2001年出现。现在比较流行的MVC框架罗列如下：

JSF：他是标准，这是他的优势。但也有一些缺点：用户较少，资源不是很丰富，和Servlet API耦合；成熟度还有待于进一步提高。

Tapestry：具有很好的分工合作。

Spring MVC框架：设计比较好，但是使用起来比较复杂，和Servlet API耦合，有人说Spring有过度设计的危险，但是我有些不理解这句话的含义。

Webwork，类似struts2，较好的设计，从ServletAPI分离。

Model1和model2：

Model1：JSP页面接受处理客户端请求，对请求处理后直接做出相应。用javabean处理业务逻辑，这个时候JSP既做控制器又做视图。

Model2：Servlet作为前端的控制器，JSP作为视图，javabean作为控制器。

二、struts2概述

Struts1的缺点：

1、  支持的表示层技术单一

Struts1只支持JSP视图技术，当然，通过某些不自然的整合可以支持velocity等技术。

2、  struts与servlet API严重耦合，难于测试

比如说：如果要对struts1的Action的execute进行测试的时候，该方法有四个参数：ActionMapping、ActionForm、HttpServletRequest和HttpServletResponse，初始化这四个参数比较困难，尤其是HttpServletRequest和HttpServletResponse两个参数，因为这两个参数通常由容器进行注入的。如果脱离web服务器，Action的测试是很困难的。

3、  struts1的侵入性太大

一个Action中包含了大量的strutsAPI，比如ActionMapping、ActionForm、ActionForwad。这种侵入式的设计最大的弱点在于：切换框架会相当困难，代码复用较低，不利于重构，对struts的依赖太严重。

Struts2则在Webwork的优良基础设计的基础上，进行了一次巨大的升级（我是这样认为的）。注意，struts2不是基于struts1，而是基于webwork的。Struts2针对struts1的不足，提出了自己的解决方案（实际上大多是webwork的解决方案）。

是使用struts2还是使用webwork？本人倾向使用struts2，原因：1、毕竟struts2是对webwork的一次升级。2、webwork已经不再升级。

Struts2的大致处理流程：

1、  浏览器发送请求，如login.action

2、  核心的控制器FilterDispatcher根据请求决定调用合适的Action。

3、  Struts2的拦截器链自动对请求应用通用功能，例如验证、填充参数、文件上传等。

4、  调用Action的execute方法，实际上是调用Action代理的方法。（基于AOP理论）

5、  将结果信息输出到视图中，视图可以是JSP，FreeMarker，Velocity甚至是JSON。

 

比较Struts1和Struts2

 

Struts1

Struts2

侵入性方面

非常大

较小

线程模式方面

Struts1 Action是单例模式并且必须是线程安全的，因为只有一个Action处理请求。

为每个请求创建一个实例，因此没有线程安全问题。