BlogJava-鹰翔宇空-文章分类-opensource

Velocity简介

TrampEagle — Wed, 31 May 2006 14:03:00 GMT

Velocity简介
原文引自：http://www.3doing.net/forums/dispbbs.asp?boardID=57&ID=593&page=1

Velocity是一个开放源吗的模版引擎，由apache.org小组负责开发，现在最新的版本是Velocity1.3.1
http://jakarta.apache.org/velocity/index.html 可以了解Velocity的最新信息。
Velocity允许我们在模版中设定变量，然后在运行时，动态的将数据插入到模版中，替换这些变量。
例如：

<HTML>
HELLO $CUSTOMERNAME
HTML>

我们可以在运行时得到客户的名字，然后把它插入到这个模版中替换变量$CUSTOMERNAME，整个替换过程是由Velocity进行控制的，而且java的调用代码也非常简单
如我们可以在java代码中这样调用

//这个文件中设定了Velocity使用的log4j的配置和Velocity的模版文件所在的目录
Velocity.init("D:\\Template\\resource\\jt.properties");
//模版文件名，模版文件所在的路径在上一条语句中已经设置了
Template template =Velocity.getTemplate("hello.vm", "gb2312");
//实例化一个Context
VelocityContext context = new VelocityContext();
//把模版变量的值设置到context中
context.put("CUSTOMERNAME", "My First Template Engine ---- Velocity.");
//开始模版的替换
template.merge(context, writer);
//写到文件中
PrintWriter filewriter = newPrintWriter(newFileOutputStream(outpath),true);
filewriter.println(writer.toString());
filewriter.close();

    这就是整个java的代码，非常的简单。如果我们有多个模版变量，我们仅需要把这些模版变量的值设置到context中。

    下面我们简单的分析一下，Velocity引擎读取模板文件时，它直接输出文件中所有的文本，但以$字符开头的除外，$符号标识着一个模版变量位置，context.put("CUSTOMERNAME", "My First Template Engine ---- Velocity.");当Velocity模板引擎解析并输出模板的结果时，模板中所有出现$CUSTOMERNAME的地方都将插入客户的名字，即被加入到VelocityContext的对象的toString()方法返回值将替代Velocity变量（模板中以$开头的变量）。
    模板引擎中最强大、使用最频繁的功能之一是它通过内建的映像（Reflection）引擎查找对象信息的能力。这个映像引擎允许用一种方便的Java“.”类似的操作符，提取任意加入到VelocityContext的对象的任何公用方法的值，或对象的任意数据成员。映像引擎还带来了另外一个改进：快速引用JavaBean的属性。使用JavaBean属性的时候，我们可以忽略get方法和括号。请看下面这个模板的例子。

<HTML>
Name: $Customer.Name()
Address: $Customer.Address()
Age: $Customer.Age()
HTML>

java的代码：

//设置客户信息
Customer mycustomer = new Customer();
mycustomer.setName("Velocity");
mycustomer.setAddress("jakarta.apache.org/velocity/index.html");
mycustomer.setAge(2);
//这个文件中设定了Velocity使用的log4j的配置和Velocity的模版文件所在的目录
Velocity.init("D:\\Template\\resource\\jt.properties");
//模版文件名，模版文件所在的路径在上一条语句中已经设置了
Template template =Velocity.getTemplate("hello.vm", "gb2312");
//实例化一个Context
VelocityContext context = new VelocityContext();
//把模版变量的值设置到context中
context.put("Customer", mycustomer);
//开始模版的替换
template.merge(context, writer);
//写到文件中
PrintWriter filewriter = newPrintWriter(newFileOutputStream(outpath),true);
filewriter.println(writer.toString());
filewriter.close();

输出结果：

<HTML>
Name: Velocity
Address: jakarta.apache.orgvelocityindex.html
Age: 2
HTML>

    除了替换变量之外，象Velocity高级引擎还能做其他许多事情，它们有用来比较和迭代的内建指令，通过这些指令我们可以完成程序语言中的条件判断语句和循环语句等

    例如，我们想要输出年龄等于2的所有客户的信息，我们可以这样定义我们的模版
    模版：

<HTML>
                #foreach ($Customer in $allCustomer)
                    #if($Customer.Age()=="2")










                    #end
                #end


名称地址年龄

$Customer.Name() $Customer.Address() $Customer.Age()
HTML>

java的代码：

//设置客户信息
ArrayList allMyCustomer = newArrayList();
//客户1
Customer mycustomer1 = new Customer();
mycustomer1.setName("Velocity");
mycustomer1.setAddress("jakarta.apache.org/velocity/index.html");
mycustomer1.setAge(2);
//客户2
Customer mycustomer2 = new Customer();
mycustomer2.setName("Tomcat");
mycustomer2.setAddress("jakarta.apache.org/tomcat/index.html");
mycustomer2.setAge(3);
//客户3
Customer mycustomer3 = new Customer();
mycustomer3.setName("Log4J");
mycustomer3.setAddress("jakarta.apache.org/log4j/docs/index.html");
mycustomer3.setAge(2);
//添加到allMyCustomer(ArrayList)中.
allMyCustomer.add(mycustomer1);
allMyCustomer.add(mycustomer2);
allMyCustomer.add(mycustomer3);
//这个文件中设定了Velocity使用的log4j的配置和Velocity的模版文件所在的目录
Velocity.init("D:\\Template\\resource\\jt.properties");
//模版文件名，模版文件所在的路径在上一条语句中已经设置了
Template template =Velocity.getTemplate("hello.vm", "gb2312");
//实例化一个Context
VelocityContext context = new VelocityContext();
/**
* 注意这里我们仅仅需要给一个模版变量负值
*/
context.put("allCustomer", allMyCustomer);
//开始模版的替换
template.merge(context, writer);
//写到文件中
PrintWriter filewriter = newPrintWriter(newFileOutputStream(outpath),true);
filewriter.println(writer.toString());
filewriter.close();

结果：

<HTML>
名称地址年龄

Velocity jakarta.apache.orgvelocityindex.html 2

Log4J jakarta.apache.orglog4jdocsindex.html 2
HTML>

    #IF语句完成逻辑判断，这个我想不用多说了。
    allCustomer对象包含零个或者多个Customer对象。由于ArrayList(List,HashMap,HashTable,Iterator,Vector等)属于Java Collections Framework的一部分，我们可以用#foreach指令迭代其内容。我们不用担心如何定型对象的类型——映像引擎会为我们完成这个任务。#foreach指令的一般格式是“#foreach in ”。#foreach指令迭代list，把list中的每个元素放入item参数，然后解析#foreach块内的内容。对于list内的每个元素，#foreach块的内容都会重复解析一次。从效果上看，它相当于告诉模板引擎说：“把list中的每一个元素依次放入item变量，每次放入一个元素，输出一次#foreach块的内容”。

    MVC设计模型：
    使用模板引擎最大的好处在于，它分离了代码（或程序逻辑）和表现（输出）。由于这种分离，你可以修改程序逻辑而不必担心邮件消息本身；类似地，你（或公关部门的职员）可以在不重新编译程序的情况下，重新编写客户列表。实际上，我们分离了系统的数据模式（Data Model，即提供数据的类）、控制器（Controller，即客户列表程序）以及视图（View，即模板）。这种三层体系称为Model-View-Controller模型（MVC）。如果遵从MVC模型，代码分成三个截然不同的层，简化了软件开发过程中所有相关人员的工作。结合模板引擎使用的数据模式可以是任何Java对象，最好是使用Java Collection Framework的对象。控制器只要了解模板的环境（如VelocityContext），一般这种环境都很容易使用。一些关系数据库的“对象-关系”映射工具能够和模板引擎很好地协同，简化JDBC操作；对于EJB，情形也类似。模板引擎与MVC中视图这一部分的关系更为密切。模板语言的功能很丰富、强大，足以处理所有必需的视图功能，同时它往往很简单，不熟悉编程的人也可以使用它。模板语言不仅使得设计者从过于复杂的编程环境中解脱出来，而且它保护了系统，避免了有意或无意带来危险的代码。例如，模板的编写者不可能编写出导致无限循环的代码，或侵占大量内存的代码。不要轻估这些安全机制的价值；大多数模板编写者不懂得编程，从长远来看，避免他们接触复杂的编程环境相当于节省了你自己的时间。许多模板引擎的用户相信，在采用模板引擎的方案中，控制器部分和视图部分的明确分离，再加上模板引擎固有的安全机制，使得模板引擎足以成为其他内容发布系统（比如JSP）的替代方案。因此，Java模板引擎最常见的用途是替代JSP也就不足为奇了。
    HTML处理：
    由于人们总是看重模板引擎用来替换JSP的作用，有时他们会忘记模板还有更广泛的用途。到目前为止，模板引擎最常见的用途是处理HTML Web内容。但我还用模板引擎生成过SQL、email、XML甚至Java源代码。

TrampEagle 2006-05-31 22:03 发表评论

DisplayTag应用

TrampEagle — Mon, 29 May 2006 10:24:00 GMT

引自：
--  作者：bibiye
--  发布时间：2005-12-16 13:18:07

--  DisplayTag应用
DisplayTag是一个非常好用的表格显示标签，适合MVC模式，其主页在http://displaytag.sourceforge.net
一、最简单的情况，未使用标签
  <%request.setAttribute( "test", new ReportList(6) );%>

  标签遍历List里的每一个对象，并将对象里的所有属性显示出来。一般用于开发的时候检查对象数据的完整性。

二、使用标签的情况







   property对应List里对象的属性（用getXXX()方法取得），title则对应表格表头里的列名。定义列有两种方式：
   A、
      使用标签里的property属性来定义
   B、email@it.com
      在标签体里增加内容，可以是常量，也可以用其他标签等等
   两种方式比较，用property属性来定义更加快速和利于排序。

三、表格显示样式的定义
  A、在和标签里指定标准的html属性，烦琐
  B、修改样式表







   通过class属性来指定所要应用的样式。可以在其默认样式表里（./css/screen.css）直接修改

四、标签取得数据的数据源
  有四种范围
   pageScope
   requestScope (默认)
   sessionScope   注意，这里要指定范围，非默认
   applicationScope

五、通过增加id属性创建隐含的对象



    static
    <%=pageContext.getAttribute("testit_rowNum")%>
    <%=((ListObject)pageContext.getAttribute("testit")).getMoney()%>

   注意到在里增加了id属性，这时就在page context里创建了一个隐含对象，指向List里的当前对象，
   可以通过(ListObject)pageContext.getAttribute("id")来捕获这个对象。同时还创建了一个id_rowNum对象，同样，可
   通过pageContext.getAttribute("testit_rowNum")来捕获，它仅仅代表当前行的行数。
   有了这两个隐含对象，就可以通过其他标签来访问，例如Jstl:










六、显示部分数据
   显示开始五条数据：通过设定length属性





   显示第三到第八条数据：通过设定offset和length属性

七、对email和url地址的直接连接





如果要显示的对象里包含email和url地址，则可以在display:column里直接设定autolink="true"来直接连接

八、使用装饰模式转换数据显示（写自己的 decorator ）
  A、对整个表格应用decorator







    org.displaytag.sample.Wrapper即自己写的decorator，它要继承TableDecorator类，看看它的一个方法：
        public String getMoney()
    {
        return this.moneyFormat.format(((ListObject) this.getCurrentRowObject()).getMoney());
    }
    很明显，它通过父类的getCurrentRowObject()方法获得当前对象，然后对其getMoney()方法进行‘油漆’
  B、对单独的column应用decorator






    org.displaytag.sample.LongDateWrapper要实现ColumnDecorator接口，它的方法：
        public final String decorate(Object columnValue)
    {
        Date date = (Date) columnValue;
        return this.dateFormat.format(date);
    }
    显然，它获得不了当前对象（因为它实现的是接口），仅仅是获得该对象的columnValue，然后‘油漆’

九、创建动态连接
   有两种方法创建动态连接：
   A、在里通过增加href、paramId、paramName、paramScope、paramProperty属性
      href             基本的URL 地址
      paramId          加在URL 地址后的参数名称
      paramName        数据bean的名称，一般为null（即使用当前List里的对象）
      paramScope       数据bean的范围，一般为null
      paramProperty    数据bean的属性名称，用来填充URL 地址后的参数值





    这种方法简便直接，但缺点是无法产生类似details.jsp?id=xx&action=xx的复合URL
   B、应用decorator 创建动态连接：





   org.displaytag.sample.Wrapper里的方法：
public String getLink1()
{
  ListObject lObject= (ListObject)getCurrentRowObject();
  int lIndex= getListIndex();
  return "" + lObject.getId() + "";
}

public String getLink2()
{
ListObject lObject= (ListObject)getCurrentRowObject();
int lId= lObject.getId();

  return "   + "&action=view\\">View | "
   + "   + "&action=edit\\">Edit | "
   + "   + "&action=delete\\">Delete";
}

十、分页
实现分页非常的简单，增加一个pagesize属性指定一次想显示的行数即可

十一、排序
   排序实现也是很简单，在需要排序的column里增加sortable="true"属性，headerClass="sortable"仅仅是
   指定显示的样式。column里的属性对象要实现Comparable接口，如果没有的话可以应用decorator
   defaultsort="1"              默认第一个column排序
   defaultorder="descending"    默认递减排序






  注意的是，当同时存在分页时排序仅仅针对的是当前页面，而不是整个List都进行排序

十二、column 分组
   分组只是需要在column里增加group属性

十三、导出数据到其他格式（页面溢出filter??）
   在里设定export="true"
   在里设定media="csv excel xml pdf" 决定该字段在导出到其他格式时被包不包含，不设定则都包含

   决定该种格式能不能在页面中导出

十四、配置属性，覆盖默认
  两种方法：
  A、在程序classpath下新建displaytag.properties文件
  B、对于单个表格，应用标签
  具体可配置的属性：http://displaytag.sourceforge.net/configuration.html

十五、一个完整的例子






   sort="list" 对整个list进行排序
   导出数据到其他格式时，group无效

解决DisplayTag有中文条件时的分页问题 (转自：http://blog.donews.com/lveyo/archive/2006/04/27/848346.aspx)

很早就开始用DisplayTag了，真得很方便，不用考虑分页，表格等问题。

但是有一个问题一直困扰我，就是有中文作为表单提交内容的时候，翻页就不能用了，中文变成了乱码。

表单传送时， form的提交采用的是Post方法，这没错，但链接采用的是Get方法，问题就出在这里，因为和Tomcat4相比，Tomcat5的post和get采用的方式不再相同了，汉字编码的实现方式也不同了。

Post是将地址传送一次，将form的数据单独提交，而Get则是将地址和参数一起传送，传送的不止是form的数据。

默认情况下，Tomcat对请求采用的默认编码是ISO-8859-1，这样我们提交的汉字被认为是ISO-8859-1的编码，所以在程序中接收时显示乱码。在过滤器中调用request.setCharacterEncoding("GBK")，那么Post上来的汉字将被认为是GBK编码，而Tomcat5对于Get请求上来的编码并不根据过滤器的设定辨认编码方式，默认的依然是ISO-8859-1，所以，即使你的页面使用默认的编码方式进行编码，然后使用ISO-8859-1进行解码，得到的结果也不对。

解决方法：
在Server.xml的connector部分设定URIEncoding的值，根据编码方式指定自己的值就可以了
例如：URIEncoding="GB2312"

TrampEagle 2006-05-29 18:24 发表评论

EasyJWeb－Velocity脚本教程

TrampEagle — Fri, 07 Apr 2006 08:57:00 GMT

引自：http://www.easyjf.com/easyjweb/velocity.htm

Velocity是一个基于java的模板引擎（template engine）。它允许任何人仅仅简单的使用模板语言（template language）来引用由java代码定义的对象。当Velocity应用于web开发时，界面设计人员可以和java程序开发人员同步开发一个遵循MVC架构的web站点，也就是说，页面设计人员可以只关注页面的显示效果，而由java程序开发人员关注业务逻辑编码。Velocity将java代码从web页面中分离出来，这样为web站点的长期维护提供了便利，同时也为我们在JSP和PHP之外又提供了一种可选的方案。

官方网站：http://jakarta.apache.org/velocity/

Velocity脚本摘要
1、声明:#set ($var=XXX)
左边可以是以下的内容
Variable reference
String literal
Property reference
Method reference
Number literal #set ($i=1)
ArrayList #set ($arr=["yt1","t2"])
技持算术运算符

2、注释:
单行## XXX
多行#* xxx
xxxx
xxxxxxxxxxxx*#

References 引用的类型
3、变量 Variables
以 "$" 开头，第一个字符必须为字母。character followed by a VTL Identifier. (a .. z
or A .. Z).
变量可以包含的字符有以下内容：
alphabetic (a .. z, A .. Z)
numeric (0 .. 9)
hyphen ("-")
underscore ("_")

4、Properties
$Identifier.Identifier
$user.name
hashtable user中的的name值.类似：user.get("name")

5、Methods
object user.getName() = $user.getName()

6、Formal Reference Notation
用{}把变量名跟字符串分开

如
#set ($user="csy"}
${user}name
返回csyname

$username
$!username
$与$!的区别
当找不到username的时候，$username返回字符串"$username"，而$!username返回空字符串""

7、双引号与引号
#set ($var="helo")
test"$var" 返回testhello
test'$var' 返回test'$var'
可以通过设置 stringliterals.interpolate=false改变默认处理方式

8、条件语句
#if( $foo )
Velocity!
#end
#if($foo)
#elseif()
#else
#end
当$foo为null或为Boolean对象的false值执行.

9、逻辑运算符:== && || !

10、循环语句#foreach($var in $arrays ) // 集合包含下面三种Vector, a Hashtable or an Array
#end
#foreach( $product in $allProducts )

$product

#end

#foreach( $key in $allProducts.keySet() )

Key: $key -> Value: $allProducts.get($key)

#end

#foreach( $customer in $customerList )
$velocityCount$customer.Name
#end
11、velocityCount变量在配置文件中定义
# Default name of the loop counter
# variable reference.
directive.foreach.counter.name = velocityCount
# Default starting value of the loop
# counter variable reference.
directive.foreach.counter.initial.value = 1

12、包含文件
#include( "one.gif","two.txt","three.htm" )

13、Parse导入脚本
#parse("me.vm" )

14、#stop 停止执行并返回

15、定义宏Velocimacros ,相当于函数支持包含功能
#macro( d )

#end
调用
#d()

16、带参数的宏
#macro( tablerows $color $somelist )
#foreach( $something in $somelist )
$something
#end
#end

17、Range Operator
#foreach( $foo in [1..5] )

Velocity用户手册---中文版 (来源网络)

Velocity是什么？

Velocity是一个基于java的模板引擎（template engine）。它允许任何人仅仅简单的使用模板语言（template language）来引用由java代码定义的对象。

当Velocity应用于web开发时，界面设计人员可以和java程序开发人员同步开发一个遵循MVC架构的web站点，也就是说，页面设计人员可以只关注页面的显示效果，而由java程序开发人员关注业务逻辑编码。Velocity将java代码从web页面中分离出来，这样为web站点的长期维护提供了便利，同时也为我们在JSP和PHP之外又提供了一种可选的方案。

Velocity的能力远不止web站点开发这个领域，例如，它可以从模板（template）产生SQL和PostScript、XML，它也可以被当作一个独立工具来产生源代码和报告，或者作为其他系统的集成组件使用。Velocity也可以为Turbine web开发架构提供模板服务（template service）。Velocity+Turbine提供一个模板服务的方式允许一个web应用以一个真正的MVC模型进行开发。

Velocity能为我们作什么？

The Mud Store Example

假设你是一家专门出售Mud的在线商店的页面设计人员，让我们暂且称它为“在线MUD商店”。你们的业务很旺，客户下了各种类型和数量的mud订单。他们都是通过输入用户名和密码后才登陆到你的网站，登陆后就允许他们查看订单并购买更多的mud。现在，一种非常流行的mud正在打折销售。另外有一些客户规律性的购买另外一种也在打折但是不是很流行的Bright Red Mud，由于购买的人并不多所以它被安置在页面的边缘。所有用户的信息都是被跟踪并存放于数据库中的，所以某天有一个问题可能会冒出来：为什么不使用velocity来使用户更好的浏览他们感兴趣的商品呢？

Velocity使得web页面的客户化工作非常容易。作为一个web site的设计人员，你希望每个用户登陆时都拥有自己的页面。

你会见了一些公司内的软件工程师，你发现他们每个人都同意客户应该拥有具有个性化的信息。那让我们把软件工程师应该作的事情发在一边，看一看你应该作些什么吧。

你可能在页面内嵌套如下的VTL声明：

Hello $customer.Name!

#foreach( $mud in $nudsOnSpecial )

#if ( $customer.hasPurchased( $mud ) )

#end

$flogger.getPromo( $mud )

Velocity Template Language(VTL):AN introduction

VTL意味着提供最简单、最容易并且最整洁的方式合并页面动态内容。

VTL使用references来在web site内嵌套动态内容，一个变量就是一种类型的reference。变量是某种类型的refreence，它可以指向java代码中的定义，或者从当前页面内定义的VTL statement得到值。下面是一个VTL statement的例子，它可以被嵌套到HTML代码中：

#set ( $a = “Velocity” )

和所有的VTL statement一样，这个statement以＃字符开始并且包含一个directive：set。当一个在线用户请求你的页面时，Velocity Templating Engine将查询整个页面以便发现所有＃字符，然后确定哪些是VTL statement，哪些不需要VTL作任何事情。

＃字符后紧跟一个directive：set时，这个set directive使用一个表达式（使用括号封闭）――一个方程式分配一个值给变量。变量被列在左边，而它的值被列在右边，最后他们之间使用＝号分割。

在上面的例子中，变量是$a，而它的值是Velocity。和其他的references一样以$字符开始，而值总是以双引号封闭。Velocity中仅有String可以被赋值给变量。

记住以下的规则：

使用$字符开始的references用于得到什么；使用#字符开始的directives用于作些什么。

Hello Velocity World!

一旦某个变量被分配了一个值，那么你就可以在HTML文件的任何地方引用它。在下面的例子中，一个值被分配给$foo变量，并在其后被引用。

#set ( $foo = “Velocity” )

Hello $foo World!

上面的实现结果是在页面上打印“Hello Velocity World！”

为了使包含VTL directives的statement更具有可读性，我们鼓励你在新行开始每个VTL statement，尽管你不是必须这么作。Set directive将在后面详细描述。

注释

单行注释：

## This is a single line comment.

多行注释：

Thus begins a multi-line comment. Online visitors won't

see this text because the Velocity Templating Engine will

ignore it.

文档格式：

#**

This is a VTL comment block and

may be used to store such information

as the document author and versioning

information:

@version 5

@author

References

在VTL中有三种类型的references：变量(variables)、属性(properties)、方法(methods)。作为一个使用VTL的页面设计者，你和你的工程师必须就references的名称达成共识，以便你可以在你的template中使用它们。

Everything coming to and from a reference被作为一个String对象处理。如果有一个对象$foo是一个Integer对象，那么Velocity将调用它的toString()方法将这个对象转型为String类型。

变量

格式要求同java。

属性

例子：

$customer.Address

$purchase.Total

$customer.Address有两种含义。它可以表示：查找hashtable对象customer中以Address为关键字的值；也可以表示调用customer对象的getAddress()方法。当你的页面被请求时，Velocity将确定以上两种方式选用那种，然后返回适当的值。

方法

一个方法就是被定义在java中的一段代码，并且它有完成某些有用工作的能力，例如一个执行计算和判断条件是否成立、满足等。方法是一个由$开始并跟随VTL标识符组成的References，一般还包括一个VTL方法体。例如：

$customer.getAddress()

$purchase.getTotal()

$page.setTitle( “My Home Page” )

$person.setAttributes( [“Strange”, “Weird”, “Excited”] )

前两个例子$customer.getAddress()和$purchase.getTotal()看起来挺想上面的属性$customer.Address 和 $purchase.Total。如果你觉得他们之间有某种联系的话，那你是正确的。

VTL属性可以作为VTL方法的缩写。$customer.Address属性和使用$customer.getAddress()方法具有相同的效果。如果可能的话使用属性的方式是比较合理的。属性和方法的不同点在于你能够给一个方法指定一个参数列表。

正式reference标记

reference的正是格式如下：

${mudSlinger}变量

${customer.Address}属性

${purchase.getTotal()}方法

非正是格式更见常用，但是有时还是使用正是格式比较适合。例如：你希望通过一个变量$vice来动态的组织一个字符串。

Jack is a $vicemaniac.

本来变量是$vice现在却变成了$vicemaniac，这样Veloctiy就不知道您到底要什么了。所以，应该使用正是格式书写

Jack is a ${vice}maniac

现在Velocity知道变量是$vice而不是$vicemaniac。

Quiet reference notation

例如：

当页面的form被初始加载时，变量$email还没有值，这时你肯定是希望它能够显示一个blank text来代替输出”$email”这样的字段。那么使用quiet reference notation就比较合适。

这样文本框的初始值就不会是email而是空值了。

正式和quiet格式的reference notation也可一同使用，像下面这样：

Getting literal

Velocity使用特殊字符$和#来帮助它工作，所以如果要在template里使用这些特殊字符要格外小心。本节将讨论$字符。

货币字符

在VTL中使用$2.5这样的货币标识是没有问题得的，VTL不会将它错认为是一个reference，因为VTL中的reference总是以一个大写或者小写的字母开始。

Escaping valid VTL reference

VTL中使用“\\”作为逃逸符。

例如：

#set( $email = “foo” )

$email

\\$email

\\\\$email

\\\\\\$email

将render为：

foo

$email

\\foo

\\\\$email

如果email变量没有被定义则

$email

\\$email

\\\\$email

\\\\\\$email

将被render为：

$email

\\$email

\\\\$email

\\\\\\$email

注意：VTL中未被定义的变量将被认为是一个字符串，所以以下例子：

#set( $foo = “gibbous” )

$moon = $foo

的输出结果是：

$moon = gibbous

Case substitution

现在你已经对reference比较熟悉了，你可以将他们高效的应用于你的template了。Velocity利用了很多java规范以方便了设计人员的使用。例如：

$foo

$foo.getBar()

## is the same as

$foo.Bar

$data.getUser(“jon”)

## is the same as

$data.User(“jon”)

$data.getRequest().getServerName()

# is the same as

$data.Request.ServerName

## is the same as

${data.Request.ServerName}

但是，注意VTL中不会将reference解释为对象的实例变量。例如：$foo.Name将被解释为Foo对象的getName（）方法，而不是Foo对象的Name实例变量。

Directives

Reference允许设计者使用动态的内容，而directive使得你可以应用java代码来控制你的显示逻辑，从而达到你所期望的显示效果。

#set

#set directive被用于设置一个reference的值。例如：

#set ( $primate = “monkey” )

#set ( $customer.Behavior = $primate )

赋值左侧的（LHS）必须是一个变量或者属性reference。右侧（RHS）可以是以下类型中一种：

l变量reference

lString literal

l属性reference

l方法reference

lnumber literal

lArrayList

下面是应用各种类型的RHS的例子：

＃set ( $monkey = $bill ) ##变量reference

＃set ( $monkey.Friend = “monica” ) ##String literal

＃set ( $monkey.Blame = $whitehouse.Leak )##属性reference

＃set ( $monkey.Plan = $spindoctor.weave($web) )##方法reference

＃set ( $monkey.Number = 123 )##Number literal

＃set ( $monkey.Say = [“Not”, $my, “fault”] )##ArrayList

注意：最后一个例子的取值方法为：$monkey.Say.get(0)

RHS也可以是一个简单的算术表达式：

#set ( $value = $foo + 1 )

#set ( $value = $bar -1 )

#set ( $value = $foo * $bar )

#set ( $value = $foo / $bar )

如果你的RHS是一个null，VTL的处理将比较特殊：它将指向一个已经存在的reference，这对初学者来讲可能是比较费解的。例如：

#set ( $resut = $query.criteria(“name”) )

The result of the first query is $result

#set ( $resut = $query.criteria(“address”) )

The result of the second query is $result

如果$query.criteria(“name”)返回一个“bill”，而$query.criteria(“address”)返回的是null，则显示的结果如下：

The result of the first query is bill

看看下面的例子：

#set( $criteria = ["name", "address"] )

#foreach( $criterion in $criteria )

#set( $result = $query.criteria($criterion) )

#if( $result )

Query was successful

#end

在上面的例子中，程序将不能智能的根据$result的值决定查询是否成功。在$result被#set后（added to the context），它不能被设置回null（removed from the context）。打印的结果将显示两次查询结果都成功了，但是实际上有一个查询是失败的。

为了解决以上问题我们可以通过预先定义的方式：

#set( $criteria = [“name”, “address”] )

#foreach( $criterion in $criteria )

#set( $result = false )

#set( $result = $query.criteria( $criterion ) )

#if( $result )

Query was successful

#end

String Literals

当你使用#set directive，String literal封闭在一对双引号内。

#set ( $directoryRoot = “www” )

#set ( $templateName = “index.vm” )

#set ( $template = “$directoryRoot/$tempateName” )

$template

上面这段代码的输出结果为：www/index.vm

但是，当string literal被封装在单引号内时，它将不被解析：

#set ( $foo = “bar” )

$foo

#set ( $blargh = ‘$foo' )

结果：

bar

$foo

上面这个特性可以通过修改velocity.properties文件的stringliterals.interpolate = false的值来改变上面的特性是否有效。

条件语句

if/elseif/else

当一个web页面被生成时使用Velocity的#if directrive，如果条件成立的话可以在页面内嵌入文字。例如：

#if ( $foo )

Velocity!

#end

上例中的条件语句将在以下两种条件下成立：

l$foo是一个boolean型的变量，且它的值为true

l$foo变量的值不为null

这里需要注意一点：Velocity context仅仅能够包含对象，所以当我们说“boolean”时实际上代表的时一个Boolean对象。即便某个方法返回的是一个boolean值，Velocity也会利用内省机制将它转换为一个Boolean的相同值。

如果条件成立，那么#if和#end之间的内容将被显示。

#elseif和#else元素可以同#if一同使用。例如：

#if( $foo < 10 )

Go North

#elseif( $foo == 10 )

Go East

#elseif( $foo == 6 )

Go South

#else

Go West

#end

注意这里的Velocity的数字是作为Integer来比较的――其他类型的对象将使得条件为false，但是与java不同它使用“＝＝”来比较两个值，而且velocity要求等号两边的值类型相同。

关系、逻辑运算符

Velocity中使用等号操作符判断两个变量的关系。例如：

#set ( $foo = “deoxyribonucleic acid” )

#set ( $bar = “ribonucleic acid” )

#if ( $foo == $foo )

In this case it's clear they aren't equivalent.So…

#else

They are not equivalent and this will be the output.

#end

Velocity有AND、OR和NOT逻辑运算符。下面是一些例子：

## logical AND

#if( $foo && $bar )

This AND that

#end

## logical OR

#if ( $foo || $bar )

This OR That

#end

##logical NOT

#if ( !$foo )

NOT that

#end

循环

Foreach循环

例子：

#foreach ( $product in $allProducts )

$product

#end

每次循环$allProducts中的一个值都会赋给$product变量。

$allProducts可以是一个Vector、Hashtable或者Array。分配给$product的值是一个java对象，并且可以通过变量被引用。例如：如果$product是一个java的Product类，并且这个产品的名字可以通过调用他的getName（）方法得到。

现在我们假设$allProducts是一个Hashtable，如果你希望得到它的key应该像下面这样：

#foreach ( $key in $allProducts.keySet() )

Key: $key -> Value: $allProducts.get($key)

#end

Velocity还特别提供了得到循环次数的方法，以便你可以像下面这样作：

#foreach ( $customer in $customerList )

#end

$velocityCount

$customer.Name

$velocityCount变量的名字是Velocity默认的名字，你也可以通过修改velocity.properties文件来改变它。默认情况下，计数从“1”开始，但是你可以在velocity.properties设置它是从“1”还是从“0”开始。下面就是文件中的配置：

# Default name of loop counter

# variable reference

directive.foreach.counter.name = velocityCount

# Default starting value of the loop

# counter variable reference

directive.foreach.counter.initial.value = 1

include

#include script element允许模板设计者引入本地文件。被引入文件的内容将不会通过模板引擎被render。为了安全的原因，被引入的本地文件只能在TEMPLATE_ROOT目录下。

#inclued ( “one.txt” )

如果您需要引入多个文件，可以用逗号分隔就行：

#include ( “one.gif”, “two.txt”, “three.htm” )

在括号内可以是文件名，但是更多的时候是使用变量的：

#inclue ( “greetings.txt”, $seasonalstock )

parse

#parse script element允许模板设计者一个包含VTL的本地文件。Velocity将解析其中的VTL并render模板。

#parse( “me.vm” )

就像#include，#parse接受一个变量而不是一个模板。任何由#parse指向的模板都必须包含在TEMPLATE_ROOT目录下。与#include不同的是，#parse只能指定单个对象。

你可以通过修改velocity.properties文件的parse_direcive.maxdepth的值来控制一个template可以包含的最多#parse的个数――默认值是10。#parse是可以递归调用的，例如：如果dofoo.vm包含如下行：

Count down.

#set ( $count = 8 )

#parse ( “parsefoo.vm” )

All done with dofoo.vm!

那么在parsefoo.vm模板中，你可以包含如下VTL：

$count

#set ( $count = $count – 1 )

#if ( $count > 0 )

#parse( “parsefoo.vm” )

#else

All done with parsefoo.vm!

#end

的显示结果为：

Count down.

All done with parsefoo.vm!

All done with dofoo.vm!

Stop

#stop script element允许模板设计者停止执行模板引擎并返回。把它应用于debug是很有帮助的。

#stop

Velocimacros

#macro script element允许模板设计者定义一段可重用的VTL template。例如：

#macro ( d )

#end

在上面的例子中Velocimacro被定义为d，然后你就可以在任何VTL directive中以如下方式调用它：

#d()

当你的template被调用时，Velocity将用替换为#d()。

每个Velocimacro可以拥有任意数量的参数――甚至0个参数，虽然定义时可以随意设置参数数量，但是调用这个Velocimacro时必须指定正确的参数。下面是一个拥有两个参数的Velocimacro，一个参数是color另一个参数是array：

#macro ( tablerows $color $somelist )

#foreach ( $something in $somelist )

$something

#end

调用#tablerows Velocimacro：

#set ( $greatlakes = [ “Superior”, “Michigan”, “Huron”, “Erie”, “Ontario” ] )

#set ( $color = “blue” )

#tablerows( $color $greatlakes )

经过以上的调用将产生如下的显示结果：

Superior

Michigan

Huron

Erie

Ontario

Velocimacros可以在Velocity模板内实现行内定义（inline），也就意味着同一个web site内的其他Velocity模板不可以获得Velocimacros的定义。定义一个可以被所有模板共享的Velocimacro显然是有很多好处的：它减少了在一大堆模板中重复定义的数量、节省了工作时间、减少了出错的几率、保证了单点修改。

上面定义的#tablerows( $color $list )Velocimacro被定义在一个Velocimacros模板库(在velocity.properties中定义)里，所以这个macro可以在任何规范的模板中被调用。它可以被多次应用并且可以应用于不同的目的。例如下面的调用：

#set ( $parts = [ “volva”, “stipe”, “annulus”, “gills”, “pileus” ] )

#set ( $cellbgcol = “#CC00FF” )

#tablerows( $cellbgcol $parts )

上面VTL将产生如下的输出：

volva

stipe

annulus

gills

pileus

Velocimacro arguments

Velocimacro可以使用以下任何元素作为参数：

lReference：任何以$开头的reference

lString literal：

lNumber literal：

lIntegerRange：[1….3]或者[$foo….$bar]

l对象数组：[“a”,”b”,”c”]

lboolean值：true、false

当将一个reference作为参数传递给Velocimacro时，请注意reference作为参数时是以名字的形式传递的。这就意味着参数的值在每次Velocimacro内执行时才会被产生。这个特性使得你可以将一个方法调用作为参数传递给Velocimacro，而每次Velocimacro执行时都是通过这个方法调用产生不同的值来执行的。例如：

#macro ( callme $a )

$a $a $a

#end

#callme( $foo.bar() )

执行的结果是：reference $foo的bar（）方法被执行了三次。

如果你不需要这样的特性可以通过以下方法：

#set ( $myval = $foo.bar() )

#callme ( $myval )

Velocimacro properties

Velocity.properties文件中的某几行能够使Velocimacros的实现更加灵活。注意更多的内容可以看Developer Guide。

Velocity.properties文件中的velocimacro.libraary：一个以逗号分隔的模板库列表。默认情况下，velocity查找唯一的一个库：VM_global_library.vm。你可以通过配置这个属性来指定自己的模板库。

Velocity.properties文件中的velocimacro.permissions.allow.inline属性：有两个可选的值true或者false，通过它可以确定Velocimacros是否可以被定义在regular template内。默认值是ture――允许设计者在他们自己的模板中定义Velocimacros。

Velocity.properties文件中的

velocimacro.permissions.allow.inline.replace.global属性有两个可选值true和false，这个属性允许使用者确定inline的Velocimacro定义是否可以替代全局Velocimacro定义（比如在velocimacro.library属性中指定的文件内定义的Velocimacro）。默认情况下，此值为false。这样就阻止本地Velocimacro定义覆盖全局定义。

Velocity.properties文件中的

velocimacro.permissions.allow.inline.local.scale属性也是有true和false两个可选值，默认是false。它的作用是用于确定你inline定义的Velocimacros是否仅仅在被定义的template内可见。换句话说，如果这个属性设置为true，一个inline定义的Velocimacros只能在定义它的template内使用。你可以使用此设置实现一个奇妙的VM敲门：a template can define a private implementation of the second VM that will be called by the first VM when invoked by that template. All other templates are unaffected。

Velocity.properties文件中的velocimacro.context.localscope属性有true和false两个可选值，默认值为false。当设置为true时，任何在Velocimacro内通过#set()对context的修改被认为是针对此velocimacro的本地设置，而不会永久的影响内容。

Velocity.properties文件中的velocimacro.library.autoreload属性控制Velocimacro库的自动加载。默认是false。当设置为ture时，对于一个Velocimacro的调用将自动检查原始库是否发生了变化，如果变化将重新加载它。这个属性使得你可以不用重新启动servlet容器而达到重新加载的效果，就像你使用regular模板一样。这个属性可以使用的前提就是resource loader缓存是off状态（file.resource.loader.cache = false）。注意这个属性实际上是针对开发而非产品的。

Velocimacro Trivia

Velocimacro必须被定义在他们被使用之前。也就是说，你的#macro()声明应该出现在使用Velocimacros之前。

特别要注意的是，如果你试图#parse()一个包含#macro()的模板。因为#parse()发生在运行期，但是解析器在parsetiem决定一个看似VM元素的元素是否是一个VM元素，这样#parse()-ing一组VM声明将不按照预期的样子工作。为了得到预期的结果，只需要你简单的使用velocimacro.library使得Velocity在启动时加载你的VMs。

Escaping VTL directives

VTL directives can be escaped with “\\”号，使用方式跟VTL的reference使用逃逸符的格式差不多。

## #include( “a.txt” ) renders as (注释行)

#include( “a.txt” )

## \\#include( “a.txt” ) renders as \\#include( “a.txt” )

\\#include( “a.txt” )

## \\\\#include ( “a.txt” ) renders as \\

\\\\#include( “a.txt” )

在对在一个directive内包含多个script元素的VTL directives使用逃逸符时要特别小心（比如在一个if-else-end statement内）。下面是VTL的if-statement的典型应用：

#if ( $jazz )

Vyacheslav Ganelin

#end

如果$jazz是ture，输出将是：

Vyacheslav Ganelin

如果$jazz是false，将没有输出。使用逃逸符将改变输出。考虑一下下面的情况：

\\#if ( $jazz )

Vyacheslav Ganelin

\\#end

现在无论$jazz是true还是false，输出结果都是：

#if ( $jazz )

Vyacheslav Ganelin

#end

事实上，由于你使用了逃逸符，$jazz根本就没有被解析为boolean型值。在逃逸符前使用逃逸符是合法的，例如：

\\\\#if ( $jazz )

Vyacheslav Ganelin

\\\\#end

以上程序的显示结果为：

\\ Vyacheslav Ganelin

但是如果$jazz为false，那么将没有输出。（书上说会没有输出，但是我觉得应该还有有“\\”字符被输出。）

VTL：Formatting issues

尽管在此用户手册中VTL通常都开始一个新行，如下所示：

#set ( $imperial = [ “Munetaka”, “Koreyasu”, “Hisakira”, “Morikune” ] )

#foreach ( $shogun in $imperial )

$shogun

#end

但是像下面这种写法也是可以的：

Send me #set($foo = [“$10 and”,”a cake”])#foreach($a in $foo)$a #end please.

上面的代码可以被改写为：

Send me

#set ( $foo = [“$10 and “,”a cake”] )

#foreach ( $a in $foo )

#end

please.

或者

Send me

#set($foo = [“$10 and “,”a cake”])

#foreach （$a in $foo ）$a

#end please.

这两种的输出结构将一样。

其他特性和杂项

math 在模板中可以使用Velocity内建的算术函数，如：加、减、乘、除

#set ( $foo = $bar + 3 )

#set ( $foo = $bar - 4 )

#set ( $foo = $bar * 6 )

#set ( $foo = $bar / 2 )

当执行除法时将返回一个Integer类型的结果。而余数你可以使用%来得到：

#set ( $foo = $bar % 5 )

在Velocity内使用数学计算公式时，只能使用像-n,-2,-1,0,1,2,n这样的整数，而不能使用其它类型数据。当一个非整型的对象被使用时它将被logged并且将以null作为输出结果。

Range Operator

Range operator可以被用于与#set和#foreach statement联合使用。对于处理一个整型数组它是很有用的，Range operator具有以下构造形式：

[n..m]

m和n都必须是整型，而m是否大于n则无关紧要。例子：

First example:

#foreach ( $foo in [1..5] )

$foo

#end

Second example:

#foreach ( $bar in [2..-2] )

$bar

#end

Third example:

#set ( $arr = [0..1] )

#foreach ( $i in $arr )

#end

Fourth example:

[1..3]

上面四个例子的输出结果为：

First example：

1 2 3 4 5

Second example：

2 1 0 -1 -2

Third example：

0 1

Fourth example：

[1..3]

注意：range operator只在#set和#foreach中有效。

Advanced Issue：Escaping and！

当一个reference被“！”分隔时，并且在它之前有逃逸符时，reference将以特殊的方式处理。注意这种方式与标准的逃逸方式时不同的。对照如下：

#set ( $foo = “bar” )

特殊形式标准格式

Render前Render后Render前Render后

$\\!foo$!foo\\$foo\\$foo

$\\!{foo}$!{foo}\\$!foo\\$!foo

$\\\\!foo$\\!foo\\$!{foo}\\$!{foo}

$\\\\\\!foo$\\\\!foo\\\\$!{foo}\\bar

Velocimacro杂记

Can I user a directive or another VM as an argument to a VM?

例如：#center ( #bold( “hello” ) )

不可以。一个directive的参数使用另外一个directive是不合法的。

但是，还是有些事情你可以作的。最简单的方式就是使用双引号：

#set ( $stuff = “#bold( ‘hello' )” )

#center ( $stuff )

上面的格式也可以缩写为一行：

#center ( “#bold( ‘hello' ) )

请注意在下面的例子中参数被evaluated在Velocimacro内部，而不是在calling level。例子：

#macro ( inner $foo )

inner : $foo

#end

#macro ( outer $foo )

#set ( $bar = “outerlala” )

outer : $foo

#end

#set ( $bar = ‘calltimelala' )

#outer( “#inner($bar)” )

输出结果为：

outer : inner : outerlala

记住Veloctiy的特性：参数的传递是By Name的。例如：

#macro ( foo $color )

There

#end

#foo ( $bar.rowColor() )

以上代码将导致rowColor()方法两次调用，而不是一次。为了避免这种现象的出现，我们可以按照下面的方式执行：

#set ( $color = $bar.rowColor() )

#foo ( $color )

can I register velocimacros via #parse()?

目前，Velocimacros必须在第一次被模板调用前被定义。这就意味着你的#macro()声明应该出现在使用Velocimacros之前。

如果你试图#parse()一个包含#macro() directive的模板，这一点是需要牢记的。因为#parse()发生在运行期，但是解析器在parsetiem决定一个看似VM元素的元素是否是一个VM元素，这样#parse()-ing一组VM声明将不按照预期的样子工作。为了得到预期的结果，只需要你简单的使用velocimacro.library使得Velocity在启动时加载你的VMs。

What is velocimacro autoreloading？

velocimacro.library.autoreload是专门为开发而非产品使用的一个属性。此属性的默认值是false。

String concatenation

开发人员最常问的问题是我如何作字符拼接？在java中是使用“＋”号来完成的。

在VTL里要想实现同样的功能你只需要将需要联合的reference放到一起就行了。例如：

#set ( $size = “Big” )

#set ( $name = “Ben” )

The clock is $size$name.

输出结果将是：The clock is BigBen.。更有趣的情况是：

#set ( $size = “Big” )

#set ( $name = “Ben” )

#set ( $clokc = “$size$name” )

The clock is $clock.

上例也会得到同样的结果。最后一个例子，当你希望混合固定字段到你的reference时，你需要使用标准格式：

#set ( $size = “Big” )

#set ( $name = “Ben” )

#set ( $clock = “${size}Tall$name” )

The clock is $clock.

输出结果是：The clock is BigTallBen.。使用这种格式主要是为了使得$size不被解释为$sizeTall。

TrampEagle 2006-04-07 16:57 发表评论

lucene全文检索实现流程

TrampEagle — Mon, 20 Feb 2006 06:31:00 GMT

引自：http://www.gamvan.com/developer/java/opener/2005/12/846.html

对于lucene全文检索，可以简约地看看它的7个主要类，这7个类同时也表达了处理全文检索的7个意念。因为数据库比较为人所熟悉，它又与全文检索某些理念极为相似，所以在对下面的概念说明时，将会大量在渗入数据库和全文检索间的类比。
1）Document ：它的中文意思是文档，对于一个文档，通常都包括它的标题、时间、作者、内容。如果让它的意思泛化，它也有文件的意思（相信Lucene的作者在取这个类名的时候也是经过再三斟酌的），对于文件，它可以指一个TXT文本、一个HTML网页、一个PDF文件等等。总而言之，它是映射着某一个具体的文件，这就是它的单位粒度。对应于数据库的概念是记录，英文是Record，weblucene在索引源的xml中就原原本本地采用了这个概念，可参照/dump/blog.xml 。

2）Field ：中文意思是字段。汉语的翻译将这个单词的意思表达得更恰如其分了，意思是文字片段，它可以是一个或多个字。字段是文档（Document）的次粒度单位，也是检索的最基本单位。注意这个概念跟在搜索引擎的输入框中随意输入的那几个字或几组字不是一样的，在搜索输入框中输入的那些文字首先需要经过一个QueryParser（这也是7个类中的一个）将其分解成真正的Field。在数据库中本来就有Field 这个概念，它即是Record的次级单位。在数据库一条或多条记录怎么被找出来的，往往就经由对Field的检索而得来。在全文检索中Document的最终取得也是差不多，它是根据现在的某个Filed来决定的。即根据文档中的某些还不完整的东西牵引出它的所需的全部。
示例代码：

代码内容
[com.chedong.weblucene.search.WebLuceneResultSetTest]
Document doc = new Document();
doc.add(Field.Keyword("keyword", "房地产"));
doc.add(Field.Keyword("keyword", "非典"));

3）IndexWriter ：索引书写者
示例代码：
[org.apache.lucene.index.TestIndexWriter]

代码内容
Document doc = new Document();
doc.add(Field.UnStored("content", "aaa"));
try {
IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true);
writer.addDocument(doc);
}
catch (IOException e) {
e.printStackTrace();
}

它的构造器new IndexWriter(dir, new WhitespaceAnalyzer(), true) 有三个参数，分别是Directory对象、分析器对象（这是下一个要介绍的类）和一个布尔量，是否要重写索引就是由这个布尔量标明的，如果取false则仅仅是将索引附加上来。

4）Analyzer ：分析器，它将目录中的一组原始文件分析成由一组Document和它相应的次级粒度Field组成的索引。因为不同的文件类型，同样的文本其内部文件流组织形式是不一样的，所以需要不同的分析器处理不同的文件类型（如PDFAnalyzer、HtmlAnalyzer）。又因为不同的文字语言处理Field拆分（Token）上是不一样的，所以在语言角度上又有另一层分析器的类别区分，如下面这行代码是处理普通中文字符的
[com.chedong.weblucene.search.WebLuceneResultSetTest]
IndexWriter writer = new IndexWriter(dir, new CJKAnalyzer(), true);

5）QueryParser ：这前面在区分Field和用户输入的搜索关键字时已经提及了。（它所用的词是Query，跟数据库所用的是一个概念的，这个词同样的检索上让人感觉没有像Search那么费尽心思去深究。）QueryParser并没有实际地去做查询工作，它只是Parser（剖析）用户输入的东西，并把剖析的结果以一种规则的形式送给Searcher去执行一个真正的搜索。作为剖析的结果，不仅仅是Field，还有Field们相互间的关系(terms，譬如逻辑和AND，逻辑或OR，逻辑非NOT)。

6）Searcher ：搜索一个Query，将结果返回。
[org.apache.lucene.search..TestNot]

代码内容
RAMDirectory store = new RAMDirectory();
IndexWriter writer = new IndexWriter(store, new SimpleAnalyzer(), true);

Document d1 = new Document();
d1.add(Field.Text("field", "a b"));

writer.addDocument(d1);
writer.optimize();
writer.close();

Searcher searcher = new IndexSearcher(store);
Query query = QueryParser.parse("a NOT b", "field", new SimpleAnalyzer());
//System.out.println(query);
Hits hits = searcher.search(query);

对于每一个搜索器对象，它都需要指定一个索引文件路径，然后由搜索器对Query对象执行查询。上面的这个类袖珍地对7个主要类都均有涉及。

7）Hits ： Lucene的类注释是：A ranked list of documents, used to hold search results. 搜索的结果不仅仅是一些文档，而且这些文档还是有级别的，这个级别是对于先后次序而言的。它对应于数据库中的RecordSet / ResultSet 。

TrampEagle 2006-02-20 14:31 发表评论

Lucene中文分词的高亮[highlight]显示

TrampEagle — Mon, 20 Feb 2006 06:30:00 GMT

引自：http://www.gamvan.com/developer/java/opener/2005/12/849.html

1、问题的来源增加分词以后结果的准确度提高了，但是用户反映返回结果的速度很慢。原因是， Lucene 做每一篇文档的相关关键词的高亮显示时，在运行时执行了很多遍的分词操作。这样降低了性能。
2 、解决方法 
在 Lucene1.4.3 版本中的一个新功能可以解决这个问题。 Term Vector 现在支持保存 Token.getPositionIncrement() 和 Token.startOffset() 以及 Token.endOffset() 信息。利用 Lucene 中新增加的 Token 信息的保存结果以后，就不需要为了高亮显示而在运行时解析每篇文档。通过 Field 方法控制是否保存该信息。修改 HighlighterTest.java 的代码如下：


代码内容
// 增加文档时保存 Term 位置信息。
private void addDoc(IndexWriter writer, String text) throws IOException
{
Document d = new Document();
//Field f = new Field(FIELD_NAME, text, true, true, true);
Field f = new Field(FIELD_NAME, text ,
Field.Store.YES, Field.Index.TOKENIZED,
Field.TermVector.WITH_POSITIONS_OFFSETS);
d.add(f);
writer.addDocument(d);
}
// 利用 Term 位置信息节省 Highlight 时间。
void doStandardHighlights() throws Exception
{
    Highlighter highlighter =new Highlighter(this,new QueryScorer(query));
highlighter.setTextFragmenter(new SimpleFragmenter(20));
for (int i = 0; i < hits.length(); i++)
{
String text = hits.doc(i).get(FIELD_NAME);
int maxNumFragmentsRequired = 2;
String fragmentSeparator = "...";
TermPositionVector tpv = (TermPositionVector)reader.getTermFreqVector(hits.id(i),FIELD_NAME);
// 如果没有 stop words 去除还可以改成 TokenSources.getTokenStream(tpv,true); 进一步提速。
   TokenStream tokenStream=TokenSources.getTokenStream(tpv);
   //analyzer.tokenStream(FIELD_NAME,new StringReader(text));
   String result =
   highlighter.getBestFragments(
 tokenStream,
   text,
   maxNumFragmentsRequired,
       fragmentSeparator);
   System.out.println(" " + result);
}
}

最后把 highlight 包中的一个额外的判断去掉。对于中文来说没有明显的单词界限，所以下面这个判断是错误的：

tokenGroup.isDistinct(token)

这样中文分词就不会影响到查询速度了。

TrampEagle 2006-02-20 14:30 发表评论

Prototype Meets Ruby: A Look at Enumerable, Array and Hash

TrampEagle — Sat, 11 Feb 2006 06:04:00 GMT

原文引自:http://encytemedia.com/blog/articles/2005/12/07/prototype-meets-ruby-a-look-at-enumerable-array-and-hash

Encytemedia

A LOOK AT SOFTWARE DEVELOPMENT, DESIGN, AND OTHER RANDOM BITS.

Working With Events In Prototype

February 08, 2006

Events drive interaction for almost everything and the web is no exception. In the style of my last article on Prototype, lets take a code-heavy look at how Prototype lets us work with events.

NOTE: This article uses Prototype 1.5.0_pre0

Basic event handling

The syntax for working with events looks like the code below.

Event.observe(element, name, observer, [useCapture]);

Assuming for a moment that we want to observe when a link was clicked, we could do the following:

// <a id="clicker" href="http://foo.com">Click mea>
Event.observe('clicker', 'click', function(event){ alert('clicked!');});

If we wanted to get the element that fired the event, we'd do this:

Event.observe('clicker', 'click', function(event){ alert(Event.element(event));});

Observing keystrokes

If we wanted to observe keystrokes for the entire document, we could do the following:

Event.observe(document, 'keypress', function(event){ if(event.keyCode == Event.KEY_TAB) alert('Tab Pressed');});

And lets say we wanted to keep track of what has been typed into your snazzy live-search box:

Event.observe('search', 'keypress', function(event) { Element.update('search-results', $F(Event.element(event)));});

Prototype defines properties inside the event object for some of the more common keys, so feel free to dig around in Prototype to see which ones those are.

A final note on keypress events; If you'd like to detect a left click you can use Event.isLeftClick(event).

Getting the coordinates of the mouse pointer

Drag and drop, dynamic element resizing, games, and much more all require the ability to track the X and Y location of the mouse. Prototype makes this fairly simple. The code below tracks the X and Y position of the mouse and spits out those values into an input box named mouse.

   Event.observe(document, 'mousemove', function(event){$('mouse').value = "X: " + Event.pointerX(event) + "px Y: " + Event.pointerY(event) + "px";});

If we wanted to observe the mouse location when it was hovering over a certain element, we'd just change the document argument to the id or element that was relevant.

Stopping Propagation

Event.stop(event) will stop the propagation of an event but there is a bug in Safari 2.0.3 that causes this to behave unexpectedly. Ryan from Particletree has posted an in-depth article on Event.stop with a workaround for Safari.

The good news is that this bug is fixed in the Webkit version of Safari. You can check out this test in Safari 2.0.3 and Webkit to see the results of both.

Events, Binding, and Objects

Everything has been fairly straight forward so far, but things start getting a little tricker when you need to work with events in and object-oriented environment. You have to deal with binding and funky looking syntax that might take a moment to get your head around.

Lets look at some code so you can get a better understanding of what I'm talking about.

EventDispenser = Class.create();
EventDispenser.prototype = {
  initialize: function(list) {
    this.list = list;

    // Observe clicks on our list items     
    $$(this.list + " li").each(function(item) {
      Event.observe(item, 'click', this.showTagName.bindAsEventListener(this));
    }.bind(this));

    // Observe when a key on the keyboard is pressed. In the observer, we check for 
    // the tab key and alert a message if it is pressed.
    Event.observe(document, 'keypress', this.onKeyPress.bindAsEventListener(this));

    // Observe our fake live search box.  When a user types something into the box, 
    // the observer will take that value(-1) and update our search-results div with it.
    Event.observe('search', 'keypress', this.onSearch.bindAsEventListener(this));

    Event.observe(document, 'mousemove', this.onMouseMove.bindAsEventListener(this));
  },


  // Arbitrary functions to respond to events
  showTagName: function(event) {
    alert(Event.element(event).tagName);
  },


  onKeyPress: function(event) {
    var code = event.keyCode;
    if(code == Event.KEY_TAB) alert('Tab key was pressed');
  },

  onSearch: function(event) {
    Element.update('search-results', $F(Event.element(event)));
  },

  onMouseMove: function(event) {
    $('mouse').value = "X: " + Event.pointerX(event) + "px Y: " + Event.pointerY(event) + "px";
  }

}

Whoa! What's going on here? Well, we've defined our a custom class EventDispenser. We're going to be using this class to setup events for our document. Most of this code is a rewrite of the code we looked at earlier except this time, we are working from inside an object.

View a live example of our document »

Looking at the initialize method, we can really see how things are different now. Take a look at the code below:

    // Observe clicks on our list items     
    $$(this.list + " li").each(function(item) {
      Event.observe(item, 'click', this.showTagName.bindAsEventListener(this));
    }.bind(this));

We've got iterators, binding and all sorts of stuff going on. Lets break down what this chunk of code is doing.

First we are hunting for a collection of elements based on it's css selector. This uses the new Prototype selector function $$. After we've found the list items we are dealing with we send those into an each iteration where we will add our observers.

Event.observe(item, 'click', this.showTagName.bindAsEventListener(this));

Now looking at the code above, you'll notice the bindAsEventListener function. This takes the method before it showTagName and treats it as the method that will be triggered when, in this case, someone clicks one of our list items.

You'll also notice we pass this as an argument to the bindAsEventListener function. This simply allows us to reference the object in context EventDispenser inside our function showTagName.

NOTE: If you prefer the jargon packed explanation of bindAsEventListener, see the Script.aculo.us wiki.

Moving on, you'll see bind(this) attached to our iterator function. This really has nothing to do with events, it is only here to allow me to use this inside the iterator. If we didn't use bind(this), I couldn't reference the method showTagName inside the iterator.

Ok, so we'll move on to looking at our methods that actually get called when an event occurs. Since we've been dealing with showTagName, lets look at it.

  showTagName: function(event) {
    alert(Event.element(event).tagName);
  }

As you can see, this function accepts one argument--the event. In order for us to get the element which fired the event we need to pass that argument to Event.element. Now we can manipulate it at will.

This covers the most confusing parts of our code. The text above is also relevant to the remaining parts of our code. If there is anything about this you don't understand, feel free to say so.

Removing Event Listeners

This one threw me for a loop the first time I tried to use it. I tried something similar to what I did in the Event.observe call with the exception of using stopObserving, but nothing seemed to change. In other words, the code below does NOT work.

$$(this.list + " li").each(function(item) {
  Event.stopObserving(item, 'click', this.showTagName);
}.bind(this));

What's the deal here? The reason this doesn't work is because there is no pointer to the observer. This means that when we passed this.showTagName in the Event.observe method before hand, we passed it as an anonymous function. We can't reference an anonymous function because it simply doesn't have a pointer.

So how do we get the job done? All we need to do is give the observing function a pointer, or the jargon free version: Set a variable that points to this.showTagName. Ok, lets change our code a bit.

this.showTagObserver = this.showTagName.bindAsEventListener(this);

// Observe clicks on our list items     
$$(this.list + " li").each(function(item) {
  Event.observe(item, 'click', this.showTagObserver);
}.bind(this));

Now we can remove the event listeners from our list like this:

$$(this.list + " li").each(function(item) {
  Event.stopObserving(item, 'click', this.showTagObserver);
}.bind(this));

One final note on removing event listeners. If you have an instance where you want to simply remove all observes in one big swoop, you can use unloadCache.

Event.unloadCache();

Summing Up

That pretty much sums up events in Prototype. If you find any errors, please let me know. The great thing about writing articles such as this is that I also learn so much in the process and develop a deeper understanding of what I'm writing about. For instance, I found out the removing event listeners bit while I was writing this article. If you've got anything you'd like to contribute, feel free to chime in. Until next time, Happy Prototyping!

Maven 让事情变得简单

TrampEagle — Thu, 09 Feb 2006 06:52:00 GMT

引自：http://www-128.ibm.com/developerworks/cn/java/j-maven/

项目管理: Maven 让事情变得简单

给您的下一个 Java 构建添加项目管理特性

文档选项

将此页作为电子邮件发送

对此页的评价

帮助我们改进这些内容

级别: 初级

Charles Chan, 高级软件开发人员, Finetix LLC

2003 年 7 月 30 日

尽管 Ant 对于构建 Java 程序而言是事实上的标准工具，但这个工具在许多方面都不胜任项目管理任务。相反，Ant 提供的东西，Maven（出自 Apache Jakarta 项目的高级项目管理工具）都能提供，而且更多。Java 开发人员 Charles Chan 将介绍 Maven 的特性，并循序渐进地指导您进行一次完整的 Maven 项目设置。

目前，绝大多数开发人员都把 Ant 当作 Java 编程项目的标准构建工具。遗憾的是，Ant 的项目管理工具（作为 make 的替代工具）不能满足绝大多数开发人员的需要。通过检查 Ant 构建文件，很难发现项目的相关性信息和其它元信息（如开发人员／拥有者、版本或站点主页）。

Maven 除了以程序构建能力为特色之外，还提供 Ant 所缺少的高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性，所以常常用两三行 Maven 构建脚本就可以构建简单的项目，而使用 Ant 则需要十几行。事实上，由于 Maven 的面向项目的方法，许多 Apache Jakarta 项目现在使用 Maven，而且公司项目采用 Maven 的比例在持续增长。

Maven vs Ant

那么，Maven 和 Ant 有什么不同呢？在回答这个问题以前，我要强调一点：Maven 和 Ant 针对构建问题的两个不同方面。Ant 为 Java 技术开发项目提供跨平台构建任务。Maven 本身描述项目的高级方面，它从 Ant 借用了绝大多数构建任务。因此，由于 Maven 和 Ant 代表两个差异很大的工具，所以我将只说明这两个工具的等同组件之间的区别，如表 1 所示。

表 1. Maven vs Ant

	Maven	Ant
标准构建文件	project.xml 和 maven.xml	build.xml
特性处理顺序	${maven.home}/bin/driver.properties ${project.home}/project.properties ${project.home}/build.properties ${user.home}/build.properties 通过 -D 命令行选项定义的系统特性最后一个定义起决定作用。	通过 -D 命令行选项定义的系统特性由任务装入的特性第一个定义最先被处理。
构建规则	构建规则更为动态（类似于编程语言）；它们是基于 Jelly 的可执行 XML。	构建规则或多或少是静态的，除非使用

名称	地址	年龄
$Customer.Name()	$Customer.Address()	$Customer.Age()

BlogJava-鹰翔宇空-文章分类-opensource

Velocity简介

DisplayTag应用

EasyJWeb－Velocity脚本教程

lucene全文检索实现流程

Lucene中文分词的高亮[highlight]显示

Prototype Meets Ruby: A Look at Enumerable, Array and Hash

Encytemedia

Working With Events In Prototype

Basic event handling

Observing keystrokes

Getting the coordinates of the mouse pointer

Stopping Propagation

Events, Binding, and Objects

Removing Event Listeners

Summing Up

Related Reading

Maven 让事情变得简单

项目管理: Maven 让事情变得简单