尽管在 Web 应用程序中尽可能多的层次中构建数据验证非常重要，但是这样做却非常耗时，以至于很多开发人员都会干脆忽略这个步骤 —— 这可能会导致今后大量问题的产生。但是随着最新版本的 Java™ 平台中引入了注释，验证变得简单得多了。在本文中，Ted Bergeron 将向您介绍如何使用 Hibernate Annotations 的 Validator 组件在 Web 应用程序中轻松构建并维护验证逻辑。

有时会有一种工具，它可以真正满足开发人员和架构师的需求。开发人员在第一次下载这种工具当天就可以在自己的应用程序中开始使用这种工具。理论上来说，这种工具在开发人员花费大量时间来掌握其用法之前就可以从中获益。架构师也很喜欢这种工具，因为它可以将开发人员导向更高理论层次的实现。Hibernate Annotations 的 Validator 组件就是一种这样的工具。

开始之前需要了解的内容 在阅读本文之前，应该对 Java 平台版本 5（尤其是注释）、JSP 2.0（因为本文中创建了一些标签文件，并在 TLD 中定义了一些函数，它们都是 JSP 2.0 的新特性）和 Hibernate 及 Spring 框架有一个基本的了解。请注意即使不使用 Hibernate 来实现持久性，也可以在自己的应用程序中使用 Hibernate Validator。

Java SE 5 为 Java 语言提供了很多需要的增强功能，不过其他增强功能可能都不如 注释 这样潜力巨大。使用 注释，我们就终于具有了一个标准、一级的元数据框架为 Java 类使用。Hibernate 用户手工编写 *.hbm.xml 文件已经很多年了（或者使用 XDoclet 来自动实现这个任务）。如果手工创建了 XML 文件，那就必须对每个所需要的持久属性都更新这两个文件（类定义和 XML 映射文档）。使用 HibernateDoclet 可以简化这个过程（请参看清单 1 给出的例子），但是这需要我们确认自己的 HibernateDoclet 版本支持要使用的 Hibernate 的版本。doclet 信息在运行时也是不可用的，因为它被编写到了 Javadoc 风格的注释中了。Hibernate Annotations，如图 2 所示，通过提供一个标准、简明的映射类的方法和所添加的运行时可用性来对这些方式进行改进。

/**
                        * @hibernate.property column="NAME" length="60" not-null="true"
                        */
                        public String getName() {
                        return this.name;
                        }
                        /**
                        * @hibernate.many-to-one column="AGENT_ID" not-null="true" cascade="none"
                        *                        outer-join="false" lazy="true"
                        */
                        public Agent getAgent() {
                        return agent;
                        }
                        /**
                        * @hibernate.set lazy="true" inverse="true" cascade="all" table="DEPARTMENT"
                        * @hibernate.collection-one-to-many class="com.triview.model.Department"
                        * @hibernate.collection-key column="DEPARTMENT_ID" not-null="true"
                        */
                        public List<Department> getDepartment() {
                        return department;
                        }
                        

@NotNull
                        @Column(name = "name")
                        @Length(min = 1, max = NAME_LENGTH) // NAME_LENGTH is a constant declared elsewhere
                        public String getName() {
                        return name;
                        }
                        @NotNull
                        @ManyToOne(cascade = {CascadeType.MERGE }, fetch = FetchType.LAZY)
                        @JoinColumn(name = "agent_id")
                        public Agent getAgent() {
                        return agent;
                        }
                        @OneToMany(mappedBy = "customer", fetch = FetchType.LAZY)
                        public List<Department> getDepartment() {
                        return department;
                        }
                        

如果使用 HibernateDoclet，那么直到生成 XML 文件或运行时才能捕获错误。使用 注释，在编译时就可以检测出很多错误；或者如果在编辑时使用了很好的 IDE，那么在编辑时就可以检测出部分错误。在从头创建应用程序时，可以利用 hbm2ddl 工具为自己的数据库从 hbm.xml 文件中生成 DDL。一些重要的信息 —— 比如name 属性的最大长度必须是 60 个字符，或者 DDL 应该添加非空约束 —— 都被从 HibernateDoclet 项添加到 DDL 中。当使用注释时，我们可以以类似的方式自动生成 DDL。

尽管这两种代码映射方式都可以使用，不过注释的优势更为明显。使用注释，可以用一些常量来指定长度或其他值。编译循环的速度更快，并且不需要生成 XML 文件。其中最大的优势是可以访问一些有用信息，例如运行时的非空注释或长度。除了清单 2 给出的注释之外，还可以指定一些验证的约束。所包含的部分约束如下：

• @Max(value = 100)
• @Min(value = 0)
• @Past
• @Future
• @Email

在适当条件下，这些注释会引起由 DDL 生成检查约束。（显然，@Future 并不是一个适当的条件。）还可以根据需要创建定制约束注释。

验证和应用程序层

编写验证代码是一个烦人且耗时的过程。通常，很多开发人员都会放弃在特定的层进行有效性验证，从而可以节省一些时间；但是所节省的时间是否能够弥补在这个地方因忽略部分功能所引起的缺陷却非常值得探讨。如果在所有应用程序层中创建并维护验证所需要的时间可以极大地减少，那么争论的焦点就会转向是否要在多个层次中进行有效性验证。假设有一个应用程序，它让用户使用一个用户名、密码和信用卡号来创建一个帐号。在这个应用程序中所希望进行验证的组件如下：

• 视图： 通过 JavaScript 进行验证可以避免与服务器反复进行交互，这样可以提供更好的用户体验。用户可以禁用 JavaScript，因此这个层次的验证最好要有，但是却并不可靠。对所需要的域进行简单的验证是必须的。
  
  
• 控制器： 验证必须在服务器端的逻辑中进行处理。这个层次中的代码可以以适合某个特定用途的方式处理验证。例如，在添加新用户时，控制器可以在进行处理之前检查指定的用户名是否已经存在。
  
  
• 服务： 相对复杂的业务逻辑验证通常都最适合放到服务层中。例如，一旦有一个信用卡对象看起来有效，就应该使用信用卡处理服务对这个信用卡的信息进行确认。
  
  
• DAO： 在数据到达这个层次时，应该已经是有效的了。尽管如此，执行一次快速检查从而确保所需要的域都非空并且值也都在特定的范围或遵循特定的格式（例如 e-mail 地址域就应该包含一个有效的 e-mail 地址）也是非常有益的。在此处捕获错误总比产生可以避免的 SQLException 错误要好。
  
  
• DBMS： 这是通常可以忽略验证的地方。即使当前正在构建的应用程序是数据库的惟一客户机，将来还可能会添加其他客户机。如果应用程序有一些 bug（大部分应用程序都可能会有 bug），那么无效的数据也可能会被发送给数据库。在这种情况中，如果走运，就可以找到无效的数据，并且需要分析这些数据是否可以清除，以及如何清除。
  
  
• 模型： 这是进行验证的一个理想地方，它不需要访问外部服务，也不需要了解持久性数据。例如，某业务逻辑可能会要求用户至少提供一个联系信息，这可以是一个电话号码也可以是一个 e-mail 地址；可以使用模型层的验证来确保用户的确提供了这种信息。

进行验证的一种典型方法是对简单的验证使用 Commons Validator，并在控制器中编写其他一些验证逻辑。Commons Validator 可以生成 JavaScript 来对视图中的验证进行处理。但是 Commons Validator 也有自己的缺陷：它只能处理简单的验证问题，并且将验证的信息都保存到了 XML 文件中。Commons Validator 被设计用来与 Struts 一起使用，而且没有提供一种简单的方法在应用程序层间重用验证的声明。

在规划有效性验证策略时，选择在错误发生时简单地处理这些错误是远远不够的。一种良好的设计同时还要通过生成一个友好的用户界面来防止出现错误。采用预先进行的方法进行验证可以极大地增强用户对于应用程序的理解。不幸的是，Commons Validator 并没有对此提供支持。假设希望 HTML 文件设置文本域的 maxlength 属性来与验证匹配，或者在文本域之后放上一个百分号（%）来表示要输入百分比的值。通常，这些信息都被硬编写到 HTML 文档中了。如果决定修改 name 属性来支持 75 个字符，而不是 60 个字符，那么需要改动多少地方呢？在很多应用程序中，通常都需要：

• 更新 DDL 来增大数据库列的长度（通过 HibernateDoclet、 hbm.xml 或 Hibernate Annotations）。
• 更新 Commons Validator XML 文件将最大值增加到 75。
• 更新所有与这个域有关的 HTML 表单，以修改 maxlength 属性。

更好的方法是使用 Hibernate Validator。验证的定义都被通过注释 添加到了模型层中，同时还有对所包含的验证处理的支持。如果选择充分利用所有的 Hibernate，这个 Validator 就可以在 DAO 和 DBMS 层也提供验证。在下面给出的样例代码中，将使用 reflection 和 JSP 2.0 标签文件多执行一个步骤，从而充分利用注释 为视图层动态生成代码。这可以清除在视图中使用的硬编写的业务逻辑。

在清单 3 中，dateOfBirth 被注释为 NotNull 和过去的日期。 Hibernate 的 DDL 生成代码对这个列添加了一个非空约束，以及一个要求日期必须是之前日期的检查约束。e-mail 地址也是非空的，必须匹配 e-mail 地址的格式。这会生成一个非空约束，但是不会生成匹配这种格式的检查约束。

/**
                        * A Simplified object that stores contact information.
                        *
                        * @author Ted Bergeron
                        * @version $Id: Contact.java,v 1.1 2006/04/24 03:39:34 ted Exp $
                        */
                        @MappedSuperclass
                        @Embeddable
                        public class Contact implements Serializable {
                        public static final int MAX_FIRST_NAME = 30;
                        public static final int MAX_MIDDLE_NAME = 1;
                        public static final int MAX_LAST_NAME = 30;
                        private String fname;
                        private String mi;
                        private String lname;
                        private Date dateOfBirth;
                        private String emailAddress;
                        private Address address;
                        public Contact() {
                        this.address = new Address();
                        }
                        @Valid
                        @Embedded
                        public Address getAddress() {
                        return address;
                        }
                        public void setAddress(Address a) {
                        if (a == null) {
                        address = new Address();
                        } else {
                        address = a;
                        }
                        }
                        @NotNull
                        @Length(min = 1, max = MAX_FIRST_NAME)
                        @Column(name = "fname")
                        public String getFirstname() {
                        return fname;
                        }
                        public void setFirstname(String fname) {
                        this.fname = fname;
                        }
                        @Length(min = 1, max = MAX_MIDDLE_NAME)
                        @Column(name = "mi")
                        public String getMi() {
                        return mi;
                        }
                        public void setMi(String mi) {
                        this.mi = mi;
                        }
                        @NotNull
                        @Length(min = 1, max = MAX_LAST_NAME)
                        @Column(name = "lname")
                        public String getLastname() {
                        return lname;
                        }
                        public void setLastname(String lname) {
                        this.lname = lname;
                        }
                        @NotNull
                        @Past
                        @Column(name = "dob")
                        public Date getDateOfBirth() {
                        return dateOfBirth;
                        }
                        public void setDateOfBirth(Date dateOfBirth) {
                        this.dateOfBirth = dateOfBirth;
                        }
                        @NotNull
                        @Email
                        @Column(name = "email")
                        public String getEmailAddress() {
                        return emailAddress;
                        }
                        public void setEmailAddress(String emailAddress) {
                        this.emailAddress = emailAddress;
                        }
                        

样例应用程序 在 下载 一节，您可以下载一个样例应用程序，它展示了本文中采用的设计思想和代码。由于这是一个可以工作的应用程序，因此代码比本文中讨论的的内容更为复杂。例如，清单 9 就节选于标签文件 text.tag；这个样例应用程序具有标签文件使用的所有代码，以及其他三个类似的标签文件使用的代码（用于选择、隐藏和检查框的 HTML 元素）。由于这是一个可以工作的应用程序，它包含了一个在这种类型的应用程序中都可以找到的架构。还有一个 Ant 构建文件、Spring 和 Hibernate XML 封装代码，以及 log4j 配置。虽然这些都不是本文介绍的重点，但是您会发现仔细研究一下这个样例应用程序的源代码是非常有用的。

如果需要，Hibernate DAO 实现也可以使用 Validation Annotations。所需做的是在 hibernate.cfg.xml 文件中指定基于 Hibernate 事件的验证规则。（更多信息请参考 Hibernate Validator 的文档；可以在 参考资料 一节中找到相关的链接）。如果真地希望抄近路，您可以只捕获服务或控制器中的 InvalidStateException 异常，并循环遍历 InvalidValue 数组。

对控制器添加验证

要执行验证，需要创建一个 Hibernate 的 ClassValidator 实例。这个类进行实例化的代价可能会很高，因此最好只对希望进行验证的每个类来进行实例化。一种方法是创建一个实用工具类，对每个模型对象存储一个 ClassValidator 实例，如清单 4 所示：

/**
                        * Handles validations based on the Hibernate Annotations Validator framework.
                        * @author Ted Bergeron
                        * @version $Id: AnnotationValidator.java,v 1.5 2006/01/20 17:34:09 ted Exp $
                        */
                        public class AnnotationValidator {
                        private static Log log = LogFactory.getLog(AnnotationValidator.class);
                        // It is considered a good practice to execute these lines once and
                        // cache the validator instances.
                        public static final ClassValidator<Customer> CUSTOMER_VALIDATOR =
                        new ClassValidator<Customer>(Customer.class);
                        public static final ClassValidator<CreditCard> CREDIT_CARD_VALIDATOR =
                        new ClassValidator<CreditCard>(CreditCard.class);
                        private static ClassValidator<? extends BaseObject> getValidator(Class<?
                        extends BaseObject> clazz) {
                        if (Customer.class.equals(clazz)) {
                        return CUSTOMER_VALIDATOR;
                        } else if (CreditCard.class.equals(clazz)) {
                        return CREDIT_CARD_VALIDATOR;
                        } else {
                        throw new IllegalArgumentException("Unsupported class was passed.");
                        }
                        }
                        public static InvalidValue[] getInvalidValues(BaseObject modelObject) {
                        String nullProperty = null;
                        return getInvalidValues(modelObject, nullProperty);
                        }
                        public static InvalidValue[] getInvalidValues(BaseObject modelObject,
                        String property) {
                        Class<? extends BaseObject>clazz = modelObject.getClass();
                        ClassValidator validator = getValidator(clazz);
                        InvalidValue[] validationMessages;
                        if (property == null) {
                        validationMessages = validator.getInvalidValues(modelObject);
                        } else {
                        // only get invalid values for specified property.
                        // For example, "city" applies to getCity() method.
                        validationMessages = validator.getInvalidValues(modelObject, property);
                        }
                        return validationMessages;
                        }
                        }
                        

在清单 4 中，创建了两个 ClassValidator，一个用于 Customer，另外一个用于 CreditCard。这两个希望进行验证的类可以调用 getInvalidValues(BaseObject modelObject)，会返回 InvalidValue[]。这则会返回一个包含模型对象实例错误的数组。另外，这个方法也可以通过提供一个特定的属性名来调用，这样做会只返回与该域有关的错误。

在使用 Spring MVC 和 Hibernate Validator 时，为信用卡创建一个验证过程变得非常简单，如清单 5 所示：

/**
                        * Performs validation of a CreditCard in Spring MVC.
                        *
                        * @author Ted Bergeron
                        * @version $Id: CreditCardValidator.java,v 1.2 2006/02/10 21:53:50 ted Exp $
                        */
                        public class CreditCardValidator implements Validator {
                        private CreditCardService creditCardService;
                        public void setCreditCardService(CreditCardService service) {
                        this.creditCardService = service;
                        }
                        public boolean supports(Class clazz) {
                        return CreditCard.class.isAssignableFrom(clazz);
                        }
                        public void validate(Object object, Errors errors) {
                        CreditCard creditCard = (CreditCard) object;
                        InvalidValue[] invalids = AnnotationValidator.getInvalidValues(creditCard);
                        // Perform "expensive" validation only if no simple errors found above.
                        if (invalids == null || invalids.length == 0) {
                        boolean validCard = creditCardService.validateCreditCard(creditCard);
                        if (!validCard) {
                        errors.reject("error.creditcard.invalid");
                        }
                        } else {
                        for (InvalidValue invalidValue : invalids) {
                        errors.rejectValue(invalidValue.getPropertyPath(),
                        null, invalidValue.getMessage());
                        }
                        }
                        }
                        }
                        

validate() 方法只需要将 creditCard 实例传递给这个验证过程，从而返回 InvalidValue 数组。如果发现了一个或多个这种简单错误，那么就可以将 Hibernate 的 InvalidValue 数组转换成 Spring 的 Errors 对象。如果用户已经创建了这个信用卡并且没有出现任何简单错误，就可以将更加彻底的验证委托给服务层进行。这一层可以与商业服务提供者一起对信用卡进行验证。

现在我们已经看到这个简单的模型层注释是如何平衡到控制器、DAO 和 DBMS 层的验证的。在 HibernateDoclet 和 Commons Validator 中发现的验证逻辑的重合现在都已经统一到模型中了。尽管这是一个非常受欢迎的改进，但是视图层传统上来说一直是最需要进行详细验证的地方。

回页首

为视图添加验证

在下面的例子中，使用了 Spring MVC 和 JSP 2.0 标签文件。JSP 2.0 允许在 TLD 文件中对定制函数进行注册，并在一个标签文件中进行调用。标签文件类似于 taglibs，但是它们是使用 JSP 代码编写的，而不是使用 Java 代码编写的。采用这种方法，使用 Java 语言写好的代码就可以封装成函数，而使用 JSP 写好的代码则可以放入标签文件中。在这种情况中，对注释的处理需要使用映像，这会由几个函数来执行。绑定 Spring 或呈现 XHTML 的代码也是标签文件的一部分。

清单 6 中节选的 TLD 代码定义 text.tag 文件可以使用，并定义了一个名为 required 的函数。

                        <?xml version="1.0" encoding="ISO-8859-1" ?>
                        <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">
                        <tlib-version>1.0</tlib-version>
                        <short-name>form</short-name>
                        <uri>formtags</uri>
                        <tag-file>
                        <name>text</name>
                        <path>/WEB-INF/tags/form/text.tag</path>
                        </tag-file>
                        <function>
                        <description>determine if field is required from Annotations</description>
                        <name>required</name>
                        <function-class>com.triview.web.Utilities</function-class>
                        <function-signature>Boolean required(java.lang.Object,java.lang.String)
                        </function-signature>
                        </function>
                        </taglib>
                        

清单 7 节选自 Utilities 类，其中包含了标签文件使用的所有函数。在前文中我们曾经说过，最适合使用 Java 代码编写的代码都被放到了几个 TLD 可以映射的函数中，这样标签文件就可以使用它们了；这些函数都是在 Utilities 类中进行编码的。因此，我们需要三样东西：定义这些类的 TLD 文件、Utilities 中的函数，以及标签文件本身，后者要使用这些函数。（第四样应该是使用这个标签文件的 JSP 页面。）

在清单 7 中，给出了在 TLD 中引用的函数和另外一个表示给定属性是否是 Date 的方法。在这个类中要涉及到比较多的代码，但是本文限于篇幅，不会给出所有的代码；不过需要注意 findGetterMethod() 除了将表达式语言（Expression Language，EL）方法表示（customer.contact）转换成 Java 表示（customer.getContact()）之外，还执行了基本的映像操作。

public static Boolean required(Object object, String propertyPath) {
                        Method getMethod = findGetterMethod(object, propertyPath);
                        if (getMethod == null) {
                        return null;
                        } else {
                        return getMethod.isAnnotationPresent(NotNull.class);
                        }
                        }
                        public static Boolean isDate(Object object, String propertyPath) {
                        return java.util.Date.class.equals(getReturnType(object, propertyPath));
                        }
                        public static Class getReturnType(Object object, String propertyPath) {
                        Method getMethod = findGetterMethod(object, propertyPath);
                        if (getMethod == null) {
                        return null;
                        } else {
                        return getMethod.getReturnType();
                        }
                        }
                        

此处可以清楚地看到在运行时使用 Validation annotations 是多么容易。可以简单地引用对象的 getter 方法，并检查这个方法是否有相关的给定的注释 。

清单 8 中给出的 JSP 例子进行了简化，这样就可以着重查看相关的部分了。此处，这里有一个表单，它有一个选择框和两个输入域。所有这些域都是通过在 form.tld 文件中声明的标签文件进行呈现的。标签文件被设计成使用智能缺省值，这样就可以根据需要允许简单编码的 JSP 可以有定义更多信息的选项。关键的属性是 propertyPath，它使用 EL 符号将这个域映射为模型层属性，就像是使用 Spring MVC 的 bind 标签一样。

<%@ taglib tagdir="/WEB-INF/tags/form" prefix="form" %>
                        <form method="post" action="<c:url value="/signup/customer.edit"/>">
                        <form:select propertyPath="creditCard.type" collection="${creditCardTypeCollection}"
                        required="true" labelKey="prompt.creditcard.type"/>
                        <form:text propertyPath="creditCard.number" labelKey="prompt.creditcard.number">
                        <img src="<c:url value="/images/icons/help.png"/>" alt="Help"
                        onclick="new Effect.SlideDown('creditCardHelp')"/>
                        </form:text>
                        <form:text propertyPath="creditCard.expirationDate"/>
                        </form>
                        

text.tag 文件的完整源代码太大了，不好放在这儿，因此清单 9 给出了其中关键的部分：

                        <%@ attribute name="propertyPath" required="true" %>
                        <%@ attribute name="size" required="false" type="java.lang.Integer" %>
                        <%@ attribute name="maxlength" required="false" type="java.lang.Integer" %>
                        <%@ attribute name="required" required="false" type="java.lang.Boolean" %>
                        <%@ taglib uri="http://www.springframework.org/tags" prefix="spring" %>
                        <%@ taglib uri="formtags" prefix="form" %>
                        <c:set var="objectPath" value="${form:getObjectPath(propertyPath)}"/>
                        <spring:bind path="${objectPath}">
                        <c:set var="object" value="${status.value}"/>
                        <c:if test="${object == null}">
                        <%-- Bind ignores the command object prefix, so simple properties of the command object
                        return null above. --%>
                        <c:set var="object" value="${commandObject}"/>
                        <%-- We depend on the controller adding this to request. --%>
                        </c:if>
                        </spring:bind>
                        <%-- If user did not specify whether this field is required,
                        query the object for this info. --%>
                        <c:if test="${required == null}">
                        <c:set var="required" value="${form:required(object,propertyPath)}"/>
                        </c:if>
                        <c:choose>
                        <c:when test="${required == null || required == false}">
                        <c:set var="labelClass" value="optional"/>
                        </c:when>
                        <c:otherwise>
                        <c:set var="labelClass" value="required"/>
                        </c:otherwise>
                        </c:choose>
                        <c:if test="${maxlength == null}">
                        <c:set var="maxlength" value="${form:maxLength(object,propertyPath)}"/>
                        </c:if>
                        <c:set var="isDate" value="${form:isDate(object,propertyPath)}"/>
                        <c:set var="cssClass" value="input_text"/>
                        <c:if test="${isDate}">
                        <c:set var="cssClass" value="input_date"/>
                        </c:if>
                        <div class="field">
                        <spring:bind path="${propertyPath}">
                        <label for="${status.expression}" class="${labelClass}"><fmt:message
                        key="prompt.${propertyPath}"/></label>
                        <input type="text" name="${status.expression}" value="${status.value}"
                        id="${status.expression}"<c:if test="${size != null}"> size="${size}"</c:if>
                        <c:if test="${maxlength != null}"> maxlength="${maxlength}"</c:if>
                        class="${cssClass}"/>
                        <c:if test="${isDate}">
                        <img id="${status.expression}_button"
                        src="<c:url value="/images/icons/calendar.png"/>" alt="calendar"
                        style="cursor: pointer;"/>
                        <script type="text/javascript">
                        Calendar.setup(
                        {
                        inputField : "${status.expression}", // ID of the input field
                        ifFormat : "%m/%d/%Y", // the date format
                        button : "${status.expression}_button" // ID of the button
                        }
                        );
                        </script>
                        </c:if>
                        <span class="icons"><jsp:doBody/></span>
                        <c:if test="${status.errorMessage != null && status.errorMessage != ''}">
                        <p class="fieldError"><img id="${status.expression}_error"
                        src="<c:url value="/images/icons/error.png"/>"
                        alt="error"/>${status.errorMessage}</p>
                        </c:if>
                        </spring:bind>
                        </div>
                        

我们马上就可以看出 propertyPath 是惟一需要的属性。size、 maxlength 和 required 都可以忽略。objectPath var 被设置为在 propertyPath 中引用的属性的父对象。因此，如果 propertyPath 是 customer.contact.fax.number， 那么 objectPath 就应该被设置为 customer.contact.fax。我们现在就使用 Spring 的 bind 标签绑定到了包含属性的对象上。这会将对象变量设置成对包含属性的实例的引用。接下来，检查这个标签的用户是否已经指定他/她们是否希望属性是必须的。允许表单开发人员覆盖从注释中返回的值是非常重要的，因为有时他/她们希望让控制器为所需要的域设置缺省值，而用户可能并不希望为这个域提供值。如果表单开发人员没有为 required 指定值，那么就可以调用这个表单 TLD 的 required 函数。这个函数调用了在 TLD 文件中映射的方法。这个方法简单地检查 @NotNull 注释；如果它发现某个属性具有这个注释，就将 labelClass 变量设置为必须的。可以类似地确定正确的 maxlength 以及这个域是否是一个 Date。

接下来使用 Spring 来绑定到 propertyPath 上，而不是像前面一样只绑定到包含这个属性的对象上。这允许在生成 label 和 input HTML 标签时使用 status.expression 和 status.value。 input 标签也可以使用一个大小 maxlength 以及适当的类来生成。如果前面已经确定属性是一个 Date，现在就可以添加 JavaScript 日历了。（可以在 参考资料 一节找到一个很好的日历组件的链接）。注意根据需要链接属性、输入 ID 和图像 ID 的标签是多么简单。）这个 JavaScript 日历需要一个图像 ID 来匹配输入域，其后缀是 _button。

最后，可以将 <jsp:doBody/> 封装到一个 span 标签中，这样允许表单开发人员在页面中添加其他图标，例如用来寻求帮助的图标。（清单 8 给出了一个为信用卡号域添加的帮助图标。）最后的部分是检查 Spring 是否为这个属性报告和显示了一个错误，并和一个错误图标一起显示。

使用 CSS，就可以对必须的域进行一下装饰 —— 例如，让它们以红色显示、在文本边上显示一个星号，或者使用一个背景图像来装饰它。在清单 10 中，将必须的域的标签设置成黑色，而且后面显示一个红色的星号（在 Firefox 以及其他标准兼容的浏览器中），如果是在 IE 中则还会在左边加上一个小旗子的背景图像：

label.required {
                        color: black;
                        background-image: url( /images/icons/flag_red.png );
                        background-position: left;
                        background-repeat: no-repeat;
                        }
                        label.required:after {
                        content: '*';
                        }
                        label.optional {
                        color: black;
                        }
                        

日期输入域自动会在右边放上一个 JavaScript 日历图标。对所有的文本域设置正确的 maxlength 属性可以防止用户输入太多文本所引起的错误。可以扩展 text 标签来为输入域类设置其他的数据类型。可以修改 text 标签使用 HTML，而不是 XHTML（如果希望这样）。可以不太费力地获得具有正确语义的 HTML 表单，而且不需学习基于组件的框架知识，就可以利用基于组件的 Web 框架的优点。

尽管标签文件生成的 HTML 文件可以帮助防止一些错误的产生，但是在视图层并没有任何代码来真正进行错误检查。由于可以使用类属性，现在就可以添加一些简单的 JavaScript 来实现这种功能了，如清单 11 所示。这里的 JavaScript 也可以是通用的，在任一表单中都可以重用。

<script type="text/javascript">
                        function checkRequired(form) {
                        var requiredLabels = document.getElementsByClassName("required", form);
                        for (i = 0; i < requiredLabels.length; i++) {
                        var labelText = requiredLabels[i].firstChild.nodeValue; // Get the label's text
                        var labelFor = requiredLabels[i].getAttribute("for"); // Grab the for attribute
                        var inputTag = document.getElementById(labelFor); // Get the input tag
                        if (inputTag.value == null || inputTag.value == "") {
                        alert("Please make sure all required fields have been entered.");
                        return false; // Abort Submit
                        }
                        }
                        return true;
                        }
                        </script>
                        

这个 JavaScript 是通过为表单声明添加 onsubmit="return checkRequired(this);" 被调用的。这个脚本简单地获取具有所需要的类的表单中的所有元素。由于我们的习惯是在标签标记中使用这个类，因此代码会通过 for 属性来查找与这个标签连接在一起的输入域。如果任何输入域为空，就会生成一条简单的警告消息，表单提交就会取消。可以简单地对这个脚本进行扩充，使其扫描多个类，并相应地进行验证。

对于基于 JavaScript 的综合的验证集合来说，最好是使用开源实现，而不是自行开发。在清单 8 中您可能已经注意到下面的代码：

 onclick="new Effect.SlideDown('creditCardHelp')"
                        

这个函数是 Script.aculo.us 库的一部分，这个库提供了很多高级的效果。如果正在使用 Script.aculo.us，就需要对所构建的内容使用 Prototype 库。 JavaScript 验证库的一个例子是由 Andrew Tetlaw 在 Prototype 基础上构建的。（请参看 参考资料 一节中的链接。）他的框架依赖于被添加到输入域的类：

<input class="required validate-number" id="field1" name="field1" />
                        

可以简单地修改 text.tag 的逻辑在 input 标签中插入几个类。将 class="required" 添加到输入标签和 label 标签中不会影响 CSS 规则，但会破坏清单 10 中给出的简单 JavaScript 验证程序。如果要混合使用框架中的代码和简单的 JavaScript 代码，最好使用不同的类名，或在使用类名搜索元素时确保类名有效并检查标签类型。

回页首

最后的考虑

本文已经介绍了模型层的注释如何充分用来在视图、控制器、DAO 和 DBMS 层中创建验证。必须手工创建服务层的验证，例如信用卡验证。其他模型层的验证，例如强制属性 C 是必须的，而属性 A 和 B 都处于指定的状态，这也是一个手工任务。然而，使用 Hibernate Annotations 的 Validator 组件，就可以轻松地声明并应用大多数验证。

展望

不论是简单例子还是所引用框架的 JavaScript 验证都可以对简单的条件进行检查，例如域必须要填写，或者客户机端代码中的数据类型必须要匹配预期的类型。需要用到服务器端逻辑的验证可以使用 Ajax 添加到 JavaScript 验证程序中。您可以使用一个用户注册界面来让用户可以选择用户名。文本标签可以进行增强来检查 @Column(unique = true) 注释。在找到这个注释时，标签可以添加一个用来触发 Ajax 调用的类。

现在您不需要在应用程序层间维护重复的验证逻辑了，这样就可以节省出大量的开发时间。想像一下您最终可以为应用程序所能添加的增强功能！

取得属性值，作为属性名的前缀

通配符，选择任意属性，不考虑名字

　　表二、逻辑运算符

　　表三、关系运算符

　　示例一：

　　从个人简历中寻找具有具有"WEB开发"技能的人的姓名与E-Mail。假设文档结构如下所示：

<document>
<resume>
<name>name</name>
<sex>sex</sex>
<birthday>birthday</birthday>
<skill>skill1</skill>
<skill>skill2</skill2>
…
<skill>skilln</skill>
</resume>
<resume>
…
</resume>
…
</document>

　　为从以上结构的个人简历中寻找出所有具有WEB开发"技能的人的姓名与E-Mail的XSL文档结构如下：

<TABLE border="1" cellspacing="0">
<TH>姓名</TH><TH>E-Mail</TH>
<xsl:for-each select="resume [$any$skill="WEB开发"]">
<TR><TD><xsl:value-of select="name"/></TD>
<TD><xsl:value-of select="E-Mail"/></TD>
</TR>
</xsl:for-each>
</TABLE>

　　说明：

　　1.[ ] ── 表示选择条件，只有满足条件的个人简历才被显示。

　　2.$any$ ── 由于每个人有多种技能，故加$any$作为前缀，以使每个人所有技能都能被比较。

　　3.skill='WEB开发' ── 筛选条件。

　　示例二、

　　仍上面的XML文档为例，如果欲选择1977/1/1之前出生的人的姓名、技能与E-Mail，相应的XSL文档结构如下（假定生日格式为yyyy/mm/dd）：

<TABLE border="1" cellspacing="0">
<TH>姓名</TH><TH>技能</TH><TH>E-Mail</TH>
<xsl:for-each select="resume[birthday$lt$"1977/1/1"]">
<TR>
<TD><xsl:value-of select="name"/></TD>
<TD>
<xsl:value-of select="skill[0]"/>
<xsl:for-each select="skill[index()>0]">、
<xsl:value-of select="."/>
</xsl:for-each>
</TD>
<TD><xsl:value-of select="E-Mail"/></TD>
</TR>
</xsl:for-each>
</TABLE>

　　说明：

　　1.birthday $lt$ '1977/1/1' ── 搜索条件，在此处使用"< "会错误，故使用"$lt$"表示小于。

　　2.skill [0] ── 表示选择skill的第一项。

　　3.skill [index()>0] ── 表示选择skill的第二项以后（包括第二项）的项目。

　　4.xsl:value-of select="." ── 表示选择当前标记的值。

　　相信大家应该注意到，在前面以及本次的例子中出现了一些函数，如index()、formatIndex()、childNumber()，也许大家还不完全明了其中的含义吧？敬请关注下一课。[page]

本期学习XSL样式方法，即可用于XSL元素<xsl:for-each>、<xsl:value-of>、<xsl:template>的select属性、<xsl:apply-templates>的match属性、<xsl:if>、<xsl:when>的test属性中，对元素的范围进行筛选，从而提供更大的灵活性。

　　XML与DHTML（动态HTML）一样，这些节点都是一个个对象，而且这些对象都是有层次的，从根节点开始构成一颗层次清淅的树状结构，这就形成了文档对象模型DOM(Document Object Model)，通过对象的属性、方法来达到访问控制XML节点的目的。

　　我们这里不打算就XML的DOM逐一详细阐述，因为这完全可以写成一个篇幅较多的教程，我们先就一些常见的方法作一些讨论，以期对DOM的对象方法有一个大致的了解。

　　注：从本期开始，所有示例不再提供完整源代码，如有不明白之处，请仔细阅读前面七期、并动手练手。

　　一、end()

　　含义：返回集合中最后一个元素。

　　示例：输出最后一份简历

　　假定XML文件格式为：

……<resume>…</resume>……<resume>…</resume>……

　　相应XSL文件内容为：

<xsl:for-each select="resume[end()]">……</xsl:for-each>

　　或：

<xsl:templates match="resume[end()]">……</xsl:templates>

　　或：

<xsl:apply-template select="resume[end()]">……</xsl:apply-template>

　　二、index()

　　含义：返回该元素在集合中的位置，返回值是一整数，其中第一个元素返回0。

　　示例：返回前面三份简历。

resume[index()$le$3]

　　注意：index()是与父元素相关的，请看下例：

<x>
<y/>
<y/>
</x>
<x>
<y/>
<y/>
</x>

　　返回所有<x>中的第一个<y>

x/y[index()=0] 或x/y[0]

　　三、nodeName()

　　含义：返回元素的名字，即标记名。

　　示例：选择任意元素，假如其名字（即标记名）等于"name"：

*[nodeName()='name'] 或 *[name]

　　四、number()

　　含义：将值转换为数值形式，如果不是数值则返回空，要求参数。

　　示例：年龄(age)小于30岁的人的简历(resume)：

resume[number(age)$lt$30] 或 resume[age$lt$30]

　　五、nodeType()

　　含义：返回结点类型，结果为是数值。以下是返回值列表：

结点类型	结点类型值	结点的字符形式描述
Element	1	'element'
Element Attribute	2	'attribute'
Markup-Delimited Region of Text	3	'text'
Processing Instruction	7	'processing_instruction'
Comment	8	'comment'
Document Entity	9	'document'

　　六、value()

　　含义：返回元素或属性的值。

　　示例：value()是元素或属性的缺省方法，以下表示是等价：

name!value()="NAME" 与 name="NAME"

@attr="attribute_value" 与 @attr="attribute_value"

　　注：@是属性前缀，@attr表示是属性attr

　　七、attribute()

　　含义：返回所有属性结点的集合，等价于"@*"。

　　示例：寻找所有的resume元素，满足条件至少有一个属性的值为"ABC"：

resume[$any$attribute()='ABC'] 或 resume[$any$@*='ABC']

　　寻找所有的resume元素，满足条件至少有一个子元素有一个属性的值为"ABC"：

resume[$any$*/attribute()='ABC'] 或 resume[$any$*/@*='ABC']

　　八、comment()

　　含义：返回所有注释结点。

　　示例：

resume[$any$comment()='禹希初的简历']

　　表示寻找含有注释语句：<!--禹希初的简历-->的<resume>元素。

　　九、cdata()

　　含义：返回所有CDATA类型的结点的集合。

　　示例：

resume[$any$cdata()='禹希初的简历']

　　表示寻找含有下述语句（必须是直接子结点）<![CDATA[禹希初的简历]]>的<resume>元素。

　　十、node()

　　含义：返回当前上下文环境中除根结点和属性结点以外的所有结点的集合，等价于：

"*|pi()|comment()|text()"

　　示例：寻找所有元素resume，其最后一个结点的名字为"skill"：

resume[node()[end()]!nodeName()='skill']

　　寻找所有resume元素的第一个结点：resume/node()[0]。

　　十一、textnode()

　　含义：返回所有文本类型的结点的集合。

　　示例：寻找每一个p元素的第二个文本结点：

p/textnode(1) 或 p!textnode(1)

　　十二、text()

　　含义：返回所有表示文本字符串的结点的集合，等价于"cdata()|textnode()"。

　　本期的内容就介绍至此，另有一个函数date()在本人的机器上一试就发生错误使浏览器自动关闭，还有一个函数pi()本人尚未找到适当的应用方法，就不介绍了，下期将讲述如何XSL中使用脚本。[page]

有时，我们可能会希望XML文档输出时能对其中内容加上一些统计信息或者如编号什么的，利用前面的知识就不太容易实现了。今天将介绍两个新元素<xsl:eval>与<xsl:script>，使我们能轻松处理这个难题。

<xsl:eval>

　　含义：计算脚本表达式，输出一个文本字符串。

　　语法：

<xsl:eval language="language-name">

　　属性：

　　language ── 规定所用脚本语言的名字，可用的属性有"JavaScript"、"JScript"、"VBScript"、"VBS"等，缺省为"JScript"。

<xsl:script>

　　含义：声明全局变量或定义函数。

　　语法：

<xsl:script language="language-name">

　　属性：同<xsl:eval>

　　示例：

　　不知大家对于第四期《跟我学XML》中的例子是否还有印象？其中的XML文档并没有对简历编号，但输出中却加上了大写的罗马数字序号。今天将再举一稍为复杂一些的例子：

　　假如我们编写一份年终生产统计表，其中需要小计一项，常规的作法是事先将其算出来，现在不必了，我们可以只给出单项统计，显示时再统计小计一项。请找出《跟我学XML》的第四期，XML文件不必修改，对XSL文件的修改如下：

<?xml version="1.0" encoding="GB2312"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl">

<xsl:template match="/">
<HTML><HEAD><TITLE>1999年生产统计</TITLE></HEAD>
<BODY><xsl:apply-templates select="document"/></BODY>
</HTML>
</xsl:template>

<xsl:template match="document">
<H3>1999年生产统计</H3>
<TABLE border="1" cellspacing="0">
<TH>班组</TH>
<TH>一季度</TH>
<TH>二季度</TH>
<TH>三季度</TH>
<TH>四季度</TH>
<xsl:apply-templates select="report"/>

<TR><TD>小计</TD>
<TD><xsl:eval>total(this,"q1")</xsl:eval></TD>
<TD><xsl:eval>total(this,"q2")</xsl:eval></TD>
<TD><xsl:eval>total(this,"q3")</xsl:eval></TD>
<TD><xsl:eval>total(this,"q4")</xsl:eval></TD>
</TR>

</TABLE>

<xsl:script>
function total(node,q)
{
　　temp=0;
　　mark='/document/report/'+q;
　　v=node.selectNodes(mark);
　　for(t=v.nextNode();t;t=v.nextNode())
　　{
　　　　temp+=Number(t.text);
　　}
　　return temp; //小计值
}
</xsl:script>

</xsl:template>

<xsl:template match="report">
<TR>
<TD><xsl:value-of select="class"/></TD>
<TD><xsl:apply-templates select="q1"/></TD>
<TD><xsl:apply-templates select="q2"/></TD>
<TD><xsl:apply-templates select="q3"/></TD>
<TD><xsl:apply-templates select="q4"/></TD>
</TR>
</xsl:template>

<xsl:template match="q1|q2|q3|q4">
<!--此处测试产量，如小于等于20则添加一STYLE属性color，其值为red（红色）-->
<xsl:if test=".[value() $le$ 20]">
<xsl:attribute name="style">color:red</xsl:attribute>
</xsl:if>
<xsl:value-of/>
</xsl:template>

</xsl:stylesheet>

上例在浏览器中的样子(IE5.0或更新版本)

　　说明：

　　注意到执行结果的变化了吗？黑体部分为添加部分，注意添加部分分为两部分，<xsl:script></xsl:script>必须置于</TABLE>之后，切记。

　　selectNodes() ── 是XMLDOMObject的一个方法，返回文档中所有满足条件的结点的集合，条件与< xsl:for-each >和select属性的取值采用同样的写法，可以加筛选、下标等限制，如寻找一季度产量大于等于50的班组：

/document/report/q1[value() $ge$ 50]

　　以上写法还有一个更简单的写法：

//q1[value()$ge$50]

　　//表示从根结点出发遍历所有结点，寻找满足条件的结点，如果文档内有同名但意义不同的结点则不能用此种方法，非不得已不建议使用。以此为例，如果希望统计年总产量，则可以下述字符串寻找结点（建议使用最后一种，此种描述将精确找到需要汇总的数据）：

//*[value()$gt$0] 或 //(q1|q2|q3|q4) 或 /document/report/(q1|q2|q3|q4)

　　nextNode() ── 返回结点集中的下一个结点

　　Number() ── 将提供的参数转换为数值

　　下期介绍XSL函数2，用于<xsl:script>及<xsl:eval>中，以及<xsl:if>和<xsl:when>的expr属性。建议读者熟悉JavaScript、JScript、VBScript中至少一种，否你能用XSL完成的工作将十分有限。由于篇幅关系，此处不作详细介绍。[page]

本期介绍多个XSL对于VBScript、JScript增加的方法、属性，以充分发挥XML的优势，用于<xsl:script>、<xsl:eval>标记内表达式的编写或<xsl:if>、<xsl:when>的expr属性。

　　一、absoluteChildNumber

　　含义：返回结点相对于它所有的兄弟（不论名字是否相同）的序号。

　　语法：absoluteChildNumber(node)

　　参数：node ── 对象，欲返回编号的结点。

　　示例：

　　1、假定文档结构为：<document><head/><body/></document>，其中document为顶层结点，下述表达式将输出：

<xsl:eval>
absoluteChildNumber(this.selectNodes('/document/body').item(0))
</xsl:eval>

　　2、确定当前结点相对于其所有兄弟的序号：

<xsl:eval>
absoluteChildNumber(this)
</xsl:eval>

　　二、ancestorChildNumber

　　含义：从给定结点出发根据给定祖先结点名返回最近的祖先结点的序号（相对于同名结点）。如果找不祖先，则返回0。

　　语法：ancestorChildNumber(bstrNodeName, pNode)

　　参数：

　　bstrNodeName ── 字符串。被搜索的祖先结点的名字。

　　pNode ── 对象。搜索开始位置的结点。

　　示例查找当前结点最近的名为report祖先结点：

ancestorChildNumber('report',this)

　　三、attributes

　　含义：返回结点属性的集合。

　　语法：object.attributes

　　参数：object ── 结点对象。

　　示例：当前结点属性的个数

this.attributes.length

　　当前结点第三个属性的值

this.attributs.item(2).value

或

this.attributes.item(2).text

或

this.attributes(2).text

　　注意：如果给定的下标大于属性总和减1将出错，第一个属性的下标是0。

　　四、baseName

　　含义：返回有名字空间限制的基本名，即不包括名字前缀。

　　语法：object.baseName

　　参数：object ── 结点对象

　　示例，当前结点的基本名：

this.baseName

　　五、childNumber

　　含义：返回结点相对于同名同胞的序号。

　　语法：childNumber(object)

　　参数：object ── 结点对象

　　示例，假定XML文档结构如下：

<x><y><z></z></y></x>

　　如果当前结点是z，则childNumber(this)返回1，而absoluteChildNumber(this)返回3。

　　六、dataType

　　含义：设定或读取结点的数据类型。

　　语法：设定结点的数据类型 object.dataType=objValue
　　　　　读取结点的数据类型 objValue=object.dataType

　　参数：object ── 结点对象。

　　示例，读取当前结点的数据类型：

dtType=this.dataType

　　七、depth

　　含义：指定结点出现在文档树上的深度，即该结点位于文档第几层，顶层结点位于第一层，根结点（即用"/"表示的结点）位于第0层。

　　语法：depth(pNode)

　　参数：pNode ── 结点对象

　　示例，当前结点的深度：

depth(this)

　　八、firstChild、lastChild

　　含义：返回结点的第一个子结点（或最后一个子结点）。

　　语法：pNode.firstChild
　　　　　pNode.lastChild

　　参数：pNode ── 结点对象

　　示例，当前结点的第一个结点的名字：

this.firstChild.nodeName

　　九、formatIndex

　　含义：用指定的计数系统格式化提供的整数。

　　语法：formatIndex(lIndex, bstrFormat)

　　参数：

　　lIndex ── 整型数值或变量

　　bstrFormat ── 数据格式，可选值有a、A、i、I、1、01（以0打头的数值形式，如果要求固定长度的编号如0001、0002则非常有用）。

　　示例，当前结点的大写罗马数字编号：

formatIndex(childNumber(this),'I')

　　十、formatNumber

　　含义：以指定格式输出数值。

　　语法：formatNumber(dblNumber, bstrFormat)

　　参数：说明同formatNumber，不同之处在于格式化的可以是小数。

　　示例，对变量a的值格式化为两位小数：

formatNumber(a,'#.00')：

　　十一、hasChildNodes

　　含义：如果结点有子结点则返回true（-1），否则为false（0）。

　　语法：pNode.hasChildNodes()

　　注意：与此前介绍的函数不同，此函数后必须带一个空括号。

　　示例，判断当前结点是否有子结点：

this.hasChildNodes

　　十二、namespaceURI、prefix

　　含义：返回结点名字空间的全局资源标识符（或前缀）。

　　语法：pNode.namespaceURI
　　　　　pNode.prifix

　　十三、nextSibling、previousSibling、parentNode

　　含义：返回结点的下一个兄弟（或前一个兄弟、或结点的父结点）。

　　语法：pNode.nextSibling
　　　　　pNode.previousSibling
　　　　　pNode.parentNode

　　注意：对根结点（即"/"）应用parentNode方法、对第一个孩子结点应用previousSibling方法、对最后一个孩子结点应用nextSibling方法均会导致错误，可通过此过关系运算符==（等于）和!=（不等于）来判断一个结点是否某一指定结点，格式为pNode1 = pNode2或pNode2 != pNode2。

　　十四、nodeName

　　含义：返回元素、属性、入口的名字或其他类型结点的一个特定字符串。

　　语法：pNode.nodeName

　　示例，当前结点的名字：

this.nodeName

　　十五、nodeType、NodeTypeString

　　含义：返回结点的类型的数值形式（或字符串形式）。

　　语法：pNode.nodeType 或 pNode.nodeTypeString

　　返回值：

结点类型	结点类型值	结点的字符形式描述
Element	1	'element'
Element Attribute	2	'attribute'
Markup-Delimited Region of Text	3	'text'
Processing Instruction	7	'processing_instruction'
Comment	8	'comment'
Document Entity	9	'document'

　　十六、nodeTypedValue

　　含义：以结点预定义的数据类型返回结点的值。

　　语法：pNode.nodeTypedValue

　　示例，假定当前结点的数据类型是fixed.14.4，下例将以数值返回结点的值，而不是文本一个字符串：

this.nodeTypedValue

　　十七、nodeValue

　　含义：返回结点的文本。

　　语法：pNode.nodeValue

　　注意：该方法不用于元素类结点，可用于属性、CDATA、注释、文本等结点。

　　示例，当前元素第一个属性的值：

this.attributes(0).nodeValue

　　当前元素内的文本（假定该元素内只有文本，无其它元素，即<mark>text</mark>，建议多尝几次掌握其确切的用法）。

this.firstChild.nodeValue

　　十八、ownerDocument

　　含义：返回包含该结点的文档的根。

　　语法：pNode.ownerDocument

　　注意：该方法用于文档的根结点将出错。

　　十九、selectNodes

　　含义：给定的样式匹配应用于当前结点并返回匹配的结点集合。

　　语法：pNode.selectNodes('pattern')

　　提示：pattern的编写与<xsl:for-each>的select属性的值类似，其中以"/"开头表示从文档的根出发搜索；以"//"开头表遍历文档的所有结点；以".."开头表示从当前结点的父结点开始；如果欲从当前结点向下搜索则不能有以上特殊字符打头。

　　示例，与当前结点同名的元素在其父元素内的个数：

childNumber(this.selectNodes("../"+this.nodeName+"[end()]").item(0))

　　当前元素内名字为"skill"的元素的个数：

childNumber(this.selectNodes("skill[end()]").item(0))

　　二十、selectSingleNode

　　含义：与selectNodes类似，不同的只返回匹配的第一个结点、而不是结点集合。

　　语法：pNode.selectSingleNode('pattern')

　　示例，与当前结点同名的元素在其父元素内的个数：

childNumber(this.selectSingleNode("../"+this.nodeName+"[end()]"))

　　当前元素内名字为"skill"的元素的个数：

childNumber(this.selectSingleNode("skill[end()]"))

　　二十一、text

　　含义：返回结点与它的子树内的文字内容。

　　语法：pNode.text

　　示例，整个文档内的文字内容：

this.ownerDocument.text

　　当前元素及其子树的文字内容：

this.text

　　二十二、xml

　　含义：返回结点及其后代的XML表示。

　　语法：pNode.xml

　　示例，当前文档的XML内容：

this.ownerDocument.xml

　　另有几个函数不作介绍，列于其下以供参考，如感兴趣，请访问http://msdn.microsoft.com获取详细说明。

formatTime(varTime, bstrFormat,varDestLocale)
formatDate(varDate, bstrFormat,varDestLocale)
apendChild(newChild)
definition
CloneNode
insertBefore(newChild, refChild)
parsed
removeChild(oldChild)
replaceChild(newChild, oldChild)
specified
transformNode(stylesheet)
transformNodeToObject(stylesheet,outputObject)
uniqueID(pNode)

<HTML>
<BODY>
<TABLE border=1 cellspacing=0>
<TH>姓名<TD>禹希初<TH>性别<TD>男<TH>生日<TD>1977.5
<TR>
<TH>技能<TD colspan=5>数据库设计与维护、WEB开发
</TABLE>
</BODY>
</HTML>

姓名	禹希初	性别	男	生日	1977.5
技能	数据库设计与维护、WEB开发

　　在这里，我们无法从标记TH、TD得知其内容表示什么，如果用XML，相应的文档（文件名：个人简历.xml）就可写成如下形式：

<?xml version="1.0" encoding="GB2312"?>
<resume>
<name>禹希初</name>
<sex>男</sex>
<birthday>1977.5</birthday>
<skill>数据库设计与维护、WEB开发</skill>
</resume>

上例在浏览器中的样子(IE5.0或更新版本)

说明：

　　version──规定了XML文档的版本，此处只能是1.0；

　　encoding── 此处规定了XML文档的编码类型，此处取值为"GB2312"，也就是"简体中文"。

　　对比两例，使用XML我们可以做到自定义标记，用标记表明内容的含义。这样在Internet上交流资料时，为用计算机处理文档提供了极大的方便，同时我们阅读源文件时也不会被一大堆格式弄得晕头转向。

　　然而，由于XML并没有为标记规定显示方式，如果我们在游览器中查看以上两个文档（建议使用IE5.0或更新版本），我们将看到xml文档并没有以诸如表格的方式来显示。难道我们就不能像HTML一样显示文档吗？回答是否定的。以个人简历为例，需要另建一个格式文件说明各个标记的显示方式，其内容如下（假设文件名为resume.css）：

resume{ display: block;}
name{ display: block; font-size:120%;}
sex{ display:block; text-indent:2em}
birthday{ display:block; text-indent:2em}
skill{ display:block; text-indent:2em}

说明：

　　以上均为CSS样式，建议读者参考有关资料熟悉CSS，在以后学习中必须用到，此处由于篇幅关系不作介绍。建立文件resume.css后，在个人简历.xml文件的第一行后添加以下文字：

<?xml:stylesheet type="text/css" href="resume.css"?>

上例在浏览器中的样子(IE5.0或更新版本)

说明：

　　此处表示引用一个外部CSS样式文件，其中type规定样式类型（可取值为text/css或text/xsl），href规定文件路径。

　　保存文件，再以IE5.0打开文件。怎么样？格式有些不一样吧。好象还不令人满意，文档内容是清晰了，但显示效果比HTML编写的文档就差得多了，XML编写的文档就只能以这种方式显示吗？！

提示：

　　1. 为了更好的理解与掌握XML，建议大家熟悉HTML 4.0与CSS 2.0语法；掌握JavaScript、VBscript中至少一种；编程经验、对数据库理论与SQL的了解均能使大家在学习XML时获益。

　　2. XML文档中标记必须成对出现，如果是空标记也必须有前加"/"的同名标记结束，或使用此种文式<xml_mark/>表示空标记。

　　3. XML以及下面将要介绍的XSL文档，属性值必须用双引号（"）或单引号（’）括起来。

　　4. XML文档必须是良构的（XSL文档也是XML文档中一种），也就是说标记必须有结束标记、标记可以嵌套但不可交叉，如：

<outer><inner></inner><inner/></outer>

是合法的，而下面的形式

<outer><inner></outer></inner>

则是错误的。如果XML文档在浏览时出错，多半是违反了上面提到的规则。[page]

上期我们讲到用CSS（层叠样式表）来格式化XML文档，其效果并不很令人满意。实际上CSS用来格式化HTML标记比较合适些，只是因为它简单才在上例中采用。

　　XML在更多的时候只是一种数据文件，怎样将它变为我们日常所看到的HTML格式那样的文件呢？如果我们将XML文件比作结构化的原料的话，那么XSL就好像"筛子"与"模子"，筛子选取自己需要的原料，这些原料再通过模子形成最终的产品：HTML。

　　这个模子大致是这样：我们先设计好表现的页面，再将其中需要从XML中获取数据来填充内容的部分"挖掉"，然后用XSL语句从XML中筛出相关的数据来填充。一言以譬之：这XSL实际上就是HTML的一个"壳子"，XML数据利用这个"壳"来生成"传统"的HTML。

　　XML在展开时是一个树形结构，我们将树形结构中自定义标记称为节点，节点之间存在父子、兄弟关系，我们要访问其中的结点从根结点就要以"／"来层层进入。

　　在XSL这个壳中，我们要从原料库XML里提取相关的数据，就要用到XSL提供的模式化查询语言。所谓模式化查询语言，就是通过相关的模式匹配规则表达式从XML里提取数据的特定语句，即我们上面所说的"筛子"。

　　参考微软的"XSL开发者指南"，我们大致可将模式语言分为三种：

　　选择模式：

<xsl:for-each>、<xsl:value-of>和 <xsl:apply-templates>

　　测试模式：

<xsl:if> 和<xsl:when>

　　匹配模式：

<xsl:template>

　　我们现在就分别对之进行介绍。

　　一、 选择模式

　　选择模式语句将数据从XML中提取出来，是一种简单获得数据的方法，这几个标记都有一个select属性，选取XML中特定的结点名的数据。

　　1、<xsl:for-each>

　　如在XML中有这样的数据:

<author>
<name>小禹</name>
<name>春华</name>
<name>秋实</name>
</author>

　　我们要读取这三个作者名字，是一个一个地按"author/name"方法来读取吗，可有多个这样的name呀？如果有一种程序性的语句来循环读取有多好啊！

　　想得很对，XSL提供了这样的具有程序语言性质的语句：<xsl:for-each>

　　用它读取这三个作者名字的方法如下:

<xsl:for-each select="author/name">
……
</xsl:for-each>

　　select，顾名思义，选取，它可以选定XML中特定唯一的标记，也可以选择某一类相同的标记，我们称之为结点集。

　　语法：

<xsl:for-each select="pattern" order-by="sort-criteria-list">

　　属性：

　　1.select

　　根据XSL样式查询考察上下文以决定哪类结点集（满足select条件）使用此样式描述。作为一种简化的表示就是，如果你想对文档中的某一种标记的内容的显示方式进行格式化，就可以将让select等于此元素的标记名。例如欲对标记xml_mark进行格式化，即可用如下方式表示：

<xsl:for-each select="xml_mark">
<!--样式定义-->
</xsl:for-each>

　　2.order-by

　　以分号（;）分隔、作为排序标准的列表。在列表元素前添加加号（+）表示按此标记的内容以升序排序，添加减号（-）表示逆序排序。作为一种简化的表示就是，排序标准列表就是由select规定的标记的子标记的序列，每个标记之间以（;）分隔。

　　2、<xsl:value-of>

　　<xsl:for-each>模式只是选取节点，并没有取出节点的值，好比猴子只是爬到了树的某个枝干上，那么就用< xsl:value-of >来摘"胜利果实"吧！

　　语法：

<xsl:value-of select="pattern">提取节点的值

　　属性：

　　select用来与当前上下文匹配的XSL式样。简单的讲，如果要在XSL文档某处插入某个XML标记（假定是xml_mark标记）的内容，可用如下方式表示：

<xsl:value-of select="xml_mark"></xsl:value-of>

　　或

<xsl:value-of select="xml_mark"/>

示例：

　　此处仍以上期的个人简历的作为例子，我们需要对文件（个人简历.xml）作一定修改，确切的说是将其中的第二行：

<?xml:stylesheet type="text/css" href="resume.css"?>

　　修改为：

<?xml:stylesheet type="text/xsl" href="resume.xsl"?>

　　然后建立一个新文件：resume.xsl，其内容如下：

<?xml version="1.0" encoding="GB2312"?>
<HTML xmlns:xsl="http://www.w3.org/TR/WD-xsl">
<HEAD>
<TITLE>个人简历</TITLE>
</HEAD><BODY>
<xsl:for-each select="resume">
<P/>
<TABLE border="1" cellspacing="0">
<CAPTION style="font-size: 150%; font-weight: bold">
个人简历
</CAPTION>
<TR>
<TH>姓名</TH><TD><xsl:value-of select="name"/></TD>
<TH>性别</TH><TD><xsl:value-of select="sex"/></TD>
<TH>生日</TH><TD><xsl:value-of select="birthday"/></TD>
</TR>
<TR>
<TH>技能</TH><TD colspan="5"><xsl:value-of select="skill"/></TD>
</TR>
</TABLE>
</xsl:for-each>
</BODY>
</HTML>

上例在浏览器中的样子(IE5.0或更新版本)

　　完成这些以后再来让我们看一下辛勤劳动的成果，怎么样？效果不错吧。更酷还在后头呢。现在我们对文件（个人简历.xml）作进一步的修改：

　　1.在标记<resume>前添加一个新标记<document>；

　　2.将标记对<resume></resume>之间的内容（包括这一对标记）复制并粘贴在其后，并在最后用<document>结束。

　　3.以Notepad.exe打开文件resume.xsl，在标记<HTML>之后添加文字：<xsl:for-each select="document">；在标记</HTML>之前添加文字：</xsl:for-each>，保存文件。

　　4.在浏览器中打开文件（个人简历.xml）。看到了什么？两份个人简历！

上例在浏览器中的样子(IE5.0或更新版本)

　　就这样，利用XML我们可以编写内容与样式完成分离的文档！当然，XSL文件比一般的HTML文件要复杂一些，然而一旦完成则可用于格式化所有同类的XML文档。[page]

经过前几日的学习，我们学习了XHTML文档的编写和以及三个XSL元素，已能编写相当灵活的XSL文档，今天将学习的是XSL模板的编写。我们都知道，短的文档、程序十分好读，但当规模增大后，其复杂性也以更快的速度增加。

　　前面我们学了<xsl:for-each>、<xsl:value-of>等，可以用它们对XML数据实现简单的格式化输出，但如果遇到比较复杂的XML格式输出，将XSL按照要求依次写下来的话，一是设计困难，可扩展性差，不利于人员之间的分工协作；另则，可修改性很差，可能会出现牵一发而动全军的情况，不利于维护。程序中模块化设计逐步细化的方法在这里得到了应用！

　　XSL模板将XSL的设计细化成一个个模板（块），最后再将这些模板（块）组合成一个完整的XSL；好比船与集装箱，我们不是将所有的货物一件件地堆起来，而是装在各自的集装箱中，然后再在船上将这些集装箱堆放起来。这种方法可以使你先从整体上考虑整个XSL的设计，然后将一些表现形式细化成不同的模块，再具体设计这些模块，最后将它们整合在一起，这样，将宏观与微观结合起来，符合人们条理化、规范化要求。

　　装集装箱－－书写模板（块）：<xsl:template>

　　语法：

<xsl:template match="node-context" language="language-name">

　　属性：

　　match ── 确定什么样的情况下执行此模板。作为一种简化的说明，在此处使用标记的名字；其中最上层模板必须将match设为"/"。

　　language ── 确定在此模板中执行什么脚本语言，其取值与HTML中的SCRIPT标记的LANGUAGE属性的取值相同，缺省值是Jscript。

　　<xsl:template>用match属性从XML选取满足条件的节点，征对这些特定的节点形成一个特定输出形式的模板。

　　吊集装箱上船－－调用模板（块）：<xsl:apply-templates>

　　语法：

<xsl:apply-templates select="pattern" order-by="sort-criteria-list">

属性：

　　select ── 确定在此上下文环境中应执行什么模板，即选取用< xsl:template >标记建立的模板（块）。

　　order-by ── 以分号（;）分隔的排序标准，通常是子标记的序列。

　　示例：

　　以个人简历为例，为便于处理我们希望"技能"中每一项都用标记对<skill></skill>括起来，有多少项技能就有多少个这种标记对，经过修改后的个人简历XML文档内容如下：

<?xml version="1.0" encoding="GB2312"?>
<?xml:stylesheet type="text/xsl" href="resume_template.xsl"?>
<document>
<resume>
<name>禹希初</name>
<sex>男</sex>
<birthday>1977.5</birthday>
<skill>数据库设计与维护</skill>
<skill>WEB开发</skill>
</resume>
</document>

　　然后，建立一个新XSL文件resume_template.xsl，采用模板的形式，其内容如下：

<?xml version="1.0" encoding="GB2312"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl">
<!--根模板-->
<xsl:template match="/">
<HTML><HEAD><TITLE>个人简历</TITLE></HEAD>
<BODY>
<xsl:apply-templates select="document/resume"/>
</BODY>
</HTML>
</xsl:template>
<!--简历模板-->
<xsl:template match="resume">
<TABLE border="1" cellspacing="0">
<CAPTION>个人简历（
<xsl:eval>formatIndex(childNumber(this),"I")</xsl:eval>
）</CAPTION>
<xsl:apply-templates select="name"/>
<xsl:apply-templates select="sex"/>
<xsl:apply-templates select="birthday"/>
<TR/>
<TD>技能</TD><TD COLSPAN="5">
<TABLE cellspacing="0">
<xsl:apply-templates select="skill"/>
</TABLE>
</TD>
</TABLE>
<BR/>
</xsl:template>
<!--姓名模板-->
<xsl:template match="name"><TD>姓名</TD>
<TD><xsl:value-of/></TD>
</xsl:template>
<!--性别模板-->
<xsl:template match="sex"><TD>性别</TD>
<TD><xsl:value-of/></TD>
</xsl:template>
<!--生日模板-->
<xsl:template match="birthday"><TD>生日</TD>
<TD><xsl:value-of/></TD>
</xsl:template>
<!--技能模板-->
<xsl:template match="skill">
<TR><TD><xsl:value-of/></TD></TR>
</xsl:template>
</xsl:stylesheet>

上例在浏览器中的样子(IE5.0或更新版本)

　　保存文件，打开文件（个人简历.xml），效果令人满意吧。其实要做到同样的效果，用前面三周介绍的方法也可做，但你得把它作为一整体考虑。

　　在上面的XSL文件中，我们将性别、生日、技能等数据项分别用模板来单独写，再用<xsl:apply-template>来调用，这样，即使你日后要对这些模板作相应的修改与扩充也很方便，不致于出现互相干扰、混杂不清的情况。这种从上至下、逐层细化的设计方法，极大地减少工作复杂程度，也大大减少了差错的产生，可以实现多人的协作设计。

　　注意：如果XML文档中不同标记有同名的子标记，在为其编写模板时，应把父标记作为其前缀，格式为（parent_mark/child_mark）。模板文件必须有一个根模板，其属性match是"/"。[page]

XML技术的优势之一就在于数据输出的可选择性，即选择需要的数据输出。前面我们所讲到的选择模式语句:<xsl:for-each>、<xsl:value-of>及<xsl:apply-template>只是简单的选取通过"/"符号层层到达的节点，如果我们对XML数据不需要全部输出，而只需要其中的满足某条件的部分数据，"萝卜青菜、各取所需"，那么条件判断<xsl:if>与多条件判断<xsl:choose>及<xsl:when>则迎合了这种需要，如果你对程序设计熟悉的话，会觉得它们似曾相识。

　　XSL中的IF，首先，介绍XSL元素<xsl:if>的语法结构：

　　语法：

<xsl:if expr="script-expression" language="language-name" test="pattern">

　　属性：

　　expr ── 脚本语言表达式，计算结果为"真"或"假"；如果结果为"真"，且通过test，则在输出中显示其中内容（可省略此项属性）。

　　language ── expr属性中表达式的脚本语言类型，其取值与HTML标记SCRIPT的LANGUAGE属性的取值相同，缺省为"JScript"。

　　test ──源数据测试条件。

　　示例：

　　此处以一份报表为例，文件名为report.xml，其内容如下：

<?xml version="1.0" encoding="GB2312"?>
<?xml:stylesheet type="text/xsl" href="report.xsl"?>
<document>

<report>
<class>
甲班
</class>
<q1>50</q1>
<q2>70</q2>
<q3>30</q3>
<q4>10</q4>
</report>

<report>
<class>
乙班
</class>
<q1>20</q1>
<q2>30</q2>
<q3>40</q3>
<q4>50</q4>
</report>

<report>
<class>
丙班
</class>
<q1>70</q1>
<q2>40</q2>
<q3>20</q3>
<q4>10</q4>
</report>

</document>

　　我们采用XSL模板结合今天所学的<xsl:if>，为其编写一个XSL文档，要求季度产量小于等于20的用红色表示，文件名为report.xsl，内容如下：

<?xml version="1.0" encoding="GB2312"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl">

<xsl:template match="/">
<HTML><HEAD><TITLE>1999年生产统计</TITLE></HEAD>
<BODY><xsl:apply-templates select="document"/></BODY>
</HTML>
</xsl:template>

<xsl:template match="document">
<H3>1999年生产统计</H3>
<TABLE border="1" cellspacing="0">
<TH>班组</TH>
<TH>一季度</TH>
<TH>二季度</TH>
<TH>三季度</TH>
<TH>四季度</TH>
<xsl:apply-templates select="report"/>
</TABLE>
</xsl:template>

<xsl:template match="report">
<TR>
<TD><xsl:value-of select="class"/></TD>
<TD><xsl:apply-templates select="q1"/></TD>
<TD><xsl:apply-templates select="q2"/></TD>
<TD><xsl:apply-templates select="q3"/></TD>
<TD><xsl:apply-templates select="q4"/></TD>
</TR>
</xsl:template>

<xsl:template match="q1|q2|q3|q4">
<!--此处测试产量，如小于等于20则添加一STYLE属性color，其值为red（红色）-->
<xsl:if test=".[value()$le$20]">
<xsl:attribute name="style">color:red</xsl:attribute>
</xsl:if>
<xsl:value-of/>
</xsl:template>

</xsl:stylesheet>

上例在浏览器中的样子(IE5.0或更新版本)

　　说明：

　　q1|q2|q3|q4 ──　标记q1、q2、q3、q3均用此模板确定输出

　　$le$ ──　是关系运算符中的"小于等于"，其它关系有小于（$lt$）、大于（$gt$）、大于等于（$ge$）、等于（$eq$）、不等于（$ne$）等。

　　. ──　表示引用当前标记。

　　[ ] ──　表示筛选，只有满足筛选条件的标记才能被选取。

　　value() ──XSL函数，其他常用XSL函数有text()、end()、index()等。

　　下期，我们将学习XSL的另外三个元素，可对同一数据进行多次测试，根据不同条件产生相应输出。[page]

上期我们学习了XSL元素<xsl:if>，已能通过测试XML数据的值来决定不同的输出形式，不知你尝试过没有，实际上<xsl:for-each>也可部分实现<xsl:if>的功能，但有时，我们希望对同一数据同时测试多个条件，根据不同条件输出相应结果。当然，我们可以用if，假如我们只有if可用的话。幸好我们有一个更好的选择，那就是用<xsl:choose>。下面介绍相关元素的语法：

　　<xsl:choose>

　　语法：<xsl:choose>

　　属性：无，表示一个多选测试的开始

　　<xsl:when>

　　语法：

<xsl:when expr="script-expression" language="language-name" test="pattern">

　　属性：

　　expr ── 脚本语言表达式，计算结果为"真"或"假"；如果结果为"真"，且通过test，则在输出中显示其中内容（可省略此项属性）。

　　language ── expr属性中表达式的脚本语言类型，其取值与HTML标记SCRIPT的LANGUAGE属性的取值相同，缺省为"JScript"。

　　test ── 源数据测试条件。

　　<xsl:otherwise>

　　语法：<xsl:otherwise>

　　属性：无，在一个多选测试中，如果没有不满足<xsl:when>规定的条件，如果在最后有此标记，则输出此标记中的内容。

　　示例：

　　此处以学生成绩单为例，要求按成绩的高低给出优秀（ >85）、一般（70~85）、及格（60~69）、不及格（< 60），而不是显示分数。其中成绩单的XML文档(文件名：grade.xml)如下：

<?xml version="1.0" encoding="GB2312"?>
<?xml:stylesheet type="text/xsl" href="grade.xsl"?>
<document>
<grade>
<name>大胖</name>
<english>80</english>
<math>90</math>
<chymest>90</chymest>
</grade>
<grade>
<name>小花</name>
<english>98</english>
<math>70</math>
<chymest>85</chymest>
</grade>
</document>

　　为实现按分数分等级显示，其XSL文档（文件名：grade.xsl）内容如下：

<?xml version="1.0" encoding="GB2312"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/TR/WD-xsl">
<xsl:template match="/">
<HTML>
<HEAD><TITLE>成绩单</TITLE></HEAD>
<BODY>
<xsl:apply-templates select="document"/>
</BODY>
</HTML>
</xsl:template>

<xsl:template match="document">
<TABLE border="1" cellspacing="0">
<TH>姓名</TH><TH>英语</TH><TH>数学</TH><TH>化学</TH>
<xsl:apply-templates select="grade"/>
</TABLE>
</xsl:template>

<xsl:template match="grade">
<TR>
<TD><xsl:apply-templates select="name"/></TD>
<TD><xsl:apply-templates select="english"/></TD>
<TD><xsl:apply-templates select="math"/></TD>
<TD><xsl:apply-templates select="chymest"/></TD>
</TR>
</xsl:template>

<xsl:template match="name">
<xsl:value-of/>
</xsl:template>

<xsl:template match="english|math|chymest">
<xsl:choose>
<xsl:when test=".[value()$gt$85]">优秀</xsl:when>
<xsl:when test=".[value()$gt$70]">一般</xsl:when>
<xsl:when test=".[value()$gt$60]">起格</xsl:when>
<xsl:otherwise>不起格</xsl:otherwise>
</xsl:choose>
</xsl:template>

</xsl:stylesheet>

上例在浏览器中的样子(IE5.0或更新版本)

　　说明：在<xsl:choose>选择中，从第一个<xsl:when>开始，逐个测试，直到满足一个测试条件就将其中的内容输出，不再测试后面的条件；如果不满足任何一个条件，则输出<xsl:otherwise>中的内容。

　　标记对<xsl:when></xsl:when>与<xsl:otherwise></xsl:otherwise>中可嵌套<xsl:if>或<xsl:choose>。

Appfuse是Matt Raible 开发的一个指导性的入门级J2EE框架，它对如何集成流行的Spring、Hibernate、ibatis、struts、Xdcolet、junit 等基础框架给出了示范，最新的1.7版更是提供了对Taperstry和JSF的支持。在持久层，AppFuse采用了Hibernate O/R映射工具（http://www.hibernate.org）；在容器方面，它采用了Spring Framework（http://www.springframework.org）。用户可以自由选择Struts、Spring/MVC， Webwork，Taperstry、JSF这几个web框架。采用TDD的开发方式，使用JUnit测试各层，甚至测试 jsp 输出的 w/o 错误。为了简化开发，预定义好了一套目录结构、基类、用来创建数据库、配置Tomcat、测试部署应用的 Ant 任务，帮助快速自动生成源程序和自动维护部分配置文件。

参考资料：
在https://appfuse.dev.java.net/可以下载Appfuse，目前的版本是1.7。
Appfuse的参考资料和文档可以在http://raibledesigns.com/wiki/Wiki.jsp?page=AppFuse查看。

二、Appfuse框架快速入门

AppFuse项目的主要目的是帮助开发人员减少在开始一个项目时所要做的工作。以下是使用它新建一个项目的基本步骤：

1、下载或从CVS (cvs -d :pserver:guest@cvs.dev.java.net:/cvs co appfuse)检出appfuse最新版本之源码。

2、安装J2SE 1.4+, 正确设置JAVA_HOME环境变量, 安装Ant 1.6.2+, 设置ANT_HOME环境变量。

3、安装MySQL 3.23.x+ (建议使用 4.1.7版本)和Tomcat 4.1.x+ (建议使用 5.0.28版本)，设置CATALINA_HOME环境变量指向你Tomcat安装目录。

注意: 如果你准备使用MySQL 4.1.7，那么你必须将其默认的字符集设置为UTF-8字符集，并且将其默认的表类型设置为InnoDB类型。也就是说，你要在你的c:\Windows\my.ini 或者/etc/my.cnf 文件中添加以下几行：
[mysqld]
default-character-set=utf8
[mysqld]
default-table-type=innodb

4、 安装一个本地的SMTP服务器，或者如果你已经有一个可用的SMTP服务器的话，你可以去修改mail.properties (在web/WEB-INF/classes目录下) 和build.properties (在根目录下 -- 为 log4j信息) 以指向你的SMTP服务器 - 默认地它是指向你的本机的SMTP服务器的。

5、将lib/junit3.8.1/junit.jar文件拷贝到$ANT_HOME/lib目录下。

6、执行 ant new -Dapp.name=YOURAPPNAME -Ddb.name=YOURDBNAME 命令。这将创建一个名为“YOURAPPNAME”的目录。

警告: 该命令对于某些app.name值将不执行 - 不要使用 "test"，任何包含 "appfuse" 在其中的名你，或者任何以数字、两个存折号(-) 等等混合出来的名称。

7、 转到新的目录，执行ant的setup任务创建数据库，同时将你的应用发布到Tomcat服务器上。只有当你的root用户没有口令建库的任务才会工作。 你也可以在需要的时候打开build.properties文件去更改这root用户的口令。如果你想进行测试并且希望了解是否所有方面均可以工作完好， 那么你可以执行ant的test-all任务进行全面的测试 -当然前提是当你做测试的时候先将Tomcat服务器停止。

8、执行ant的test-reports任务 - 当这个任务执行完后，会有一条消息告诉你如何查看那些产生的测试报告。

当你确定你通过以上步骤配置好你的AppFuse开发环境后 - 下面你需要做的事就是学习一下指南来了解如何使用 AppFuse 进行你的开发。

可选择的安装

如果你愿意选择用iBATIS做为你的持久层框架，请专门去看一下extras/ibatis目录下的 README.txt 文件。
如果你愿意选择用Spring做为你的WEB层框架，请专门去看一下extras/spring目录下的 README.txt 文件。
如果你愿意选择用WebWork做为你的WEB层框架，请专门去看一下extras/webwork目录下的 README.txt 文件。
如果你愿意选择Tapestry做为你的web层框架，请专门去看一下extras/tapestry目录下的 README.txt 文件。
如果你愿意选择JSF做为你的web层框架，请专门去看一下extras/jsf目录下的 README.txt 文件。

如果你希望你能够通过脚本来自动地完成创建和测试，那么可以参考以下的脚本：
rm -r ../appfuse-spring
ant new -Dapp.name=appfuse-spring -Ddb.name=ibatis
cd ../appfuse-spring
ant install-ibatis install-springmvc
cd extras/ibatis
ant uninstall-hibernate
cd ../..
ant setup
ant test-all test-reports

如果你并不想安装iBATIS, Spring MVC 或者 WebWork，在你将你的项目放入代码控制仓库前你应该删除掉它们在extras目录中的安装内容。

--------------------------------------------------------------------------------

通 常当你完成了以上所有步骤并使它们可以工作后，最可能的事是你会希望把“org.appfuse”包名，改为类似“com.company”这样的包名。 现在做这件事已经非常简单了，所有你需要做的事就是下载一个改包名的工具，看看它的README文件，以了解它的安装和使用。

注意: 使用这个工具前你最好是将你的项目做一个备份，从而保证能够恢复它。

如果你将org.appfuse.webapp.form包改为如test.web.form这样的包名，你得同时去修改一下src/service包中的ConverterUtil类，getOpposingObject方法是你的朋友，让我们来看一下：

name = StringUtils.replace(name, "model", "webapp.form");
name = StringUtils.replace(name, "webapp.form", "model");

三、AppFuse 开发指南

如果你已经下载了AppFuse并且想在你的机器上安装它，你最好按照快速入门中的步骤进行安装。一旦你已经将所有的内容安装好后，以下的指南是你学习如何使用AppFuse进行开发的最好的教程。

注意: 这个开发指南在AppFuse的发布版本中同样包含一份，如果你想更新在你的工程中的那份拷贝（它在docs目录中），可以通过执行 "ant wiki"来完成。

对 于AppFuse 1.6.1, 你能够本指南中告诉你的方法生成大部分代码。如果你正在使用的是Struts+Hibernate这样一个组合，你甚至可以完全生成它们。而如果你的 web层框架选择了Spring或者WebWork就不那么幸运了, 对于它们来说要写一个自动化的安装脚本存在许多困难，所以你就不得不自己动手来配置那些Controllers和Actions了。这主要是因为我没有对 这些web层框架使用XDoclet，同时也是由于使用Ant工具作为安装工具的局限性所致。自动生成代码的工具我称之为 AppGen ，我在 Part I 中讲解如何使用它。

Part I: 在AppFuse中创建新的 DAOs 和对象 - 这是一个关于如何创建一个基于数据为中表的Java对象以及如何创建Java类从而持久化对象到数据库中的教程。

1、关于这个指南：

本指南将向你展示如何在数据库中创建一个新的表，以及如何创建访问这个表的Java代码。

我们将创建一个对象和一些其他的类来将这个对象持久化（保存、装载、删除）到数据库中。用 Java 的语言来说，我们称这个对象是一个POJO对象（Plain Old Java Object ），这个对象基本上与数据库中的某张表是相对应的，其他的类将是：

一个数据访问对象（也称为是一个DAO），一个接口，一个 Hibernate 实现类。
一个 JUnit 类，用来测试我们的 DAO 对象是否可以正确工作。
注 意:如果你是在使用 MySQL 并且如果你想要使用事务 (一般说来你肯定会选择使用的)，那么你必须将 table-type设置为 InnoDB。你可以这样做，将下面的内容加到你的 mysql 配置文件 (/etc/my.cnf or c:\Windows\my.ini) 中。第二个设置（用来设置UTF-8字符集）是mysql 4.1.7+所需要的。

[mysqld]
default-table-type=innodb
default-character-set=utf8

如果你使用 PostgreSQL 遇到批处理发生混淆的错误，可以试着在你的src/dao/**/hibernate/applicationContext-hibernate.xml文件中加入 0 配置来关闭批处理。

AppFuse 使用 Hibernate 作为它默认的持久层。 Hibernate 是一个对象关系映射框架，它使你将你的Java对象与数据库的表建立起一种映射。使你可以很容易地在你的对象上执行CRUD (Create, Retrieve, Update, Delete) 操作。

你也同样可以使用iBATIS 作为持久层的另一个可能的选择。如果要在 AppFuse安装iBATIS，请看一下extras/ibatis目录中的 README.txt 文件。如果你想用 iBATIS 替换 Hibernate，我希望你是有足够的理由并且你应该对它是熟悉的。我也希望你能够针对如何在AppFuse中使用iBATIS 为本指南提出好的建议。 ;-)

下面我将用文字来告诉你在实际的开发过程中我是如何做的。
让我们从在AppFuse项目结构中创建一个新的对象，一个DAO和一个测试用例来开始。

内容列表

[1] 创建一个新的对象并且加入 XDoclet 标签
[2] 使用Ant，基于我们新建的对象创建一个新的数据库表
[3] 创建一个新的 DAOTest 以便对于DAO 进行JUnit测试
[4] 创建一个新的 DAO 对于我们这个对象执行 CRUD 操作
[5] 为Person对象和PersonDAO配置Spring配置文件
[6] 运行 DAOTest 进行测试

[1] 创建一个新的对象并且加入 XDoclet 标签

我们需要做的第一件事就是创建一个对象去持久化它。让我们创建一个简单 "Person" 对象 (创建到 src/dao/**/model 目录中) ，我们让它有一个 id, 一个 firstName 和一个 lastName (作为这个对象的属性)。

package org.appfuse.model;

public class Person extends BaseObject {
private Long id;
private String firstName;
private String lastName;

/*
Generate your getters and setters using your favorite IDE:
In Eclipse:
Right-click -> Source -> Generate Getters and Setters
*/
}

这 个类应该继承自 BaseObject,由于BaseObject有 3 个抽象方法: (equals(), hashCode() and toString()) ，所以你必须在这个Person类中实现它们。前两个方法是 Hibernate 要求的，最简单的方法是使用工具（如：Commonclipse）来完成它，如果你想知道关于使用这个工具的更多的信息你可以去Lee Grey的网站去找。另外一个你可以使用的工具是Commons4E，它是一个 Eclipse Plugin ，我没有用过，所以我无法告诉你它有什么功能。

如果你使用的是 IntelliJ IDEA ，你可以生成 equals() 和 hashCode()，但是生成不了 toString()，当然有一个 ToStringPlugin，但我从来没有亲自用过。

现在我们已经有了一个创建好的 POJO ，我们需要在里面加上 XDoclet 标签以便由它生成 Hibernate 映射文件。这个映射文件是让 Hibernate 来映射对象到表，映射属性到表的列的。

首先，我们加入一个 @hibernate.class 标签，这个标签告诉 Hibernate 这个对象将映射哪一张表：

/**
* @hibernate.class table="person"
*/
public class Person extends BaseObject {

我们也必须加一个主键映射，否则当生成映射文件的时候XDoclet将出现错误。注意所有这些@hibernate.* 标签应该放置在你的POJO对象的 getter方法的 Javadocs 位置。

/**
* @return Returns the id.
* @hibernate.id column="id"
* generator-class="increment" unsaved-value="null"
*/

public Long getId() {
return this.id;
}

我 使用 generator-class="increment" 代替 generate-class="native" ，因为我发现当在其他一些数据库上使用"native"时存在一些问题。如果你只打算使用MySQL，我推荐你使用"native"，而我们的这个指南使 用“increment”。

[2] 使用Ant，基于我们新建的对象创建一个新的数据库表

你可以通过运行"ant setup-db"来创建person表。这个任务创建一方面会创建Person.hbm.xml文件，另一方面可以在数据库中创建一张"person"表。从ant的控制台，你可以看到Hibernate为你创建的表模型：

[schemaexport] create table person (
[schemaexport] id bigint not null,
[schemaexport] primary key (id)
[schemaexport] );

如果你想看一下Hibernate为你生成的 Person.hbm.xml 文件的内容，你可以去 build/dao/gen/**/model 目录去看，下面我列出其内容：

"-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

name="org.appfuse.model.Person"
table="person"
dynamic-update="false"
dynamic-insert="false"
>

name="id"
column="id"
type="java.lang.Long"
unsaved-value="null"
>

　　看来，现在大多数人倾向于更加突出Java了，J2EE容易让初学者误解是独立于一套Java的技术方案。

　　从更深层次来看，Java诞生十年来，很多近十年前的业务组件至今还可以使用，软件应用不再由于语言的更迭革命带来毁灭的打击了。

　　但是，随着WEB和EJB容器概念诞生，使得软件应用业开始担心SUN的伙伴们是否还在Java平台上不断推出翻新的标准框架，致使软件应用业的业务核心组件架构无所适从，从一直以来是否需要EJB的讨论声中说明了这种彷徨。

　　笔者曾经在2004年底中国软件技术大会Ioc微容器(也就是Jdon框架的实现原理)演讲中指出：我们需要一个跨J2SE/WEB/EJB的微容器，保护我们的业务核心组件（中间件），以延续它的生命力，而不是依赖J2SE/J2EE版本，如下图：

　　此次J2EE改名为Java EE，实际也反映出业界这种共同心声。

　　让我们看看Java EE 5有哪些新的功能或规定，我们可以从SUN网站下载Java EE 5规范。其架构图如下：

　　图中灰色加黑部分是Java EE 5新的功能，我们看到，在WEB层主要加入了JSF这个新的表现层框架，和我们日常开发关系密切的是，引入了新的Java Persistence标准，这个标准正在由EJB 3.0专家组制定。

　　值得指出的是，这个Java持久化标准也可以嵌入在WEB层调用，所以，它肯定不会从属于EJB标准，这样，当前所有的Java持久层标准如：JDBC/JDO/Hibernate/Entity Bean将可能统一，减少用户的架构选择 痛苦。

　　从架构图可以看出，无论Web结构或EJB结构，提供实现的功能相差不多，这样，我们的业务核心组件就可以根据需要部署在Web或EJB中运行，而不依赖具体的Java EE容器了。前面一章图的目标在Java EE 5中可以实现了。

　　当然，Java EE 5重要改变还是：Java EE不再象以前那样只注重大型商业系统的开发，而是更关注小到中型系统的开发，简化这部分系统开发步骤。

　　落实这一简化行动的最大特征是在Java 5.0(Java 1.5)中加入Annotations，通过Annotations引入，降低Java EE开发时，既要写code，又要写XML配置文件之苦，来回照顾，疲于奔命，Annotations既是得益于C++语言，也是从开源项目xDoclet实践中获得经验。

　　但是Annotations是一把双刃剑，初学者用得不好，将会使得原本在XML中的Hard code（硬编码） 写进入代码Annotations，破坏代码的简洁和灵活性，Annotations讨论按这里。

　　当然，Annotations的引入不只是解决XML配置，从大的概念说，是解决一个资源注射问题(XML属于其中一个资源)，在原理J2EE中，容器管理的资源都是由JNDI向应用程序提供的，现在通过Annotations可以方便实现注射。

　　资源注射（Resource injection）设计概念其实是来自Ioc模式(Dependency Injection )，笔者设计开发的Jdon框架其实已经将Annotations这一宗旨的目的实现，在Jdon框架应用演示源码SimpleJdonFrameworkTest中，在jdonframework.xml中有一段如下配置：

<pojoService class="com.jdon.framework.test.dao.JdbcDAO" name="jdbcDAO">
　　<constructor value="java:/TestDS"/>
</pojoService>

　　这段配置是将数据库的JNDI名java:/TestDS注射到JdbcDAO中。Jdon Framework下一个版本将是基于Java 5.0，这行配置 将可通过 Annotations写在jdbcDAO代码中，方便程序员开发。

　　从这里，大家也可以知道EJB 3.0和EJB 2.0的区别了，有的人疑惑，是学习EJB 3.0还是学习EJB 2.0，其实EJB 3.0并没有在原理机制上对EJB有多大改动，只是做了编程方面的简化，另外EJB CMP参考了Hibernate新特点，EJB 3.0最大简化变动是CMP编程方法上。所以，无论学习EJb 3.0/2.0，EJB原理和运行机制都是一样，这部分才是学习EJB最大的困难处，而不是因为到了EJB 3.0，理解EJB就会容易。

　　初学者可从Eclipse+Xdoclet开发EJB 2.0开始学习， EJB 3.0 = EJB 2.0 + xDoclet，这里有一篇Eclipse开发EJB教程，使用JBossIDE非常简单，无需Lomboz等插件。

　　Security安全是Java EE的一个重要特点，也就是基于容器的安全访问，无需自己手工编码，具体实现可参考Jdon框架应用演示源码JdonNews。这虽然是基于J2EE 1.3编写，但是和Java EE 5区别不是很大。

　　事务管理Transaction Management也是Java EE 5的一个重要部分，该标准文档 从几个方面阐述了事务管理的要点，标准中规定了在WEB层中使用事务和线程的处理关系，标准中规定：Web服务器如Tomcat无需在Web层提供事务支持，因为Web组件根本不支持事务繁衍/传递。

　　因为目前一些架构如Struts+Spring+Hibernate/Struts+Hibernate是标准中的Web结构，因此Java EE 5在J2EE 4.2.2规定了 Web组件事务的生命周期，如果Web组件直接调用JTA，事务就不可以跨一个客户端的多个请求，事务只能在一个请求(Servlet/Jsp)中完成，这个标准规定了我们在Web架构中（如上述架构）无法使用长事务(如工作流/状态图中跨页面请求事务)，针对一个客户端跨请求的事务目前只有唯一解决方案：只有使用EJB的有态Session。参考文章：I manage long duration transactions?

　　以上是Java EE 5主要部分，Java EE包含更多其他技术部分如Jdbc JMS JCA JNDI 等等，需要用户在实践中摸索。