BlogJava-Sunshine village-文章分类-strutshttp://www.blogjava.net/keweibo/category/25070.htmlAs long as you are there to lead me ,I won't lose my way zh-cnThu, 20 Sep 2007 09:01:12 GMTThu, 20 Sep 2007 09:01:12 GMT60在Struts2中实现文件上传(二)http://www.blogjava.net/keweibo/articles/146616.htmlKEKEWed, 19 Sep 2007 14:14:00 GMThttp://www.blogjava.net/keweibo/articles/146616.htmlhttp://www.blogjava.net/keweibo/comments/146616.htmlhttp://www.blogjava.net/keweibo/articles/146616.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/146616.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/146616.html

在Struts2中实现文件上传(二)

 发布者：[IT电子教育门户]   

发布运行应用程序，在浏览器地址栏中键入：http://localhost:8080/Struts2_Fileupload/FileUpload.jsp，出现图示页面：

 
清单7 FileUpload页面

选择图片文件，填写Caption并按下Submit按钮提交，出现图示页面：

 
清单8 上传成功页面

更多配置
在运行上述例子，如果您留心一点的话，应该会发现服务器控制台有如下输出：

Mar 20 , 2007 4 : 08 : 43 PM org.apache.struts2.dispatcher.Dispatcher getSaveDir
INFO: Unable to find 'struts.multipart.saveDir' property setting. Defaulting to javax.servlet.context.tempdir
Mar 20 , 2007 4 : 08 : 43 PM org.apache.struts2.interceptor.FileUploadInterceptor intercept
INFO: Removing file myFile C:\Program Files\Tomcat 5.5 \work\Catalina\localhost\Struts2_Fileupload\upload_251447c2_1116e355841__7ff7_00000006.tmp 清单9 服务器控制台输出
上述信息告诉我们，struts.multipart.saveDir没有配置。struts.multipart.saveDir用于指定存放临时文件的文件夹，该配置写在struts.properties文件中。例如，如果在struts.properties文件加入如下代码：

struts.multipart.saveDir = /tmp 清单10 struts配置
这样上传的文件就会临时保存到你根目录下的tmp文件夹中（一般为c:\tmp），如果此文件夹不存在，Struts 2会自动创建一个。

错误处理
上述例子实现的图片上传的功能，所以应该阻止用户上传非图片类型的文件。在Struts 2中如何实现这点呢？其实这也很简单，对上述例子作如下修改即可。

首先修改FileUpload.jsp，在<body>与<s:form>之间加入“<s:fielderror />”，用于在页面上输出错误信息。

然后修改struts.xml文件，将Action fileUpload的定义改为如下所示：

        < action name ="fileUpload" class ="tutorial.FileUploadAction" >
            < interceptor-ref name ="fileUpload" >
                < param name ="allowedTypes" >
                    image/bmp,image/png,image/gif,image/jpeg
                </ param >
            </ interceptor-ref >
            < interceptor-ref name ="defaultStack" />           
            < result name ="input" > /FileUpload.jsp </ result >
            < result name ="success" > /ShowUpload.jsp </ result >
        </ action > 清单11 修改后的配置文件
显而易见，起作用就是fileUpload拦截器的allowTypes参数。另外，配置还引入defaultStack它会帮我们添加验证等功能，所以在出错之后会跳转到名称为“input”的结果，也即是FileUpload.jsp。

发布运行应用程序，出错时，页面如下图所示：

 
清单12 出错提示页面

上面的出错提示是Struts 2默认的，大多数情况下，我们都需要自定义和国际化这些信息。通过在全局的国际资源文件中加入“struts.messages.error.content.type.not.allowed=The file you uploaded is not a image”，可以实现以上提及的需求。对此有疑问的朋友可以参考我之前的文章《在Struts 2.0中国际化(i18n)您的应用程序》。

实现之后的出错页面如下图所示：

 
清单13 自定义出错提示页面

同样的做法，你可以使用参数“maximumSize”来限制上传文件的大小，它对应的字符资源名为：“struts.messages.error.file.too.large”。

字符资源“struts.messages.error.uploading”用提示一般的上传出错信息。

多文件上传
与单文件上传相似，Struts 2实现多文件上传也很简单。你可以将多个<s:file />绑定Action的数组或列表。如下例所示。

< s:form action ="doMultipleUploadUsingList" method ="POST" enctype ="multipart/form-data" >
    < s:file label ="File (1)" name ="upload" />
    < s:file label ="File (2)" name ="upload" />
    < s:file label ="FIle (3)" name ="upload" />
    < s:submit />
</ s:form > 清单14 多文件上传JSP代码片段
如果你希望绑定到数组，Action的代码应类似：

     private File[] uploads;
     private String[] uploadFileNames;
     private String[] uploadContentTypes;

     public File[] getUpload()  { return this .uploads; }
      public void setUpload(File[] upload)  { this .uploads = upload; }
 
      public String[] getUploadFileName()  { return this .uploadFileNames; }
      public void setUploadFileName(String[] uploadFileName)  { this .uploadFileNames = uploadFileName; }
 
      public String[] getUploadContentType()  { return this .uploadContentTypes; }
      public void setUploadContentType(String[] uploadContentType)  { this .uploadContentTypes = uploadContentType; } 清单15 多文件上传数组绑定Action代码片段
如果你想绑定到列表，则应类似：

     private List < File > uploads = new ArrayList < File > ();
     private List < String > uploadFileNames = new ArrayList < String > ();
     private List < String > uploadContentTypes = new ArrayList < String > ();

     public List < File > getUpload()  {
         return this .uploads;
    }
      public void setUpload(List < File > uploads)  {
         this .uploads = uploads;
    }
 
      public List < String > getUploadFileName()  {
         return this .uploadFileNames;
    }
      public void setUploadFileName(List < String > uploadFileNames)  {
         this .uploadFileNames = uploadFileNames;
    }
 
      public List < String > getUploadContentType()  {
         return this .uploadContentTypes;
    }
      public void setUploadContentType(List < String > contentTypes)  {
         this .uploadContentTypes = contentTypes;
    } 清单16 多文件上传列表绑定Action代码片段
总结
在Struts 2中实现文件上传的确是轻而易举，您要做的只是使用<s:file />与Action的属性绑定。这又一次有力地证明了Struts 2的简单易用。

KE 2007-09-19 22:14 发表评论
]]>在Struts2中实现文件上传(一)http://www.blogjava.net/keweibo/articles/146615.htmlKEKEWed, 19 Sep 2007 14:11:00 GMThttp://www.blogjava.net/keweibo/articles/146615.htmlhttp://www.blogjava.net/keweibo/comments/146615.htmlhttp://www.blogjava.net/keweibo/articles/146615.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/146615.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/146615.html

在Struts2中实现文件上传(一)

转自:http://www.mldn.cn/articleview/2007-8-22/article_view_2245.htm

前一阵子有些朋友在电子邮件中问关于Struts 2实现文件上传的问题， 所以今天我们就来讨论一下这个问题。

实现原理
Struts 2是通过Commons FileUpload文件上传。Commons FileUpload通过将HTTP的数据保存到临时文件夹，然后Struts使用fileUpload拦截器将文件绑定到Action的实例中。从而我们就能够以本地文件方式的操作浏览器上传的文件。

具体实现
前段时间Apache发布了Struts 2.0.6 GA，所以本文的实现是以该版本的Struts作为框架的。以下是例子所依赖类包的列表：

依赖类包的列表 
清单1 依赖类包的列表

首先，创建文件上传页面FileUpload.jsp，内容如下：

<% @ page language = " java " contentType = " text/html; charset=utf-8 " pageEncoding = " utf-8 " %>
<% @ taglib prefix = " s " uri = " /struts-tags " %>

<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" >
< html xmlns ="http://www.w3.org/1999/xhtml" >
< head >
    < title > Struts 2 File Upload </ title >
</ head >
< body >
    < s:form action ="fileUpload" method ="POST" enctype ="multipart/form-data" >
        < s:file name ="myFile" label ="Image File" />
        < s:textfield name ="caption" label ="Caption" />       
        < s:submit />
    </ s:form >
</ body >
</ html > 清单2 FileUpload.jsp
在FileUpload.jsp中，先将表单的提交方式设为POST，然后将enctype设为multipart/form-data，这并没有什么特别之处。接下来，<s:file/>标志将文件上传控件绑定到Action的myFile属性。

其次是FileUploadAction.java代码：

 package tutorial;

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.Date;

 import org.apache.struts2.ServletActionContext;

 import com.opensymphony.xwork2.ActionSupport;

 public class FileUploadAction extends ActionSupport  {
     private static final long serialVersionUID = 572146812454l ;
     private static final int BUFFER_SIZE = 16 * 1024 ;
   
     private File myFile;
     private String contentType;
     private String fileName;
     private String imageFileName;
     private String caption;
   
     public void setMyFileContentType(String contentType)  {
         this .contentType = contentType;
    }
   
     public void setMyFileFileName(String fileName)  {
         this .fileName = fileName;
    }
       
     public void setMyFile(File myFile)  {
         this .myFile = myFile;
    }
   
     public String getImageFileName()  {
         return imageFileName;
    }
   
     public String getCaption()  {
         return caption;
    }
 
      public void setCaption(String caption)  {
         this .caption = caption;
    }
   
     private static void copy(File src, File dst)  {
         try  {
            InputStream in = null ;
            OutputStream out = null ;
             try  {               
                in = new BufferedInputStream( new FileInputStream(src), BUFFER_SIZE);
                out = new BufferedOutputStream( new FileOutputStream(dst), BUFFER_SIZE);
                 byte [] buffer = new byte [BUFFER_SIZE];
                 while (in.read(buffer) > 0 )  {
                    out.write(buffer);
                }
             } finally  {
                 if ( null != in)  {
                    in.close();
                }
                  if ( null != out)  {
                    out.close();
                }
            }
         } catch (Exception e)  {
            e.printStackTrace();
        }
    }
   
     private static String getExtention(String fileName)  {
         int pos = fileName.lastIndexOf( " . " );
         return fileName.substring(pos);
    }
 
    @Override
     public String execute()      {       
        imageFileName = new Date().getTime() + getExtention(fileName);
        File imageFile = new File(ServletActionContext.getServletContext().getRealPath( " /UploadImages " ) + " / " + imageFileName);
        copy(myFile, imageFile);
         return SUCCESS;
    }
   
} 清单3 tutorial/FileUploadAction.java
在FileUploadAction中我分别写了setMyFileContentType、setMyFileFileName、setMyFile和setCaption四个Setter方法，后两者很容易明白，分别对应FileUpload.jsp中的<s:file/>和<s:textfield/>标志。但是前两者并没有显式地与任何的页面标志绑定，那么它们的值又是从何而来的呢？其实，<s:file/>标志不仅仅是绑定到myFile，还有myFileContentType（上传文件的MIME类型）和myFileFileName（上传文件的文件名，该文件名不包括文件的路径）。因此，<s:file name="xxx" />对应Action类里面的xxx、xxxContentType和xxxFileName三个属性。

FileUploadAction作用是将浏览器上传的文件拷贝到WEB应用程序的UploadImages文件夹下，新文件的名称是由系统时间与上传文件的后缀组成，该名称将被赋给imageFileName属性，以便上传成功的跳转页面使用。

下面我们就来看看上传成功的页面：

<% @ page language = " java " contentType = " text/html; charset=utf-8 " pageEncoding = " utf-8 " %>
<% @ taglib prefix = " s " uri = " /struts-tags " %>

<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" >
< html xmlns ="http://www.w3.org/1999/xhtml" >
< head >
    < title > Struts 2 File Upload </ title >
</ head >
< body >
    < div style ="padding: 3px; border: solid 1px #cccccc; text-align: center" >
        < img src ='UploadImages/<s:property value ="imageFileName" /> ' />
        < br />
        < s:property value ="caption" />
    </ div >
</ body >
</ html > 清单4 ShowUpload.jsp
ShowUpload.jsp获得imageFileName，将其UploadImages组成URL，从而将上传的图像显示出来。

然后是Action的配置文件：

<? 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 ="fileUploadDemo" extends ="struts-default" >
        < action name ="fileUpload" class ="tutorial.FileUploadAction" >
            < interceptor-ref name ="fileUploadStack" />
            < result name ="success" > /ShowUpload.jsp </ result >
        </ action >
    </ package >
</ struts > 清单5 struts.xml
fileUpload Action显式地应用fileUploadStack的拦截器。

最后是web.xml配置文件：

<? xml version="1.0" encoding="UTF-8" ?>
< web-app id ="WebApp_9" version ="2.4"
    xmlns ="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi ="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation ="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" >

    < display-name > Struts 2 Fileupload </ display-name >

    < filter >
        < filter-name > struts-cleanup </ filter-name >
        < filter-class >
            org.apache.struts2.dispatcher.ActionContextCleanUp
        </ filter-class >
    </ filter >
   
    < filter >
        < filter-name > struts2 </ filter-name >
        < filter-class >
            org.apache.struts2.dispatcher.FilterDispatcher
        </ filter-class >
    </ filter >
   
    < filter-mapping >
        < filter-name > struts-cleanup </ filter-name >
        < url-pattern > /* </ url-pattern >
    </ filter-mapping >

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



KE 2007-09-19 22:11 发表评论
]]>struts标签使用举例--logic篇http://www.blogjava.net/keweibo/articles/145473.htmlKEKESun, 16 Sep 2007 02:24:00 GMThttp://www.blogjava.net/keweibo/articles/145473.htmlhttp://www.blogjava.net/keweibo/comments/145473.htmlhttp://www.blogjava.net/keweibo/articles/145473.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/145473.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/145473.html          该标签是用来判断是否为空的。如果为空，该标签体中嵌入的内容就会被处理。该标签用于以下情况：

         1）当Java对象为null时；

         2）当String对象为""时；

         3）当java.util.Collection对象中的isEmpty()返回true时；

         4）当java.util.Map对象中的isEmpty()返回true时。
          eg. 
            <logic:empty   name="userList">   
              ...   
           </logic:empty> 
           该句等同于：
           if   (userList.isEmpty())   {   
                 ...   
           }   
   2.  logic:notEmpty
          该标签的应用正好和logic:empty标签相反，略。
   3. logic:equal
          该标签为等于比较符。
          eg1. 比较用户的状态属性是否1，若为1，输出"启用";
                 <logic:equal   name="user"   property="state"   value="1">
                     启用
                 </logic:equal>
         eg2. 如果上例中的value值是动态获得的，例如需要通过bean:write输出，因struts不支持标签嵌套，可采用EL来解决该问题。
                <logic:equal   name="charge"   property="num"   value="${business.num}">   
                    ......
                </logic:equal>
    4. logic:notEqual
          该标签意义与logic:equal相反，使用方法类似，略。
    5. logic:forward
          该标签用于实现页面导向，查找配置文件的全局forward。
          eg. <logic:forward name="index"/>
    6. logic:greaterEqual
          为大于等于比较符。
          eg. 当某学生的成绩大于等于90时，输出“优秀”：
               <logic:greaterEqual name="student" property="score" value="90">
                  优秀
            </logic:greaterEqual>
    7. logic:greaterThan
          此为大于比较符，使用方法同logic:greaterEqual，略;
    8. logic:lessEqual
          此为小于等于比较符，使用方法同logic:greaterEqual,略;
    9. logic:lessThan
          此为小于比较符，使用方法同logic:greaterEqual,略;
    10. logic:match
          此标签比较对象是否相等；
          eg1. 检查在request范围内的name属性是否包含"amigo"串： 
            <logic:match name="name" scope="request" value="amigo">
                  <bean:write name="name"/>中有一个“amigo”串。
            </logic:match>
         eg2. 检查在request范围内的name属性是否已“amigo”作为起始字符串：
           <logic:match name="name" scope="request" value="amigo" location="start">
               <bean:write name="name"/>以“amigo”作为起始字符串。
            </logic:match>
         eg3. 
            <logic:match header="user-agent" value="Windows">
               你运行的是Windows系统
            </logic:match>
    11.  logic:notMatch

 

 

          此标签用于比较对象是否不相同，与logic:match意义相反，使用方法类似，略。
     12. logic:messagePresent
          该标签用于判断ActionMessages/ActionErrors对象是否存在；
          eg. 如果存在error信息，将其全部输出：
               <logic:messagePresent property="error"> 
                  <html:messages property="error" id="errMsg" > 
                        <bean:write name="errMsg"/> 
                  </html:messages>   
               </logic:messagePresent >
     13. logic:messagesNotPresent
          该标签用于判断ActionMessages/ActionErrors对象是否不存在,使用方法与logic:messagePresent类似，略
      14. logic:present
           此标签用于判断request对象传递参数是否存在。
           eg1. user对象和它的name属性在request中都存在时，输出相应字符串：
              <logic:present name="user" property="name">
                  user对象和该对象的name属性都存在
            </logic:present> 
          eg2. 若有一个名字为“user”的JavaBean，输出对应字符串：
             <logic:present name="user" >
                  有一个名字为“user”的JavaBean。
            </logic:present>
          eg3. 
            <logic:present header="user-agent">
                  we got a user-agent header.
            </logic:present>
      15. logic:notPresent
           此标签用于判断request对象传递参数是否不存在，意义与了logic:present相反，使用方法类似，略。
      16. logic:redirect
           该标签用于实现页面转向，可传递参数。
           eg1. <logic:redirect href="http://www.chinaitlab.com"/>
       
       17. logic:iterator
            用于显示列表为collection的值（List ,ArrayList,HashMap等）。
            eg1. 逐一输出用户列表(userlList)中用户的姓名：
               <logic:iterate  id="user" name="userList">
                  <bean:write name="user" property="name"/><br>
               </logic:iterate>
            eg2. 从用户列表中输出从1开始的两个用户的姓名
               <logic:iterate  id="user" name="userList" indexId="index"  offset="1" length="2">
                  <bean:write name="index"/>.<bean:write name="user" property="name"/><br>
               </logic:iterate>
            eg3. logic:iterator标签的嵌套举例
                <logic:iterate id="user" indexId="index" name="userList">
                       <bean:write name="index"/>. <bean:write name="user" property="name"/><br>
                       <logic:iterate id="address" name="user" property="addressList" length="3" offset="1">
                           <bean:write name="address"/><br>
                       </logic:iterate>
               </logic:iterate>



KE 2007-09-16 10:24 发表评论
]]>应用中异常的处理(二)http://www.blogjava.net/keweibo/articles/140663.htmlKEKETue, 28 Aug 2007 13:19:00 GMThttp://www.blogjava.net/keweibo/articles/140663.htmlhttp://www.blogjava.net/keweibo/comments/140663.htmlhttp://www.blogjava.net/keweibo/articles/140663.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/140663.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/140663.html业务异常的设计

  业务异常的层次结构设计在开发中也是非常重要的要作,业务异常体系结构的设计方法将直接影响
到异常处理的方法.
  对于异常系统的结构通常会被划分为三个层次,第一层为异常的基类,第二层为功能层或者模块层,
第三层为业务异常层,层与层之间是父子工的继承关系.
  对于一个通用的异常系统而言,通常会定义一个异常基类,假设是BaseException,该类继承自RuntimeException
之所以将业务异常的基类定义为RuntimeException,是因为业务异常是否需要开发人员在开发过程中进行捕获的
对于业务异常的捕获交给系统的框架或者表示层来完成.
  接下来,在BaseException的基础之上,还要为应用中的每个层次定义一个异常基类.例如,业务层的异常
可以定义为BusinessException,持久层的异常可以定义为DAOException等.当然,这一层次的异常也可以按照
功能或者模块来进行划分,划分的方式主要依赖于顶层对异常的处理方法.
  最后,就是为每一个业务异常定义相应的业务对象.另外,为减少异常对象的数量,在这一层也可以采取错误
代码,使得顶层的拦截程序可以依据错误代码来得到相应的错误信息.

异常处理方法

  Servlet容器中异常的处理
在web.xml文件中进行异常处理的配置是通过<error-page>元素来进行的,它支持两种类型的异常拦截.

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

<error-page>
 <error-type>java.lang.NullPointException</error-type>
 <location>/error/nullPointer.jsp</location>
</error-page>

从JSP 2.0开始,除了在错误页面中可以使用绑定到request的exception对象外,还增加了一个名称为
errorData的绑定到pageContext的对象,该对象是javax.servlet.jsp.ErrorData类的实例,它可以当做
一个普通的Bean来使用,通过它的属性可以了解到异常的更多信息.
其属性如下:
属性      类型      描述
requestURI   String     发生请求失败的URI
servletName   String     发生错误的Servlet或者JSP页面的名称
statueCode   int       发生错误的状态码
throwable    Throwable    导致当前错误的异常
例如:
...
<title>404状态码错误的页面</title>
...
<jsp:useBean id="now" class="java.util.Date" />
发生异常的时间:${now}<br>
请求的地址: ${pageContext.errorData.requestURI }<br>
错误状态码: ${pageContext.errorData.statueCode }<br>
异常:    ${pageContext.errorData.throwable }
...

自定义异常页面

  自己在JSP页面中的定义将会覆盖在web.xml中的定义
  自定义异常页面的方法如下
<%@ page errorPage="/error/errorPage.jsp" %>

 



KE 2007-08-28 21:19 发表评论
]]>应用中异常的处理(一)http://www.blogjava.net/keweibo/articles/140656.htmlKEKETue, 28 Aug 2007 12:49:00 GMThttp://www.blogjava.net/keweibo/articles/140656.htmlhttp://www.blogjava.net/keweibo/comments/140656.htmlhttp://www.blogjava.net/keweibo/articles/140656.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/140656.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/140656.html应用中异常的处理的原则

  在处理应用中的异常时,通常可以将应用中所遇到的异常分为两大类,一种是业务异常,一种是非业务异常.
  业务异常是指在进行正常的业务处理时,由于某些业务的特殊需求而导致处理不能继续所抛出的异常,这种异常
常是由开发人员所定义,它属于可以预知的异常. 
  非业务异常是指在正常情况下所产生的异常.例如,由于网络故障而导致无法访问数据库,必要的配置文件不存在
等情况下所产生的异常都属于非业务异常.非业务异常是不可预知的.

业务异常的处理

  在业务层或者业务处理方法中抛出异常,在表示层拦截异常,并将异常以友好的方式反馈给操作者,以
便其可以提示信息正确的完成业务功能处理.在这里要注意的是,在表示层拦截异常不是只需要针对每个异常
都进行拦截和处理,而是是充分利用框架来进行统一的处理.最好做到正常的处理流程中看不到任何异常处理.

非业务异常的处理

  在应用的框架中进行统一的拦截和处理,在开发中不需要进行任何处理.对于非业务异常的处理结果
通常是返回到专门的错误页面,给出很泛泛的提示信息,表明系统发生不可预知的异常,并请与管理员联系
此类信息.

注:本文来自 struts,spring,hibernate集成开发 一书 



KE 2007-08-28 20:49 发表评论
]]>利用公共的Action实现用户合法性的校验http://www.blogjava.net/keweibo/articles/140649.htmlKEKETue, 28 Aug 2007 12:23:00 GMThttp://www.blogjava.net/keweibo/articles/140649.htmlhttp://www.blogjava.net/keweibo/comments/140649.htmlhttp://www.blogjava.net/keweibo/articles/140649.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/140649.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/140649.html利用公共的Action实现用户合法性的校验

  在这里,我们可以通过实现一个公共的Action并增加相应的权限验证功能来实现用户权限的校验工作.
这样,在进行业务功能开发的时候,所有需要执行权限校验的Action都需要继承自此公共的Action.
下面是一个简单的例子
具有校验功能的Action(SecureAction.java)
/*
 * Generated by MyEclipse Struts
 * Template path: templates/java/JavaClass.vtl
 */
package dgut.ke.struts.secure;

import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

/**
 * MyEclipse Struts
 * Creation date: 08-28-2007
 *
 * XDoclet definition:
 * @struts.action validate="true"
 */
public abstract class SecureAction extends Action {
 /*
  * Generated Methods
  */

 /**
  * Method execute
  * @param mapping
  * @param form
  * @param request
  * @param response
  * @return ActionForward
  */
 public final ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response)throws Exception {
  HttpSession session = request.getSession();
  String userId = (String)session.getAttribute("SESSION.USER");
  if(userId==null)
   return (mapping.findForward("isNullSession"));
  else
   return doExecute(mapping,form,request,response);
 }
 
 public abstract ActionForward doExecute(ActionMapping mapping,
             ActionForm form,
             HttpServletRequest request,
             HttpServletResponse response)
 throws Exception;
    
}
下面编写一个普通的Action(isNullSessionAction.java)继承自此公共Action
/*
 * Generated by MyEclipse Struts
 * Template path: templates/java/JavaClass.vtl
 */
package dgut.ke.struts.secure;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;


public class IsNullSessionAction extends SecureAction {

 @Override
 /*重写类中的方法*/
 public ActionForward doExecute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
  //通过父类的权限验证则该方法会被执行
  return mapping.findForward("success");
 }
}
struts-config.xml中的相关配置
  <action path="/isNullSession" type="dgut.ke.struts.secure.IsNullSessionAction">
     <forward name="success" path="/success.jsp"></forward>
     <forward name="isNullSession" path="/index.jsp"></forward>
  </action>
  <action path="/secureAction" type="dgut.ke.struts.secure.SecureActionAction"/>



KE 2007-08-28 20:23 发表评论
]]>使用Struts的PlugIn进行Web应用的扩展http://www.blogjava.net/keweibo/articles/140637.htmlKEKETue, 28 Aug 2007 11:18:00 GMThttp://www.blogjava.net/keweibo/articles/140637.htmlhttp://www.blogjava.net/keweibo/comments/140637.htmlhttp://www.blogjava.net/keweibo/articles/140637.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/140637.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/140637.html使用Struts的PlugIn进行Web应用的扩展

  Struts提供了PlugIn的方式来扩展Struts的功能,这种方式的扩展适合于实现Struts启动或者
停止时需要执行的某些特殊处理的情况,可以方便地实现Web应用启动时的系统初始化工作以及在Web
应用卸载时的资源释放工作,它不能实现针对每个用户请求的处理功能.
  开发一个Struts的PlugIn需要以下两个步骤:
(1)实现Struts定义的PlugIn接口,其中的init()方法将在应用启动时被调用,而destory()方法将在服务
终止时被调用.
(2)在Struts的配置文件中配置该PlugIn以及设置的初始化参数.Struts还允许为PlugIn定义一些参数,
在默认的情况下,这些参数必须作为PlugIn属性的形式出现,并且为每个参数提供符合javabean规范
的setter方法,而这些参数在struts的配置文件中进行.
  基本的配置形式如下:
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
 <set-property property="pathnames"
        value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>
</plug-in>
下面是一个例子.在服务器启动和停止时输出系统的时间.
MyPlugIn.java

package dgut.ke.struts.plugIn;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import javax.servlet.ServletException;

import org.apache.struts.action.ActionServlet;
import org.apache.struts.action.PlugIn;
import org.apache.struts.config.ModuleConfig;

public class MyPlugIn implements PlugIn {

 private String timePattern;
 public String getTimePattern() {
  return timePattern;
 }

 public void setTimePattern(String timePattern) {
  this.timePattern = timePattern;
 }

 public void destroy() {
  // TODO 自动生成方法存根
  DateFormat df = new SimpleDateFormat(getTimePattern());
  Calendar rightNow = Calendar.getInstance();
  Date now = rightNow.getTime();
  System.out.println("The service shutdown at --> "+df.format(now));
 }

 public void init(ActionServlet actionServlet, ModuleConfig moduleConfig)
   throws ServletException {
  DateFormat df = new SimpleDateFormat(getTimePattern());
  Calendar rightNow = Calendar.getInstance();
  Date now = rightNow.getTime();
  System.out.println("The service start at ---> "+df.format(now));

 }

}
相关配置
<plug-in className="dgut.ke.struts.plugIn.MyPlugIn">
    <set-property property="timePattern" value="yyyy-MM-dd" />
  </plug-in>



KE 2007-08-28 19:18 发表评论
]]>ForwardAction和IncludeActionhttp://www.blogjava.net/keweibo/articles/139960.htmlKEKEMon, 27 Aug 2007 07:18:00 GMThttp://www.blogjava.net/keweibo/articles/139960.htmlhttp://www.blogjava.net/keweibo/comments/139960.htmlhttp://www.blogjava.net/keweibo/articles/139960.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/139960.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/139960.htmlForwardAction

  基于struts的WEB应用系统通常情况下应该避免JSP页面之间的跳转.因为这样跳转的用户请求没有
经过Struts的处理,会导致很多在Struts框架中进行的处理不起的作用.
  对于每个用户的请求,struts的RequestProcessor将会进行一系列的处理,其中包括了国际化,权限
缓存等多方面.如果采用页面之间的直接跳转会导致很多内容都需要自己处理.

在struts中配置ForwardAction
  <action path="home"
      type="org.apache.struts.actions.ForwardAction"
      parameter="/index.jsp"
  />
  其中path属性是Action的匹配路径,type属性说明实现Action的类,parameter属性用于指定往哪转发
也就是转发的目的URI.这三个属性是必须的,其它的可以省略.
forward属性和ForwardAction
  使用forward进行页面跳转的配置方法如下
  <action path="/home"
      forward="/index.jsp"
  />
  forward属性和ForardAction在页面中使用时是没有区别的,并且在通常情况下struts对这两种形式
的跳转的处理也是相同的.但是使用自己的RequestProcessor并且覆盖了父类的processForwardConfig()
方法时,这两种方式就存在一定的区别了.

IncludeAction

  IncludeAction类的意义类似于ActionForward类,它和页面中的<jsp:include>动作或Servlet中的
RequestDispatcher的include()方法执行的功能一样的.在基于struts框架结构的应用中,最好不要在
<jsp:include>标记中直接引用另一个JSP页面,而是通过IncludeAciton来实现页面之间的引用,这样比较
安全等等.
  IncludeAction的使用
IncludeAction的使用和Forward基本相同,在页面中还可以通过<jsp:include>标记来调用.
<jsp:include page="/somePath/someAction.do" />
  IncludeAction的配置
  <action path="/include"
      type="org.apache.struts.actions.IncludeAction"
      parameter="/include.jsp"
  />
  include属性和IncludeAction
  Struts也可以通过使用include属性来在Action的配置文件中直接定义被引用的页面.如
  <action path="/include"
      include="/include.jsp"
  />



KE 2007-08-27 15:18 发表评论
]]>ActionForm中对集合属性的处理http://www.blogjava.net/keweibo/articles/139821.htmlKEKEMon, 27 Aug 2007 03:09:00 GMThttp://www.blogjava.net/keweibo/articles/139821.htmlhttp://www.blogjava.net/keweibo/comments/139821.htmlhttp://www.blogjava.net/keweibo/articles/139821.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/139821.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/139821.htmlpackage com.ke.struts.bean;

import java.util.ArrayList;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;


public class ActionForm extends ActionForm {

 private List<String> friends = new ArrayList<String>();
 private static String[] skillLevels = new String[]{"Beginner","Intermediate","Advanced"};
 private Map<String,Object> skills = new HashMap<String,Object>();
 

public ActionErrors validate(ActionMapping mapping,
   HttpServletRequest request) {
  // TODO Auto-generated method stub
  return null;
 }
 public void reset(ActionMapping mapping, HttpServletRequest request) {

  this.friends.clear();
 }
 public Object getSkill(String key)
 {
  return skills.get(key);
 }
 public void setSkill(String key,Object value)
 {
  skills.put(key, value);
 }
 public Map getSkills()
 {
  return skills ;
 }
 public String[] getSkillLevels()
 {
  return skillLevels;
 }
 public List<String> getFriends() {
  return friends;
 }

 public void setFriends(List<String> friends) {
  this.friends = friends;
 }
 
 public void setFriend(int index,String friend)
 {
  if(this.friends.size() > index)
  {
   /*用指定的元素替代此列表中指定位置上的元素*/
   this.friends.set(index, friend);
  }
  else
  {
   while(this.friends.size() < index)
   {
    this.friends.add(null);
   }
   this.friends.add(index, friend);
  }
 }
 
 public String getFriend(int index)
 {
  if(this.friends.size() > index)
  {
   return (String)this.friends.get(index);
  }
  else
  {
   return null ;
  }
 }
}
输入页面
     Friend 1 :<html:text property="friend[0]"></html:text><br>   <!-- 调用setFriend(int index,String friend)-->
     Friend 2 :<html:text property="friend[1]"></html:text><br>
     Friend 3 :<html:text property="friend[2]"></html:text><br>
java skill: <html:select property="skill(java)">   <!-- 调用setSkill(String key,Object value) -->
                <html:options property="skillLevels"/>
              </html:select><br>
  jsp skill:<html:select property="skill(jsp)">
                <html:options property="skillLevels"/>
              </html:select><br>
  struts skill:<html:select property="skill(struts)">
                   <html:options property="skillLevels"/>
                 </html:select><br>

输出页面
    Friend 1:<bean:write name="ActionForm" property="friend[0]"/><br><!-- 调用getFriend(int index)-->
    Friend 2:<bean:write name="ActionForm" property="friend[1]"/><br>
    Friend 3:<bean:write name="ActionForm" property="friend[2]"/><br>
  java skill :<bean:write name="ActionForm" property="skill(java)"/><br><!-- 调用getSkill(String key) -->
  jsp skill :<bean:write name="ActionForm" property="skill(jsp)"/><br>
  struts skill :<bean:write name="ActionForm" property="skill(struts)"/>

 



KE 2007-08-27 11:09 发表评论
]]>柱状图显示http://www.blogjava.net/keweibo/articles/139803.htmlKEKEMon, 27 Aug 2007 02:41:00 GMThttp://www.blogjava.net/keweibo/articles/139803.htmlhttp://www.blogjava.net/keweibo/comments/139803.htmlhttp://www.blogjava.net/keweibo/articles/139803.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/139803.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/139803.html<%@ page language="java" contentType="text/html;charset=gbk"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>柱状图显示页面</title>
  </head>
  <body>
    <div align="center">
      <h3>Color Bar Chart (horizontal)</h3>
      <table width="60%">
        <c:forEach var="col" items="${weekWeather}">
          <tr>
            <td align="right" width="20%">${col.item }(${col.percent }%)</td>
            <td align="left" width="80%">
              <table width="100%" height="20">
                <tr>
                  <td width="${col.percent }%" bgcolor="#003366"></td>
                  <td width="${100-col.percent }%"></td>
                 </tr>
              </table>
        </c:forEach>
      </table>
      <hr>
      <h3>Color BAr Chart (vertical)</h3>
      <table width="300" height="500">
        <tr>
        <c:forEach var="row" items="${weekWeather }">
         <td>
          <table width="100%" height="100%">
             <tr>
               <td height="${100-row.percent }%"></td>
             </tr>
               <tr>
              <td height="${row.percent }%" bgcolor="#006633"></td>
            </tr>
            <tr>
              <td align="center">${row.item }(${row.percent }%)</td>
            </tr>
          </table>
      </td>
        </c:forEach>
        </tr>
      </table>
    </div>
  </body>
</html>



KE 2007-08-27 10:41 发表评论
]]>struts中AtionErrors和ActionMessages的区别(转)http://www.blogjava.net/keweibo/articles/138223.htmlKEKEMon, 20 Aug 2007 12:26:00 GMThttp://www.blogjava.net/keweibo/articles/138223.htmlhttp://www.blogjava.net/keweibo/comments/138223.htmlhttp://www.blogjava.net/keweibo/articles/138223.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/138223.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/138223.htmlstruts中AtionErrors和ActionMessages的区别

尽管Struts框架提供了有效的异常处理机制，但不能保证处理所有的错误，这时Struts框架会把错误抛给Web容器，在默认情况下Web容器会向用户浏览器直接返回原始信息。如果想避免直接让用户看到这些原始信息，可以在web.xml中配置<error-page>元素，以下代码演示了如何避免用户看到HTTP 404、HTTP 500错误和Exception异常。

web.xml:
  <error-page>
    <error-code>404</error-code>
    <location>/exception/error404.jsp</location>
  </error-page>
  <error-page>
    <error-code>500</error-code>
    <location>/exception/error500.jsp</location>
  </error-page>
  <error-page>
    <exception-type>java.lang.Exception</exception-type>
    <location>/exception/default.jsp</location>
  </error-page>
当WEB容器捕获到exception-type或error-code指定的错误时将跳到由location指定的页面。

 问题：当form bean 为动态bean时，在action中无法对form bean数据进行验证，因为formbean没有具体实现类。action中无法引用
 ActionError/ActionErrors/ActionMessage/ActionMessages:

有时候你需要向用户提供相关处理信息，包括表单验证时发现错误等。
1. 相关类介绍：
ActionMessage：用于保存一个与资源束对应的提示信息。主要构造函数如：
ActionMessage(String message)；
ActionMessage(String message,paramater)。

ActionMessages:用于保存多个ActionMessage。并在html:errors 和html:messages中起作用。
主要构造函数：
ActionMessages().
主要方法是add(String property,ActionMessage message)
ActionMessages有一个HashMap类型messages保存多个ActionMessage对象，每个ActionMessage对象都有唯一的一个property标识。这个property可以是自定义的任意字符串，也可以由org.apache.struts.action.ActionMessages.GLOBAL_MESSAGE指定
html:messages/html:errors使用property属性访问某个资源

ActionErrors：用于保存一个与资源束对应的错误信息。用法跟ActionMessages差不多。
ActionError不赞成使用。


2. 版本：
struts1.1中用ActionErrors报告错误，用ActionMessages提供信息。
在struts1.2中使用ActionMessages提供信息和错误，不赞成使用ActionError
struts1.3中已经没有ActionError类了。

3． AtionErrors和ActionMessages的区别

1． ActionErrors是ActionMessages的一个子类，功能几乎相同，不同点在于标签<html:errors/>和<html:messages>的使用上的区别。
html:errors指定了footer和header属性。默认值为errors.header和errors.footer,需要时可以自己指定。如果资源属性文件配置了 errors.header和errors.footer，则任何时候使用html:errors时开头和结尾都是这两个属性对应的资源信息。
而html:message默认情况下没有errors.header和errors.footer值，当然可以自己指定。

2． html:errors可以根据property属性指定显示一个错误信息。html:messages有一个必添项id。html:messages不能直接显示信息，它将选出的信息放入一个用id标识的Iterator对象里，然后在用ben:write或JSTL c:out标签显示每个信息.例如：
<html:messages message="true" id="msg">
    <c:out value="${msg}"/><br />
</html:messages>

3. 具体的一个例子：
接受输入页面input.jsp:

  <html:form action="/errormessage/input">
    phoneNumber : <html:text property="phoneNumber"/> <html:errors     property="<%=org.apache.struts.action.ActionMessages.GLOBAL_MESSAGE %>"/><br/>
  <html:submit/><html:cancel/>
  </html:form>

struts-config.xml:
  <form-beans >
    <form-bean name="inputForm" type="cn.rolia.struts.form.errorexception.InputForm" />
  </form-beans>
  <action-mappings >
    <action
      attribute="inputForm"
      input="/errormessage/input.jsp"
      name="inputForm"
      path="/errormessage/input"
      scope="request"
      type="com.yourcompany.struts.action.errormessage.InputAction"
      validate="false">
      <forward name="success" path="/errormessage/success.jsp" />
    </action>
  </action-mappings>

InputAction.java:

public ActionForward execute(ActionMapping mapping, ActionForm form,
    HttpServletRequest request, HttpServletResponse response) {
  cn.rolia.struts.form.errorexception.InputForm inputForm = (cn.rolia.struts.form.errorexception.InputForm) form;// TODO Auto-generated method stub
  String phoneNumber = inputForm.getPhoneNumber();
  if(phoneNumber.length()<4){
  ActionErrors messages = new ActionErrors();
    messages.add(org.apache.struts.action.ActionMessages.GLOBAL_MESSAGE,new ActionMessage("error.errormessage.input"));
    this.saveErrors(request, messages);
    return mapping.getInputForward();
  }

  return mapping.findForward("success");
}
解说：用户输入手机号码，页面跳转到InputAction控制层进行处理，若输入数据小于4，则创建一个ActionMessage类存储相关错误信息。然后再创建ActionErrors类将此ActionMessage放入ActionErrors。再调用Action的saveErrors方法将此ActionErrors保存的request范围里，然后返回input.jsp页面要求重新输入并用html:errors提示错误信息。

4. Action包含saveErrors()方法和saveMessages()方法。

如果创建的ActionErrors则应该调用saveErrors()，若创建的是ActionMessages则应该调用saveMessages()方法。
saveErrors()接收ActionMessages而不是ActionErrors;同时将其保存在request中并用一个由org.apache.struts.Globals.ERROR_KEY指定的常量” org.apache.struts.Globals.ERROR_KEY”标识这个ActionMessages，便于html:errors查找。saveMessages()方法接收ActionMessages同时将其保存在request中并用一个由org.apache.struts.Globals.MESSAGE_KEY指定的常量” org.apache.struts.Globals.MESSAGE_KEY”标识这个ActionMessages，进而让html:messages从常量Globals.ERROR_KEY中遍历获取信息。可以将其属性message设置为true，那么它将从常量Globals.MESSAGE_KEY中遍历获取信息。

5. 默认情况下html:messages从如果你想将信息保存在session里而不是request，struts1.2提供了
struts1.1没有的saveMessages(HttpSession session, ActionMessages messages)方法和saveErrors(javax.servlet.http.HttpSession session, ActionMessages errors)方法。
InputAction.java:

public ActionForward execute(ActionMapping mapping, ActionForm form,
    HttpServletRequest request, HttpServletResponse response) {
cn.rolia.struts.form.errorexception.InputForm inputForm = (cn.rolia.struts.form.errorexception.InputForm) form;// TODO Auto-generated method stub
  String phoneNumber = inputForm.getPhoneNumber();
  if(phoneNumber.length()<4){
    ActionErrors messages = new ActionErrors();
    messages.add(org.apache.struts.action.ActionMessages.GLOBAL_MESSAGE,new ActionMessage("error.errormessage.input"));
    this.saveErrors(request.getSession(true), messages);
    return mapping.getInputForward();
  }

  return mapping.findForward("success");
}



KE 2007-08-20 20:26 发表评论
]]>Struts标签库(转)http://www.blogjava.net/keweibo/articles/138222.htmlKEKEMon, 20 Aug 2007 12:23:00 GMThttp://www.blogjava.net/keweibo/articles/138222.htmlhttp://www.blogjava.net/keweibo/comments/138222.htmlhttp://www.blogjava.net/keweibo/articles/138222.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/138222.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/138222.html阅读全文

KE 2007-08-20 20:23 发表评论
]]>Action中添加请求参数http://www.blogjava.net/keweibo/articles/138088.htmlKEKEMon, 20 Aug 2007 04:29:00 GMThttp://www.blogjava.net/keweibo/articles/138088.htmlhttp://www.blogjava.net/keweibo/comments/138088.htmlhttp://www.blogjava.net/keweibo/articles/138088.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/138088.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/138088.htmlAction中的内容
ActionForward  forwrad  =   mapping . findForward(" show" );

StringBuffered path = new StringBuffered(forward.getPath());

if ( path.indexOf("?") >= 0 )
{
      path.append(" &nbsp;paramId=paramValue");
}
else
{
      path.append("?paramId=paramValue");
}

return new ActionForward( path.toString() );

struts-config.xml中的内容

<forward  name="show"  path="/show.jsp"  />



KE 2007-08-20 12:29 发表评论
]]>Struts中配置Validator插件http://www.blogjava.net/keweibo/articles/137801.htmlKEKESat, 18 Aug 2007 05:02:00 GMThttp://www.blogjava.net/keweibo/articles/137801.htmlhttp://www.blogjava.net/keweibo/comments/137801.htmlhttp://www.blogjava.net/keweibo/articles/137801.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/137801.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/137801.html    <set-property property="pathnames" value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml" />
 </plug-in>
required : 强制某个域不能为空，它没有参数。
validwhen : 通过一个域的值来检查另一个域的值。
minlength ; 检查用户输入的数据长度不小于某个指定的值，需要一个最小的长度变量。
                 配置方法如下
                  <field property="username" depends="required,minlength">
                     <arg key="form.username" />
                     <arg position="1" name="minlength" key="${var : minlength}" resource="false" />
                     <var>
                           <var-name>minlength</var-name>
                           <var-value>6</var-value>
                     </var>
                  </field>
maxlength : 检查用户输入的最大长度。具体配置方法参照上面minlength的配置。
mask : 根据正则表达式来检查数据的格式，它需要一个正则表达式掩码变量。从struts1.1开始，正则表达式必须以“^”开始并以“$”结束，其配置如下
            <field property="username" depends="mask">
               <arg key="form.username" />
               <var>
                    <var-name>mask</var-name>
                    <var-value>^[a-zA-Z]*$</var-value>
                </var>
            </field>
data : 检查一个域是否可以被转换成Data对象。它使用java.text.SimpleDateFormat来进行分析和检验，它可以使用dataPatten或者dataPattenStrict(这个比较严格，它要求输入的数据长度必须与模式中的指定长度一致）例如：
             <field property="birthday" depends="date">
                <arg key="form.date"/>
                <var>
                    <var-name>dataPattern</var-name>
                    <var-value>yyyy-MM-dd</var-value>
                </var>
             </field>
intRange  /  floatRange  /  doubleRange : 检验一个整数 / 浮点数 / 双精度浮点数 的值是否在一个指定的范围内，需要最大值和最小值来指定范围。这些检验分别要依赖于 integer  /  float  / double  检验，所以也要要求将它们也指定到depends属性中。它定义的方法如下（这里以intRange为例）
            <field proerty="age" depends="required,integer,intRange">
               <arg position="0" key="form.age" />
               <arg position="1" name="intRange" key="${var : min }" resource="false" />
               <arg position="2" name="intRange" key="${var : max}" resource="false" />
                     <var>
                           <var-name>min</var-name>
                           <var-value>6</var-value>
                     </var>
                     <var>
                           <var-name>max</var-name>
                           <var-value>16</var-value>
                     </var>
creditCard : 检验一个信用卡的格式是否正确，不需要任何参数，它的定义如下。
                  <field property="card" depends="required,creditCard">
                        <arg key="form.card" />  
                   </field>
email : 检验电子邮件地址格式是否正确，不需要任何参数，它的定义如下。
                 <field property="email" depends="required,email">
                      <arg key="form.email"/>
                  </field>
url : 检验URL的格式是否正确。它有四个参数，分别是allowallschemes,allow2slashes,nofragments和schemes 。
   allowallschemes : 用来指明是否允许所有的schemes 。它的值可以为true(允许）/  false（禁止），默认值为false。如果这个值被设置为真，那么将会忽略schemes变量。
   allow2slashes : 用来指明是否允许两个“/”出现。它的值可以为true(允许）/  false（禁止），默认值为false。
   nofragments : 用来说明是否不允许分段。它的值可以为true(不允许）/  false（允许），默认值为false。
   schemes : 指定合法的schemes，多个可以用逗号分隔。如果没有进行指定，那么默认为http , https ,  和 ftp  。
            url检验的方法如下
           <field proper="custUrl" depends="url" >
                <arg key = "form.coutUrl" />
            </field>

         <field proper="custUrl" depends="url" >
                <arg key = "form.coutUrl" />
                  <var>
                     <var-name>nofragments</var-name>
                     <var-value>true</var-value>
                  </var>
                  <var>
                     <var-name>schemes</var-name>
                     <var-value>http,https,telnet,file</var-value>
                  </var>
            </field>
验证两个输入域是否相等
             <field property="password2" depends="required,validwhen">
                <arg position="0" key="form.password2" />
                <arg position="1" key="form.password" />
                <msg name="validwhen" key="error.password.mathch"/>
                <var>
                    <var-name>test</var-name>
                    <var-value>(*this* == password)</var-value>
                </var>
              </field>


初始化配置文件
 validation.xml内容如下
 <?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE form-validation PUBLIC "-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1.3//EN" "validator_1_1_3.dtd" >
<form-validation>
 <formset>
  <form name="userForm">
      <field proper="" depends="">
            ....................................
      </field>
  </form>
 </formset>
</form-validation>
-------------------------------------------------------------------------------------------------------------------------------
Validator的调用配置
Validator的调用方法要依据所采用的验证方式而定。
   后台服务器端验证
      Action中的Validate属性值设为 true
      还有在页面中通过<html:errors />标记来显示错误信息
   前台Javascrip验证
      Action中的Validate属性值设为 false
     还有在页面用使用<html:javascript />
      <html:form onsubmit="return ValidateXXXForm(this)" >
      </html:form>
      <html:javascript forName="XXXForm" />


KE 2007-08-18 13:02 发表评论
]]>重写ActionServlet解决乱码http://www.blogjava.net/keweibo/articles/137536.htmlKEKEFri, 17 Aug 2007 06:09:00 GMThttp://www.blogjava.net/keweibo/articles/137536.htmlhttp://www.blogjava.net/keweibo/comments/137536.htmlhttp://www.blogjava.net/keweibo/articles/137536.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/137536.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/137536.html写一个MyActionServlet来并覆盖ActionServlet中的process（）方法。
添加一行代码:request.setCharacterEncoding("gbk");就可以了.

package com.ke.struts;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionServlet;

public class MyActionSerlvet extends ActionServlet
{

 @Override
 protected void process(HttpServletRequest request,
   HttpServletResponse response) throws IOException, ServletException {
  request.setCharacterEncoding("gbk");
  super.process(request, response);
 }
 
}

当然别忘了改一下web.xml里面的配置
  <servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>com.ke.struts.MyActionSerlvet</servlet-class><!-- 需要修改的地方 -->
    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <init-param>
      <param-name>debug</param-name>
      <param-value>3</param-value>
    </init-param>
    <init-param>
      <param-name>detail</param-name>
      <param-value>3</param-value>
    </init-param>
    <load-on-startup>0</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>

改一下servlet-class标签中的内容就可以！

真的可以，一劳用yi！

具体编码的理论就不说了，google上已经够多了。

另外，如果不用struts的话，hibernate也可能碰到中文乱码问题，
只要在hibernate.cfg.xml配置中如下：

<property name="hibernate.connection.url">   jdbc:microsoft:sqlserver://Localhost:1433;SelectMethod=cursor;characterEncoding=GBK;DatabasName=myDatabase. 
</property>

characterEncoding=GBK！就可以了



KE 2007-08-17 14:09 发表评论
]]>使Struts 中的 properties属性的文件支持中文的插件的安装方法http://www.blogjava.net/keweibo/articles/137531.htmlKEKEFri, 17 Aug 2007 06:05:00 GMThttp://www.blogjava.net/keweibo/articles/137531.htmlhttp://www.blogjava.net/keweibo/comments/137531.htmlhttp://www.blogjava.net/keweibo/articles/137531.html#Feedback0http://www.blogjava.net/keweibo/comments/commentRss/137531.htmlhttp://www.blogjava.net/keweibo/services/trackbacks/137531.html使Struts 中的 properties属性的文件支持中文的插件的安装方法
 在此想和大家分享一个不错的编写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的图标作为标识。
 



KE 2007-08-17 14:05 发表评论
]]>