BlogJava-Linden.zhang-文章分类-Jsf

JavaScript 访问 JSF 组件的方法

Linden.zhang — Tue, 12 Jun 2007 15:14:00 GMT

先看下面的 JSF 页面：

<%@ page language="java" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h"%>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f"%>

<html>
  <head>
    <title>My JSF 'login.jsp' starting pagetitle>
    <script type="text/javascript">
    function isEmpty() {
      var username = document.getElementById("formLogin:txtUsername").value;
      var password = document.getElementById("formLogin:txtPassword").value;
      if(username == "") {
        alert("给老子输用户名！");
        document.getElementById("formLogin:txtUsername").focus();
        return false;
      }
      if(password == "") {
        alert("不输密码你登录个铲铲！");
        document.getElementById("formLogin:txtPassword").focus();
        return false;
      }
    }
    script>
  head>

  <body>
    <center>
      <f:view>
        <h:form id="formLogin">
          <div id="input">
            <h:outputLabel value="用户名：" />
            <h:inputText value="#{LoginManager.username}" id="txtUsername"
              styleClass="formText" />
            <br>
            <h:outputLabel value="密码：" />
            <h:inputSecret value="#{LoginManager.password}" id="txtPassword"
              styleClass="formText" />
          div>
          <div id="submit">
            <h:commandButton value="提交" action="#{LoginManager.check}"
              onclick="return isEmpty();" styleClass="formButton" />
            <h:commandButton value="重置" type="button"
              onclick="javascript:document.getElementById('formLogin').reset();
              document.getElementById('formLogin:txtUsername').focus();"
              styleClass="formButton" />
          div>
        h:form>
      f:view>
    center>
  body>
html>

这个页面使用 JavaScript 来确认登录时用户名和密码是否为空，表单名为 formLogin，两个输入组件名为 txtUsername 和 txtPassword，当单击按钮时，将调用 JavaScript 函数 isEmpty()，根据条件判断显示对话框或是提交表单。

要注意的是，不能在 JavaScript 函数中使用如下类似语法来访问表单组件：
document.formLogin.txtUsername.value;
而应使用：
document.getElementById("formLogin:txtUsername").value;
或者：
document.forms.formLogin["formLogin:txtUsername"].value;

这是因为 JSF 解释上面的 ... 一段时会生成如下代码：

<form id="formLogin" method="post" action="/Project_Blog/login.faces"
  enctype="application/x-www-form-urlencoded">
  <div id="input">
    <label>用户名：label>
    <input id="formLogin:txtUsername" type="text"
      name="formLogin:txtUsername" class="formText" />
    <br>
    <label>密码：label>
    <input id="formLogin:txtPassword" type="password"
      name="formLogin:txtPassword" value="" class="formText" />
  div>
  <div id="submit">
    <input type="submit" name="formLogin:_id2" value="提交"
      onclick="return isEmpty();" class="formButton" />
    <input type="button" name="formLogin:_id3" value="重置"
      onclick="javascript:document.getElementById('formLogin').reset();
      document.getElementById('formLogin:txtUsername').focus();" class="formButton" />
  div>
  <input type="hidden" name="formLogin" value="formLogin" />
form>

JSF 产生的所有表单控件都有符合 formName:componentName 格式的名称，这里的 formName 表示控件的表单的名称，而 componentName 表示组件名称。如果没有指定 id 属性，则 JSF 框架会自动创建标识符，就象上面的 HTML 片段中的按钮一样。因此，要访问上面的用户名字段，必须使用下列方法：
document.getElementById("formLogin:txtUsername").value;

Linden.zhang 2007-06-12 23:14 发表评论

JSF中实现分页（三）

Linden.zhang — Tue, 12 Jun 2007 09:01:00 GMT

好久没有写点东西了，这次想把JSF中的分页系列文章再扩充一点，说明一下查询和分页结合的情况，当我们把查询条件和查询结果放到一个页面上时，查询还是非常容易实现的，甚至不需要我们手工去从数据库中查询。

在本系列文章中的第二篇中，介绍了一种 Load On Demand的方式，我们在这里需要继续利用这种方式，并对其做一些小小的扩展。这里我们使用 Hibernate3 作为持久化方案。

简单的介绍一下应用情景，一个系统中包含了一些 Customer 的信息，我们需要对其进行查询并对查询结果进行分页。

首先处理条件查询的情况，通常会根据 VO 中的字段进行 like 型查询，有时候时间或数字之类的会使用Between查询，因为查询条件一般不会很复杂，在这里，使用 Hibernate3 中的 Criteria 查询来处理这样的情况，我们把所有的查询条件通过 Customer 这个 VO 传进来，然后只对非空字段进行 like 查询，我们用到这样的方法。

public List queryByConditions(Customer customer, int startRow, int pageSize)
{
Criteria criteria = getSession().createCriteria(Customer. class );
if ( ! StringUtils.isEmpty(customer.getCustomerName()))
{
  criteria.add(QueryUtils.getCriteriaParam( " customerName " , customer.getCustomerName()));
}
if ( ! StringUtils.isEmpty(customer.getAddress()))
{
  criteria.add(QueryUtils.getCriteriaParam( " address " , customer.getAddress()));
}
if ( ! StringUtils.isEmpty(customer.getFax()))
{
  criteria.add(QueryUtils.getCriteriaParam( " fax " , customer.getFax()));
}
return criteriaPagedList(criteria, startRow, pageSize);
}

另外对应的一个count方法略去，只需要在前面加入一个
criteria.setProjection(Projections.count("customerId"));

因为考虑到以后的扩展，使用了一个Utils方法，QueryUtils.getCriteriaParam方法

public static final SimpleExpression getCriteriaParam(String name, String param)
{
return Expression.like(name, " % " + param + " % " );
}

我们可以很容易的在 Backing Bean 上通过 Service 层拿到这个查询结果的 List 和 Count 值，相关的getDatePage方法如下。
如果你不了解这个 getDataPage 方法的含义，请仔细阅读“在JSF中实现分页(二)”一文，并仔细思考该方法的含义。

protected DataPage getDataPage( int startRow, int pageSize)
{
List queryCustomerList = customerService.queryCustomer(customer, this .startRow, this .getPageSize());
int dataSetSize = customerService.countQueryCustomer(customer);
return new DataPage(dataSetSize, startRow, queryCustomerList);
}

在同一个 Backing Bean 中，我们放了一个存放查询条件的VO - Customer，并在页面中使用保存其状态，使其查询条件不会随着翻页而丢失。

在页面中，我们把所有的查询条件都放到该 VO 中，在 getDataPage 方法中就会在适当的时候调用新的查询条件来查询新的数据，这一切都不需要我们动手的。

在 Backing Bean 中有这样的一个方法：

public String query()
{
dataModel.setWrappedData(getDataPage( 0 , getPageSize()));
return " success " ;
}

只是把数据清空，并强制 PagedListDataModel 读取数据，然后我们返回相同的页面，这个时候，系统按照用户输入的查询条件拿到查询结果以后，返回同一页面，该页面中的使用 LocalDataModel 的那个 DataTable 就会把结果显示出来。

请注意，这里 LocalDataModel 和 Customer 都在同一个 Backing Bean 中。

是不是觉得很简单呢，一切都归功于 getDataPage 这个方法，我们几乎不需要做什么额外的操作就可以达到我们的目的。

因为该方法在一个商业项目中使用，代码不便公布，只能把里面的一些代码抽取出来，零零碎碎的拿给大家看，如果大家有什么疑问的话，可以在论坛上提出来，我会尽力解答的，另外这个方法也会在空闲的时候 Merge 到 MyPSP 项目中去。

Linden.zhang 2007-06-12 17:01 发表评论

JSF中实现分页（二）

Linden.zhang — Tue, 12 Jun 2007 08:54:00 GMT

摘要: 前面一篇直接使用了Myfaces中的两个Component完成了一个简单的分页，这里将会介绍一种On-demand loading的方法来进行分页，仅仅在需要数据的时候加载。先来说一些题外话，为了实现这种方式的分页，公司里大约5-6个人做了半个多月的工作，扩展了dataTable，修改了dataScrollor，以及各种其他的方... 阅读全文

Linden.zhang 2007-06-12 16:54 发表评论

JSF中实现分页（一）

Linden.zhang — Tue, 12 Jun 2007 08:51:00 GMT

对于大多数Web应用，分页都是必不可少的功能，当然在JSF中也一样，我在这里用两篇文章介绍两种方法来展示一下，如何在JSF中实现分页。本文假定你已经对JSF有了一些简单的了解，懂得基本配置和使用，并建立起一个blank项目。

Myfaces是Apache基金会中的一个一级项目，除了实现JSF标准外，做了很多的扩展工作，在Myfaces包中有一个扩展包Tomahawk，我们将主要使用其中的两个Component实现分页：一个是，另一个是，在第一篇里面，我们简易的组合这两个Component来实现一种简单，但并不高效的分页。

下面的例子来自于Myfaces-Sample，我省去了其中和分页逻辑无关的内容，详细的例子可以下载Myfaces-Sample包或者访问http://www.irian.at/myfaces/home.jsf 查看。

第一部分：dataTable

<t:dataTable id="data"
                  var="car"
                  value="#{pagedSort.cars}"
                  rows="10">
    ……
t:dataTable>

在这一部分中，dataTable绑定了一个backing bean - pagedSort中的cars属性，我们可以在这个属性中加入数据访问逻辑，从数据库或者其他来源取得用于显示的数据。比如我们可以通过Hibernate获取一个List，其中包含有我们用于显示的POJOs。

注意，dataTable中的rows属性指的是每页的行数，是必须指定的，否则是无法进行分页的，如果在项目中会使用固定行数的分页，建议把这个值写在BaseBackingBean中，并暴露一个property，供页面调用，所以每次在页面中就可以这么写#{backingBean.pageSize}。

第二部分：dataScroller

    <t:dataScroller id="scroll_1"
                        for="data"
                        fastStep="10"
                        paginator="true"
                        paginatorMaxPages="9">
            <f:facet name="first" >
                <t:graphicImage url="images/arrow-first.gif" border="1" />
            f:facet>
            <f:facet name="last">
                <t:graphicImage url="images/arrow-last.gif" border="1" />
            f:facet>
            <f:facet name="previous">
                <t:graphicImage url="images/arrow-previous.gif" border="1" />
            f:facet>
            <f:facet name="next">
                <t:graphicImage url="images/arrow-next.gif" border="1" />
            f:facet>
            <f:facet name="fastforward">
                <t:graphicImage url="images/arrow-ff.gif" border="1" />
            f:facet>
            <f:facet name="fastrewind">
                <t:graphicImage url="images/arrow-fr.gif" border="1" />
            f:facet>
        t:dataScroller>

这里定义了我们用于分页的，最主要的是配置该分页Component针对哪个dataTable进行分页的“for”属性，该属性与dataTable绑定，并对其进行分页，在这里，绑定了第一部分中的id="data"的dataTable，下面有很多的是指定分页的导航样式的，这里使用了图片作为导航，可以把他们改成文字形式的导航。

当然这只是最简单，也是一种不推荐的分页方式，因为在每次进行分页的时候，将会从数据库中取回所有的记录放入List中，然后，dataScroller在对这个List进行分页，如果在数据量很大的情况下，这种方式显然是不符合要求的，假设每条记录占用1k内存，数据库中有100万条记录，每次要把这个List全部读取出来将占用1G内存。我们需要一种Load on demand方式的读取，也就是只在需要查看某页的时候读取该页的数据。

另外一方面，JSF的生命周期中有多个阶段会调用到#{pagedSort.cars}中对应的方法，如果在这里调用了数据访问逻辑，就会在只显示一次页面的情况下进行多次数据库操作，也是相当的耗费资源的。

所以我们需要有更好的分页方式去解决以上问题，下一篇我将介绍另一种方法以改善这些问题。

Linden.zhang 2007-06-12 16:51 发表评论

JSF入门与提高目录

Linden.zhang — Thu, 07 Jun 2007 09:06:00 GMT

如果您是从使用的角度来看JSF，则您不用理会HTTP、数据转换等细节，JSF将细节都隐藏起来了，无论您是网页设计人员或是应用程序设计人员，都可以使用自己熟悉的方式来看JSF。

入门
藉由以下的几个主题，可以大致了解JSF的轮廓与特性，我们来看看网页设计人员与应用程序设计人员各负责什么。
o 简介JSF
o 第一个JSF程序
 o 简单的导航 Navigation
o 导航规则设置
 o JSF Expression Language
o 国际化讯息
Managed Beans
JSF 使用 Bean 来达到逻辑层与表现层分离的目的，Bean 的管理集中在组态档案中，您只要修改组态档案，就可以修改 Bean 之间的相依关系。
o Backing Beans
o Beans 的组态与设定
 o Beans 上的 List, Map
数据转换与验证
转换器（Converter）协助模型与视图之间的数据转换，验证器（Validator）协助进行语意检验（Semantic Validation）。
o 标准转换器
 o 自订转换器
 o 标准验证器
 o 自订验证器
 o 错误讯息处理
 o 自订转换, 验证标签
事件处理
JSF的事件模型提供一个近似的桌面GUI事件模式，让熟悉GUI设计的人员也能快速上手Web程序设计。
o 动作事件
 o 实时事件
 o 值变事件
 o Phase 事件
　JSF 标签

　　网页设计人员要作的就是了解JSF的标签的使用方式，这就像是学习进阶的HTML标签，另一件事就是与程序设计人员沟通好各个Bean的名称绑定。

标签入门
卷标的相关属性查询，您可以参考 Tag Library Documentation，这边的介绍只是一些简单的入门实例。
o 简介JSF标准标签
o 输出类标签
o 输入类标签
o 命令类标签
o 选择类标签一
o 选择类标签二
o 其它标签

表格处理
对于必须使用表格方式呈现的数据，JSF 的卷标协助您进行动态表格数据的输出。
o 简单的表格
o 表头, 表尾
o TableModel 类别
　
自订组件

　　JSF 让您可以自订组件，每个组件都是可替换的，这使得组件在搭配时更有弹性，但相对的却使开发组件的过程复杂的多，这边对自订JSF 组件只是个入门砖，更多有关自订组件的细节可得要专书来说明。

JSF 生命周期与组件概述
要开发 JSF 组件，您需要更深入了解 JSF 的一些处理细节，包括了 JSF 生命周期以及 JSF 框架。
o JSF 生命周期
o 概述自订组件
简单实例
在不考虑组件有子组件的情况下，这边以实际的一个例子来说明开发组件的过程，至于考虑子组件的情况请参考专书介绍。
o 编码, 译码
o 组件卷标
o 使用自订组件
o 自订 Renderer

Linden.zhang 2007-06-07 17:06 发表评论

AJAX+JSF组件实现高性能的文件上载

Linden.zhang — Thu, 07 Jun 2007 03:48:00 GMT

一、引言

　　基于浏览器的文件上传，特别是对于通过＜input type="file"＞标签包含到Web页面来实现上传的情况，还存在较严重的性能问题。我们知道，超过10MB的上传文件经常导致一种非常痛苦的用户体验。一旦用户提交了文件，在浏览器把文件上传到服务器的过程中，界面看上去似乎处于静止状态。由于这一切发生在后台，所以许多没有耐心的用户开始认为服务器"挂"了，因而再次提交文件，这当然使得情况变得更糟糕。

　　为了尽可能使得文件上传感觉更友好些，一旦用户提交文件，许多站点将显示一个中间过程动画（例如一旋转图标）。尽管这一技术在上传提交到服务器时起一些作用，但它还是提供了太少的有关文件上传状态的信息。解决这个问题的另外一种尝试是实现一个applet——它通过FTP把文件上传到服务器。这一方案的缺点是：限制了你的用户，必须要有一个支持Java的浏览器。

　　在本文中，我们将实现一个具有AJAX能力的组件——它不仅实现把文件上传到服务器，而且"实时地"监视文件上传的实际过程。这个组件工作的四个阶段显示于下面的图1，2，3和4中：

图1.阶段1:选择文件上传

图2.阶段2:上传该文件到服务器

图3.阶段3:上传完成

图4.阶段4:文件上传摘要

　　二、实现该组件

　　首先，我们分析创建多部分过滤的过程，它将允许我们处理并且监视文件上传。然后，我们将继续实现JavaServer Faces（JSF）组件-它将提供给用户连续的回馈，以支持AJAX的进度条方式。

　　(一) 多部分过滤：UploadMultipartFilter

　　多部分过滤的任务是拦截到来的文件上传并且把该文件写到一个服务器上的临时目录中。同时，它还将监视接收的字节数并且确定已经上载该文件的程度。幸运的是，现在有一个优秀的Jakarta-Commons开源库可以利用（FileUpload），可以由它来负责分析一个HTTP多部分请求并且把文件上传到服务器。我们要做的是扩展该库并且加入我们需要的"钩子"来监视已经处理了多少字节。

public class UploadMultipartFilter implements Filter{
　public void doFilter(ServletRequest request，ServletResponse response，FilterChain chain)
　throws IOException， ServletException {
　　HttpServletRequest hRequest = (HttpServletRequest)request;
　　//检查是否我们在处理一个多部分请求
　　String contentHeader = hRequest.getHeader("content-type");
　　boolean isMultipart = ( contentHeader != null && contentHeader.indexOf("multipart/form-data") != -1);
　　if(isMultipart == false){
　　　chain.doFilter(request，response);
　　}else{
　　　UploadMultipartRequestWrapper wrapper = new UploadMultipartRequestWrapper(hRequest);
　　　chain.doFilter(wrapper，response);
　　}
　　...
　}

　　正如你所见，UploadMultipartFilter类简单地检查了当前的请求是否是一个多部分请求。如果该请求不包含文件上传，该请求将被传递到请求链中的下一个过滤，而不进行任何另外的处理。否则，该请求将被包装在一个UploadMultipartRequestWrapper中。

　　(二) UploadMultipartRequestWrapper类

public class UploadMultipartRequestWrapper
extends HttpServletRequestWrapper{
　private Map＜String，String＞ formParameters;
　private Map＜String，FileItem＞ fileParameters;
　public UploadMultipartRequestWrapper(HttpServletRequest request) {
　　super(request);
　　try{
　　　ServletFileUpload upload = new ServletFileUpload();
　　　upload.setFileItemFactory(new ProgressMonitorFileItemFactory(request));
　　　List fileItems = upload.parseRequest(request);
　　　formParameters = new HashMap＜String，String＞();
　　　fileParameters = new HashMap＜String，FileItem＞();
　　　for(int i=0;i＜fileItems.size();i++){
　　　　FileItem item = (FileItem)fileItems.get(i);
　　　　if(item.isFormField() == true){
　　　　　formParameters.put(item.getFieldName()，item.getString());
　　　　}else{
　　　　　fileParameters.put(item.getFieldName()，item);
　　　　　request.setAttribute(item.getFieldName()，item);
　　　　}
　　　}
　　　}catch(FileUploadException fe){
　　　　//请求时间超过-用户可能已经转到另一个页面。
　　　　//作一些记录
　　　　//...
　　　}
　　　...

　　在UploadMultipartRequestWrapper类中，我们将初始化ServletFileUpload类，它负责分析我们的请求并且把文件写到服务器上的缺省临时目录。ServletFileUpload实例针对在该请求中遇到的每一个字段创建一个FileItem实例（它们包含文件上传和正常的表单元素）。之后，一个FileItem实例用于检索一个提交字段的属性，或者，在文件上传的情况下，检索一个到底层的临时文件的InputStream。总之，UploadMultipartRequestWrapper负责分析该文件并且设置任何FileItem-它在该请求中把文件上传描述为属性。然后，这些属性由JSF组件所进一步收集，而正常表单字段的行为保持不变。

　　默认情况下，通用FileUpload库将使用DiskFileItems类的实例来处理文件上传。尽管DiskFileItem在处理整个临时文件业务时是很有用的，但在准确监视该文件已经处理程度方面存在很少支持。自版本1.1以来，通用FileUpload库能够使开发者指定用于创建FileItem的工厂。我们将使用ProgressMonitorFileItemFactory和ProgressMonitorFileItem类来重载缺省行为并监视文件上传过程。

　　(三) ProgressMonitorFileItemFactory类

public class ProgressMonitorFileItemFactory extends DiskFileItemFactory {
　private File temporaryDirectory;
　private HttpServletRequest requestRef;
　private long requestLength;
　public ProgressMonitorFileItemFactory(HttpServletRequest request) {
　　super();
　　temporaryDirectory = (File)request.getSession().getServletContext().getAttribute("javax.servlet.context.tempdir");
　　requestRef = request;
　　String contentLength = request.getHeader("content-length");
　　if(contentLength != null){requestLength = Long.parseLong(contentLength.trim());}
　}
　public FileItem createItem(String fieldName， String contentType，boolean isFormField， String fileName) {
　　SessionUpdatingProgressObserver observer = null;
　　if(isFormField == false) //这必须是一文件上传.
　　　observer = new SessionUpdatingProgressObserver(fieldName，fileName);
　　　ProgressMonitorFileItem item = new ProgressMonitorFileItem(
　　　　　fieldName，contentType，isFormField，
　　　　　fileName，2048，temporaryDirectory，
　　　　　observer，requestLength);
　　　　return item;
　}
　...
　public class SessionUpdatingProgressObserver implements ProgressObserver {
　　private String fieldName;
　　private String fileName;
　　...
　　public void setProgress(double progress) {
　　　if(request != null){
　　　　request.getSession().setAttribute("FileUpload.Progress."+fieldName，progress);
　　　　request.getSession().setAttribute("FileUpload.FileName."+fieldName，fileName);
　　　}
　　}
　}
}

　　ProgressMonitorFileItemFactory Content-Length头由浏览器设置并且假定它是被设置的上传文件的精确长度。这种确定文件长度的方法确实限制了你在每次请求中上传的文件-如果有多个文件在该请求中被编码的话，不过这个值是不精确的。这是由于，浏览器仅仅发送一个Content-Length头，而不考虑上传的文件数目。

　　除了创建ProgressMonitorFileItem实例之外，ProgressMonitorFileItemFactory还注册了一个ProgressObserver实例，它将由ProgressMonitorFileItem来发送文件上传过程中的更新。我们所使用的ProgressObserver的实现（SessionUpdatingProgressObserver）针对被提交字段的id把进度百分数设置到用户的会话中。然后，这个值可以由JSF组件存取以便把更新发送给用户。
(四) ProgressMonitorFileItem类

public class ProgressMonitorFileItem extends DiskFileItem {
　private ProgressObserver observer;
　private long passedInFileSize;
　...
　private boolean isFormField;
　...
　@Override
　public OutputStream getOutputStream() throws IOException {
　　OutputStream baseOutputStream = super.getOutputStream();
　　if(isFormField == false){
　　　return new BytesCountingOutputStream(baseOutputStream);
　　}else{return baseOutputStream;}
　}
　...
　private class BytesCountingOutputStream extends OutputStream{
　　private long previousProgressUpdate;
　　private OutputStream base;
　　public BytesCountingOutputStream(OutputStream ous){ base = ous; }
　　...
　　private void fireProgressEvent(int b){
　　　bytesRead += b;
　　　...
　　　double progress = (((double)(bytesRead)) / passedInFileSize);
　　　progress *= 100.0
　　　observer.setProgress();
　　}
　}
}

　　ProgressMonitorFileItem把DiskFileItem的缺省OutputStream包装到一个BytesCountingOutputStream中，这可以在每次读取一定数目的字节后更新相关的ProgressObserver。

　　(五) 支持AJAX的JavaServer Faces（JSF）上传组件

　　这个组件负责生成HTML文件上传标签，显示一个进度条以监视文件上传，并且生成一旦文件上传成功需要被显示的组件。使用JavaServer Faces实现这个组件的一个主要优点是，大多数复杂性被隐藏起来。开发人员只需要把组件标签添加到JSP，而后由组件负责所有的AJAX及相关的进度条监控细节问题。下面的JSP代码片断用于把上传组件添加到页面上。

＜comp:fileUpload
　value="#{uploadPageBean.uploadedFile}"
　uploadIcon="images/upload.png"
　styleClass="progressBarDiv"
　progressBarStyleClass="progressBar"
　cellStyleClass="progressBarCell"
　activeStyleClass="progressBarActiveCell"＞
＜%--下面是一旦文件上传完成将成为可见的组件--%＞
＜h:panelGrid columns="2" cellpadding="2" cellspacing="0" width="100%"＞
＜f:facet name="header"＞
＜h:outputText styleClass="text"
value="文件上传成功." /＞
＜/f:facet＞
＜h:panelGroup style="text-align:left;display:block;width:100%;"＞
＜h:commandButton action="#{uploadPageBean.reset}"
image="images/reset.png"/＞
＜/h:panelGroup＞
＜h:panelGroup style="text-align:right;display:block;width:100%;"＞
＜h:commandButton action="#{uploadPageBean.nextPage}"
image="images/continue.png"/＞
＜/h:panelGroup＞
＜/h:panelGrid＞
＜/comp:fileUpload＞

　　文件上传组件的value属性需要用一个拥有一个FileItem的属性绑定到一个bean上。组件只有在该文件被服务器成功收到时才显示。

　　三、实现AJAX文件上传组件

　　实质上，上载组件或者生成一个完整的自已，或者在一个AJAX请求的情况下，只生成部分XML以更新在页面上进度条的状态。为了防止JavaServer Faces生成完整的组件树（这会带来不必要的负荷），我们还需要实现一个PhaseListener（PagePhaseListener）以取消该faces的请求处理的其它部分-如果遇到一个AJAX请求的话。我在本文中略去了所有的关于标准配置（faces-config.xml和标签库）的讨论，因为它们相当直接且已经在以前讨论过；而且这一切都包含在随同本文的源码中，你可以详细分析。

　　(一) AJAX文件上传组件生成器

　　该组件和标签类的实现比较简单。大量的逻辑被包含到生成器中，具体地说，它负责以下：

　　· 编码整个的上传组件（和完整的HTML文件上传标签）、文件被上传完成后要显示的组件，还有实现AJAX请求的客户端JavaScript代码。

　　· 适当地处理部分AJAX请求并且发送回必要的XML。

　　· 解码一个文件上传并且把它设置为一个FileItem实例。

　　(二) 编码整个上传组件

　　前面已经提及，文件上传组件由三个阶段组成。在该组件的整个编码期间，我们将详细分析这三个阶段的编码。注意，在页面上的该组件的可视化（使用CSS显示）属性将由AJAX JavaScript来控制。

　　(三) 阶段一

　　图5显示了该上传组件的第一个阶段。

图5.选择文件上传

　　在第一阶段中，我们需要生成HTML文件Upload标签和点击Upload按钮时相应的执行代码。一旦用户点击了Upload按钮，表单将被一个IFRAME（为防止页面阻塞）提交并初始化第二个阶段。下面是生成代码的一部分：

//文件上传组件
writer.startElement("input"， component);
writer.writeAttribute("type"， "file"， null);
writer.writeAttribute("name"， component.getClientId(context)， "id");
writer.writeAttribute("id"， component.getClientId(context)，"id");
if(input.getValue() != null){
　//如果可用，则生成该文件名.
　FileItem fileData = (FileItem)input.getValue();
　writer.writeAttribute("value"， fileData.getName()， fileData.getName());
}
writer.endElement("input");
String iconURL = input.getUploadIcon();
//生成图像，并把JavaScript事件依附到其上.
writer.startElement("div"， component);
writer.writeAttribute("style"，"display:block;width:100%;text-align:center;"， "style");
writer.startElement("img"， component);
writer.writeAttribute("src"，iconURL，"src");
writer.writeAttribute("type"，"image"，"type");
writer.writeAttribute("style"，"cursor:hand;cursor:pointer;"，"style");
UIForm form = FacesUtils.getForm(context，component);
if(form != null) {
　String getFormJS = "document.getElementById('" + form.getClientId(context) + "')";
　String jsFriendlyClientID = input.getClientId(context).replace(":"，"_");
　//设置表单的编码为multipart以用于文件上传，并且通过一个IFRAME
　//来提交它的内容。该组件的第二个阶段也在500毫秒后被初始化.
　writer.writeAttribute("onclick"，getFormJS + ".encoding='multipart/form-data';" +
getFormJS + ".target='" + iframeName + "';" + getFormJS + ".submit();" +
getFormJS + ".encoding='application/x-www-form-urlencoded';" +
getFormJS + ".target='_self';" +
"setTimeout('refreshProgress" + jsFriendlyClientID + "();'，500);"，null);
}
...
writer.endElement("img");
//现在实现我们将要把该文件/表单提交到的IFRAME.
writer.startElement("iframe"， component);
writer.writeAttribute("id"， iframeName， null);
writer.writeAttribute("name"，iframeName，null);
writer.writeAttribute("style"，"display:none;"，null);
writer.endElement("iframe");
writer.endElement("div");
writer.endElement("div"); //阶段1结束

　　(四) 阶段二

　　第二阶段是显示当前百分比的进度条和标签，如图6所示。该进度条是作为一个具有100个内嵌span标签的div标签实现的。这些将由AJAX JavaScript根据来自于服务器的响应进行设置。

图6.上传文件到服务器

writer.startElement("div"，component);
writer.writeAttribute("id"， input.getClientId(context) + "_stage2"， "id");
...
writer.writeAttribute("style"，"display:none"， "style");
String progressBarID = component.getClientId(context) + "_progressBar";
String progressBarLabelID = component.getClientId(context) + "_progressBarlabel";
writer.startElement("div"， component);
writer.writeAttribute("id"，progressBarID，"id");
String progressBarStyleClass = input.getProgressBarStyleClass();
if(progressBarStyleClass != null)
writer.writeAttribute("class"，progressBarStyleClass，"class");
for(int i=0;i＜100;i++){
　writer.write("＜span＞＜/span＞");
}
writer.endElement("div");
writer.startElement("div"，component);
writer.writeAttribute("id"，progressBarLabelID，"id");
...
writer.endElement("div");
writer.endElement("div"); //阶段2结束

　　(五) 阶段三

　　最后，作为阶段三，一旦文件成功上传，需要被显示的组件即被生成，见图7。这些是在生成器的encodeChildren方法中实现的。

图7.上传完成

public void encodeChildren(FacesContext context，
UIComponent component) throws IOException {
　ResponseWriter writer = context.getResponseWriter();
　UIFileUpload input = (UIFileUpload)component;
　//一旦文件上传成功，处理将被显示的子结点
　writer.startElement("div"， component);
　writer.writeAttribute("id"， input.getClientId(context) + "_stage3"， "id"); //阶段3.
　if(input.getValue() == null){
　　writer.writeAttribute("style"，"display:none;"，null);
　}else{
　　writer.writeAttribute("style"，"display:block"，null);
　}
　List＜UIComponent＞ children = input.getChildren();
　for(UIComponent child : children){
　　FacesUtils.encodeRecursive(context，child);
　}
　writer.endElement("div"); //阶段3结束
}

四、处理AJAX请求

　　AJAX请求的生成是在这个组件的解码方法中处理的。我们需要检查这是否是一个实际的AJAX请求（为了区别于正常的编译行为），然后基于由ProgressMonitorFileItemFactory类的SessionUpdatingProgressObserver实例设置在会话中的值把一个XML响应发送回客户端。

public void decode(FacesContext context， UIComponent component) {
　UIFileUpload input = (UIFileUpload) component;
　//检查是否这是一个上传进度请求，或是一个实际的上传请求.
　ExternalContext extContext = context.getExternalContext();
　Map parameterMap = extContext.getRequestParameterMap();
　String clientId = input.getClientId(context);
　Map requestMap = extContext.getRequestParameterMap();
　if(requestMap.get(clientId) == null){
　　return;//什么也不做，返回
　}
　if(parameterMap.containsKey(PROGRESS_REQUEST_PARAM_NAME)){
　　//这是一个在该文件请求中的得到进度信息的请求.
　　//得到该进度信息并把它生成为XML
　　HttpServletResponse response = (HttpServletResponse)context.getExternalContext().getResponse();
　　//设置响应的头信息
　　response.setContentType("text/xml");
　　response.setHeader("Cache-Control"， "no-cache");
　　try {
　　　ResponseWriter writer = FacesUtils.setupResponseWriter(context);
　　　writer.startElement("progress"， input);
　　　writer.startElement("percentage"， input);
　　　//从会话中获得当前进度百分数(由过滤器所设置).
　　　Double progressCount = (Double)extContext.getSessionMap().
　　　get("FileUpload.Progress." +input.getClientId(context));
　　　if(progressCount != null){
　　　　writer.writeText(progressCount， null);
　　　}else{
　　　　writer.writeText("1"， null);//我们还没有收到上传
　　　}
　　　writer.endElement("percentage");
　　　writer.startElement("clientId"， input);
　　　writer.writeText(input.getClientId(context)， null);
　　　writer.endElement("clientId");
　　　writer.endElement("progress");
　　} catch(Exception e){
　　　//做一些错误记录...
　　}
　　}else{
　　　//正常的译码请求.
　　...

　　五、正常的译码行为

　　在正常的编译期间，文件上传生成器从请求属性中检索FileItem，正是在此处它被过滤器所设置，并且更新该组件的值绑定。然后，该会话中的进度被更新到100％，这样在页面上的JavaScript就可以把组件送入第3个阶段。

//正常的译码请求.
if(requestMap.get(clientId).toString().equals("file")){
try{
　HttpServletRequest request = (HttpServletRequest)extContext.getRequest();
　FileItem fileData = (FileItem)request.getAttribute(clientId);
　if(fileData != null) input.setSubmittedValue(fileData);
　//现在我们需要清除与该项相关的任何进度
　extContext.getSessionMap().put("FileUpload.Progress." + input.getClientId(context)，new Double(100));
}catch(Exception e){
　throw new RuntimeException("不能处理文件上传" +" - 请配置过滤器."，e);
}
}

　　客户端JavaScript负责向服务器发出进度请求并通过不同阶段来移动组件。为了简化处理所有的浏览器特定的XMLHttpRequest对象的问题，我选用了Matt Krause提供的AjaxRequest.js库。该库最大限度地减少我们需要编写的JavaScript代码的数量，同时可以使这个组件正常工作。也许把这部分JavaScript代码打包为该组件的一部分，然后从PhaseListener生成它更好一些，但是，我已经通过定义一个到JSP页面上的JavaScript库的链接来尽力使得它简单。

　　组件中的getProgressBarJavaScript方法被调用以生成JavaScript。使JavaScript正常工作通常是实现AJAX组件最困难的部分；不过我想，下面的代码已经非常清晰易于理解了。尽管在我的示例中JavaScript是嵌入到Java代码中的，但是把它放到一个外部独立的文件中也许更好一些。在本文中，我只是想使问题更为简单些且只关心本文的主题。下面是一个将由组件生成的JavaScript的示例。其中假定，fileUpload1是被赋值到该文件组件的客户端JSF Id，而uploadForm是HTML表单的Id。

　　六、结论

　　我很希望，本文能够在有关如何使得文件上传更具有用户友好性，并且把AJAX和JavaServer Faces用于实现高级用户接口组件的可能性方面引发你的进一步思考。毫无疑问，本文中的方案比较冗长并且有可能得到进一步的改进。我希望你能详细地分析一下本文中所提供的完整的源代码来深入理解本文中所讨论的概念。

Linden.zhang 2007-06-07 11:48 发表评论

jsf国际化

Linden.zhang — Wed, 06 Jun 2007 09:32:00 GMT

JSF的国际化（Internnationalization）信息处理是基于Java对国际化的支援，您可以在一个信息资源档中统一管理信息资源，资源文件的名称是.properties，而內容是名称与值的配对，例如：

messages.properties

titleText=JSF Demo
hintText=Please input your name and password
nameText=name
passText=password
commandText=Submit

资源档名称由basename加上语言与地区来组成，例如：

basename.properties
basename_en.properties
basename_zh_TW.properties

沒有指定语言与地区的basename是预设的资源档名称，JSF会根据浏览器送來的Accept-Language header中的內容来決定该使用哪一个资源档名称，例如：

Accept-Language: zh_TW, en-US, en

如果浏览器送来这些header，则预设会使用繁体中文，接著是美式英文，再来是英文语系，如果找不到对应的信息资源档，则会使用预设的信息资源档。

由于信息资源档必須是ISO-8859-1编码，所以对于非西方语系的处理，必须先将之转换为Java Unicode Escape格式，例如您可以先在信息资源档中写下以下的內容：

messages_zh_TW.txt

titleText=JSF示範
hintText=請輸入名稱與密碼
nameText=名稱
passText=密碼
commandText=送出

然后使用JDK的工具程式native2ascii来转换，例如：

native2ascii -encoding Big5 messages_zh_TW.txt messages_zh_TW.properties

转换后的內容会如下：

messages_zh_TW.properties

titleText=JSF\u793a\u7bc4
hintText=\u8acb\u8f38\u5165\u540d\u7a31\u8207\u5bc6\u78bc
nameText=\u540d\u7a31
passText=\u5bc6\u78bc
commandText=\u9001\u51fa

（所有资源文件放入你的JFS应用的WEB-INF/classes目录下）

接下来您可以使用标记來指定载入信息资源，一个例子如下：

index.jsp

<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@page contentType="text/html;charset=UTF8"%>

<h:outputText value="#{msgs.titleText}"/>

   actionListener="#{user.verify}"
action="#{user.outcome}"/>

如此一來，如果您的浏览器预设接受zh_TW语系的话，则页面上就可以显示中文，否則预设将以英文显示，也就是messages.properties的內容，为了能显示多国语系，我们设定网页编码为UTF8。

可以设定locale属性，直接指定所要使用的语系，例如：

直接指定以上的話，则会使用繁体中文来显示，JSF会根据的basename属性加上的locale属性來決定要使用哪一个信息资源档，就上例而言，就是使用messages_zh_TW.properties，如果设定为以下的话，就会使用messages_en.properties：

您也可以在faces-config.xml中设定语系，例如：

en
zh_TW

.....

在一定有一个，而可以有好几个，这告訴JSF您的应用程序支援哪些语系。

当然，如果您可以提供一个选项让使用者选择自己的语系会是更好的方式，例如根据user这个Bean的locale属性来决定页面语系：

在页面中设定一个表单，可以让使用者选择语系，例如设定单选钮：

   itemLabel="#{msgs.zh_TWText}"/>
   itemLabel="#{msgs.enText}"/>

Linden.zhang 2007-06-06 17:32 发表评论

jsf简单例子

Linden.zhang — Wed, 06 Jun 2007 09:27:00 GMT

从下载的jsf-1_1_01中看到了四个例子，(下载地址： http://java.sun.com/j2ee/javaserverfaces/download.html)，自己jsf刚刚起步，应该认真研究。
首先下载jsf-1_1_01.zip，并解压。在解压的目录中找到samples目录，把其中的jsf-cardemo.war放到Tomcat 5的webapps目录中，启动Tomcat 5,在浏览器中输入：http://127.0.0.1:8080/jsf-guessNumber/。

例子是简单了点！
greeting.jsp

程序代码：

<%@ page contentType="text/html;charset=GBK"%>

Hello
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
"white">

"helloForm" >

我的名字叫Duke. 我想好了一个数字，范围是
"#{UserNumberBean.minimum}"/> 到
"#{UserNumberBean.maximum}"/>. 你能猜出它？

"waveImg" url="/wave.med.gif" />
"userNo" value="#{UserNumberBean.userNumber}" validator="#{UserNumberBean.validate}"/>
"submit" action="success" value="Submit" />

"color: red; font-family: 'new Century Schoolbook', serif; font-style: oblique; text-decoration: overline" id="errors1" for="userNo"/>

数字的最大值、最小值、猜对与否、及数字的验证都绑到了UserNumberBean上，没有使用标准验证器。且来看看这个应用中的主角：

程序代码：

package guessNumber;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.LongRangeValidator;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;
import java.util.Random;
public class UserNumberBean {
    Integer userNumber = null;
    Integer randomint = null;
    String  response = null;
    protected String[] status = null;
    private int minimum = 0;
    private boolean minimumSet = false;
    private int maximum = 0;
    private boolean maximumSet = false;
    public UserNumberBean() {
        Random randomGR = new Random();
        randomint = new Integer(randomGR.nextInt(10));
        System.out.println("Duke's number: " + randomInt);
    }
    public void setUserNumber(Integer user_number) {
        userNumber = user_number;
        System.out.println("Set userNumber " + userNumber);
    }
    public Integer getUserNumber() {
        System.out.println("get userNumber " + userNumber);
        return userNumber;
    }
    public String getResponse() {
        if (userNumber != null && userNumber.compareTo(randomInt) == 0) {
            return "Yay! You got it!";
        } else {
            return "Sorry, " + userNumber + " is incorrect.";
        }
    }

    public String[] getStatus() {
        return status;
    }
    public void setStatus(String[] newStatus) {
        status = newStatus;
    }

    public int getMaximum() {
        return (this.maximum);
    }
    public void setMaximum(int maximum) {
        this.maximum = maximum;
        this.maximumSet = true;
    }
    public int getMinimum() {
        return (this.minimum);
    }
    public void setMinimum(int minimum) {
        this.minimum = minimum;
        this.minimumSet = true;
    }
    public void validate(FacesContext context,
                         UIComponent component,
                         Object value) throws ValidatorException {
        if ((context == null) || (component == null)) {
            throw new nullPointerException();
        }
        if (value != null) {
            try {
                int converted = intValue(value);
                if (maximumSet &&
                    (converted > maximum)) {
                    if (minimumSet) {
                        throw new ValidatorException(
                            MessageFactory.getMessage
                            (context,
                             Validator.NOT_IN_RANGE_MESSAGE_ID,
                             new Object[]{
                                 new Integer(minimum),
                                 new Integer(maximum)
                             }));
                    } else {
                        throw new ValidatorException(
                            MessageFactory.getMessage
                            (context,
                             LongRangeValidator.MAXIMUM_MESSAGE_ID,
                             new Object[]{
                                 new Integer(maximum)
                             }));
                    }
                }
                if (minimumSet &&
                    (converted < minimum)) {
                    if (maximumSet) {
                        throw new ValidatorException(MessageFactory.getMessage
                                                     (context,
                                                      Validator.NOT_IN_RANGE_MESSAGE_ID,
                                                      new Object[]{
                                                          new Double(minimum),
                                                          new Double(maximum)
                                                      }));
                    } else {
                        throw new ValidatorException(
                            MessageFactory.getMessage
                            (context,
                             LongRangeValidator.MINIMUM_MESSAGE_ID,
                             new Object[]{
                                 new Integer(minimum)
                             }));
                    }
                }
             } catch (NumberFormatException e) {
                throw new ValidatorException(
                    MessageFactory.getMessage
                    (context, LongRangeValidator.TYPE_MESSAGE_ID));
            }
        }
    }
    private int intValue(Object attributeValue)
        throws NumberFormatException {
        if (attributeValue instanceof Number) {
            return (((Number) attributeValue).intValue());
        } else {
            return (Integer.parseInt(attributeValue.toString()));
        }
    }
}

数字的最小值，最大值在faces-config.xml中设置。这里主要看看那个validate方法，它在数字不在0-10范围时，抛出ValidatorException异常。异常信息将会由标记输出。这些异常信息如何本地化定制？那就是从资源包中获取！请看：

程序代码：

package guessNumber;
import javax.faces.application.Application;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import java.text.MessageFormat;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
public class MessageFactory extends Object {

    private MessageFactory() {
    }
   //这个方法是用做参数替换

    public static String substituteParams(Locale locale, String msgtext, Object params[]) {
        String localizedStr = null;
        if (params == null || msgtext == null) {
            return msgtext;
        }
        StringBuffer b = new StringBuffer(100);
        MessageFormat mf = new MessageFormat(msgtext);
        if (locale != null) {
            mf.setLocale(locale);
            b.append(mf.format(params));
            localizedStr = b.toString();
        }
        return localizedStr;
    }
//上面方法的用法例子
    public static void main(String args[]){         String msgtext="我由于{0},不能去{1}";         String params[]={"有事","北京"};         String s=substituteParams(Locale.CHINESE,msgtext,params);         System.out.println(s);   }
/**
运行结果：  D:\java>java   Test  我由于有事,不能去北京
   D:\java>
*/

    /**
     * This version of getMessage() is used in the RI for localizing RI
     * specific messages.
     */
    public static FacesMessage getMessage(String messageId, Object params[]) {
        Locale locale = null;
        FacesContext context = FacesContext.getCurrentInstance();
        // context.getViewRoot() may not have been initialized at this point.
        if (context != null && context.getViewRoot() != null) {
            locale = context.getViewRoot().getLocale();
            if (locale == null) {
                locale = Locale.getDefault();
            }
        } else {
            locale = Locale.getDefault();
        }
        return getMessage(locale, messageId, params);
    }
//从资源包中获取信息，从而构造jsf页面标记与中所要显示的详细和摘要信息
    public static FacesMessage getMessage(Locale locale, String messageId,
                                          Object params[]) {
        FacesMessage result = null;
        String
            summary = null,
            detail = null,
            bundleName = null;
        ResourceBundle bundle = null;
        // see if we have a user-provided bundle
        if (null != (bundleName = getApplication().getMessageBundle())) {//资源包的名字
            if (null !=
                (bundle =
                ResourceBundle.getBundle(bundleName, locale,
                                         getCurrentLoader(bundleName)))) {//获取资源包
                // see if we have a hit
                try {
                    summary = bundle.getString(messageId);//从资源包中获取信息摘要
                } catch (MissingResourceException e) {
                }
            }
        }
        // 如果不能在用户提供的资源包中获取信息摘要，再从默认的资源包中查找
        if (null == summary) {
            // see if we have a summary in the app provided bundle
            bundle = ResourceBundle.getBundle(FacesMessage.FACES_MESSAGES,
                                              locale,
                                              getCurrentLoader(bundleName));
            if (null == bundle) {
                throw new nullPointerException(" bundle " + bundle);
            }
            // see if we have a hit
            try {
                summary = bundle.getString(messageId);
            } catch (MissingResourceException e) {
            }
        }
        // we couldn't find a summary anywhere!  return null
        if (null == summary) {
            return null;
        }
        // At this point, we have a summary and a bundle.
        if (null == summary || null == bundle) {
            throw new nullPointerException(" summary " + summary + " bundle " +
                bundle);
        }
//参数替换，用参数params替换摘要中的{0},{1}等占位符。
        summary = substituteParams(locale, summary, params);
        try {
//详细信息
            detail = substituteParams(locale,
                                      bundle.getString(messageId + "_detail"),
                                      params);
        } catch (MissingResourceException e) {
        }
        return (new FacesMessage(summary, detail));
    }
    //
    // Methods from MessageFactory
    //
    public static FacesMessage getMessage(FacesContext context, String messageId) {
        return getMessage(context, messageId, null);
    }
    public static FacesMessage getMessage(FacesContext context, String messageId,
                                          Object params[]) {
        if (context == null || messageId == null) {
            throw new nullPointerException(" context " + context + " messageId " +
                messageId);
        }
        Locale locale = null;
        // viewRoot may not have been initialized at this point.
        if (context != null && context.getViewRoot() != null) {
            locale = context.getViewRoot().getLocale();
        } else {
            locale = Locale.getDefault();
        }
        if (null == locale) {
            throw new nullPointerException(" locale " + locale);
        }
        FacesMessage message = getMessage(locale, messageId, params);
        if (message != null) {
            return message;
        }
        locale = Locale.getDefault();
        return (getMessage(locale, messageId, params));
    }
    public static FacesMessage getMessage(FacesContext context, String messageId,
                                          Object param0) {
        return getMessage(context, messageId, new Object[]{param0});
    }
    public static FacesMessage getMessage(FacesContext context, String messageId,
                                          Object param0, Object param1) {
        return getMessage(context, messageId, new Object[]{param0, param1});
    }
    public static FacesMessage getMessage(FacesContext context, String messageId,
                                          Object param0, Object param1,
                                          Object param2) {
        return getMessage(context, messageId,
                          new Object[]{param0, param1, param2});
    }
    public static FacesMessage getMessage(FacesContext context, String messageId,
                                          Object param0, Object param1,
                                          Object param2, Object param3) {
        return getMessage(context, messageId,
                          new Object[]{param0, param1, param2, param3});
    }
    protected static Application getApplication() {
        return (FacesContext.getCurrentInstance().getApplication());
    }
    //获取当前的类加载器，需要该类加载器来查找资源包
    protected static ClassLoader getCurrentLoader(Object fallbackClass) {
        ClassLoader loader =
            Thread.currentThread().getContextClassLoader();
        if (loader == null) {
            loader = fallbackClass.getClass().getClassLoader();
        }
        return loader;
    }
} // end of class MessageFactory

当然我们需要在faces-config.xml中定义资源包名

程序代码：

zh_CN

guessNumber.messages

并写出messages_zh_CN.properties文件:
javax.faces.validator.NOT_IN_RANGE=验证错误: 数字应该在{0}和{1}之间
javax.faces.validator.LongRangeValidator.MAXIMUM=验证错误: 数字不应该比{0}大
javax.faces.validator.LongRangeValidator.MINIMUM=验证错误:数字不应该比{0}小
javax.faces.validator.LongRangeValidator.TYPE=验证错误:数字类型错误.
javax.faces.component.UIInput.CONVERSION=转换数字时发生错误.
javax.faces.component.UIInput.REQUIRED=请输入数字 ...

Linden.zhang 2007-06-06 17:27 发表评论

BlogJava-Linden.zhang-文章分类-Jsf

JavaScript 访问 JSF 组件的方法

JSF中实现分页（三）

JSF中实现分页（二）

JSF中实现分页（一）

JSF入门与提高目录

AJAX+JSF组件实现高性能的文件上载

jsf国际化

jsf简单例子

我的名字叫Duke. 我想好了一个数字，范围是"#{UserNumberBean.minimum}"/> 到"#{UserNumberBean.maximum}"/>. 你能猜出它？

我的名字叫Duke. 我想好了一个数字，范围是
"#{UserNumberBean.minimum}"/> 到
"#{UserNumberBean.maximum}"/>. 你能猜出它？