BlogJava-Velocity空间-文章分类-Velocity

CHAPTER 14 在Turbine里使用Velocity

KINGWEE — Wed, 29 Oct 2008 03:12:00 GMT

摘要: 如果你从事Web应用程序开发已经很久了，那么你可能已经意识到你正花费大量的时间在重新发明轮子。典型的任务包括数据库连接池、构建控件Servlets、书写导航菜单和设计众多的页面。重复使用在哪里？组件？还是框架？幸运的是，许多人已经认真思考过这个问题，并创建了一些Web开发者需要的工具。在这一章里，我们将介绍Turbine，它是一个试图把Web开发带入和传统软件开... 阅读全文

KINGWEE 2008-10-29 11:12 发表评论

CHAPTER 13 Velocity和国际化

KINGWEE — Mon, 27 Oct 2008 10:46:00 GMT

如果你正在构建一个世界级的Web站点，你是否想过只支持美语或英语？当然不！世界上众多的站点都支持多种语言，当单击对应语言的链接时，直接进入该语言版本的站点。幸运的是，Java自身的一些组件也提供了一些让站点支持国际化功能的方法。在这里，我们使用Velocity的组件来轻松构建国际化站点。在这一章里，我们只简要介绍Java组件，之后重点介绍chapter 12里CD收藏管理示例的Velocity应用程序版本。

Java国际化组件

在这一章里，我们将调试一些可用于国际化的Java组件。为了充分理解这个处理过程，请参考http://java.sun.com/docs/books/tutorial/i18n/的Java入门教程。在我们正式开始之前，让我们把注意力集中于构建一个可以使用英语和德语阅读的Web应用。

或许最简便的方法就是为这两种语言构建两张页面。假定你已经有了一个名叫index.html的原始的Web页面。对于英语版本的，对应的位置为/en/index.html下，在相同目录的德语版本为indexgerman.html，当然，也可以为他们建立不同的目录，比如：英语版为/en/index.html，德语版为/de/index.html。

当然，构建两张或20张页面来完全这两个语言版本的页面不是太难，只是浪费了一些时间而已。但如果是若干页面，同时有些页面需要进行改动该怎么办？现在有一种好方法来为这两种语言版本构建页面，那就是使用Java、Servlets以及Velocity，这是最好的解决方案。

Java本地类

Java本地（Locale）类用于包罗其他的Java类。这个本地（Locale）对象被传递给一个类，这个类知道如何处理世界上不同的地理位置。通过传递两个参数来创建一个本地对象，这两个参数是：你想使用的语言和国家。这两个参数都使用只有2个字符的缩写，比如：英语用en，德语用de。美国用US，德国用DE。

好，你现在可以用下面的代码来创建一个本地对象：

Locale location = new Locale('en', 'US');

你可以在www.ics.uci.edu/pub/ietf/http/related/iso639.txt里查询语言代码的完整列表。国家代码可以在www.chemie.fuberlin.de/diverse/doc/ISO_3166.html里查询。

资源绑定（Bundles）

对Java国际化来说，大量工作都集中在ResourceBundle对象里。这个对象扮演了一个巨大的多维地图，让你提供一个关键字字符串和一个从Locale对象返回的值给bundle。ResourceBundle对象依靠properties files（属性文件），该文件是一个文本文件，在其中定义了关键字和其关键值。在这里总是有一个名叫MessagesBundle.properties的默认属性文件。如果ResourceBundle对象不能找到其他和所提供位置匹配的属性文件，那么，这个默认的属性文件（bundle）将被使用。让我们首先来看一下，如何创建一个ResourceBundle对象。

message = ResourceBundle.getBundle("MessagesBundle", location);

The statement instantiates a ResourceBundle object based on the property filename of MessagesBundle and the provided Locale object. If you are planning to code a Web application for English/U.S. and German/Germany locations, you need two additional properties files:

语句初始化一个基于MessagesBundle的属性文件名和所提供的本地对象的ResourceBundle对象，如果你计划用English/U.S.和German/Germany编写一个Web应用，那么你需要两个附加的属性文件：

■ MessagesBundle_en_US.properties

■ MessagesBundle_de_DE.properties

ResourceBundle对象主要负责选择属性文件。正如我们曾提及的一样，每一个属性文件包含了关键字和值对。比如：为了显示一个对用户的祝贺，你将在属性文件里包含如下的实体：

Greet = Hello

当然，你需要为默认情况包含适当的实体，即U.S.和德语文件。之后，在当前Locale对象中查询ResourceBundle对象以返回关键字“Greet”的值，比如：

String hello = messages.getString("Greet");

在这个代码里，适当的祝贺词被呈现给用户。现在，让我们看一如如何使用这些知识来构建一个国际化Web站点。

一个国际化CD Web应用

在之间的章节里，我们创建了一个应用，以用于存储和找回CD，以及他们的歌曲。和你回想的一样，应用显示了一个主Web页面以用于输入CD和歌曲，同时显示其对应的信息。这个程序使用的语言是英语。现在，我们准备对这个程序进行国际化修改。

现在让我们开始为这个主页面创建一个允许用户选择语言和国家的操作，见Listing 13.1。显示结果见Figure 13.1。

Listing 13.1 The international.html file.

Figure 13.1 The language/country select page.

在Listing 13.1里有两个重要的操作，第一在

标记里。当用户单击submit按钮里，他们将发送给一个名叫cdIindex的新Servlets。这个Servlets主要负责为请求的语言获取用于显示的文本。同时也要注意国家和语言选择框。这个输入窗体被传递给cdIndex servlet，以便让Servlets知道当前需要的是哪个属性文件（即需要是什么语言版本）。

从cdIndex servlet里输出的是一个用于显示输入信息和显示CD的Velocity模板。Listing 13.2显示了这个模板的代码。

$createstring

method="post">

$title
$artist
$tracks

$displaystring

$viewstring

$addstring

Listing 13.2 The index.vm Velocity template.

这个显示页面被划分为四个任务。每一个任务显示一个指示和几个字段。所有在页面上的文本显示被转换到Velocity引用。这些Velocity引用被cdIndex servlet进行填充，见Listing 13.3。

import java.io.*;

import java.util.*;

import javax.servlet.*;

import javax.servlet.http.*;

import org.apache.velocity.Template;

import org.apache.velocity.context.Context;

import org.apache.velocity.servlet.VelocityServlet;

import org.apache.velocity.exception.*;

import javax.naming.*;

import javax.ejb.*;

import cd.*;

import org.apache.velocity.app.Velocity;

public class cdIndex extends VelocityServlet {

protected Properties loadConfiguration(ServletConfig config )

throws IOException, FileNotFoundException

{

Properties p = new Properties();

String path = config.getServletContext().getRealPath("/");

if (path == null) {

System.out.println(

" SampleServlet.loadConfiguration() : unable to "

+ "get the current webapp root. Using '/'. Please fix.");

path = "/";

}

p.setProperty( Velocity.FILE_RESOURCE_LOADER_PATH, path );

return p;

}

public Template handleRequest( HttpServletRequest req,

HttpServletResponse res, Context context ) {

Template template = null;

String country = req.getParameter("country");

String language = req.getParameter("language");

Locale currentLocale = new Locale(language, country);

ResourceBundle messages =

ResourceBundle.getBundle("MessagesBundle", currentLocale);

context.put("title", messages.getString("title"));

context.put("artist", messages.getString("artist"));

context.put("ID", messages.getString("ID"));

context.put("name", messages.getString("name"));

context.put("length", messages.getString("length"));

context.put("tracks", messages.getString("tracks"));

context.put("createstring", messages.getString("createstring"));

context.put("displaystring", messages.getString("displaystring"));

context.put("viewstring", messages.getString("viewstring"));

context.put("addstring", messages.getString("addstring"));

try {

template = getTemplate("index.vm");

} catch( Exception e ) {

e.printStackTrace();

}

return template;

}

Listing 13.3 cdIndex.java.

cdIndex servlet有两个任务：第一，当被用户调用时，用于从

获取语言和国家信息，同时利用这些信息来构建一个Locale对象。这个Locale对象被用于获取一个ResourceBundle对象。依靠语言和国家的选择，这个ResourceBundle要么选择默认的属性文件（U.S.文件，见Listings 13.4），要么选择德语（German）文件（Listings 13. 6）。这些文件都拥有相同的目录。

第二个任务对Servlets来说或许是最为重要的任务，它主要负责向上下文中填充适当的应用或他们的值。你可以在代码看到，每一个引用连同其对应的值（通过使用messages.getString(String)方法调用）一起被加入到上下文中。最后的结果是所有cdIndex Velocity模板需要引用被填充到上下文中。

当用户选择US时，显示结果见Figure 13.2。如果选择的是German，显示结果见Figure 13.3。正如你所见的一样，为你的应用增加国际化支持是一件非常轻松的事。比如，现在需要增加西班牙语支持，只需在HTML选择里包含适当的标识符，并创建适当的属性文件即可。

title = Title:

artist = Artist:

ID = ID:

name = Name:

length = Length:

tracks = Tracks:

createstring = To Create a New CD:

displaystring = To display CDs for an Artist

viewstring = To see all Tracks for a CD

addstring = To add a new track

Listing 13.4 MessagesBundle.properties.

Figure 13.2 The U.S. display page.

Figure 13.3 The German display page.

title = Title:

artist = Artist:

ID = ID:

name = Name:

length = Length:

tracks = Tracks:

createstring = To Create a New CD:

displaystring = To display CDs for an Artist

viewstring = To see all Tracks for a CD

addstring = To add a new track

Listing 13.5 MessagesBundle_en_US.properties.

title = Titel

artist = Kônstler

ID = IDENTIFIZIERUNG

name = Name

length = L?nge

tracks = Spuren

createstring = Um eine neue CD zu schaffen

displaystring = Um CDS fôr einen Kônstler darzustellen

viewstring = Um CD Spuren anzusehen

addstring = Um Spuren hinzuzufôgen

Listing 13.6 MessagesBundle_de_DE.properties.

本章小结和下章介绍

在这一章里，我们显示了如何在Velocity中联合Java的国际化特性来构建一个世界级的Web站点，让你的用户能够获得多种语言的支持。在下一章里，我们将研究在Turbine里使用Velocity，Turbine是一个应用程序框架，它提供了一个让你构建企业级应用的工具。

KINGWEE 2008-10-27 18:46 发表评论

CHATPER 12 在Servlets里使用 Velocity

KINGWEE — Fri, 24 Oct 2008 08:35:00 GMT

摘要: 通过前面章节的学习，我们了解到Velocity主要用作MVC框架View组件的脚本语言。Servlets是Java下MVC框架里用得最多的编程方式。通过把Servlets用作控制器（controller），Velocity用作显示层（View），把Servlets或JavaBeans作用模型（model），这样就创建了一个理想的Web开发全面解决方案。在这一章里，我们将学习如何在S... 阅读全文

KINGWEE 2008-10-24 16:35 发表评论

CHAPTER 11 Velocity、XML和 Anakia

KINGWEE — Wed, 22 Oct 2008 09:53:00 GMT

摘要: 可扩展标记语言（XML）是过去几年里谈论得最多的技术。刚开始的时候，这个技术的潜能可能被夸大了。但不要怀疑它基于文本格式来表现数据的能力。在这一章里，我们将着眼于两个XML主题，以及考虑这两个主题是如何涉及到Velocity的：从Velocity模板里的DOM对象访问XML数据和使用Anakia来处理XML数据转换。在Velocity模板里访问XML 你大概知道，Sun正努力为Java开发者... 阅读全文

KINGWEE 2008-10-22 17:53 发表评论

CHAPTER 10 Velocity的控制讨论

KINGWEE — Tue, 21 Oct 2008 03:37:00 GMT

摘要: 在之前的章节里，我们讨论了Velocity模板语言的核心组件和Velocity上下文在模板处理中扮演的角色。这些章节提供了设计需要的相关信息和基于模板的应用程序实现。许多附加的Velocity特性让你真正能够获得模板处理的控制权。在这一章里，我们将介绍这些特性，包含运行时配置、事件、空白符（whitespace）管理和上下文链（chaining）。初始化运行时配置在Chapter 9讨论V... 阅读全文

KINGWEE 2008-10-21 11:37 发表评论

CHAPTER 9 Velocimacros

KINGWEE — Sun, 19 Oct 2008 13:28:00 GMT

摘要: 在之前的章节里，我们讨论了所有Velocity的指令，包括#macro指令。然而，我们只是简要介绍了#macro指令。在这里，我们将重新讨论#macro指令（也可以称为Velocimacros）。我们将讨论参数传递、宏库、运行时配置和其他与Velocimacros相关的主题。参数传递Argument Passing 当我们在Chapter 8里介绍#macro指令时，我们展示... 阅读全文

KINGWEE 2008-10-19 21:28 发表评论

CHAPTER 8 使用指令

KINGWEE — Sat, 18 Oct 2008 15:54:00 GMT

摘要: 在前面的章节里，我们明确了引用在Velocity模板里的角色。除了讨论如何直接通过变量和属性引用获取值之外，我们也介绍了方法引用，方法引用允许模板设计者通过定制的Java方法引用上下文对象操作和访问数据。方法引用提供在窗体里返回字符串的能力。虽然这些功能能够充分支持任何模板处理需要做的事情，但Velocity仍然为大家带来了模板语言，模板语言为许多通用任务提供了捷径。这就是Velocity指令表演... 阅读全文

KINGWEE 2008-10-18 23:54 发表评论

CHAPTER 7 References引用探索

KINGWEE — Fri, 17 Oct 2008 02:12:00 GMT

摘要: 在之前的章节里，我们对Velocity引用进行了简要的介绍，甚至在示例里使用了部分引用。然而，再三延缓讨论引用的目的是为了让学习曲线更平缓、易学。既然你已经了解Velocity是什么和了解一个基本的应用程序是如何工作的，那么就让我们开始仔细学习Velocity引用吧！只有相当熟悉地掌握了Velocity引用，才能为你学习和掌握Velocity提供强大的动力! 引用类型正如我们... 阅读全文

KINGWEE 2008-10-17 10:12 发表评论

CHAPTER 6 理解模板和上下文

KINGWEE — Tue, 14 Oct 2008 00:52:00 GMT

在之前的章节里，我们介绍了Velocity和Hello World 示例，并从中看到了Velocity的一些简单应用，是时候学习Velocity核心组件了。本章将深入学习模板和上下文。后续章节将在本章知识的基础上，详细讨论Velocity的引用、指令和宏。

使用模板

Velocity是一个模板引擎，使用Velocity进行开发将是一件非常愉快的事。但是如何来制作模板呢？Velocity的模板定义和许多领域使用的模板概念相似，比如许多文本处理包为通用文档提供了文档处理的预定义包，如office备忘录等，这些都与Velocity模板的概念相当接近。Velocity俱乐部应用程序窗体（详见Figure 6.1）是常规模板的另一个例子。

Figure 6.1 An example of a general template.

Velocity俱乐部应用程序的内容包含了两个部分的内容：静态内容和动态内容。静态内容由标题、标签（如：First Name:， Last Name: 等）、问题和全部的布局等组成；动态内容就是表单中的下划线部分，用于申请人填写个人信息。

普通模板定义（如Velocity俱乐部应用程序的模板）和真实的Velocity模板最大的不同之处在于，Velocity的动态内容是指定的。当应用程序窗体依赖于插入空白部分的动态内容时，Velocity使用了引用的概念。现在，你可以简单想一下，Velocity引用就好比某种实体引用了一个存储在别处的值。比如，基于Velocity引用的基本语法，一个模板或许包含了一个名叫$name的实体和字符串“John Doe”对应，该字符串一般存储在模板外的某个地方（如数据库）。如果你对这个含糊的定义有些困惑的话，请不要太担心，我们将在下章详细讨论引用的细节，重要的是要紧记Velocity引用从本质上来讲是作为模板中动态内容的占位符。如果你想把这个俱乐部应用程序转换成Velocity模板，只需要把那些空白部分替换成适当的Velocity引用就行。如何制定一个适当的Velocity引用定义？首先定义要符合Velocity引用语法，其次是设计者和编程人员要对模板引用的名称进行约定。一种可能的模式实现详见Listing 6.1。

CLUB VELOCITY APPLICATION

First Name: $firstName

Last Name: $lastName

Address: $streetAddress

City: $city State: $state Zip: $zip

Phone Number: $phoneNumber

Email Address: $emailAddress

Occupation: $occupation

Other Interests: $otherInterests

Is this a new membership request or a renewal? $appType

How long have you been using Velocity? $useTime

Do you use Velocity for work or play? $useType

Do you want to receive our newsletter? $wantNewsletter

Listing 6.1 The club application form after conversion to a Velocity template.

正如你所看见的一样，Velocity模板从本质上讲，和应用程序原来的窗体是相同的，除了空白地方被Velocity引用替换外。下面我们先假定引用的值分别如下：

$firstName => "John"

$lastName => "Doe"

$streetAddress => "123 Jane Ave. "

$city => "Azusa"

$state => "CA"

$zip => "91702"

$phoneNumber => "626-555-1234"

$emailAddress => "john@nodom.com"

$occupation => "Web Developer"

$otherInterests => "Hiking,Biking"

$appType => "New"

$useTime => "6 months"

$useType => "Work"

$wantNewsletter => "Yes"

那么输出结果为（Listing 6.2）：

CLUB VELOCITY APPLICATION

First Name: John

Last Name: Doe

Address: 123 Jane Ave.

City: Azusa State: CA Zip: 91702

Phone Number: 626-555-1234

Email Address: john@nodom.com

Occupation: Web Developer

Other Interests: Hiking,Biking

Is this a new membership request or a renewal? New

How long have you been using Velocity? 6 months

Do you use Velocity for work or play? Work

Do you want to receive our newsletter? Yes

Listing 6.2 Sample output for the Velocity template version of the club application form.

现在，你已经明白了如何从模板输出内容，让我们快速考虑一下在处理过程中如何防止模板的部分内容被输出。具有这样的处理能力不仅对你有用，对你的同事也有使用，一句注解或几句模板代码的说明能让你在阅读代码时更易理解你当时设计代码的意图。另外，也具有在调试session期间选择性地让部分模板内容停止输出的能力，有时还需要明确地停止Velocity的默认处理行为。Velocity支持模板注释机制提供了这种能力，它包括块注释和单行注释。块注释由#*开始，到 *#结束，所有在它们之间的内容将被模板引擎丢弃。单行注释由两个##开始的。Listing 6.3提供了一些模板注释示例。

之前的内容描述了Velocity的概貌，但我们忽视了几个重要的主题。首先，这将意味着Velocity引用比我们目前透露的还要多。此外，Velocity还提供了许多可直接控制模板内容的指令和宏。指令提供了流控制、文件包含和引用处理功能；宏为模板代码提供了一个强大的可再使用机制。我们将在随后的章节里讨论这些主题。

This is a block comment. It is being used to point out

that this listing is intended to demonstrate the use of

comments in Velocity templates.

##This line is not rendered.

This part is rendered,## but this part is not.

If only the #*middle*# bit needs to be commented out, a

block comment will do the job.

Listing 6.3 Velocity comment examples.

上下文

在前面的部分，我们为应用程序模板里的引用指定了字符串。然而，我们曾经提到过把Velocity引用和字符串值绑定在一起的机制，这就是Velocity上下文的概念。上下文在应用程序端表现为通过在org.apache.velocity.context中定义的上下文接口。上下文通过关键字映射存储的对象。上下文只存储java.lang.Object类型的对象，该对象的关键字类型为java.lang.String。

引用除了具有$前缀外，用于关键字的字符串值和用于引用名称的值必须相同。例如，字符串值"John"在上下文里对应关键字firstName，模板将通过引用$firstName访问字符串值"John"。大体上，模板的动态内容通过关键字在上下文中查找内容来指定。$前缀让模板引擎知道$后的文本就是上下文中关键字的名称。

Velocity上下文和对象进行组装有三条途径。首先，Velocity自身可以向上下文中插入有效的值，比如使用#foreach指令进行反复计算。第二，#set指令允许模板向上下文中直接插入值。最后，更为重要的是，Velocity上下文接口允许编程人员使用双方约定的关键字名称，利用设计人员需要的数据来组装上下文。

我们只讲解最后一种情况。

在一个典型的应用程序里，上下文表现为一个org.apache.velocity.VelocityContext的实例，它实现了上下文接口。上下文实例存储了对象"John" 和 "Doe"，对应关键字分别为"first-Name" 和 "lastName"，代码如下：

VelocityContext context = new VelocityContext();

context.put( "firstName", "John" );

context.put( "lastName", "Doe" );

创建好后，模板就可以使用引用$firstName 和 $lastName来访问对象"John"和"Doe"。在这种情况下，虽然上下文中的对象已经是JAVA字符串类型，但是它比其他的JAVA类型（比如Integer 或 Float）更容易接受的。在其他情况下，Velocity使用对象的toString()方法来生成一个字符串，以用于显示输出。当然，它也可能是比简单值更复杂的一个对象，这通常发生在模板的需求包含了高级功能的情况下，这时只能通过对象的方法存储在上下文中。最后一种情况的细节将在Chapter 7讨论（Velocity引用）。

除了组装上下文外，上下文接口还允许编程人员对上下文进行查询和更深入的操作，提供的附加方法如下：

boolean containsKey( java.lang.Object key )

java.lang.Object[] getKeys()

java.lang.Object remove( java.lang.Object key )

java.lang.Object get( java.lang.String key )

containsKey()方法允许通过关键字检索上下文，返回true（表示找到了和关键字对应的对象）和false。getKeys()方法返回所有关键字的列表，要注意的是返回的类型为对象数组，而不是字符串数组。remove()方法用于移除关键字对应的对象，同时也将移除关键字，返回值为被移除对象的值。get()方法允许编程人员通过关键字访问对象。

Putting the Pieces Together放置组合体？

既然你已经对模板和上下文在Velocity中扮演的角色有了大概了解，那就让我们把组合体放到应用程序的窗体里，对 Velocity模板进行处理，以显示俱乐部Velocity成员应用程序的窗体。既然本应用示例的真实意图是用于阐明Velocity应用的基础结构，那我们就让它的逻辑尽量简单。特别的，本示例中，动态组件的最终内容是来自硬编码的字符串，在现实的应用程序中，这些动态内容更多来自数据库或产生于别的途径。

在查看应用程序代码之前，先来了解大概的顺序。把Listing 6.1定义的模板作为起点，开发一个处理模板的应用程序，用Velocity上下文中适当的文本替换所有的引用，最终内容（包含直接取自模板的静态内容和取自上下文的动态内容）将被应用程序输出，结果详见Listing 6.2。

符合这个目标的应用程序源代码详见Listing 6.4。这些代码是比较典型的通用代码，适用于多数 Velocity应用程序，它有完善的注释。它共有六个步骤：模板引擎初始化，模板包含，上下文创建，上下文组装，模板和上下文合并和内容表示。要注意的是，这仅仅是一个通用模式，它还有一些弹性，可以进行进一步扩展。但是，如果你牢牢记住了这个模式，就会少犯错误。

import java.io.StringWriter;

import org.apache.velocity.Template;

import org.apache.velocity.VelocityContext;

import org.apache.velocity.app.Velocity;

import org.apache.velocity.exception.*;

public class ClubApp

{

public static void main( String[] args )

{

// Initialize template engine

try

{

Velocity.init();

}

catch( Exception x )

{

System.err.println( "Failed to initialize Velocity: " + x );

System.exit( 1 );

}

// 获取模板

Template clubTemplate = null;

try

{

clubTemplate = Velocity.getTemplate( "ClubApp.vm" );

}

catch( ResourceNotFoundException rnfX )

{

System.err.println( "Template not found: " + rnfX );

System.exit( 1 );

}

catch( ParseErrorException peX )

{

System.err.println( "Failed to parse template: " + peX );

System.exit( 1 );

}

catch( Exception x )

{

System.err.println( "Failed to initialize template: " + x );

System.exit( 1 );

}

// 创建上下文

VelocityContext context = new VelocityContext();

// Populate context

context.put( "firstName", "John" );

context.put( "lastName", "Doe" );

context.put( "streetAddress", "123 Jane Ave." );

context.put( "city", "Azusa" );

context.put( "state", "CA" );

context.put( "zip", "91702" );

context.put( "phoneNumber", "626-555-1234" );

context.put( "emailAddress", "john@nodom.com" );

context.put( "occupation", "Web Developer" );

context.put( "otherInterests", "Hiking,Biking" );

context.put( "appType", "New" );

context.put( "useTime", "6 months" );

context.put( "useType", "Work" );

context.put( "wantNewsletter", "Yes" );

// Merge template and context

StringWriter writer = new StringWriter();

try

{clubTemplate.merge( context, writer );}

catch( ResourceNotFoundException rnfX )

{

System.err.println( "Template not found on merge: " + rnfX );

System.exit( 1 );

}

catch( ParseErrorException peX )

{

System.err.println( "Failed to parse template on merge: " + peX );

System.exit( 1 );

}

catch( MethodInvocationException miX )

{

System.err.println( "Application method exception: " + miX );

System.exit( 1 );

}

catch( Exception x )

{

System.err.println( "Failed to merge template: " + x );

System.exit( 1 );

}

// Render merged content

System.out.println( writer.toString() );

}

Listing 6.4 An application for processing the club membership form.

我们现在来讨论一下这个示例，可以说是把它放到放大镜下进行观察。代码开始于import语句，你可以看到java.io.StringWriter被导入到程序中，虽然StringWriter类并非必须，但一般情况下，导入StringWriter类是适当的，因为模板和上下文的合并处理通常需要一个java.io.Writer的衍生对象或衍生类。导入的第一个Velocity包是org.apache.velocity.Template，其相应的模板类提供了一个由应用程序使用的、常驻内存的模板。接着导入的是org.apache.velocity.VelocityContext类，用于处理Velocity上下文。之后，应用程序导入了org.apache.velocity.app.Velocity类，它提供了独立模式的Velocity模板引擎。通过org.apache.velocity.app.VelocityEngine类（将在Chapter 10讨论）可实现非独立模式Velocity模板引擎（non-Singleton implementation）。最后导入的是org.apache.velocity.exception.*，它提供了一个访问各种Velocity异常类的能力。

Import语句之后，将进入模板处理的执行代码。正如前面提及的，紧随其后的是Velocity应用的通用代码。第一个元素是初始化模板引擎，使用的是独立模式，初始化操作非常容易，仅仅调用静态方法Velocity.init()即可，如果因其他原因造成初始化失败，将抛出一个java.lang.Exception类型的通用异常；如果使用的是非独立模式，你需要创建VelocityEngine的实例来代替它，并调用该实例的init()方法，而不是直接调用Velocity的静态方法Velocity.init()。

初始化模板引擎之后，应用程序下一步将获取一个常驻内存的模板。随着模板引擎的初始化，这一步完成时创建的manner（依赖于独立或非独立模式）就可以使用了。在独立模式下，通过调用Velocity类的静态方法getTemplate()，将返回一个模板的实例。这个方法通过模板名称参数获得并加载了一个模板文件，本例中是ClubApp.vm。注意，虽然VM是公认的Velocity模板文件标准后缀，你也不必遵守这个约定，你可以将其改成其他的后缀，比如：XXX。

如果一个非独立模式被替换用于模板获取，剩余的处理必须相同。关键差别在于调用getTemplate()方法，非独立模式只能用VelocityEngine创建的实例来调用，不能采用调用Velocity静态方法的方式来调用。不管采用哪种模式，都必须增加相同的异常处理集，包括ResourceNotFoundException、 ParseErrorException和Exception。前两个Velocity异常在org.apache.velocity.exception包里指定，最后一个是标准的java.lang. Exception包。ResourceNotFoundException异常在Velocity不能定位指定模板文件时抛出；ParseErrorException异常在Velocity不能解析模板时抛出；最后，Exception异常在模板获取期间，发生任何其他问题时抛出。

在正确获取模板之后，你就可以创建和组装上下文了。首先要创建一个VelocityContext实例。上下文的组装通过实例调用VelocityContext的put()方法来完成，每一个关键字对应一个JAVA对象。在一个典型的Velocity应用中，很多处理都将围绕上下文组装这个操作，这里是生成让模板设计者可用的动态内容的地方，所有的数据中转和处理都将在这里完成。

现在你手里已经有了模板和上下文，下一步就是合并他们。这一步的作用是用从上下文中获取的数据替换模板中的引用，该合并操作是通过调用模板实例（之前创建的）的merge()方法完成的。模板的merge()方法需要两个参数，第一个是上下文（实现了上下文接口的任何对象），这里，你需要传递一个Velocity-Context的实例；第二个是java.io.Writer类型的对象，或其他Writer的衍生类型对象。Writer对象用于保存模板处理的结果。

最后，将输出最后的处理结果。一旦你把StringWriter用于合并操作，render操作将不再调用Writer的toString()方法，而是直接输出到适当的位置，比如浏览器。输出结果见Listing 6.2。

本章小节和下章介绍

这一章全面介绍了Velocity模板和上下文基础，我们通过一个示例应用示范了如何使用模板和上下文，并且对他们进行了详细的讨论。通过这些内容的学习，你应该可以设计一些基本的模板或开发简单的模板处理应用程序了。然而，在使用Velocity进行更多高级模板处理任务时，仍有许多障碍，要清除这些障碍，我们首先需要对Velocity引用进行更广泛的研究，这就是我们下一章将要学习的内容。

KINGWEE 2008-10-14 08:52 发表评论

CHAPTER 5 构建Hello World示例

KINGWEE — Sun, 12 Oct 2008 16:42:00 GMT

目前，你已经对Velocity有了一个很好的理解，并且理解了MVC是如何工作的，同时也搭建一个Velocity的工作环境，是时候开始学习如何Velocity了。正如你所期望的一样，第一个示例就是Hello World。

Hello World!

首先，你需要确定HTML页面的Hello World模板和在页面上显示些什么信息。如果我们仅仅简单的输出“Hello World”，这就不能很好体现Velocity的特性。因此，我们准备生成一个模板，输出内容为：“Hello World, Sam is Here”，在这里，“Sam”用的是引用值。

现在，你已经知道了页面需要输出的内容，接下来，你需要和JAVA开发者一起讨论并确定页面所需要引用对象的名称（此处的引用对象是“Sam”），在这里我们将这个引用对象的名称约定为“name”。在构建Hello World示例时，你需要考虑以下三个版本：

■ 不使用上下文的Velocity模板

■ 使用上下文的Velocity模板

■ 使用WEB的Velocity模板

如果你已经非常熟悉服务器端语言，比如PHP，你或许会非常惊奇，在Velocity模板被浏览时，我们为什么不讨论WEB服务器的解释程序。这是因为Velocity并不含解释程序，它是纯JAVA语言，属性编译运行方式，而非解释运行方式。所有在模板和上下文之间的合并处理都是通过JAVA代码来完成的。这些JAVA代码可能存在于Servlet中，也可嵌入JSP或应用程序中。

在WEB中使用Velocity时，很多情况下是使用Servlet来处理模板转换工作的。

不使用上下文的Velocity模板

Hello World示例代码见Listing 5.1，它使用Velocity指令语句#set来为模板中引用指定一个值（在模板中使用），同时使用嵌入Hello World文本的$name指令来引用#set指定的值。

这个示例比较容易理解，在Velocity对模板进行解析时，如果是普通的文本，则忽略，直接输出；当遇到#set指令时，它就创建一个名叫$name的内部变量（在模板文件中指定的），并赋值为"Sam"（在模板文件中指定的）；接着，程序将直接输出“Hello World”文本；在系统处理到$name引用时，系统将尝试在上下文中查找一个名叫$name的对象，如果在上下文中没有匹配的对象，系统将尝试匹配之前用#set创建的引用。

#set( $name = "Sam" )

Hello World, $name is Here

Listing 5.1 The Velocity Hello World template.

当然，仅仅拥有一个模板是不能工作的，你还需要一个把模板和上下文合并，并输出给用户的途径。Listing 5.2显示了一个独立应用需要用到的相关代码。

import org.apache.velocity.app.Velocity;

import org.apache.velocity.VelocityContext;

import org.apache.velocity.Template;

import org.apache.velocity.exception.ParseErrorException;

import org.apache.velocity.exception.ResourceNotFoundException;

import java.io.*;

import java.util.ArrayList;

public class Example {

//从命令行参数获取模板文件，并进行初始化操作

public Example(String templateFile) {

try {

Velocity.init();

VelocityContext context = new VelocityContext();

Template template = null;

try {

template = Velocity.getTemplate(templateFile);

} catch(ResourceNotFoundException e2 ) {

System.out.println(

"cannot find template " + templateFile );

} catch(ParseErrorException e ) {

System.out.println(

"Syntax error in template : " + e);

}

BufferedWriter writer = new BufferedWriter(

new OutputStreamWriter(System.out));

if ( template != null)

template.merge(context, writer);

writer.flush();

writer.close();

} catch( Exception e ) {

System.out.println(e);

}

public static void main(String[] args) {

Example t = new Example(args[0]);

}

Listing 5.2 The Velocity application without context. (continued)

和许多的JAVA应用程序一样，这个示例需要导入一些JAVA包，前面5个导入了运行Velocity需要的类。当第一次运行这个示例时，需要在命令行提供模板文件名这个参数。如：

java Example example.vm

回头查看Listing 5.2的模板示例我们可以看到，模板文件的名称被放置到命令行上，并传递给新创建的示例对象。在这里，首先需要完成Velocity引擎的初始化操作，示例利用一个独立模式关联应用程序和Velocity引擎，这就意味着仅有一个静态引擎是可用的。记住这个事实很重要，因为你肯定不希望再看到示例中还有其他任何初始化引擎的代码。

一旦引擎被初始化，就将从本地磁盘上加载模板。模板是通过Velocity引擎对象的getTemplate(String)方法进行加载的，该方法的结果是调用了一个模板对象；另外，如果没有找到，就会抛出异常。很重要的一点是，当找不到模板文件或把模板文件解析成模板对象出错时，异常将通过ResourceNotFoundException进行抛出。当读取模板并进行解析时出错，也会抛出ParseErrorException异常。

当模板被读入到系统之后，你就可以开始处理输出了。此处要注意的是，除了输出到控制台的方式外，还可以输出为一个文件、一个套接字socket或其他的输出。

在这个示例里，你已经在应用程序里使用了几个不同的内容：

■ Velocity—一个静态对象，表现为Velocity引擎

■ Context—一个上下文对象

■ Template—一个模板对象，在从本地磁盘读入Velocity模板文件时创建

■ Writer—一个BufferedWriter对象，用于向控制台直接输出（通过System.out流）。在输出前，要核实BufferedWriter已经正确进行了初始化。之后，Velocity引擎通过使用模板对象的merge()方法（带有两参数：一个上下文对象和一个BufferedWriter对象）来完成内容合并。merge()方法带有两参数：一个上下文对象和一个BufferedWriter对象，当模板对象执行merge()方法时，上下文被合并到模板文件中，同时用上下文中对应的值替换模板中的脚本元素，完成输出创建工作。

最后，冲洗（flush）和关闭输出流。Figure 5.1 显示了输出结果。

Figure 5.1 Output from the Hello World example.

在这个示例里，我们将Listing 5.1中的模板内容保存为一个文件，命名为helloworld.vm。在这里，扩展名不限于VM，也可以是其他的扩展名，目的是与其他文件进行区别，比如：HTML或JSP，当然，也完全可以是定义的，比如XX。另外，我们把Listing 5.2的内容保存到一个名叫Example.java的文件中，并将其编译成class文件。

javac Example.java

执行示例的命令为

java Example helloworld.vm

如果Velocity引擎不能定位模板文件位置，将产生一个错误。

使用上下文的Velocity模板

在上一个示例里，我们通过#set指令来给$name引用指定值。但这样做将限制Velocity的动态处理能力，比如，如果需要动态的更改用户名称，就成为一个不可能完成的任务。要想获得这个能力，需要使用上下文对象，在第二个示例里，我们使用和Listing 5.1相同的模板，但删除了#set指令这一行，只保留现在这一行：

Hello World, $name is Here

在JAVA代码中找到下面这行代码

VelocityContext context = new VelocityContext();

在其之后加上下面这行代码：

context.put("name", "New Sam");

存储这个文件，编译和执行它。你就将看到这样的输出“Hello World, New Sam is Here.”。现在让我们试一试其他，打开这个应用程序代码，改变context.put的参数内容。

context.put("names", "New Sam");

重新编辑并执行。输出结果为“Hello World, $name is here”，为什么会得到这个输出？好，让我们再仔细看一下context.put()语句。正如你在前面章节学到的一样，Velocity像变魔法一样把模板和上下文合并到一起，所有在模板的引用，比如$name必须和上下文对象中的关键字相匹配。因此，Velocity将尝试在上下文对象中查找关键字“name”来与模板引用$name相匹配。如果匹配上了，则将上下文中关键字“name”中保存的值“New Sam”合并入模板并返回给用户；如果在上下文中没有找到对应的关键字，引擎将直接把“$name”作为字符串返回，不进行任何合并操作。

在这里，之所有输出为“Hello World, $name is here”，是因为我们把context.put()的关键字改成了“names”，也就是说在上下文中保存的是“names”关键字的值，Velocity引擎也就不能匹配模板的$name引用，所以Velocity引擎直接返回$name字符串。

使用WEB的Velocity模板

迄今为此，我们所做的两个示例都是用于独立的JAVA应用程序。然而，当把Velocity用于替代jSP时，你可能最期待的就是把Velocity用于WEB应用程序。在这一节里，我们将看一看如何在Servlets里使用Velocity。关于这个主题的更多信息，详见Chapter 12“在Servlets里使用Velocity”，Listing 5.3展示了一个用于在浏览器里显示一个XML文档的新模板。正如你所看到的一样，这个模板有一些小的功能。

在之后的章节里，我们将检验更多的模板语句。目前，你首先需要关注的第一个在#foreach和#next指令之间的语句。这些指令允许你创建一个基于某些引用（此处为$value）的循环。

#foreach( $value in $list )

$value

#end

Listing 5.3 The servlet example template.

Listing 5.4 向你展示了用于产生XML的servlet代码。正如我们说及的一样，我们将在Chapter 12详细讨论Servlets，这里我们只关注Velocity对象的创建和三个增加到里面的值。用context.put("list", v)语句把整个Vector对象附属到上下文中。

import java.util.Vector;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.velocity.Template;

import org.apache.velocity.context.Context;

import org.apache.velocity.servlet.VelocityServlet;

import org.apache.velocity.exception.ResourceNotFoundException;

import org.apache.velocity.exception.ParseErrorException;

public class VelocityServletExample extends VelocityServlet {

public Template handleRequest( HttpServletRequest request,

HttpServletResponse response,

Context context ) {

Vector v = new Vector();

v.add("one");

v.add("two");

v.add("three");

context.put("list", v);

Template template = null;

try {

template = getTemplate("displaylist.vm");

} catch( Exception e ) {

System.out.println("Error " + e);

}

return template;

}

Listing 5.4 The servlet code for our example.

一旦vector被放置到上下文对象中，就需要从本地磁盘上获取用于显示上下文信息的模板。现在不再使用模板对象的merge()方法进行合并操作，而是简单的返回模板。这个模板实际上不会直接返回给用户，而是在后台对“被返回来的”模板和上下文进行合并处理，并返回给用户一个XML的类型的内容。在Figure 5.2里，你可以看到由Servlets和模板创建的XML输出。如果需要，你也可以使用Velocity向用户的浏览器输出HTML。

Figure 5.2 The servlet and template example output.

本章小节和下章介绍

在这一章里，我们向你展示了如何用Velocity来书写Hello World独立应用程序。你可以使用Velocity来开发独立应用程序和WEB应用。在下一章里，我们将开始详细介绍Velocity，并学习它与其他语言不一样的特性。

KINGWEE 2008-10-13 00:42 发表评论

CHAPTER 4 安装Velocity

KINGWEE — Sun, 12 Oct 2008 07:49:00 GMT

摘要: 读完之前的介绍性章节之后，你已经不再担忧开始使用Velocity来开发WEB页和独立应用程序了。在你开始钻研语言和应用示例之前，你必须完全设置和配置好开发环境。在这一章里，我们将介绍Velocity的首要条件，同时向你说明如何获取、安装和测试Velocity。我们也将介绍本书示例（依赖于Servlets的示例）将要用到的应用程序服务器的安装过程。如果你是一个开发者，不要担心，我们计划慢慢地对整个安... 阅读全文

KINGWEE 2008-10-12 15:49 发表评论

CHAPTER 3 Velocity介绍

KINGWEE — Sat, 11 Oct 2008 16:23:00 GMT

在Chapter 2里，你已经了解了WEB开发者（负责界面设计）和WEB设计者（负责商业逻辑设计）是如何在一起配合工作的，你也看到了ASP、JSP和PHP语言是如何在后台操作数据的。在这一章里，我们将开始Velocity的探索之旅，并了解它是如何工作的。

Velocity是什么?

Velocity是一种让WEB设计者易于掌握和使用的模板语言，主要目的是简化WEB动态页面的开发。为了获取这种语言的支持，你需要JAVA基础类集合，才能在MVC的MODEL模型和VIEW组件之间搭建一座桥梁。Velocity最重要的一个特性就是它仅仅通过一组简单的语法（WEB设计者用于显示内容的语法）就能清晰地把VIEW和其他MVC组件之间区别开了。同时，JAVA编程人员只需集中精力关注应用的后台逻辑就行。

Velocity不但可以用于开发WEB页面，也可以用于开发独立运行的应用程序。它不仅能够输出HTML，也能输出其他类型的内容，比如：源代码、SQL或XML。Velocity的一些主要功能如下：

■包括用于操作页面内容的LOOP、条件语句的模板语言

■ 访问JAVA对象方法

■ 直接支持Turbine Web 应用框架

■ 利用Anakia转换XML到其他格式的内容

■ Texan

■ 直接支持servlets

它是如何工作的？

为了对Velocity有所了解，让我们考虑一下这个应用，该应用允许用户显示他们的个人详细信息。让我们假定在这个示例中，用户已经登录到这个应用系统，这里，我们需要创建一个显示页面来显示用户的登录信息。

页面设计

在MVC架构里，WEB设计者负责设计界面，WEB开发者负责后台逻辑，并确保设计者所设计的页面能够正确显示所需要的数据。第一步就是由WEB设计者完成可视化布局设计，设计者使用HTML标记创建一个包含了全部所需图片和文本的页面，对于动态信息，比如用户的account号和地址等，设计者使用占位符进行替代（比如：<**user account name**>）。

Hello, <**user account name**>

Listing 3.1 The designer page example.

第二步，一旦完成页面可视化设计，设计者就应该和开发者召开一次会议，对动态内容（所使用的变量名称）进行讨论和确定，以保证页面能够正确显示。

获到正确的信息

在设计者和开发者之间召开的会议必须明确页面中需要插入动态内容的变量名称。这些变量名称将决定最终页面能否正确显示。

由于我们是使用MVC方式进行设计的，并且我们已经知道把JAVA代码放入WEB页面来获得内容不是正确的选择。Velocity为WEB设计者提供了一个脚本级的工作环境，它通过在HTML代码里放置脚本元素来产生一个模板。这些脚本元素由逻辑语句和访问JAVA对象的语法组成（比如loops和条件语句）。我们不要指望从VIEW组件里直接访问MODEL模型组件，因此Velocity需要一个可以在MVC各层之间传递数据，并且名叫上下文（Context）的集合。这个上下文对象内保存着控制器和模型组件，并提供给WEB页模板。

Velocity实现代码负责解析模板，并且用从上下文对象中获取的文本内容替换所有的Velocity脚本元素。一旦WEB设计者使用来自上下文的对象，这儿肯定需要一个设计者和开发者都理解的上下文对象名字约定。任何名字的不一致都将导致错误，这是因为Velocity是通过引用网页模板中的对象名字来进行数据传递的。

对信息进行编码Coding the Information

在设计者和开发者进行会议结束后，双方都将回去完成WEB开发最后的部分。在这一步中，MVC框架的优势是很明显的，因为设计者只需在WEB模板中增加脚本元素并加入双方约定的名称，而开发者则将开发焦点集中于如何返回约定名称的内容上。

对于开发者来讲，只有很少的工作需要去做，比如将新的页面集成到当前框架、确认当前用户的需要的信息（如：account number）是正确可用的，同时把设计者需要的数据放入上下文中。要注意的是，我们不能放弃前两步工作而直接跳到第三步上。

在许多以JAVA为基础的MVC应用中，用户实际浏览的页面是基于Servlet的。Servlet担当了MVC中的控制器角色。数据实体一般表现为模型，Session Bean可能考虑为控制器。控制器或Servlet负责把数据加入到上下文中。

一旦进行上下文和当前用户必须的动态数据的组装时（populate），开发者需要确定当前用户所请求使用的模板，然后将上下文中的数据并入模板中，最后生成HTML输出。Listing 3.2 显示了开发者在编码中必须要创建的基本语句。

Velocity.init();

VelocityContext context = new VelocityContext();

context.put( "name", new String("Jane Doe") );

Template template = Velocity.getTemplate("account.vm");

StringWriter sw = new StringWriter();

template.merge( context, sw );

Listing 3.2 Developer code for Velocity.

在Listing 3.2里，开发者首先要进行Velocity初始化工作，随后需要创建一个新的上下文。通过上下文的put()方法将一个字符串对象指派给关键字“name”，并且将字符串值"Jane Doe"粘贴到上下文中（此处的关键字“name”是先前设计者和开发者开会是约定的名称）。接着，使用getTemplate()方法获得（设计者创建的）模板。然后，用StringWriter来处理HTML输出。最后，模板和上下文被merge()方法合并到一起，并将最后的合并结果传送到StringWriter对象中保存，用于最后输入。

在这个示例中，许多细节被忽略。在下一节里，我们将用图例的方式来说明开发者为提供模板所需要的动态信息必须要做的工作。这在个示例里，我们指派了一个简单的字符串对象给上下文，同时也介绍了复合对象和如何使用Velocity来访问对象的属性和方法。

显示信息Displaying the Information

设计者或许可以很轻松的对已经设置好上下文和API的页面进行处理。使用Velocity模板语言（更广泛的讨论在Chapter 6里），所有的动态信息占位符被Listing 3.3所示的代码（$name）替换。

Hello, $name

Listing 3.3 Velocity Web页示例

在这里，用户名占位符被Velocity语句$name替换。当这个模板被上下文合并时，$name将被上下文中的名叫$name的对象的值替换。

Velocity 特性

在这个示例里，我们看到了如何使用一个在Velocity里定义的简单脚本元素和上下文来产生一个动态WEB页面的过程，这些定义都在MVC框架范围内。Velocity包含了许多别的特性，在这里，我们将通过以下介绍来了解其大概情况：

References—Velocity包含了三种类型的引用：变量、属性和方法。

变量以$符号开始，后紧跟英文符号或数字来进行定义。变量的值来自上下文同名的对象或直接量（Set idrective）。

属性以$符号开始，后紧跟英文符号或数字，而后是一点”.”，最后跟上别的定义。属性引用自上下文中JAVA对象的属性或调用对象方法返回的值。方法的定义必须是get<定义>这种格式。

方法以$符号开始，后紧跟英文符号或数字，而后是一点”.”，最后跟上别的定义和方法体（比如 ()）。A call is made to the exact method identifier specified（此句未译）。

Directives指令—Velocity指令允许WEB设计者控制所有引用。脚本元素包括set(为变量名指定值或叫直接量)、loop控制、条件和include指令。

Velocimacros Velocity宏—Velocimacro允许设计者构建多次重复使用的HTML和Velocity脚本元素宏。

Logging日志—Velocity利用log4J系统来产生日志。

Resource loaders资源加载—The resource loaders give you control over the templates used in the production of Web pages（此句未译）.

Anakia—这是一个示例应用，它允许使用Velocity代替XSL （Extensible Stylesheet Language）来处理XML。

Application servers应用服务器—Velocity支持所有主流的应用服务器和Servlet，比如Resin, Tomcat, 和 BEA WebLogic等。

本章小节和下章介绍

在这一章里，我们提供了一个Velocity系统的快速浏览，解释了设计者和开发者是如何使用Velocity的。在下一章里，我们将开始学习Velocity和相关软件的安装。

KINGWEE 2008-10-12 00:23 发表评论

CHAPTER 2 MVC 基本原理

KINGWEE — Sat, 11 Oct 2008 14:51:00 GMT

如果你已经充分了解Internet，你或许会像我一样，准备开始传统的软件开发。在此之前，我们最好先学一下方法学，以便为今后的开发节约更多的时间。

不同的开发人员（比如页面设计者和代码开发者）完成不同的开发任务，尽量避免交叉，这样做可以起到事半功倍的效果。

在这一节，我们将公正的深入讨论一下混杂式编程，同时介绍MVC方法学，并介绍MVC是如何解决混杂式编程问题的。

混合呈现和逻辑

在此，我们创建了一个嵌入数据库调用脚本的WEB页面，并对它进行分析。

<%@ page language='java' import='java.sql.*' %>

Test

ResultSet rs;

try {

Class.forName("com.mysql.jdbc.Driver");

connection = DriverManager.getConnection(

"jdbc:mysql://localhost/products");

statement = connection.createStatement();

if (request.getParameter("submit") = "submit") {

rs = statement.executeQuery("SELECT username, password,

city, state FROM product where username = " +

request.getParameter("username"));

if (rs.next()) {

value="<%= rs.getString("username") %>">

value="<%= rs.getString("password") %>">

value="<%= rs.getString("city") %>">

value="<%= rs.getString("state") %>">

<% } else { %>

No Information

<% }

}

else if (request.getParameter("submit") = "update") {

statement.executeUpdate("UPDATE product set password= '"

+ request.getParameter("password") + "'" +

", city = '" + request.getParameter("city") + "'" +

", state = '" + request.getParameter("state") + "'" +

"where username = '" +

request.getParameter("username"));

}

} catch(ClassNotFoundException e) {

out.println("Driver Error");

} catch(SQLException e) {

out.println("SQLException: " + e.getMessage());

}

Listing 2.1 A mixed presentation logic page.

以上代码是JSP页面的一个混合VIEW呈现和逻辑很好的例子，让我们来考虑以下几个在使用这个页面时必须面对的问题。

作为一个开发者，假设公司让你去创建一个简单的HTML窗体，以接收或显示用户名细节情况。这个需求的改变将导致你需要从复杂的页面代码中分离出商业逻辑逻辑，并在适应的位置增加新逻辑。

当然，并非所有的页面都这么简单，有些时候，需要在页面中增加一些图片时。对代码开发者来说，由于他对界面设计不太了解，最终结果将导致页面非常难看；对页面设计者来说，由于他不了解JAVA代码，最终可能出现程序不能运行的结果。

最后的结果就页面将难以维护和继续。

我希望这个故事对你来讲最好不要成为现实，但现实的情况恬恬如此。

Smalltalk-80 MVC三合一架构

当Smalltalk-80被大量使用的时候，一种用于分离显示和逻辑的方法就显得非常重要了。进行分离后，前台只负责显示任务，后台负责数据获取和格式化处理，各司其职。下图为Smalltalk-80 MVC三合一架构。

Figure 2.1 The Smalltalk-80 MVC triad.

In Figure 2.1，我们发现它有三个主要组件：model， view和controller。下面将对这三者和它们之间的关系进行解释。

Model

MVC的模型部分通常由以下两部分组成：

■类或者别的数据结构，用于呈现系统或应用程序状态

■动作/方法，用于改变系统状态

在很多情况下，模型用于呈现数据库里的数据。如果你在JAVA中使用MVC，则模型将被创建为JavaBeans，用于访问或加载系统数据。

使用模型的最核心想法是为了从用户呈现页面中完全分离数据。意思是模型与所有的输入和输入无关。可以从VIEW和控制器中访问模型。控制器从用户窗体接收输入信息，当信息需要进行加工时，控制器与模型进行交互，以得到适当的数据。

为了显示模型的信息，VIEW组件在模型里注册自己。当信息发生改变时，模型通知所有注册了的VIEW，告诉他们信息已经改变，可以获取新的信息并呈现给用户。模型不限于一个VIEW，它可以允许多个VIEW进行注册，并向他们告知系统目前的状态。

Figure 2.2 Model inputs and outputs.

正如你在Figure 2.2里看到的一样，模型主要连接到数据源（可以是数据库、固定格式的文件或一些扩展接口）。模型负责维护数据的真实性和可用性和完整性。其他输入包括VIEW组件更新注册和数据更新通知。

View

在我们讨论模型的时候已经接触到了VIEW。VIEW组件是一个可视化组件，它用于向用户显示由模型建立的数据。在多数情况下，VIEW被设计成几种格式：比如字符、简单列表或一个组合风格。

当用户需要使用模型中的信息时，应用将生成一个新的用于某种特定格式显示数据的VIEW组件，VIEW将在模型里自动注册，以便于在数据或状态发生改变时，模型好通知该生成的VIEW组件。VIEW是如何获取数据的呢？其实，他可以通过调用模型中的特定方法，或接受串行化数据对象。VIEW也可以从控制器中获取数据（下一节，我们将讨论这个问题）。

Controller

控制器组件负责处理所有在应用和用户之间的交互。所有从键盘、鼠标和其他扩展接口的输入都将被发送到控制器组件。使用预先定义的逻辑，控制器确定数据是否需要在模型里更新或是否需要创建一个新的VIEW组件。

正如你所了解的一样，一些商业逻辑都包含在控制器和模型里，在VIEW组件里不包含商业逻辑。

MVC架构

MVC架构在Gang的四本书里都有涉及（Design Patterns: Elements of Reusable Object-Oriented Software）。在高级语言里建立MVC观念需要做很多工作，比如：JAVA包括两个有个的接口，java.util.Observable 和 java.util.Observer，用于监测和通知状态改变。在剩余章节里，我们主要关注MVC在WEB开发中相关的内容。

Sun模式1 和 2

之前，我们讨论了Smalltalk-80的MVC定义，在WEB开发的开初，用于快速开发的新技术不断产生。JSP，一个类似的技术，允许WEB页面从静态内容向动态内容转变。把JSP用于ＭVC的模式1时，很不幸，除非你非常小心，一个动态WEB页面看起来像Listing 2.1一样，并且有太多的VIEW和控制器代码混杂在里面。

随着servlet的发展，开发者可以把控制器代码建立在动态页面里，并在里面放置自己的组件。这时，SUN提出了模式2，因为在MVC架构里有2个组件被使用。但许多可能需要考虑，其中之一就是模式2和MVC之间如果联系，许多典型的原因就是WEB应用无法利用Observer（监测）模式。

将MVC扩展到WEB应用

WEB站点利用HTTP协议进行数据传递。当用户访问WEB站点时，单击按钮或链接将向WEB服务器发送一个GET 或 POST HTTP协议请求。然后，WEB服务器处理这个请求并返回HTML页面给用户。如Figure 2.3所示

Figure 2.3 Web page processing.

正如Figure 2.3显示的一样，整个处理过程是线性的，所有信息被转换附加到请求上。事实上，在Figure 2.3显示的处理中，WEB页面直接访问数据，从VIEW到数据层之间没有任何中介处理层，这将导致许多问题，这不是一个好的处理办法。解决方法是，在处理层加入适当的层，把它们进行分离。如Figure 2.4所示的三层结构。

Figure 2.4 Three-tier Web page processing.

在Figure 2.4里，我们尝试把MVC架构带入WEB开发中，以分离不同层之间的功能。

MVC实践

在学习了以上知识的基础上，让我们看一下如何把Listing 2.1中的代码转换为MVC方式，让WEB设计者和WEB开发者的工作更容易。首先，我们需要创建一个包含所有显示信息的VIEW。如Listing 2.2所示：

Test

Listing 2.2 Example view code.

正如你在Listing 2.2里看到的一样，我们仍旧需要WEB设计者拥有一些通过控制器操作MODEL模型里数据的能力。根据个人经验，在VIEW层使用Loop和条件将减轻WEB应用开发相当多的工作。这些代码不能被用户直接访问，在显示给用户之前， WEB服务器将把它当作模板进行处理。

处理来自VIEW的请求，需要创建一个servlet（JAVA），详见Listing 2.3

public class ControllerServet extends HttpServlet {

private AccountLocalHome home = null;

public void init() throws ServletException {

try {

Context cmp = (Context) new

InitialContext().lookup("java:comp/env/cmp");

home = (AccountLocalHome) cmp.lookup("AccountBean");

} catch (NamingException e) {

e.printStackTrace();

}

public void doGet(HttpServletRequest req, HttpServletResponse res)

throws IOException, ServletException {

if (home == null) {

out.println("home is null");

} else {

AccountLocal account = home.create();

ServletContext app = getServletContext();

app.setAttribute("username", account.username);

app.setAttribute("passowrd", account.password);

app.setAttribute("city", account.city);

app.setAttribute("state", account.state);

RequestDispatcher disp;

disp = app.getRequestDispatcher("/ViewAccount.tmp");

disp.forward(request, response);

}

public void doPost(HttpServletRequest req, HttpServletResponse res)

throws IOException, ServletException {

doGet(req, res);

}

Listing 2.3 Example servlet code.

这个Servlet可以使用EJBs作为MODEL模型组件访问数据。在很多情况下，控制器Servlet将为特定的商业功能处理其他Servlet或对象。我们的Servlet将获得一个Account对象和对象与当前WEB应用的上下文之间的联系。这个处理将把存储在上下文中的数据传送到模板代码中（Listing 2.2）。

本章小节和下章介绍

在这一章里，我们探索了一MVC架构（一个用于分离系统组件和商业逻辑的方法）。最突出的问题是在VIEW组件里应该使用什么语言。我们的解决方案是使用Velocity——一个为WEB设计者特制的用于处理信息显示的语言。在下一章里，我们将介绍Velocity，分析其结构，并且用示例说明如何把Velocity集成到MVC架构里。

※※译者注：MVC是一种方法学，而不是一种特定的语言框架※※

KINGWEE 2008-10-11 22:51 发表评论

CHAPTER 1 Web 开发基础

KINGWEE — Sat, 11 Oct 2008 14:43:00 GMT

如果你还记得大约10年前的时候，或许你已经了解WWW起初是如何工作。Telnet和FTP是最早的沟通方式。虽然这些技术不能直接用于WEB，但他们的确是WWW的先驱。

很快，新的技术不断出现，使WEB开发变得越来越强大，本书主要探索最近几年才出现的WEB技术的一部分：向客户端提供动态数据显示。我们主要关注一个名叫Velocity的新技术。

在这一节里，我们将向你展现WEB开发历史的概览。

静态WEB页面

一切都是从静态页面开始的，静态页面只能呈现一些静态的内容，它不能从数据库或其他应用里提取数据。比较接近于“所见既所得”的表现方式。

静态页面最大的问题是不能提供动态内容，以满足不同用户的需要。随着WEB技术的发展，开始有了用于WEB开发的动态技术。

CGI介绍

CGI (Common Gateway Interface)公共网关接口对WEB开发有着重要的意义。于1993年开发出来， CGI 是第一个通过服务器后端处理后向客户提供动态信息的WEB开发技术。

在使用CGI的时候，应用的动作一般由高级语言书写，比如C，Perl或C++。CGI通过网页窗体的按钮事件获取用户输入，并返回最终结果给用户。

Listing 1.1 CGI示例（C语言书写）

int main(int argc, char* argv[]) {

printf("content-type: text/html"r"n");

printf(""r"n");

printf("");

printf("

Hello World!

");

printf(""n");

return(0);

}

因为CGI应用执行在WEB服务器端，安全性就非常重要。许多服务器需要CGI应用放置到文件夹/cgi-bin下。除此而外，服务器不允许执行任何程序。

Scripting: JSP/ASP/PHP

正如你所了解的一样，使用CGI和Perl或C++进行WEB开发对WEB设计者来说是非常困难的。也就是说WEB设计者只有完全掌握这些高级语言后才能进行WEB开发。

和这些高级语言不同的时，脚本语言通过解释程序执行，他们很容易学习并用于WEB程序开发。解释程序由高级语言编写，在HTTP服务器端加载，丢弃了CGI接口。脚本语言通过在HTML文档中嵌入语句和脚本语言关键字来向客户端递送动态信息。

Listing 1.2 脚本语言示例

Time Example

The time is

In Listing 1.2,我们增加了一些脚本用于显示当前时间。当用户浏览该页的时候，他们将通HTTP服务器得到当前时候。

嵌入脚本的页面虽然看起来像HTML页面。然后，其后缀不能是.html或.htm。只能是对应的后缀，比如：.jsp，.asp，.php等。这些扩展名非常重要，它主要是用于告诉服务器该页面是否需要进行服务器端处理。如果需要进行处理，解释程序将脚本代码进行后台运算，最后将运算结果以标准的HTML形式嵌入HTML文档中返回给客户。

未来的发展

当我们在讨论脚本语言的时候，你应该关注以下可用到的脚本语言——如JavaScript，Java，和ActiveX。Listing 1.3展现了一个用Java脚本写的HTML页面。

<%@ page language='java' import='java.sql.*' %>

Test

ResultSet rs;

try {

Class.forName("com.mysql.jdbc.Driver");

connection = DriverManager.getConnection(

"jdbc:mysql://localhost/products");

statement = connection.createStatement();

Listing 1.3 Using Java in an HTML page.

在HTML页面中嵌入Java脚本是为了让WEB站点具有动态处理的能力。你不仅需要了解Java，同时也需要了解在服务器端执行的Java代码是如何编写的。

我们讨论很多不同类型的动态页面技术，但他们都有一个共同点，就是将显示和商业逻辑混杂在一起。在下一节里，我们将讨论混杂编程是多么的令人头痛。

本章小节和下章介绍

这一章里，我们分析了WEB页面的开发历史。下一节，我们将讨论WEB开发的方法学，并且主要关注MVC模式。

KINGWEE 2008-10-11 22:43 发表评论

概述

KINGWEE — Sat, 11 Oct 2008 14:26:00 GMT

起初，WEB页面是一个为所有访问者提供一个统一的信息静态实体。开发者很快就想到为拥有一种为每一个用户提供唯一数据的能力，一个大的技术分类随之而来，比如PHP,ASP和JSP。当这些语言在解决这个问题的同时，也导致了一个非常大的问题。

这些语言直接和HTML标签相混合，导致程序可维护性大大降低。如果开发者想改变页面外观，修改工作将难以进行。

幸运的是，模型-视图-控制器（MVC）设计范例完全把私有代码从页面和数据中分离出来。使用MVC模式进行设计时，WEB设计者只关注于创建页面表现外观，而WEB开发者则只需关注代码的处理。Velocity是一种用于从私有代码中分离Java Web代码的技术（通过MVC方式）， Web设计者通过使用java基础模板，引用用java书写的私有代码。

这本书提供了一个使用Velocity1.3.x创建可维护站点的综合处理方案（通过本书示例的帮助）。

这本书里有些什么？

因为Velocity是为Web设计者和开发者而设计的，这本书包含了VTL（velocity模板语言）的全部内容。我们展示了如何把VTL语言应用到你的Velocity模板的窗体数据里，以及如何使用这些模板开发应用程序。

我们假定你不知道Velocity，因此在编写第一个实际应用之前，我们提供了一个示例以便于你能够理解系统是如何工作的。在这个实例里，我们展示了如何利用MYSQL数据库来构建一个CD收藏应用。通过这个应用，你将学会如何利用MVC方式书写代码。你也将学会如何用velocity模板来进行web输出、文本报表和生成XML。本书第二个示例是一个酒店预约系统，用于验证如何使用Maverick 和 Velocity 模板来构建一个完整的WEB应用。这个应用允许用户使用某几个标准进行房间信息搜索，预订想要的房间，然后显示预约确认。许多Velocity模板和三个控制类被用于完成应用，用一个Velocity模板来展现。

谁最应该读这本书

本书是为帮助WEB开发者和WEB设计者维护和开发WEB站点和应用而写的。许多组织把这些分成WEB设计者和软件开发者这两个角色，并分别雇用图形设计者来进行WEB表现设计和雇用软件设计者来进行WEB开发。这两个角色都是（critical）独立的：WEB开发者专注于Servlet Veloctiy后端（back-end）支持，WEB设计者利用WEB开发者提供的后端支持进行界面设计。

在这里，我们假定WEB开发者已经具备JAVA开发工作的经验和知识，并且已经能够熟练使用servlets和EJBs进行交互，同时假定WEB设计者已经具备HTML开发工作的经验和知识。如果他们（exposure）不得不使用JSP/ASP或其他服务器端语言进行开发，Velocity将很容易进行转换（虽然我们假定他们不了解这些知识）。

本书由三部分组成。第一部分是MVC和Velocity的介绍。一旦你已经掌握或了解了（under your belt）这些介绍性的知识，我们将进入Velocity语言和它的特性讨论环节（第二部分）。最后，第三部分提供了许多示例和全面的示例应用，并举例说明如何使用Velocity。

Part I: Velocity和MVC介绍

Chapter 1: Web开发基础(development basics)

直到今天，Internet开发仅仅是目前技术革新的一小部分。通过internet，把相互连接性进一步延长，它允许个体和公司以相同的方式向全球成千上万的客户和朋友呈现信息。最初，WEB页面开发仅限于使用HTML来产生一个静态页面。

随着internet语言的进化和站点需求的增加，开始向动态页面发展，并利用数据库进行数据管理和复杂应用处理。新的复杂性是，结果常常导致在同一个文件里混杂view和处理代码。Velocity利用MVC方式为设计者和开发者提供了一个解决方案。本章为internet发展历史和velocity是如何brings to the table(使表恢复知觉？)提供了一个全面的概览。

Chapter 2: MVC基本原理

当Smalltalk-80设计出来的时候，一个叫做Model-View-Controller（MVC）的体系被用于从数据和控制逻辑中分离view，几年过去了，MVC已经变成一个能够被所有现代语言所应用的模式。MVB已经带进WEB舞台，同时能够被Velocity充分利用。

本章给你一个全面的MVC概览，同时向你解释MVC在internet开发处理中的角色。我们向你呈现了代码示例，同时描述了每一个MVC组件是如何解决在创建组合代码过程中所出现的问题。

Chapter 3: Velocity介绍

本章主要介绍Veloctiy。我们向你呈现了Velocity是如何工作的，并且调试我们在本书中将使用的代码。随着学习的深入，你将对这个系统有一个好的理解。

Part II: Velocity 基础

Chapter 4: 安装Velocity

在你开始关注Velocity细节之前，你必须先安装它。本章提供了一个全面的Velocity安装手册。涵盖windows和Unix平台下所有必须的开发工具和先决条件包。我们将对Velocity测试组进行全面讨论，同时提供一个执行示例应用的手册和sevlets支持包。一些支持包包含了Java SDK和一个应用服务器（比如Tomcat或Resin）。

Chapter 5:创建Hello World 示例

正如你所期待的一样，一个新的开发范例都是从Hello World应用开始的。在这一节里，你将书写你的第一个Velocity应用-but with a twist。你可以书写用于单机和WEB格式的应用，以此证明Velocity能够用于任何类型的应用输出。当然，书写代码仅仅是战斗的一部分——你还必须能够部署和执行你的应用。本章将告诉你每一个详细的步骤。

Chapter 6: 理解和模板和上下文

Velocity的两个主要组件就是templates模板和context上下文。模板为WEB设计者创建应用界面提供了一个区域，这个界面将通过单机应用生成一个WEB页面或产生一个报表；上下文为WEB开发者放置所有设计者designer和Velocity模板所需要的信息提供了一个区域。本章将介绍这些组件。我们将通过调试一个完整的示例来展示组件是如何在一起工作的，同时，我们将讨论他们的一般用法。

Chapter 7: Exploring References引用探索

在Velocity内部，引用在模板和上下文（一个存储数据的地方）之间提供了一个接口。在这一节里，我们将描述以下三种类型的引用：语法、正式的和非正式的（？），我们也将讨论逃逸（escaping）、静态（quiet）和属性符号（property notation），同时提供一个示例来说明这些概念。

Chapter 8: 使用指令（Directives）

Velocity和许多别的Internet语言一样，提供了一个命叫指令（directives）的控制和判断结构，这些指令（如#foreach 和 #if）为WEB设计者提供了一个强大的工具，来熟练操作上下文中的数据。本章涵盖了directives和includes示例，同时也包含了一个用于快速查找的引用片段。

Chapter 9: Velocimacros介绍

当你发现自己再三重复同样的Velocity代码时，你就应该开始学习velocimacros了。这些宏允许你创建一些用于模板的模块，以产生清晰（clean-looking）的代码，同时有助于今后开发的维护。本章涵盖了velocimacros内容，同时提供了广泛的例子。

Chapter 10: Velocity控制器讨论

Velocity开发者需要包含了几个结构——比如事件、资源加载和其他系统属性（帮助你定制Velocity的行为）。本章用示例来说明如何更改Velocity模式以适用于你的应用。

Part III: Velocity开发

Chapter 11: Velocity, XML, 和 Anakia

XML是宣传和介绍的最多的技术。用于HTML时，XML允许用户自定义标记来识别包含在文本里的数据。为了使XML更易用，人们设计了XSLT，用于快速、便捷地操控和转换XML数据。

Anakia设计者使用Ant任务，利用强大的XSLT功能（found）和XML来创建输出。

Chapter 12:在Servlets里使用Velocity

当你使用Velocity开发应用时，MVC范例模式是创建可维护性应用最有效方式。第一个控制器开发的就是Servlet。本章里，我们将向你展示如何使用Servlet和Velocity书写一个CD收藏应用。许多模板都是有插图的，同时我们将讨论在下载表文件的窗体里利用Velocity来输出文本。该应用同时也利用了EJBs来作为MVC范例模式的模型（model）组件。在EJBs里，数据通过Collection（收藏）对象窗体里的上下文来传递到模板。VTL指令（directives）把显示给用户的Collection（收藏）数据填充到数据库行。

Chapter 13: Velocity和国际化

当你正在设计一个WEB应用的时候，你可能习惯考虑使用母语来书写应用里的文本，但是你可能忘记了其他国家的用户或许正在使用这个应用的功能。虽然Velocity不能改变在JAVA基础WEB应用上完成国际化任务的现状，但它提供了一个创建被许多语言理解的兼容站点的框架。本章展示了如何把德语文本增加到你的CD收藏Velocity应用中。使用这个本章介绍的这个技术，你可以很容易地为你的Velocity应用增加其他语言支持。

Chapter 14: 在Turbine（涡轮）里应用Velocity

在Jakarta的开发小组中，Turbine是一个为开发者提供的创建企业级应用工具的应用框架，其目标是提供一个让开发者自行创建其想要的组件框架（？）。

在本章里，我们将讨论如何使用Turbine和Velocity获取、安装和部署一个应用。让你利用Turbine的MVC支持进行Velocity开发。

Chapter 15: 在Maverick里使用Velocity

如果你正在使用J2EE和MVC构建一个应用，可以考虑使用Maverick框架。这个框架联合了Velocity和DVSL，它允许你构建一个企业级的XML应用。你也可以在应用中混合使用JDBC和EJBs。

Chapter 16: Velocity IDEs

虽然许多开发者和设计者都使用文本编辑器来操作他们的WEB页面，一些人更喜欢使用IDE。本章提供了各种不同的第三方IDE插件和文本编辑器插件。我们将涵盖许多开发工具的插件，比如IntelliJ's IDEA, UltraEdit, JEdit, TextPad,和 Emacs。

Chapter 17: 在Struts里使用Velocity

Struts或许是目前用得最多的MVC框架了。Velocity团队预期的开发目标是使用Velocity作为MVC框架里的VIEW组件，同时创建可利用的接口包来进行综合处理。本章为使用Struts和Velocity创建一个应用提供了完整的说明。

Chapter 18: 酒店预约Velocity应用系统

在这一节时里，我们使用Velocity和MVC框架书写了一个完整的WEB应用文档。我们使用许多模板来为WEB用户提供输入和显示页面。控制器使用MYSQL数据库跟踪酒店房间信息。

Chapter 19: 在JSP里使用Velocity

许多WEB设计者和开发者对JSP已经非常熟悉，他们不想切换到Velocity或不想放弃JSP页面，只想把JSP和Velocity混合在起编程。本节向你展现了如何在JSP页面里使用Velocity标记库将Velocity命令嵌入到JSP页面中。

Chapter 20: DVSL和Velocity

Velocity类型声明语言（DVSL）是为许多XSLT特性功能而设计的（？），它可以使用许多XSLT中相同的方法函数来转换XML。本章提供了一些使用DVSL例子。

Appendix A: The Velocity规范

Velocity系统由许多类和接口组成。本附录提供了一个完整的概览。

Appendix B: Velocity 站点

本附录提供了一个Velocity帮助站点列表。

KINGWEE 2008-10-11 22:26 发表评论