struts初认识笔记心得

来源：互联网发布：js获取input数组的值编辑：程序博客网时间：2024/06/13 22:32

Struts的配置：
1：首先将所用架包拷贝到WEB-INF/lib下
2：在WEB-INF/下建立struts-config.xml文件即提供struts-config.xml文件
<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.2//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_2.dtd">
<struts-config>

<form-beans>里面的内容是ActionForm信息</form-beans>

<action-mappings>
  <action 这里面有一些属性要配置>
  <forward name="" path=""/>
  </action>
</action-mappings>
</struts-config>
其实一开始只需要有一个框架即可。<struts-config></struts-config>
3:修改web.xml文件配置ActionServlet
怎么配置呢？
这里使用的是官方的
<servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts-config.xml</param-value>
    <load-on-startup>2</load-on-startup>
</servlet>
4：根据具体的项目，看看有多少Action以及所需相应的ActionForm（ActionForm根据实际情况，可有可无）在structs-config.xml的配置如下

：在<form-beans><form-bean name="loginForm" type="com.bjsxt.struts.LoginActionForm"/></form-beans>这里的name的命名可以任意，

自己感觉怎么方便怎么起。但是type必须指定该class具体的包名+类名。
但是在<action-mappings>
  <action path="/login"
    type="com.bjsxt.struts.LoginAction"
    name="loginForm"
    scope="request"
    validate="false"
  >
   <forward name="success" path="/login_success.jsp"/>
   <forward name="error" path="/login_error.jsp"/>
  </action>

</action-mappings>
中<action-mapping></action-mapping>中设置相应的action信息，其中action中的path指的是信息页面所提交页面的路径的最后一个“/”与

“.”之间的内容包括“/”。type指定的是该Action所在的包名和类名。name指的是该Action涉及到ActionForm类所起的别名，但是必须和

<form-bean>中的name一致。
设置<forward name="" path="">这里的name与定义的Action（该Action继承了Structs中的Action）类中重构方法
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws Exception{}

中return mapping.Forward("")中的字符串相同。这里就是转向控制的，关于其他的属性，在以后的学习中继续总结。12:03 2010-2-15
下面对struts taglib部分总结：
struts标签的配置和使用
配置：
在struts-config.xml文件中加入<message-resources parameter="MessageResources"/>到<struts-config></struts-config>中，但是由于

dtd的限制，必须将该语句放到最后。
同时拷贝MessageResources.properties文件拷到src下。
使用：
在jsp页面中要使用struts taglib则必须引用以下相应的标签指令。
<%@ taglib prefix="bean" uri="http://struts.apache.org/tag-bean"%>
<%@ taglib prefix="logic" uri="http://struts.apache.org/tags-logic"%>
关于bean标签：主要有以下功能标签;
其中的<bean:write name="" filter="" format="yyyy-MM-dd HH:mm:ss" property="">
下面解释一下各个属性的意义。(这里用到的是struts的架构)
name就是在定义的Action中request.setAttribute("Str",object)的Str
filter的属性只用两个，true和false如果是true，则输出的内容按原模样输出，像“<font color='red'>北京欢迎您</font>“输出的内容仍

为<font color='red'>北京欢迎您</font>，如果是false则输出的则是“北京欢迎你”且字体为红色。
关于format无论你怎么定义都可以，format="###,###.####"
format="###,###.0000"后者，如果数据位数不够，怎么自动补零，但是前者不会，如果位数不够，有多少，显示多少。property一般用在有结

构的数据中，但是很常用的。像定义个用户，该用户拥有自己的属性，像年龄，姓名，同时还涉及到其他对象，像组别等，就是耦合，像：
<li>结构</li>
姓名：<bean:write name="user" property="username" /><br>
年龄：<bean:write name="user" property="age"/><br>
组名：<bean:write name="user" property="group.name"/>
(这里的property对应的名字必须和编写的JavaBean中getXXX()的XXX相对应。因为这里调用了该方法，如果不这样写，就会出现错误。)
下面介绍
<logic:empty name="">为空</logic:empty>
<logic:notEmpty name="">不为空</logic:notEmpty>
<logic:present name="">存在</logic:present>
<logic:notPresent name="">不存在</logic:notPresent>
其实上面显示的都是true OR false;
只用条件满足时，才会显示相应的信息。
下面介绍：
iterate标签，
这是个迭代标签，可以遍历输出list中相关的数据。要实现这种功能，必须借助上述标签。才可以。例如：
<table border="1">
  <tr>
   <td>姓名</td>
   <td>年龄</td>
   <td>所属组</td>
  </tr>
  <logic:empty name="userlist">
  <tr>
    <td colspan="3">没有符合条件的数据!</td>
   </tr>

  </logic:empty>
  <logic:notEmpty name="userlist">
  <logic:iterate id="u" name="userlist">
   <tr>
     <td>
      <bean:write name="u" property="username"/>
     </td>
     <td>
      <bean:write name="u" property="age"/>
     </td>
     <td>
      <bean:write name="u" property="group.name"/>
     </td>
    </tr>
  </logic:iterate>

  </logic:notEmpty>
</table>
其中<logic:iterate id="u" name="userlist">中，id指的就是遍历时，每一个对象。而userlist指的就是在Action类中实现的用户链表，然

后又加到request对象中。request.setAttrbute("userlist",userlist);即可。常用的struts标签就总结到此。11:47 2010-2-17

下面介绍：JSTL核心库认识与总结。
首先，将jstl.jar和standard.jar拷贝到WEB-INF/lib下。如果只使用el表达式，不需要拷贝这两个jar
(注意jstl必须在能够支持j2ee1.4/servlet2.4/jsp2.0版本上的容器才能运行，这个环境是目前较为常用的环境)
标签库的使用
采用taglib指令引入
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>

<c:out value="" escapeXml="" default="" />
OR
<c:out value="" escapeXml="">defaultvalue</c:out>
上面的两种情况，其实是一样的。其中value代表的是值，如果不用el表达式，结果为输入的什么值，就是什么。escapeXml只有两个值，true

Or false 其实和标签<bean:write name="" filter=""/>中的 filter是一样的效果。
下面介绍一下<c:set value="" var="" scope="">上述标签的意思是给变量var所代表的“实体名”赋值,而这个值就是value所代表的。这里可

以用到el标签。
下面介绍一下<c:remove var=""/>标签
这里的var和<c:set var="" value=""/>中的含义是一样的。
下面介绍<c:if test="${v1 lt v2}" var="v">
v1小于v2<br>v=${v }<br>
</c:if>
test代表的是true OR false var代表的是该表达式返回的是true Or false的变量标签
<c:if test="${empty v3}">
v3为空<br>

</c:if>
下面介绍c:choose c:when c:otherwise标签
首先声明，c:choose是上述三个标签的开始标签。意思是要用到c:when和c:otherwise,就必须有c:choose标签，该标签在外在c:choose中可以

有多个c:when标签，但是c:otherwise只有一个，且在最后。且c:otherwise没有条件。
<c:choose>
<c:when test="${v1 lt v2}">
v1小于v2<br>
</c:when>
<c:when test="${v1 gt v2}">
v1大于v2<br>
</c:when>
</c:choose>

<c:choose>
<c:when test="${empty v4}">
v4为空<br>
</c:when>
<c:otherwise>
v4不为空<br>
</c:otherwise>
</c:choose>
下面是对c:forEach标签的总结
看下面代码示例即可。
<c:choose>
     <c:when test="${empty userlist}">
<tr>
    <td colspan="3">没有符合条件的            数据!</td>
</tr>
     </c:when>
     <c:otherwise>
<c:forEach              var="u"items="${userlist}">
                <tr>
                    <td>${u.username }</td>
                    <td>${u.age}</td>
                    <td>${u.group.name }</td>
                </tr>
            </c:forEach>

    </c:otherwise>

</c:choose>
上述代码主要是依次遍历userlist中元素的值。
下面介绍一下标签循环控制标签c:forEach,Varstatus
<c:forEach var="u" items="${userlist}" varStatus="vs">
<c:choose>
   <c:when test="${vs.count % 2 == 0}">
tr bgcolor="red">
   </c:when>
<c:otherwise>
<tr>
</c:otherwise>
</c:choose>
<td>${u.username }</td> </c:forEach>
上述的vs.count指的是遍历的第几个。
下面介绍循环控制标签c:forEach,begin,end,step
代码示例如下：
<c:forEach var="u" begin="1" end="90" step="2" items="${userlist}">   <tr>

<td>${u.username }</td> </tr> </c:forEach>
遍历采用的是步长是2，从1开始遍历，如果数据充足，到90。否则直到数据结尾或结尾-1
下面介绍循环控制标签c:forEach，输出map
<c:forEach items="${mapvalue}" var="map">
${map.key }
</c:forEach>
下面介绍循环控制标签c:forTokens
<c:forTokens items="${strTokens}" delims="," var="v">
${v }
</c:forTokens>
得到的items是含有符号“，”，则去掉“，”将其挨个分开。其实delims可以定义任何类型的符号。

下面介绍c:catch标签
<li>测试c:catch</li><br>
<%
  try {
   Integer.parseInt("asdfsdf");
  }catch(Exception e) {
   out.println(e.getMessage());
  }
%>
<p>
<c:catch var="exinfo">
  <%
   Integer.parseInt("asdfsdf");
  %>
</c:catch>
${exinfo }

下面介绍引用页面的标签c:import
<c:import url="http://localhost:8080/structs_login_lab/login.jsp"></c:import>在引用的位置显示该页面。应该有一定用处
下面介绍的是怎么把url及参数赋值呢？
下面介绍标签c:url和c:param
前者是可以给url赋值，后者可以给url后面带的的参数赋值。源码示例如下：
<c:url var="v" value="http://localhost:8080/shop/admin/productadd.jsp">
<c:param name="name" value="nameValue"></c:param>
<c:param name="normalPrice" value="233"></c:param>
<c:param name="memberPrice" value="232"></c:param>
<c:param name="categoryid" value="categoryidvalue"></c:param>
<c:param name="descr" value="descrvalue"></c:param>
</c:url>
${v }
(注意c:param标签在c:url标签里。)
上述${v}的值为http://localhost:8080/shop/admin/productadd.jsp?

name=nameValue&normalPrice=233&memberPrice=232&categoryid=categoryidvalue&descr=descrvalue
像上述的标签还是比较有用的。
下面对重定向标签的定义，
<c:redirect url="http://localhost:8080/shop/admin/productadd.jsp"></c:redirect>

下面介绍对jstl格式化库的部分认识。
today(default):<fmt:formatDate value="${today}"/><br>
today(type="date"):<fmt:formatDate value="${today}" type="date"/><br>
today(type="time"):<fmt:formatDate value="${today}" type="time"/><br>
today(type="both"):<fmt:formatDate value="${today}" type="both"/><br>
today(dateStyle="short"):<fmt:formatDate value="${today}" dateStyle="short" type="both"/><br>
today(dateStyle="medium"):<fmt:formatDate value="${today}" dateStyle="medium" type="both"/><br>
today(dateStyle="long"):<fmt:formatDate value="${today}" dateStyle="long" type="both"/><br>
today(dateStyle="full"):<fmt:formatDate value="${today}" dateStyle="full" type="both"/><br>
today(pattern="yyyy/MM/dd HH:mm:ss"):<fmt:formatDate value="${today}" pattern="yyyy/MM/dd HH:mm:ss"/><br>
today(pattern="yyyy/MM/dd HH:mm:ss"):<fmt:formatDate value="${today}" pattern="yyyy/MM/dd HH:mm:ss" var="d"/><br>
上述最后一个示例中带var="d"则不会显示数据，只有在其后加上${d}
显示如下：
测试日期的格式化
today(default):2010-2-20
today(type="date"):2010-2-20
today(type="time"):16:55:49
today(type="both"):2010-2-20 16:55:49
today(dateStyle="short"):10-2-20 16:55:49
today(dateStyle="medium"):2010-2-20 16:55:49
today(dateStyle="long"):2010年2月20日 16:55:49
today(dateStyle="full"):2010年2月20日星期六 16:55:49
today(pattern="yyyy/MM/dd HH:mm:ss"):2010/02/20 16:55:49
today(pattern="yyyy/MM/dd HH:mm:ss"):
2010/02/20 16:55:49
<li>测试数字的格式化</li><br>
n(default):<fmt:formatNumber value="${n}" ></fmt:formatNumber><br>
n(pattern="###,###.##"):<fmt:formatNumber value="${n}" pattern="###,###.##" ></fmt:formatNumber><br>
(pattern="###,###.0000"):<fmt:formatNumber value="${n}" pattern="###,###.0000" ></fmt:formatNumber><br>
n(groupingUsed="false"):<fmt:formatNumber value="${n}" groupingUsed="false"></fmt:formatNumber><br>
n(minIntegerDigits="10"):<fmt:formatNumber value="${n}" minFractionDigits=""></fmt:formatNumber><br>
n(type="currency"):<fmt:formatNumber value="${n}" type="currency"></fmt:formatNumber><br>
n(type="currency" currencySymbol="$"):<fmt:formatNumber value="${n}" type="currency"

currencySymbol="$"></fmt:formatNumber><br>
n(type="percent"):<fmt:formatNumber value="${n}" type="percent"></fmt:formatNumber><br>
显示的结果如下：
测试数字的格式化
n(default):123,456.123
n(pattern="###,###.##"):123,456.12
n(pattern="###,###.0000"):123,456.1230
n(groupingUsed="false"):123456.123
n(minIntegerDigits="10"):123,456.123
n(type="currency"):￥123,456.12
n(type="currency" currencySymbol="$"):$123,456.12
n(type="percent"):12,345,612%
下面介绍一下自定义函数库
1、首先定义类和方法(方法必须是public static类型的)
2、其次是编写自定义的tld文件，并将此文件放到WEB-INF或WEB-INF任意子目录下
3、再次，在jsp中采用taglib指令引入自定义标签库。
4、最后，在jsp页面中引用采用前缀+冒号+函数名，调用即可。
TLD文件模板：
<?xml version="1.0" encoding="UTF-8" ?>

<taglib 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-jsptaglibrary_2_0.xsd"
version="2.0">

<description>my functions library</description>
<display-name>my functions</display-name>
<tlib-version>1.0</tlib-version>
<short-name>my</short-name>
<uri>http://www.syah.com/functions</uri>

<function>
    <name>say</name>
    <function-class>com.sy.struts.MyFunctions</function-class>
    <function-signature>java.lang.String sayHello(java.lang.String)</function-signature>
</function>

</taglib>
下面解释一下上面代码的含义：
<uri>可以随意定义。
在jsp页面引用时，一定要一样。
下面主要介绍标签<function></fountion>中间的内容。name指的是在jsp页面中调用的函数名，它可以不是类中的静态方法名，可以任意，但

是最好和方法名一样，有利于辨认。<function-class>指的是具体的包名+类名
<function-signature>指的是方法返回的类型+方法名(这里不可以任意)
定义的类及方法：
package com.sy.struts;

public class MyFunctions {

/**
* 方法必须是public static
* @param name
* @return

*/
public static String sayHello(String name) {
  return "Hello " + name;
}
}
jsp页面的引用：
<%@ taglib prefix="my" uri="http://www.syah.com/functions" %>
jsp页面标签的使用：
<li>测试自定义函数库</li><br>
${my:say(name) }
自定义函数库和自定义标签库是有差异的。这里不仔细说了。
下面介绍动态ActionForm
动态ActionForm是为了避免ActionForm膨胀而设计的，使用动态ActionForm可以获得标准ActionForm的所有功能。
*在struts-config.xml文件中定义动态ActionForm，如：
<form-beans>
  <form-bean name="dynaForm" type="org.apache.struts.action.DynaActionForm">
   <form-property name="username" type="java.lang.String" />
   <form-property name="age" type="java.lang.Integer"/>
  </form-bean>
</form-beans>
*在Action中使用动态ActionForm
DynaActionForm daf = (DynaActionForm)form;
String username = (String)daf.get("username");
Integer age = (Integer)daf.get("age");
在这里唯一的区别是：获取数据时，只用到get方法，方法有参数，而标准的ActionForm自己定义getXXX()方法。动态的ActionForm取值时就像

mysql中rs.getString("")等等。
动态ActionForm其实是把页面中的html元素的名字和值放到map中，所以通过get方法可以取出相应的值。
动态ActionForm采用El表达式的输出方式${dynaform.map.prop}其中prop代表属性名，dynaform指的是struts-config.xml文件中定义的动态

ActionForm的name属性值。
动态Action的验证，通常使用动态验证框架validator
2、采用struts上传文件
* 页面的配置，如：
<form action="upload.do" method="post" enctype="multipart/form-data">
  标题：<input type="text" name="title"><br>
  文件：<input type="file" name="myfile"><br>
<input type="submit" value="提交">
</form>
*ActionForm中使用FormFile来接收上传的文件
private String title;
private FormFile myfile;
给这两个属性生成get和set方法即可
* 在Action中调用FormFile取得上传文件数据，采用流输出，即完成上传，参见：UploadActionForm uaf=(UploadActionForm)form;

FormFile myfile=uaf.getMyfile();
if(myfile!=null){
    System.out.println("fileName="+myfile.getFileName());
    FileOutputStream fos=new FileOutputStream("d://"+myfile.getFileName());
fos.write(myfile.getFileData());
fos.flush();
fos.close();
* 采用<controller/>标签配置上传参数，如：<controller maxFileSize="10M"/>，此标签在struts-config.xml中配置，且放到较后位置。
3、空字段测试
* 在表单中没有input输入域，jsp脚本接收到的值为null，el表达式接收到的值为空串
* 如果表单中的值，没有输入，那么jsp脚本和el表达式接收到的值都为空串
4、测试ActionForm类型的自动转换
* boolean:yes,1,on,true都会转换成True类型，而且忽略大小写，其他情况转换成false
* Date类型的转换：
  * 如果是java.sql.Date，页面日期的格式必须为yyyy-mm-dd，才可以转换
  * 如果是java.util.Date,默认情况下struts无法转换
* 自定义转换器的实现步骤
* 实现converter接口，实现convert方法
实现Converter接口，实现covert方法。
public Object convert(Class arg0, Object value) {
System.out.println("UtilDateConverter. value="+value);
  Date d = null;
  if(value instanceof Date){
   d=(Date)value;
  }
  else if(value instanceof String){
   SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
   try {
    d=sdf.parse((String)value);
   } catch (ParseException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  return d;
}
* 将实现的converter注册，通常情况采用servlet注册
* 采用servlet注册需要注意标签的配置,<servlet-name>UtilDateConverterInitWithServlet</servlet-name>
    <servlet-class>com.sy.struts.UtilDateConverterInitWithServlet</servlet-class>
  <load-on-startup>3</load-on-startup>其中<load-on-startup>3</load-on-startup>必须有，因为在servlet启动时，要执行，

servlet代码如下：
public void init() throws ServletException {
  // Put your code here
  System.out.println("UtilDateConverterInitWithServlet.init()");
  ConvertUtils.register(new UtilDateConverter(), Date.class);

}
其实采用servlet注册，是麻烦的，不如才有struts plugin注册，只要在struts-config.xml文件中加入下面的标签<plug-in

className="com.sy.struts.UtilDateConverterInitWithPlugin"></plug-in>
其中UtilDateConverterInitWithPlugin.class中实现接口PlugIn然后实现init方法。
public void init(ActionServlet servlet, ModuleConfig config)
throws ServletException {
ConvertUtils.register(new UtilDateConverter(), Date.class);
}

总的来说，无论采用的是servlet注册，还是才有实现接口PlugIn注册，都是在Init方法中实现，只是前者在web.xml中配置，特别要注意要加

上<load-on-startup>10</load-on-startup>，后者在struts-config.xml中配置,主要是<plug-in

className="com.sy.struts.UtilDateConverterInitWithPlugin"></plug-in>
。
Struts对ActionForm的自动搜集过程：
*将页面数据放到map中，其中map中的key为页面中的名称，map中的value为页面中的value值。
*调用BeanUtils.setProperties方法，将map中的值逐个设置到ActionForm实例上，对于ActionForm中的每个属性根据类型调用相应的

Converter，然后调用相应的converter方法，将相应的字符串转换成ActionForm中指定的类型。
可以通过BeanUtils.copyProperties(目标对象，源对象)方法进行对象值的复制。

session.setAttribute("user", u);这样写只能在jsp页面中，（目前知道的情况下），但是用到struts时，编写action时，判断session时，

可以用到对应的写法：request.getSession().getAttribute("username")!= null
以及赋值session：
request.getSession().setAttribute("username", username);

<forward name="login" path="/login.jsp" redirect="true" ></forward>像这种配置转向标签，如果没有redirect="true"则地址栏中只会

显示action中提交的地址如<action="login.do" method="post">
下面主要介绍一下DynaActionForward的使用，这样可以减少在struts-config.xml文件中相应action标签中forward的配置。因为在Action中
重构了返回值为ActionForward的execute(ActionMapping, ActionForm, HttpServletRequest, HttpServletResponse)方法，我只要在方法体

中实例化一个ActionForward对象(该对象主要功能是转向)
然后调用对象的setPath(String)其中String代表工程根目录下面路径，示例代码如下：
ActionForward af=new ActionForward();
af.setRedirect(true);//用于转向定义，主要是地址栏显示问题。
af.setPath("/admin/page"+page+".jsp?name=Tom");
return af;
总之：ActionForward的使用

1、理解全局和局部ActionForward的概念
2、redirect的使用
3、struts-config.xml文件不允许动态修改
4、理解动态ActionForward，动态的ActionForward是可以运行期修改的
17:54 2010-2-26

在一个工程中若请求的页面不存在，像错误404等，怎么转到指定的提示信息。可以用到struts中的标签<action path="/"
unknown="true"
forward="/testunknown.jsp"
></action>
这里主要是unknown属性值的设定。path属性值可以是任意的。这样所有的请求错误都会转到testunknown.jsp页面。但是前提条件是请求的

是.do的请求。因为在web.xml中已经设置对应的请求设置，对应的action已经设置好了。

1、struts-config.xml文件中，每个<action>标签对应一个ActionMapping实例
2、了解<action>标签中的forward和unknown属性的含义，只能有一个Action含有unknown
3、了解采用jstl和struts标签保持页面数据

在选择jstl遍历输出产品：
  <c:forEach items="${stepForm.productId}" var="p" varStatus="vs">
   产品${p }
   <c:if test="${vs.count != fn:length(stepForm.productId)}" var="v">
    ,
   </c:if>
  </c:forEach>
时，要注意el表达式的书写。特别是在判断，是否输出“,”时，{}两边不能有空格，否则会有异常。

下面介绍一下struts国际化配置问题：

1、struts国际化的配置
*在struts-config.xml文件中加入：
<message-resources parameter="MessageResources"/>这里的MessageResources可以为任意的，只是配置文件名而已。
2、提供不同版本的国际化资源文件，中文需要采用native2ascii转化成unicode
这里常用另一个备份文件，予以参考，后期维护的方便。
3、在jsp中采用<bean:message>标签来读取国际化消息文本
4、了解利用struts默认将locale放到session中的特性，完成采用编程的方式切换语言设置，意思是可以自己用编程的方式设置locale属性，

就是可以不用计算机系统所设置的语言项（可以通过控制面板设置），自己设置。一般在action中设置。
String lang = request.getParameter("lang");

  Locale currentLocale = Locale.getDefault();
  if ("zh".equals(lang)) {
   currentLocale = new Locale("zh", "CN");
  }else if("en".equals(lang)) {
   currentLocale = new Locale("en", "US");
  }
  //request.getSession().setAttribute(Globals.LOCALE_KEY, currentLocale);

  this.setLocale(request, currentLocale);

5、消息文本的国际化处理，共有三个步骤：
*创建国际化消息
*传递国际化消息
*显示国际化消息

前两个一般在action中设置：
ActionMessages messages = new ActionMessages();
try {
   UserManager.getInstance().login(username, password);

   //创建国际化消息文本
   ActionMessage message = new ActionMessage("user.login.success", username);
   //ActionMessage message = new ActionMessage("user.login.success", new Object[]{username});
   messages.add("loginSuccess1", message);

   ActionMessage message1 = new ActionMessage("user.login.success", username);
   messages.add("loginSuccess2", message1);

   //传递国际化消息文本
   this.saveMessages(request, messages);
   return mapping.findForward("success");
  }catch(UserNotFoundException unfe) {
   unfe.printStackTrace();

   //创建国际化消息文本
   ActionMessage message = new ActionMessage("user.not.found", username);
   messages.add("error1", message);

   //传递国际化消息文本
   this.saveErrors(request, messages);
  }catch(PasswordErrorException pee) {
   pee.printStackTrace();
   //创建国际化消息文本
   ActionMessage message = new ActionMessage("user.password.error");
   messages.add("error2", message);

   //传递国际化消息文本
   this.saveErrors(request, messages);
  }

其中：MessageResources_en_US.properties

# -- standard errors --
errors.header=<UL>
errors.prefix=<LI><font color="red">
errors.suffix=</font></LI>
errors.footer=</UL>

user.title=User Login
user.username=User Name
user.password=Password
user.button.login=Login

user.login.success={0},Login Success
user.not.found=User Not Found,UserName[{0}]
user.password.error=Password Error
user.login.error=Login Error

下面就是国际化消息的现实，
在jsp页面中：
显示错误消息：可以用到 <html:errors/>，为什么呢？
你也许会看到上述：this.saveErrors(request, messages);这个方法名，一看就知道什么意思。
如果直接输出MessageResources_language_COUNTRY.properties文件中代表名称的值。则可以用到一下标签，如：<bean:message

key="user.title"/>
可以用到key属性。首先将标签库引入：
<%@ taglib prefix="bean" uri="http://struts.apache.org/tags-bean"%>

如果用到struts中html标签还要引入：
<%@ taglib prefix="html" uri="http://struts.apache.org/tags-html" %>
像上面的错误信息提示：
<html:errors/>也可以用
font color="red">
  <html:messages id="msg" property="error1">
   <bean:write name="msg"/>
  </html:messages>
</font>
<font color="blue">
  <html:messages id="msg" property="error2">
   <bean:write name="msg"/>
  </html:messages>
</font>
更具体，更详细，更优化，但是就是繁琐。
如何创建国际化消息？
理解ActionMessage和ActionMessages两个对象的区别
ActionMessage 每次可以生成一条信息，而ActionMessages可以生成相当一个信息容器，将所有的ActionMessage对象加入其中。
如何传递国际化消息？
* 调用saveMessage()传递普通消息，调用saveErrors传递错误消息

如何显示国际化消息？
通过<html:messages>标签显示消息（可以显示普通消息和错误消息）
通过<html:errors>显示消息（只能显示错误消息） 18:19 2010-3-1

struts validator验证框架：

1、配置
*加入国际化配置在struts-config.xml文件中，如<message-resources parameter="MessageResources"/>
以及form-bean
    <form-beans>
        <form-bean name="loginForm" type="org.apache.struts.validator.DynaValidatorForm">
            <form-property name="username" type="java.lang.String"/>
            <form-property name="password" type="java.lang.String"/>
       </form-bean>
    </form-beans>
*提供国际化资源文件
*引入validator插件在struts-config.xml文件中，如：<plug-in className="org.struts.validator.ValidatorPlugIn">
<set-property property="pathnames"
value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"
/>
</plug-in>
*提供validation.xml和validator_rules.xml文件，将此文件拷到WEB-INF下
其中：validator_rules.xml内容是：
<!DOCTYPE form-validation PUBLIC
          "-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1.3//EN"
          "http://jakarta.apache.org/commons/dtds/validator_1_1_3.dtd">
<!--
$Id: validator-rules.xml 159291 2005-03-28 20:19:29Z niallp $

   This file contains the default Struts Validator pluggable validator
   definitions. It should be placed somewhere under /WEB-INF and
   referenced in the struts-config.xml under the plug-in element
   for the ValidatorPlugIn.

      <plug-in className="org.apache.struts.validator.ValidatorPlugIn">
        <set-property property="pathnames" value="/WEB-INF/validator-rules.xml,
                                                  /WEB-INF/validation.xml"/>
      </plug-in>

   These are the default error messages associated with
   each validator defined in this file. They should be
   added to your projects ApplicationResources.properties
   file or you can associate new ones by modifying the
   pluggable validators msg attributes in this file.

   # Struts Validator Error Messages
   errors.required={0} is required.
   errors.minlength={0} can not be less than {1} characters.
   errors.maxlength={0} can not be greater than {1} characters.
   errors.invalid={0} is invalid.

   errors.byte={0} must be a byte.
   errors.short={0} must be a short.
   errors.integer={0} must be an integer.
   errors.long={0} must be a long.
   errors.float={0} must be a float.
   errors.double={0} must be a double.

   errors.date={0} is not a date.
   errors.range={0} is not in the range {1} through {2}.
   errors.creditcard={0} is an invalid credit card number.
   errors.email={0} is an invalid e-mail address.

   Note: Starting in Struts 1.2.0 the default javascript definitions have
         been consolidated to commons-validator. The default can be overridden
         by supplying a <javascript> element with a CDATA section, just as
         in struts 1.1.

-->

<form-validation>

<validator name="includeJavaScriptUtilities"
            classname=""
               method=""
         methodParams=""
              depends=""
                  msg=""
           jsFunction="org.apache.commons.validator.javascript.validateUtilities"/>

</global>

</form-validation>

2、validator服务器端验证
*配置validation.xml文件

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE form-validation PUBLIC
"-//Apache Software Foundation//DTD Commons Validator Rules Configuration 1.1.3//EN"
"http://jakarta.apache.org/commons/dtds/validator_1_1_3.dtd">

<form-validation>
    <formset>
        <form name="loginForm">
            <field property="username" depends="required">
                    <arg key="prompt.username"/>
            </field>
            <field property="password" depends="required,mask">
                    <arg key="prompt.password"/>
                    <var>
                        <var-name>mask</var-name>
                        <var-value>^[0-9a-zA-Z]*$</var-value>
                    </var>
            </field>
        </form>
    </formset>
</form-validation>
3、validator客户端验证(javascript)
* 配置validation.xml文件
* 在jsp页面中包含< html:javascript>
例如：
<h1>登录(validator框架客户端验证(javascript))</h1>
<hr>
<html:javascript formName="loginForm"/>
<html:form action="login2.do" onsubmit="return validateLoginForm(this)">
   username : <html:text property="username"/><br/>
    password : <html:password property="password"/><br>
   <html:submit/>
</html:form>
* 对需要验证的表单定义onsubmit事件,其中事件名称为validate+ActionForm的名称，如：validateLoginForm

1、编程式异常
* 截获异常

* 创建相应的异常消息

* 传递异常消息

* 转向相应的页面处理异常
像以前的做的小的功能，判断用户名和密码是否是正确时，所编写的JavaBean，像
public class UserNotFoundException extends RuntimeException {

public UserNotFoundException(String msg) {
super(msg);
}
}

然后再编写相应方法，加上相应的try catch等等。然后再转向。
2、声明式异常（自动处理的异常）
* 在struts-config.xml文件中配置<exeception/>标签

<action path="/login"
    type="com.bjsxt.struts.LoginAction"
    name="loginForm"
    scope="request"
    validate="false"
    input="/login.jsp"
  >

   <exception key="user.not.found" type="com.bjsxt.struts.UserNotFoundException"

path="/login_error.jsp"/><!--这里的path属性的优先级高于input属性，代表的意思是如果出现异常，就会转到path的路径，如果没有path

属性，则转到input的请求页面。-->
<exception key="user.password.error" type="com.bjsxt.struts.PasswordErrorException"

path="/login_error.jsp"/>

   <forward name="success" path="/login_success.jsp"/>
   <forward name="error" path="/login.jsp"/>
  </action>
* 理解局部和全局exception
针对相应的action，对应的exception，局部先执行。

* 注意局部<exception/>标签需要配置到<forward/>标签的前面，详见dtd中的约束

<exeception/>标签中的属性说明：
  * key：指异常信息对应的国际化消息文本，这个key值需要在国际化资源文件中定义
  * type: 处理那种异常
  * path: 定义一但出现异常，需要转向那个页面，如果不定义path，
           默认情况下将使用<action>标签中input属性对应的页面
  * scope：可以取值request和session，默认为request
  * handler：异常的处理类，struts默认采用org.apache.struts.action.ExceptionHandler，
              如果做个性化的异常处理可以继承此类覆写相应的方法

  参见：ErrorCodeExceptionHandler.java和AppExceptionHandler.java

struts的声明式异常，都会涉及到struts的国际化。<exception key="" type="" handler=""/>其中handler不写，默认值为...上述中已介绍

。像struts-config.xml中的<exception key="user.not.found" type="com.bjsxt.struts.UserNotFoundException"

handler="org.apache.struts.action.ExceptionHandler"/>
<exception key="user.password.error" type="com.bjsxt.struts.PasswordErrorException"

handler="org.apache.struts.action.ExceptionHandler"/>
就是没有重新写handler类，直接用官方的。
而个性化的异常，要重新编写handler来覆盖原始的，但是要继承org.apache.struts.action.ExceptionHandler，一般在该类中重写execute方

法像简单的
public class AppException extends RuntimeException {

public AppException(String msg) {
  super(msg);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public class AppExceptionHandler extends ExceptionHandler {

    public ActionForward execute(
          Exception ex,
          ExceptionConfig ae,
          ActionMapping mapping,
          ActionForm formInstance,
          HttpServletRequest request,
          HttpServletResponse response)
          throws ServletException {

       if (!(ex instanceof AppException)) {
        return super.execute(ex, ae, mapping, formInstance, request, response);
       }

          ActionForward forward = null;
          ActionMessage error = null;
          String property = null;

          // Build the forward from the exception mapping if it exists
          // or from the form input
          if (ae.getPath() != null) {
              forward = new ActionForward(ae.getPath());
          } else {
              forward = mapping.getInputForward();
          }

          // Figure out the error
          if (ex instanceof ModuleException) {
              error = ((ModuleException) ex).getActionMessage();
              property = ((ModuleException) ex).getProperty();
          } else {
          AppException appe = (AppException)ex;
          error = new ActionMessage(ae.getKey(), appe.getMessage());
          property = error.getKey();

              //error = new ActionMessage(ae.getKey(), ex.getMessage());
              //property = error.getKey();
          }

this.logException(ex);

          // Store the exception
          request.setAttribute(Globals.EXCEPTION_KEY, ex);
          this.storeException(request, property, error, forward, ae.getScope());

return forward;

}

而个性化异常：
public class ErrorCodeException extends RuntimeException {

private String errorCode;

private Object[] args;

public ErrorCodeException(String errorCode) {
  this(errorCode, null);
}

public ErrorCodeException(String errorCode, Object args0) {
  this(errorCode, new Object[]{args0});
}

public ErrorCodeException(String errorCode, Object[] args) {
  this.errorCode = errorCode;
  this.args = args;
}

public String getErrorCode() {
  return errorCode;
}

public Object[] getArgs() {
return args;
}
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public class ErrorCodeExceptionHandler extends ExceptionHandler {

    public ActionForward execute(
            Exception ex,
            ExceptionConfig ae,
            ActionMapping mapping,
            ActionForm formInstance,
            HttpServletRequest request,
            HttpServletResponse response)
            throws ServletException {

      if (!(ex instanceof ErrorCodeException)) {
       return super.execute(ex, ae, mapping, formInstance, request, response);
      }
            ActionForward forward = null;
            ActionMessage error = null;
            String property = null;

            // Build the forward from the exception mapping if it exists
            // or from the form input
            if (ae.getPath() != null) {
                forward = new ActionForward(ae.getPath());
            } else {
                forward = mapping.getInputForward();
            }

            // Figure out the error
            if (ex instanceof ModuleException) {
                error = ((ModuleException) ex).getActionMessage();
                property = ((ModuleException) ex).getProperty();
            } else {
            ErrorCodeException ece = (ErrorCodeException)ex;
            String errorCode = ece.getErrorCode();
            Object[] args = ece.getArgs();
            error = new ActionMessage(errorCode, args);
            property = error.getKey();

                //error = new ActionMessage(ae.getKey(), ex.getMessage());
                //property = error.getKey();
            }

this.logException(ex);

            // Store the exception
            request.setAttribute(Globals.EXCEPTION_KEY, ex);
            this.storeException(request, property, error, forward, ae.getScope());

return forward;

}
}
对应的struts-config.xml中的exception配置
<!--
<exception key="error.exception" type="com.bjsxt.struts.ErrorCodeException"

handler="com.bjsxt.struts.ErrorCodeExceptionHandler"/>
   -->
   <!--
   <exception key="error.exception" type="com.bjsxt.struts.AppException"

handler="com.bjsxt.struts.AppExceptionHandler"/>
    -->

   <exception key="error.exception" type="com.bjsxt.struts.AppException"/>
抛出异常的方法：
// public void login(String username, String password) {
//  if (!"admin".equals(username)) {
//   throw new UserNotFoundException(username);
//  }
//  if (!"admin".equals(password)) {
//   throw new PasswordErrorException();
//  }
// }

// public void login(String username, String password) {
//  if (!"admin".equals(username)) {
//   throw new ErrorCodeException("user.not.found", username);
//  }
//  if (!"admin".equals(password)) {
//   throw new ErrorCodeException("user.password.error");
//  }
// }

public void login(String username, String password) {
  if (!"admin".equals(username)) {
   throw new AppException("用户不能找到，用户=【" + username + "】");
  }
  if (!"admin".equals(password)) {
   throw new AppException("密码不正确!");
  }
}

下面在介绍一下：国际化中的占位符问题：
像声明，会只需要写一个异常：
<exception key="error.exception" type="com.bjsxt.struts.AppException"/>
而其他的要声明，（国际化文本error.exception={0}）如果没有用到占位符，怎么要声明两个（像用户登陆时的，用户名和密码的异常）
如：
<exception key="user.not.found" type="com.bjsxt.struts.UserNotFoundException"

handler="org.apache.struts.action.ExceptionHandler"/>
<exception key="user.password.error" type="com.bjsxt.struts.PasswordErrorException"

handler="org.apache.struts.action.ExceptionHandler"/>

关于异常的东西，有点模棱两可！

ForwardAction的运用：

意思是，不用再定义action了，重写execute方法了。属性parameter指的是转向的页面，意思是，不需要判断直接进入该界面，不像<forward

name="" path=""/>

struts中的DispatchAction的用法：
关于DispatchAction的提出，更好的为系统后期维护而提出的。主要目的是减少struts-config.xml文件中action的定义。像用户管理模块，针

对CRUD操作，所对应的Action，如果编写4个，则相当的没有必要。这时可以定义一个Action继承DispatchAction即可。每种对应的操作，定义

相应的方法，且该方法的返回值，以及参数都要和execute方法一致。这时，有人又会提出疑问，struts怎么调用呢？
在struts-config.xml中有配置，在action标签中parameter属性就是调用action中的方法名。
其中关于DispatchAction中的容错处理，有点像action中的unknown属性，它用到方法unspecified，例如：
protected ActionForward unspecified(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response)
   throws Exception {

  System.out.println("-----------UserAction.unspecified()-----------");

  //调用业务逻辑操作
  List userList = UserManager.getInstance().findAllUserList();
  request.setAttribute("userlist", userList);

  return mapping.findForward("list_success");
}
像其他的对应操作action方法：
例如增加用户：
public ActionForward add(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response)
   throws Exception {

  //获取从页面表单中提交过来的值
  UserActionForm uaf = (UserActionForm)form;

  User user = new User();
  BeanUtils.copyProperties(user, uaf);
  user.setCreateDate(new Date());

  //调用业务逻辑操作
  UserManager.getInstance().addUser(user);


  return mapping.findForward("success");
}

部分配置：

<global-forwards>
    <forward name="success" path="/user/usermaint.do" redirect="true"/>
    </global-forwards>

    <action-mappings>
    <action path="/user/usermaint"
       type="com.bjsxt.drp.web.usermgr.actions.UserAction"
       name="userForm"
       scope="request"
       parameter="command"
    >
      
      <forward name="find_success" path="/user/user_modify.jsp"/>
      <forward name="list_success" path="/user/user_list.jsp"/>
    </action>

下面主要介绍一下，这种的配置的思想，首先parameter="command"代表的意思是command传递的值，就是调用类似execute方法的方法名，像上

述的ActionForward add(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)即command=add是会自动调用add方法，然后转向到

全局forward，这时会有人不明白，为什么定义全局<forward name="success" path="/user/usermaint.do" redirect="true"/>因为定义CRUD

操作相应的类似execute方法都可以将最后返回值设为return mapping.findForward("success")，因为command在一次的操作中只能设置一次，

所以只调用一次相应方法，只设置转向一次，即使forward中name值一样（全局的）最终实现的操作，还是实现了。