《Apache Velocity用户攻略》官方文档-Java-优质IT资源分享社区

admin
管理员
管理员
  • UID1
  • 粉丝30
  • 关注4
  • 发帖数581
  • 社区居民
  • 忠实会员
  • 原创写手
阅读:224回复:0

  《Apache Velocity用户攻略》官方文档

楼主#
更多 发布于:2016-05-31 16:43

Quick Start

本项目是 Apache

Velocity官方文档的中文翻译版,Velocity类似与JSP,是一种依据Java的模板引擎。它可以在web页面中引证Java代码中界说的数据和目标,而Velocity的效果即是把Web视图和java代码进行组装在一同。本次翻译首要针对对Velocity感兴趣和作业中运用到Velocity的开发人员供给有价值的中文材料,期望可以对咱们的作业和学习有所协助。

由于我也是首次触摸Velocity,还不是很深化,翻译的时分也查看了一些博客以及别的网上材料。也测验着去了解它和JSP方面的不相同以及优缺点,一同也去了解了下它和别的Java引擎模板的区别,比方freemaker的区别,等等。可是仍是由于才能才智有限,翻译过程中不免呈现自己的片面或许客观因素致使与官方文档存在区别。在此,我仍是主张有才能的童鞋可以自己去Velocity官方看看。

译者注:由于本次翻译比照匆促,内部不免呈现一些不合理的当地,小村长在此恳请咱们发现过错可以第一时间在谈论中指出来,我会第一时间进行修正,防止给热爱学习的同学形成误解。一同,也期望咱们多多提出过错和主张,小村长在此谢谢

! ! !

About this Guide(导读)

What is Velocity?(啥是Velocity)

What can Velocity do for me?(Velocity能做啥)

The Mud Store example(Mud 商铺实例)

What jar should I use?(怎样运用Velocity jar)

Maven users(Maven用户)

Other users(别的用户)

Velocity Template Language (VTL): An

Introduction(Velocity模板言语 (VTL): 简介)

Hello Velocity World!(Velocity简略实例:Hello Velocity

World)

Comments(注释)

References(引证)

Variables(变量)

Properties(特色)

Methods(办法)

Property Lookup Rules(特色调用规矩)

Rendering(烘托输出)

Index Notation(索引标识符)

Formal Reference Notation(正式引证标识符)

Quiet Reference Notation(静态引证标识符)

Strict Reference Mode(严厉引证办法)

Case Substitution(大小写变换)

Directives(指令)

Relational and Logical Operators(联络和逻辑运算符)

Set(调集)

Literals(字面量)

If-Else Statements(if-else句子)

Foreach Loops(foreach循环)

Include(引证,包括)

Parse(解析)

Break(间断)

Stop(中止)

Evaluate(核算)

Define(界说)

Velocimacros(宏)

Getting literal(获取字符)

Currency(并发)

Escaping Valid VTL References(转义VTL引证)

Escaping Invalid VTL References(转义不可用VTL引证)

Escaping VTL Directives(转义VTL指令)

VTL: Formatting Issues(VTL:格局评论)

Other Features and Miscellany(其它特征和功用)

Math(算术)

Range Operator(规模操作符)

Advanced Issues: Escaping and !(高档评论:转义和!)

Velocimacro Miscellany(Velocimacro杂谈)

String Concatenation(字符串拼接)

Feedback(反应)

导读

Velocity用户导游,用于协助页面规划者和内容供给者,了解Velocity和它简略有效的脚本言语,

这个脚本言语即是Velocity模板言语,简称 (VTL)。

在接下来的章节中,有许多实例运用Velocity嵌入动态内容到页面中,但一切的VTL的实例在别的页面和模板相同适用。

谢谢你挑选Velocity!

啥是 Velocity?

Velocity是依据Java的模板引擎,它容许页面规划者引证Java中界说的办法。页面规划者和Java开发者可以一同运用MVC的办法开发网站,这么页面规划者可以把精力放在页面的规划上,程序员也可以把精力放在代码开发上。Velocity把Java代码从Web页面中别离,

使网站可维护性更强,一同也在Java效劳器页面(JSPs)或许PHP中供给了可视化交互的挑选。

Velocity可以运用模板生成Web页面,  SQL,PostScript

和别的内容。并可以生成的源代码和报表中的一个独立的单元,或许作为一个别的体系的组件。装备完结后,Velocity将供给为Turbine

页面运用结构供给模板效劳。 Velocity+Turbine将供给一个模板效劳,它将容许页面运用依照MVC的办法进行开发。

Velocity可以做啥?

Mud商铺实例

假设你是一个专卖mub的网上商城页面规划者.。咱们暂时称它为”The Online Mud

Store”。顾客订货各种类型和数量的产品. 他们运用用户名和暗码登入你的网站, 登入今后答应他们看到订单,并采购更多的mud。就在如今, Terracotta

Mud正在出售,,而且十分热销。少有些用户也采购 Bright Red Mud,

它也在出售,可是并不十分热销,把它放在Web页面的边缘。经过数据库来盯梢每个顾客的信息,如今新疑问呈现了,

为啥不运用Velocity来对顾客感兴趣的mud的类型进行特性处理呢?

Velocity很简略完结页面依照拜访者来进行格外定制。作为一个Mud商城的规划者,你思考一副这么的场景,当你的顾客登入网站今后,你将向他展现一个怎样样的页面。

你和你们公司的软件工程师进行交流, 每一自己都附和运用 $customer存储当时登入顾客的信息,

$mudsOnSpecial将展现一切当时在售的mud类型信息。$flogger目标包括一些的办法用来促销产品。对于这些需求完结的使命,这些涉及到咱们的使命只是需求三个引证。记住,

你不需求忧虑软件工程师,怎样从数据库中提取必要的数据, 你只是需求它可以正常的作业. 这么你进行你的作业, 而软件工程师进行他们的作业。

你需求在页面中嵌入下面的VTL句子如下:

Hello $customer.Name!

#foreach( $mud in $mudsOnSpecial )   #if ( $customer.hasPurchased($mud) )

#end#end[table][tr][td]$flogger.getPromo( $mud )[/td][/tr][/table]

foreach句子具体细节将在后边章节中具体描绘;

首要的是这个简略的脚本在你页面中的效果。当一个偏好Bright Red Mud登入时, 而且Bright Red Mud

正处于出售状态,这即是消费者即将看到的,将会突出显现。假设另一个长期采购Terracotta Mud 记载用户登入了,Terracotta Mud

将放在中心显眼方位.。Velocity是很灵敏的,受限制的只是是你的创造力 .

VTL文档中运用了许多别的的 Velocity元素,

它们将给你展现一个灵敏的有利的页面。当你越了解这些元素,你将开端了解Velocity的力量。

怎样运用Velocity jar?

Velocity2.x版别需求几个jar,现已发布到Maven库房,可以经过Maven来引证。

Maven 用户

在你的POM文件中引证下面依靠:

org.apache.velocityvelocity-engine-corex.x.x

假设你想在Velocity中引进Logging, SLF4J,

Log4j或许效劳器logger日志, 在POM文件中增加一下依靠:

org.apache.velocityvelocity-engine-commons-loggingx.x.xorg.apache.velocityvelocity-engine-slf4jx.x.xorg.apache.velocityvelocity-engine-log4jx.x.xorg.apache.velocityvelocity-engine-servletx.x.x

别的用户

首要,下载发布的Velocity版别。

假设你想迅速装置你的运用,

很简略把velocity-x.x.x.jar放到你的classpath中:它包括一切的Velocity类

(还包括一些拓展实例)。包括一切的子目录lib中的一切jar.

别的的jar你也许运用到.

velocity-engine-core-x.x.x.jar:

Velocity的中心jar包,它有必要被引证.

velocity-engine-commons-logging-x.x.x.jar:

它用来绑定通用的日志信息Logging, 一切的日志信息将指向它. 用在衔接Logging (包括”lib” 目录).

velocity-engine-slf4j-x.x.x.jar:它首要用来绑定SLF4J,一切的日志信息将指向它.

用在衔接SLF4J (包括”lib” 目录).

velocity-engine-log4j-x.x.x.jar:

它首要是绑定Log4j日志,一切的日志音讯将运用它. 用在衔接Log4j (包括 “lib” 的目录).

velocity-engine-servlet-x.x.x.jar:

它首要用来绑定效劳器日志. 运用在效劳器容器中.

拓展的jar中你将需求 Commons Collections 和Commons Lang,

它现已包括在 “lib” 目录中.

Velocity模板言语(VTL): 入门攻略

Velocity模板言语

(VTL)供给了简略,简略,和清洗办法兼并动态内容在你的页面上。即便一个页面开发者有少数或许没有编程经历也能很快有才能运用VTL嵌入动态内容到你的Web页面。

VTL运用引证嵌入动态内容到Web页面, 一个引证也是一个引证类型.

变量是一种引证类型可以引证Java中界说变量,或许可以获取它的值在你的Web页面中经过VTL句子。这儿有一个比如

VTL句子可以被嵌入到你的HTML文档中:

#set( $a = "Velocity" )

这个VTL 句子, 像一切的VTL句子相同,经过 # 字符开端并包括一个指令: set.

当一个用户拜访你的页面时,Velocity模板 将在你的Web页面中查找一切的#字符, 然后以为它是VTL句子的开端,可是#字符并没有实际意义。

字符 #后边紧跟着, set.set 指向一个表达式 (放在括号里边) —

一个等式为变量分配一个值。变量的界说在左面赋值在右边; 它们之间经过 = 分隔。

在上面的实例中, 变量是 $a ,它的值是Velocity。这个变量像其它的引证相同, 经过 $

字符开端。字符串的值放在引号中,单引号或双引号都可以。单引号确保引号里边的值分配给变量。双引号答应你运用velocity的引证和指令,例如  “Hello

$name”,  $name 将被界说的变量值=右边的内容所更换

下面的规矩能使你十分好的了解Velocity的作业原理:引证是经过$ 开端的,用来获取值。指令#

用来界说值。

在上面实例中, #set 被用来给变量分配一个值。这个变量是 $a, 可以在模板中运用并输出

“Velocity”。

Hello Velocity World实例

当一个值分配给一个变量时, 你可以引证这个变量在你的HTML 文档中.鄙人面的实例中, 先对

$foo 进行赋值,然后引证它.

#set( $foo = "Velocity" )Hello $foo World!

这个页面的成果是容许出 “Hello Velocity World!”.

为了是包括VTL句子指定可读性更强, 咱们鼓舞你开端每个VTL句子在新的一行,

但并不强行恳求你这么做.set 指令将在后边章节具体介绍.

注释

注释以一种不被Velocity模板修正的原样输出描绘文本。注释是一种很有用的办法,提示你而且通知别的人VTL句子的效果,

或许存放对你有用的别的信息。下面即是VTL注释的实例:

## 这是一个单行注释.

## 表明的是单行注释表明本行都被注释。假设你需求多行注释,

不需求一行一行的注释。你可以运用多行注释, 多行注释以 #* 开端,以 *#做为完毕, 可以用它来处理多行注释的状况.

这是多行注释,阅读者能看到它。#* Thus begins a multi-line

comment. Online visitors won't see this text because the Velocity Templating

Engine will ignore it.*#这儿多行注释; 它是可见的.

这儿有许多实例阐明多行注释和单行注释:

This text is visible. ## This text is not.This

text is visible.This text is visible. #* This text, as part of a

multi-linecomment, is not visible. This text is not visible; it is alsopart of

the multi-line comment. This text still notvisible. *# This text is outside the

comment, so it is visible.## This text is not visible.

这是第三种的注释,  VTL注释块, 它被用来贮存一些你需求重视的信息模板 (例如.

javadoc作者版别信息):

#**This is a VTL comment block andmay be used to

store such informationas the document author and

versioninginformation:@author@version 5*#

引证

在VTL中有三种类型的引证: 变量,特色和办法。作为一个运用VTL的规划者,

你和工程师有必要一同在你的模板中,指定姓名以及它所代表的引证。

变量

VTL中变量标识符前面需求增加 “$” 来进行符号. AVTL标识符有必要以字母 (a .. z

or A .. Z)开端. 别的的字符可以运用下面几种:

alphabetic (a .. z, A .. Z)

numeric (0 .. 9)

hyphen (“-“)

underscore (“_”)

下面有一些可用的变量引证实例在VTL中:

$foo$mudSlinger$mud-slinger$mud_slinger$mudSlinger1

当VTL运用一个变量时, 例如$foo,这个变量可以获取一个值从模板的 set指令中,

或许从Java代码中。例如,假设在Java中界说了一个变量$foo,java中界说的值Web页面中一切的 $foo引证. 或许, 我在页面中界说下面句子

#set( $foo = "bar" )

$foo输出的成果将和你界说的是相同的。

特色

VTL中第二个特色明显的引证是特色引证, 特色有一个异乎寻常的格局.

它的标识符前面需求增加一个$变量标识符, 紧跟着后边一个点(“.”) . 下面是一个在VTL中特色引证的实例:

$customer.Address$purchase.Total

就拿第一个实例来说, $customer.Address.它有两个意思.

它意味着,查询被customer 标识的哈希表回来和它相关联的Address 的值。一同$customer.Address也能被一个办法引证

(办法的引证鄙人一章在评论); $customer.Address是$customer.getAddress()的一种缩写办法。假设你的页面有需求,

Velocity 将可以使这两种办法变的有意义, 然后回来精确的值。

办法

Java中界说的办法可以界说许多有用的作业, 像进行核算或许到达某种意图. 办法的引证是经过 “$”

标识符, 后边紧跟着办法体. VTL办法体紧跟着左括号符  (“(“), 紧跟着参数列表, 紧跟着右括号符(“)”). 下面是VTL中办法引证的实例:

$customer.getAddress()$purchase.getTotal()$page.setTitle(

"My Home Page" )$person.setAttributes( ["Strange", "Weird", "Excited"] )

前两个实例 — $customer.getAddress() 和

$purchase.getTotal() — 可以看着是特色的引证, $customer.Address

和$purchase.总之.这些引证在VTL中是许多见的!

VTL 特色引证可以被当着办法引证的简写. 特色 $customer.Address 引证和

$customer.getAddress()办法的引证效果是相同的. 一般状况下假设可以,咱们经过简写的办法来引证办法.特色和办法首要不相同是办法可以引证参数

.

下面的办法可以被简写

$sun.getPlanets()$annelid.getDirt()$album.getPhoto()

咱们也许期望办法回来归于太阳的行星的姓名, 喂蚯蚓, 或许活动一张图像或许专辑.

下面办法有很长的符号.

$sun.getPlanet( ["Earth", "Mars", "Neptune"] )##

Can't pass a parameter list with $sun.Planets$sisyphus.pushRock()## Velocity

assumes I mean $sisyphus.getRock()$book.setTitle( "Homage to Catalonia" )##

Can't pass a parameter

自从Velocity 1.6, 一切的数组引证被看这固定长度列表.

这意味着你可以调用java.util.Lis办法在数组引证。所以, 假设你有一个引证在数组上 ( 假定这儿有一个字符数组后三个字),你可以这么做:

$myarray.isEmpty()$myarray.size()$myarray.get(2)$myarray.set(1,

'test')

在Velocity 1.6支撑可变参数办法. 一个办法public void

setPlanets(String... planets)或许乃至是public void setPlanets(String[]

planets)(假设你运用Java 5 JDK), 如今可以承受任何数量的参数时调用的模板.

$sun.setPlanets('Earth', 'Mars',

'Neptune')$sun.setPlanets('Mercury')$sun.setPlanets()## Will just pass in an

empty, zero-length array

特色调用规矩

正如前面说到的, 特色常常涉及到父类办法的引证.

Velocity是十分拿手处理办法对应的特色获取,它可以依据几种不相同的命名约好进行挑选,精确的查找规矩依靠是不是特色的姓名以大写开端。对于小写姓名,例如

$customer.address, 调用的次序是

getaddress()

getAddress()

get(“address”)

isAddress()

对于大写的特色姓名像 $customer.Address, 它略微不相同:

getAddress()

getaddress()

get(“Address”)

isAddress()

烘托

每一个引证的值(变量,特色,或许办法)都被变换为一个字符串并作为终究的输出。假设这儿有一个目标表明为$foo

(例如一个整数目标), 当Velocity调用它时,Velocity会调用它的.toString()办法转化为字符串.

索引标识符

运用$foo[0]的符号办法可以拜访被界说的索引目标。这个办法和经过get调用一个目标是相同的例如$foo.get(0),

供给了一种简略的语法操作。下面是这种操作的实例:

$foo[0]       ## $foo takes in an Integer look

up$foo[$i]      ## Using another reference as the index$foo["bar"]   ## Passing

a string where $foo may be a Map

这相同的语法也可以运用在Java数组上由于由于Velocity封装了数组在拜访目标上供给了一个get(Integer)办法,它能回来一个格外的元素。

相同的语法可以在任何.get的当地运用,例如:

$foo.bar[1].junk$foo.callMethod()[1]$foo["apple"][4]

一个引证也可以经过索引来进行赋值, 例如:

#set($foo[0] = 1)#set($foo.bar[1] =

3)#set($map["apple"] = "orange")

指定的元素被赋值给定的值。Velocity 测验首次 ‘set’ 办法在元素上, 然后经过’put’

来进行赋值.

正式引证标识符

上面的实例向咱们展现了引证标识符的运用, 然后,Velocity也供给了正式引证标识符的引证,

请看下面实例:

${mudSlinger}${customer.Address}${purchase.getTotal()}

在大多数状况下你可以运用标识符引证,可是有些状况下恳求精确的符号被恳求精确的处理。

假设你构建一个句子$vice被运用作为一个根底句子的单词。它的意图容许有人挑选根底单词发作这种成果:

“Jack is a pyromaniac.” 或许 “Jack is a

kleptomaniac.”。运用简写标识符将不满意这种需求。思考下面的例句:

Jack is a $vicemaniac.

它是含糊不清的, Velocity以为它是$vicemaniac, 而不是$vice.

发现变量$vicemaniac,没有赋值,它将回来 $vicemaniac. 如今运用正式标识符可以处理这种疑问.

Jack is a ${vice}maniac.

如今Velocity可以辨认$vice, 而不误以为$vicemaniac.

正式引证常常被运用在引证指向邻近文本的模板中.

静态引证标识符

当Velocity遇到一个没有界说的引证时,正常的是输出图像引证. 例如,

假设下面的引证是VTL模板的一有些.

当它初始化时, 变量 $email运用并没有值, 可是你甘愿”$email”是一个空白文本字段 .

运用静态引证标识符防止这种规范的做法; 经过在你的VTL模板中运用$!email替代$email。上面的实例可以改成下面这种办法:

如今当初始化时假设$email没有值, 一个空的字符串将输出替代”$email”。

正式运用和静态引证常常一同运用,就像下面实例相同.

严厉引证办法

Velocity

1.6介绍了一种新的概念,即是严厉引证办法,它是经过装备特色的办法来完结灵敏的设置。这种设置的意图是使Velocity的特性愈加严厉区别没有界说或许不置可否的实例中,

类似与编程言语, 它更适合Velocity的运用。当遇到没有界说或许不置可否的状况Velocity将抛出反常。下面将评论严厉运用和传统引证的不相同之处。

设置引证恳求在上下文中或许被#set

指令界说否则Velocity将抛反常。在上下文中引证一个null值并不会发作反常。此外,假设你妄图在一个目标中调用一个没有界说的办法或许特色时,它将抛反常。假设调用的办法或特色是一个null值也会发作反常。

鄙人面的实例中 $bar被界说了可是 $foo却没有被界说,一切这些句子将抛出反常:

$foo                         ## Exception#set($bar

= $foo)            ## Exception#if($foo == $bar)#end        ##

Exception#foreach($item in $foo)#end  ## Exception

一同, 你调用一个并不存在的办法或特色时,也会发作反常。鄙人面的实例中 $bar目标界说一个特色

‘foo’ 回来一个字符串 , ‘retnull’ 将回来null.

$bar.bogus          ## $bar does not provide

property bogus, Exception$bar.foo.bogus      ## $bar.foo does not provide

property bogus, Exception$bar.retnull.bogus  ## cannot call a property on null,

Exception

一般严厉引证运用一切状况除了格外的 #if 指令.假设一个引证运用 #if 或许#elseif

指令没有任何办法或特色,假设它并没有和别的值进行比照,这种引证是答应的.这种办法一般用来判别一个引证是不是被界说. 鄙人面的实例中$foo

并没有界说可是它也不会抛反常.

#if ($foo)#end                  ## False#if ( !

$foo)#end               ## True#if ($foo && $foo.bar)#end      ## False

and $foo.bar will not be evaluated#if ($foo && $foo == "bar")#end ##

False and $foo == "bar" wil not be evaluated#if ($foo1 || $foo2)#end        ##

False $foo1 and $foo2 are not defined

严厉办法在 #if 指令中可以运用 >, <,>= or <=. 一同,参数

#foreach有必要可以迭代的 (这种特性可以被特色指令.foreach.skip.invalid修正).

不过,在严厉办法下没有界说的引证也将抛反常。

Velocity妄图调用一个null值将致使反常. 对于简略的调用在这个实例中你可以用 ‘$!’替代

‘$’, 这种类似于非严厉办法。请记住,当你运用严厉引证调用不存在的变量时会呈现反常。例如, 下面的$foo 在上下文中值为null

this is $foo    ## throws an exception because

$foo is nullthis is $!foo   ## renders to "this is " without an exceptionthis is

$!bogus ## bogus is not in the context so throws an exception

办法更换

如今你现已了解了引证,

你可以在你的模板中运用它们。Velocity引证运用了一些Java的规划原则进行规划,很简略运用。 例如:

$foo$foo.getBar()## is the same

as$foo.Bar$data.setUser("jon")## is the same as#set( $data.User = "jon"

)$data.getRequest().getServerName()## is the same as$data.Request.ServerName##

is the same as${data.Request.ServerName}

这些实例是供给了多重挑选,可是效果却是相同的。Velocity运用Java的特性和Bean特性处理上下文中姓名在目标和办法中的引证。它是也许的在你的模板中嵌入和引证的值.

Velocity是模仿sun公司的bean界说的规范,大小写灵敏的;

可是,开发者尽也许的防止和纠正用户也许呈现的过错 . 当getFoo() 办法在模板中被$bar.foo引证时,

Velocity首要将测验着调用$getfoo。假设失利了, 它将测验着调用$getFoo。相同的, 当一个模板引证$bar.Foo,

Velocity首要将测验着调用 $getFoo() 然后在调用getfoo().

留意: 在模板中引证实例变量是不容许的。只是引证特色等同于 JavaBean

getter/setter 办法是可以的 (例如.$foo.Name可以经过Foo’sgetName()实例办法来引证,

可是不是对一个公共的Name实例的变量Foo).

指令

引证容许规划者在页面上生成动态的内容,

指令很简略运用脚本元从来创建和操作输出的Java代码,并容许Web规划者重视页面的内容。

指令一向以#开端. 像引证相同,指令的姓名也许是持平的经过{和}符号. 这是好的办法在指令后跟文本.

例如下面的程序有一个过错:

#if($a==1)true enough#elseno way!#end

在这个实例中, 运用方括号把#else与别的行分隔.

#if($a==1)true enough#{else}no way!#end

#set #set 指令被用来设定一个引证的值.

这个值可以被分配一个变量引证或许特色引证,这种状况发作在括号中, 如下实例:

#set( $primate = "monkey" )#set(

$customer.Behavior = $primate )

左面的(LHS)有必要分配一个变量引证或许特色引证. 右边的(RHS)可以是以下类型:

Variable reference

String literal

Property reference

Method reference

Number literal

ArrayList

Map

这些实例演示了上面的每种类型:

#set( $monkey = $bill ) ## variable reference#set(

$monkey.Friend = "monica" ) ## string literal#set( $monkey.Blame =

$whitehouse.Leak ) ## property reference#set( $monkey.Plan =

$spindoctor.weave($web) ) ## method reference#set( $monkey.Number = 123 )

##number literal#set( $monkey.Say = ["Not", $my, "fault"] ) ## ArrayList#set(

$monkey.Map = {"banana" : "good", "roast beef" : "bad"}) ## Map

注释: 对于界说的ArrayList 实例元素可以运用ArrayList 类里边界说的办法, 例如,

你可以拜访上面第一个元素运用$monkey.Say.get(0).

类似的, 对于Map实例, 元素经过 { } 操作符来界说你可以运用Map类中界说的办法. 例如,

你可以拜访上面实例中第一个元素经过$monkey.Map.get(“banana”) 而且回来 ‘good’, 乃至你可以运用

$monkey.Map.banana来回来相同的值.

RHS也能运用简略的算术表达式:

#set( $value = $foo + 1 )#set( $value = $bar - 1

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

假设RHS是一个null的特色和办法引证,

它将不能分配给LHS.这首要依靠你的装备,经过这种机制一般不能移除一个现已存在的引证. (留意它答应你改动Velocity装备特色). 新手对这点比照迷惑.

例如:

#set( $result = $query.criteria("name") )The

result of the first query is $result#set( $result = $query.criteria("address")

)The result of the second query is $result

假设$query.criteria(“name”) 回来”bill”,

 $query.criteria(“address”) 回来null, 上面的 VTL将输出如下内容 :

The result of the first query is billThe result of

the second query is bill

对于入门者对于 #foreach

循环妄图#set一个运用经过一个特色或许办法引证是很迷惑的,接着经过 #if指令来进行测验. 例如:

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

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

 #if( $result )        Query was successful    #end#end

在上面的实例中, 它并不期望经过$result 来决议查询是不是成功. $result 今后经过

#set (增加到上下文中),它不能回来为null  (被移除从上下文中). #if 和 #foreach指令相关的细节将在今后的文档中都涉及到.

一种处理这种状况经过预设 $result为 false. 然后假设

$query.criteria() 调用失利, 你可以检测到.

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

$criterion in $criteria )    #set( $result = false )    #set( $result =

$query.criteria($criterion) )    #if( $result )        Query was successful  

 #end#end

不像别的的Velocity指令,#set 指令并没有 #end句子.

Literals当你运用 #set指令的时分,

在双引号里边的字符串将被解析, 如下所示:

#set( $directoryRoot = "www" )#set( $templateName

= "index.vm" )#set( $template = "$directoryRoot/$templateName" )$template

输出成果为

www/index.vm

可是, 当字符串处在单引号中, 它将不被解析:

#set( $foo = "bar" )$foo#set( $blargh = '$foo'

)$blargh

输出成果是:

bar  $foo

默许状况, 这种特征运用单引号不解析Velocity中的可用变量.

你也可以经过改动velocity.properties 中的stringliterals.interpolate=false装备来改动这种默许设置.

或许,  #[[don’t parse me!]]#

语法答应模板规划者很简略的运用许多的句子块,而这些句子块中的变量不会被解析.

它格外有用尤其在防止有许多的指令上当地或许别的无效的内容(不想被解析的)VTL.

#[[#foreach ($woogie in $boogie)  nothing will

happen to $woogie#end]]#

显现如下:

#foreach ($woogie in $boogie)  nothing will happen

to $woogie#end

条件句子

If / ElseIf / Else

Velocity中 #if 指令可以包括一段文本当生成Web页面时, 当条件句子为true时.

例如:

#if( $foo )   Velocity!#end

变量$foo核算出是不是是true,下面三种状况哪种状况将发作:

假设是true值时,$foo是一个 boolean类型 (true/false)

假设不为空目标或空值时,$foo是一个字符串或条件表达式。

假设不为空目标,且不是字符串或条件表达式时,$foo是一个目标。

记住 Velocity上下文只是包括目标,所以当咱们说 ‘boolean’,它将代表 Boolean

(类)。这是实在的即便这个办法回来的值为布尔值,它内部本来回来的是一个Boolean值。假设if为true #if 和 #end 内容将输出。在这个实例中,

假设 $foo 为 true, 它将输出为: “Velocity!”。相反的, 假设 $foo 有一个 null 值,或许它的布尔值为false,

这个句子的成果为false,这儿将没有输出。

#elseif 或许 #else 元素可以和#if 元素一同运用. 留意Velocity

模板将中止在第一个表达式中当发现第一个表达式为true时, 假设$foo值为 15 $bar 值为6.

#if( $foo < 10 )    Go

North#elseif( $foo == 10 )    Go East#elseif( $bar ==

6 )    Go South#else    Go West#end

在这个实例中, $foo 大于10,所以第一个两个比照是false。下一个$bar 和6持平,

所以显现true, 所以输出 Go South。

联络和逻辑操作符

Velocity 运用等号决议两个变量之间的联络. 下面简略实例展现了等会的怎样运用.

#set ($foo = "deoxyribonucleic acid")#set ($bar =

"ribonucleic acid")#if ($foo == $bar)  In this case it's clear they aren't

equivalent. So...#else  They are not equivalent and this will be the

output.#end

留意 == 语法和Java中的语法是不相同,Java中==只是表明目标是不是持平.

Velocity中的等号操作符只是表明两个数字,字符串,或目标的比照。当两个类目标是不一同, 字符串是经过调用toString()来获取的然后来比照.

Velocity的逻辑操作符有AND, OR 和NOT 操作符. 下面的逻辑操作符显现了 AND,

OR 和NOT 操作符的运用.

## logical AND#if( $foo && $bar )   This AND that#end

#if() 指令成果为true 假设 $foo 和$bar都为true. 假设

$foo为false,表达式的成果为 false; $bar将不会核算. 假设 $foo 为 true,Velocity模板将核算$bar的值; 假设

$bar为 true, 然后全部表达式为true输出 This AND that . 假设 $bar为

false,假设表达式为false这儿将没有输出.

逻辑表达OR

操作符也是这种状况,只是只要一种状况需求核算总个表达式,即是全部表达式为true.思考下面的实例.

## logical OR#if( $foo || $bar )    This

OR That#end

假设$foo为 true, Velocity模板不需求核算$bar; 不管$bar 是不是为

true 或 false, 这全部表达式为true,This OR That 将被输出. 假设 $foo 为 false,

可是, $bar有必要需求核算. 在这个实例中, 假设 $bar 也为 false,这表达式成果为 false 这儿没有任何输出. 另一方面, 假设$bar 为

true, 可是全部表达式为true, 输出的结构是 This OR That

逻辑运算符NOT ,这儿只是有一个参数 :

##logical NOT#if( !$foo )  NOT

that#end

这儿, 假设$foo为 true, 然后!$foo核算成果为false,这儿没有输出。假设

$foo为 false, 可是 !$foo核算成果为true 输出成果为 NOT that . 留意不要把它和静态引证

$!foowhich混杂,它们是不相同的。(ifeve.com校正注:一个!在前,一个在后)

这儿也有字符办法的逻辑运算符如 eq, ne, and, or, not, gt, ge, lt,

和le.

温馨提示.当你期望在#else 指令后边包括一个文本你需求把else放在一个大括号

里边来表明它与后边的文本是不相同的. (任何指令都能被放在括号里边, 一般用在#else中).

#if( $foo == $bar)it's true!#{else}it's

not!#end

循环

Foreach LoopThe #foreach元素用来循环操作.

例如:

  • #foreach( $product in $allProducts )

  • $product

  • #end

#foreach循环将把 $allProducts列表里边的值赋值给products . 每次遍历,

$allProducts 里边的值将赋值给$product.

$allProducts 变量的内容是一个数组, Hashtable 或许 Array.

分配给$product 变量的值是Java的目标和一个变量的引证. 例如, 假设 $product是Java里边一个实在的Product类, 它的姓名可以被引证

$product.Name 办法(ie: $Product.getName()).

比方说 $allProducts 是一个Hashtable. 假设你想引证Hashtable

里边的key, 你的代码可以这么写:

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

  • Key: $key -> Value:

    $allProducts.get($key)

  • #end

Velocity供给了一种简略的循环计数以至于你可以做一些作业,如下所示:

#foreach( $customer in $customerList )

#end[table][tr][td]$foreach.count[/td][td]$customer.Name[/td][/tr][/table]

Velocity也供给了一种简略的办法来判别是不是是最终一次迭代 :

#foreach( $customer in $customerList )  

 $customer.Name#if( $foreach.hasNext ),#end#end

假设你想从零开端的#foreach循环, 你可以运用 $foreach.index

替代$foreach.count. 相同的, $foreach.first 和 $foreach.last

也供给了$foreach.hasNext办法.假设你想拜访 #foreach外面的这些特色, 你可以引证它们经过 $foreach.parent或

$foreach.topmost 特色 (e.g. $foreach.parent.index 或许

$foreach.topmost.hasNext).

你也可以设置最大的循环履行次数. 默许状况下没有设置 (可以指定一个值 0 或许更小的),

可以设置一个数字在velocity.properties的装备文件里边. This is useful as a fail-safe.

# The maximum allowed number of

loops.directive.foreach.maxloops = -1

假设你想中止一个foreach 循环在你的模板中, 你可以运用

#break指令在任何时分中止循环:

## list first 5 customers only#foreach( $customer

in $customerList )    #if( $foreach.count > 5 )        #break    #end  

 $customer.Name#end

引进

#include脚本元素答应规划者引进一个本地文件, 然后刺进到你#include

指令地点的当地。文件的内容不经过模板引擎处理. 由于安全的因素,这个文件只是可以放在 TEMPLATE_ROOT下面.

#include( "one.txt" )

#include 指定指向的文件放在括号以内. 假设包括多个文件,经过逗号进行分隔.

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

被引证的文件不需求经过姓名引证;

实际上,一般运用一个变量来替代文件名。当你恳求输出规范页面时十分便利。下面实例展现了文件名和变量.

#include( "greetings.txt", $seasonalstock )

解析

#parse脚本元素答应模板规划者引证一个包括VTL的本地文件。Velocity将解析其间的VTL并输出里边的元素。

#parse( "me.vm" )

向 #include指令, #parse可以被看着带着一个变量而不是模板. 任何被 #parse

指令引证的模板有必要放在TEMPLATE_ROOT下面. 不像 #include指令, #parse 只是带着了一个参数.

VTL模板中#parse运用的文件可以够嵌套引证包括#parse的模板. 默以为 10,

用户可以经过velocity.properties中directive.parse.max.depth来自界说设置单个文件中#parse引证文件个数. (留意:

假设velocity.properties文件中directive.parse.max.depth没有设置, Velocity默以为10.) 答应递归调用,

例如,假设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.” 今后的被显现, Velocity可以解析parsefoo.vm,

把count设置为8. 当count大于0, 它将显现 “All done with parsefoo.vm!” . 本实例中,

Velocity将回来dofoo.vm并输出 “All done with dofoo.vm!” 句子.

Break

#break指令中止任何正在履行的效果域中的输出. 履行效果域是本质上是 with content

(i.e. #foreach, #parse, #evaluate, #define, #macro, 或许 #@somebodymacro) 或许

任何”root” 效果域(例如. template.merge(…), Velocity.evaluate(…) or

velocityEngine.evaluate(…)). 不像#stop, #break 它只是中止的是循环内部, 效果域内部, 而不是全部程序.

假设你期望中止一个正在履行的效果域, 你可以运用效果域操控引证(例如. $foreach,

$template, $evaluate, $define, $macro, or $somebodymacro) 作为一个参数#break. (例如.

#break($macro)). 它将中止输出一切的到指定的一个. 在同一类型的嵌套规模内, 你可以拜访它的爸爸经过 $.parent 或许

$.最高的和传递这些到#break 替代(例如. #break($foreach.parent) o或许

#break($macro.topmost)).

Stop指令

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

#stop 指令中止任何正在履行的输出。这是实在的即便嵌套另一个模板经过 #parse

指令或许坐落一个velocity macro. 兼并输出将包括一切的内容到遇到 #stop 指令的方位. 它是很便利的随时停止模板解析.收支调试的意图,

你可以供给一个将被写到stop指令履行前日志 (DEBUG 级别, 当然是)音讯参数 (例如. #stop(‘$foo 并不在内容中’) ).

Evaluate指令

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

#evaluate指令用来动态的核算。它可以在加载的时分当令核算一个字符串.

例如一个字符串也许被用来国家化或则包括一有些数据库模板.

下面的实例将显现abc.

#set($source1 = "abc")#set($select =

"1")#set($dynamicsource = "$source$select")## $dynamicsource is now the string

'$source1'#evaluate($dynamicsource)

Define指令

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

#define指令可以指定对VTL一个块的引证.

下面的实例将显现:Hello World!.

#define( $block )Hello $who#end#set( $who =

'World!' )$block

宏调用

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

#macro 脚本元素答应模板规划者界说一个可重用的VTL模板片段.

Velocimacros(宏调用)被广泛用在简略和杂乱的场景中.Velocimacro可以用来保存用户的点击次数和起码的板式过错,

供给一个简略的概念介绍。

#macro( d )

#end[table][tr][td][/td][/tr][/table]

上个实例中Velocimacro被界说为d, 它可以像别的VTL办法相同被调用:

#d()

当#d()被调用的时, Velocity将用界说的一行内容来更换#d().假设你想内行里边增加内容,

你也可以向下面这么来改动macro的界说:

#macro( d )

#end[table][tr][td]$!bodyContent[/td][/tr][/table]

如今, 假设你想调用macro会和之前有点不相同, 姓名之前需求加上#@

加上一个内容体,一同以#end调用, 当Velocity加载时遇见 $!bodyContent会进行显现:

#@d()Hello!#end

假设你一向坚持像之前那种办法调用, 咱们运用隐形的引证替代body引证($!bodyContent

替代$bodyContent), 它将一向显现一个空的单元格.

Velocimacro也可以带着许多参数 — 乃至是不带参数, 好像第一个实例中, 参数是可选项–

可是当Velocimacro履行时, 它有必要调用和你界说的办法的参数匹配. 被履行的Velocimacros要多于上面界说的.

下面实例所示一个Velocimacro带着两个参数一个是color和一个数组.

#macro( tablerows $color $somelist )#foreach(

$something in $somelist )

#end#end[table][tr][td]$something[/td][/tr][/table]

上面的Velocimacro实例中, 界说一个tablerows,带两个参数.

第一个参数是$color, 第二个参数是 $somelist.

任何可以被放到VTL模板中都可以作为Velocimacro的函数体.  tablerows

是Velocimacro的一个 foreach句子. 这儿有两个 #end句子被界说在#tablerows中; 第一个是归于#foreach,

第二个是归于Velocimacro .

#set( $greatlakes =

["Superior","Michigan","Huron","Erie","Ontario"] )#set( $color = "blue" )

#tablerows( $color $greatlakes )

留意$greatlakes 替代 $somelist. 当 #tablerows被调用时,

将输出以下内容:

Superior
Michigan
Huron
Erie
Ontario

Velocimacros可以界说在Velocity模板的行内,意味着在同一个页面上它不可以运用别的的Velocity模板。界说一个Velocimacro并在一切模板中同享,这使它具有明显的优势:

它防止了在各个页面中重复界说Velocimacro, 削减作业量而且可以防止过错, 这种也可以经过改动一个当地而到达别的当地一同修正的意图.

#tablerows($color $list) Velocimacro 被界说在

Velocimacros 模板的依靠包中, 它可以确保在别的当地被许多运用. 它可以被多次重复运用来处理不相同的疑问.

在模板mushroom.vm中专心与正真的作业,#tablerows Velocimacro 可以被遍历,显现一切有些:

#set( $parts =

["volva","stipe","annulus","gills","pileus"] )#set( $cellbgcol = "#CC00FF" )

#tablerows( $cellbgcol $parts )

当你恳求mushroom.vm, Velocity 将在模板依靠包中查询#tablerows

(在velocity.properties界说的) 并输出下面内容:

volva
stipe
annulus
gills
pileus

Velocimacro

ArgumentsVelocimacros可以带着下面的VTL元素作为参数 :

Reference : anything that starts with ‘$’

String literal : something like “$foo” or

‘hello’

Number literal : 1, 2 etc

IntegerRange : [ 1..2] or [$foo .. $bar]

ObjectArray : [ “a”, “b”, “c”]

boolean value true

boolean value false

当传递一个引证作为Velocimacros的参数时,留意引证是经过姓名传递的.

这意味着它们的值是在Velocimacro中现已生成了. 这个特性答应你传递一个办法的调用引证在办法中也可以运用办法调用. 例如,

当咱们调用下面的Velocimacro将显现

#macro( callme $a )         $a $a $a     #end    

#callme( $foo.bar() )

在办法中 bar() 的成果将被调用三次.

首次看到这个特性会发现很惊讶,

当你仔细的思考Velocimacros背后的动机–消除VTL中公共的重复运用 –它变的有意义. 它答应你做一些作业,比方传递一个目标的状态,

例如在Velocimacro中重复生成有颜色的表格目标.

假设你不想运用这个特性,你就想从一个引证的办法中获取值,你可以这么做 :

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

)

Velocimacro

Properties在velocity.properties文件中答应灵敏的完结Velocimacros.

这儿也供给了开发者文档Developer Guide.

velocimacro.library– 一个通用的和别的依靠包分隔的

Velocimacro模板依靠包. 默许, Velocity看起来想一个独自的 函数库: VM_global_library.vm.

装备模板的途径用来运用找到Velocimacro 函数库.

velocimacro.permissions.allow.inline–

这个特色的值可以是true或许false, 决议是不是可以在模板中界说Velocimacros. 默许状况是, true,

答应模板规划者可以自行界说Velocimacros.

velocimacro.permissions.allow.inline.to.replace.global-它的值可以设定为true或许false,

这个设置答运用户指定一个模板中界说的Velocimacro能替代大局界说, 它在发动的时分被velocimacro.library特色加载.

默许是,false, 防止在发动时分模板中界说的Velocimacros变成大局Velocimacros.

velocimacro.permissions.allow.inline.local.scope–

这个特色也许值为true 或许 false, 默以为 false, 操控 界说的Velocimacros对界说中的模板是可见的.简而言之, 假设这个特色设置为

true, 一个模板可以界说可以被界说的模板运用的VMs内 . You can use this for fancy VM tricks – if a

global VM calls another global VM, 内行内的效果域内, 一个模板可以界说一个私有的完结第二个VM,它能被第一个VM调用.

可是对别的模板没有影响.

velocimacro.library.autoreload–

这个特色操控Velocimacro依靠包主动加载.

这个默许是的是false.当把特色设置为true,当Velocimacro被履行时它将查看Velocimacro是不是改动,

它重载很有必要的.它答应你改动和测验Velocimacro 不需求重庆你的运用和效劳器容器, 只是像你可以用一般的模板.

这个办法需求关闭缓存才起效果(e.g.file.resource.loader.cache = false). 这个特征首要用于开发办法,

而不是出产办法.

获取字面量

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

VTL运用了格外字符,例如 $ 和 #, 做为关键词,

所以一些运用者重视在模板中怎样运用这些字符.这章将评论转义字符 .

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

Currency(通用)

你这么写是没有疑问的 “I bought a 4 lb. sack of potatoes at

the farmer’s market for only $2.50!” 像上面说到的相同, VTL 标识符一向都是以大写或许小写的字母开端的, 所以

$2.50 不会被过错引证.

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

Escaping Valid VTL

References(屏蔽VTL中的引证)

你也许遇到这种状况,在Velocity中不想有一个引证输出.

屏蔽格外的字符是输出格外字符的最佳的办法, 你可以运用反斜杠字符,当遇见这些格外的字符是VTL引证的一有些时. *

#set( $email = "foo" )$email

假设在你的Velocity 模板中遇到一个 $email,它将在上下文中查询并输出精确的值.

上实例中将输出 foo, 由于$email 现已被界说了.假设 $emailis没有被界说, 它将输出$email.

参加 $email 现已界说了 (例如, 它的值为 foo), 可是你想输出 $email.

这儿有几种办法可以完结, 最简略的办法是运用转义字符. 请看下面实例:

## The following line defines $email in this

template:#set( $email = "foo" )$email\$email

输出

foo$email

假设,由于某种因素, 你需求在它之前增加一个反斜杠, 你需求依照下面实例做:

## The following line defines $email in this

template:#set( $email = "foo" )\\$email\\\$email

输出成果

\foo\$email

留意 \ 字符绑定到$ 左面的字符. 左面绑定规矩致使 \\\$email 输出为$email.

比照下面实例看看$email是不是被界说.

$email\$email\\$email\\\$email

输出

$email\$email\\$email\\\$email

留意Velocity界说的引证不相同于那些没有界说的引证 . 本实例中$foo

界说值为gibbous.

#set( $foo = "gibbous" )$moon = $foo

输出成果为: $moon = gibbous —

$moon将作为字符输出而$foo的当地将输出gibbous.

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

Escaping Invalid VTL

References(转义不可用VTL引证)

有时分你也许会遇到这种状况,当你的Velocity解析你的模板时遇见了一个你从来都没有计划把它当着引证的不可用的引证.

屏蔽格外的字符, 最佳的办法是你可以处理把握这种状况,在这种状况下, 反斜杠也许会失利. 你可以运用简略的办法来屏蔽对于$或#疑问,

你也许只是是更换一下:

${my:invalid:non:reference}

可以想这么

#set( $D = '$' )${D}{my:invalid:non:reference}

你也可以经过Java代码把  $或#字符串指令放到你的文本中

 (例如context.put("D","$");)来防止在你的模板中增加额定的 #set() 指令. 或许, 你也可以运用VelocityTools,

你可以运用EscapeTool:

${esc.d}{my:invalid:non:reference}

有效的和无效的VTL 指令运用相同的办法进行转义的; 在指令章节将对此进行具体描绘.

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

Escaping VTL

Directives(转义VTL指令)

VTL 指令可以被屏蔽经过反斜杠(“”) 字符和疲敝VTL引证办法是相同的.

## #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" )

需求格外关心的是转义在一个独自的指令中包括多个脚本元素VTL 指令(例如在一个

if-else-end句子). 这儿是一个典型的VTL if句子:

#if( $jazz )    Vyacheslav Ganelin#end

假设 $jazz为 true, 输出成果为

Vyacheslav Ganelin

假设$jazz 为false,这儿没有任何输出. Escaping 脚本元素修正输出成果.

思考下面实例:

\#if( $jazz )    Vyacheslav Ganelin\#end

它将致使指令被疏忽, 可是变量 $jazz 正常显现. 所以, 假设$jazz 为

true,输出成果是

#if( true )     Vyacheslav Ganelin #end

假设脚本之前的元素被反斜杠转义:

\\#if( $jazz )   Vyacheslav Ganelin\\#end

在本实例中, 假设$jazz 为 true,输出为

\ Vyacheslav Ganelin\

为了了解这一点,留意#if( arg ) 假设在新的一行完毕时,输出时将省掉这一行. 别的,

 #if()的句子块将紧跟着 ‘’,   在#if()之前参加两个'\\'. 最终的 \和文本在不相同的行由于在 ‘Ganelin’今后有一个新行,

所以终究\,#end之前的有些是程序体.

假设$jazz是 false, 输出成果为

\

留意一些履行将被中断假设元素没有特色被转义.

\\\#if( $jazz )    Vyacheslave Ganelin\\#end

这儿 #if 被转义, 可是这儿保存一个 #end 标签; 剩余的标签将致使解析过错.

VTL: Formatting Issues(格局化疑问)

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

尽管VTL的用户运用攻略中常常显现换行符和空格,VTL显现如下

#set( $imperial =

["Munetaka","Koreyasu","Hisakira","Morikune"] )#foreach( $shogun in $imperial )

   $shogun#end

上面实例和下面实例是等效的, Geir Magnusson Jr.

写给用户的邮件来说明这点彻底无关:

Send me #set($foo=["$10 and ","a pie"])#foreach($a

in $foo)$a#end please.

Velocity可以去掉剩余的空格. 前面的指令可以写成:

Send me#set( $foo = ["$10 and ","a pie"]

)#foreach( $a in $foo )$a#endplease.

or as

Send me#set($foo       = ["$10 and ","a pie"])    

            #foreach           ($a in $foo )$a         #end please.

在这些实例中输出成果将是相同的.

Other Features and Miscellany(别的的特性和杂记)

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

Math(算术操作)

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

Velocity中内置了一个算术函数,这些函数你可以在VTL模板中进行调用

.下面的实例别离展现加减乘数的运用:

#set( $foo = $bar + 3 )#set( $foo = $bar - 4

)#set( $foo = $bar * 6 )#set( $foo = $bar / 2 )

当两个整数相除时,成果是整数, 小数有些被丢弃. 模板中也可以运用求模运算符 (%).

#set( $foo = $bar % 5 )

Range Operator(规模操作符)

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

规模操作符可以联络着 #set 和 #foreach 句子运用.

用它可以发作一个证书数组,它的语法成果如下:

[n..m]

发作一个n到m的整数.

不管m大于或许小于n都不首要;在这个实例中这个规模即是简略的核算.下面的实例展现了规模操作符的运用:

第一个实例:#foreach( $foo in [1..5]

)$foo#end第二个实例:#foreach( $bar in [2..-2] )$bar#end第三个实例:#set( $arr = [0..1]

)#foreach( $i in $arr )$i#end第四个实例:[1..3]

输出成果为:

First example:1 2 3 4 5Second example:2 1 0 -1

-2Third example:0 1Fourth example:[1..3]

留意规模操作符只是发作数组当联络 #set 和 #foreach 指令,

正如在第四个比如中展现的.

页面规划者联络一个制造规范大小的表格, 有些状况下没有满足的数据填充表格,

将发现规模操作符格外有用.

Advanced Issues: Escaping and !(高档疑问:转义和!)

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

当一个引证前面加上! 字符和! 字符前面加上一个 \ 转义字符, 这种引证需求一种格外的处理办法.

留意规范的转义符和格外的\今后紧跟 !实例的不相同:

#set( $foo = "bar"

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

输出成果为:

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

比照这个规范 \ 优先$的转义:

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

输出成果为:

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

Velocimacro Miscellany(杂记)

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

这一章节是对于Velocimacros一些小疑问.本章节今后还会常常改动 ,

所以它很值得你重视.

Note : 贯穿全部章节, ‘Velocimacro’ 将被简写成 ‘VM’.

Can I use a directive or another VM as an

argument to a VM?Example :#center( #bold("hello") )

No. 一个指令不是一个可用的指令参数, 出于有用的意图, 一个VM是一个指令.

可是…, 这儿有许多作业你需求做. 一个简略的处理方案是运用编译器 ‘doublequote’

(“) 输出显现它的内容. 你可以想下面办法来做

#set($stuff = "#bold('hello')" )#center( $stuff

)

You can save a step…

#center( "#bold( 'hello' )" )

在这个实例中参数是在VM中核算的,而不是在调用时 . 简而言之, the argument to

the VM的参数传递到VM中进行核算 . 它答应你这么操作:

#macro( inner $foo )  inner : $foo#end#macro(

outer $foo )   #set($bar = "outerlala")   outer : $foo#end#set($bar =

'calltimelala')#outer( "#inner($bar)" )

输出成果为

Outer : inner : outerlala

由于 “#inner($bar)” 的核算发作在 #outer()的内部, 所以 $bar 的值是在

#outer() 内部进行赋值的.

这是一种有意的维护功用 – 参数经过姓名传递到VMs, 所以你可以传递VMs像状态引证,例如

#macro( foo $color )

#end#foo( $bar.rowColor() )

Hi
There

rowColor()被重复调用,而不是只是调用一次.为了防止这种状况, 在VM外面履行办法,

并把值传递给VM.

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

Can I register Velocimacros via #parse()

?Yes! This became possible in Velocity 1.6.

假设你运用之前的版别, 你的Velocimacros有必要首次运用之前就现已被界说

.它的意思是有的当你运用  #macro()之前都现已被界说了.

这是很首要的假设你妄图 #parse() 一个包括#macro() 指令模板. 由于

#parse() 在运行时才被调用,解析时 解析器决议是不是在你的模板中 VM-looking 元素是一个 VM, #parse()-ing 设置 VM

声明并不向期望那样作业. 为了避开这一点, 可以运用velocimacro.library来使Velocity发动时从头加载VMs.

What is Velocimacro

Autoreloading?这个特色用在开发办法下,  而不是生成环境 :

velocimacro.library.autoreload

默许是false. 当设置为true时

.resource.loader.cache = false

(是你运用资本的姓名, 例如 ‘file’)

然后Velocity将主动加载现已修正的Velocimacro依靠包文件当你装备该选项时,

所以你不比清空你的效劳器(或许引证的)或许经过别的办法来是Velocimacros重载.

这儿是一个简略的装备文件设置.

file.resource.loader.path = templates  

 file.resource.loader.cache = false    velocimacro.library.autoreload = true

在出产环境不能运用这种装备.

String Concatenation(字符串的拼接)

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

开发者常常会问一个很一般的疑问,即是怎样去拼接两个字符串?是不是类似于Java里边的’+’?.

为了实如今VTL中两个字符串的拼接VTL, 你只是需求把它们放在一同.

你需求把他们放在一同当你需求的时分, 请看下面实例.

在一个有规矩的 ‘schmoo’ 模板 (当你增加一个有规矩的内容时) :

#set( $size = "Big" )       #set( $name = "Ben" )

     The clock is $size$name.

输出成果为 ‘The clock is BigBen’. 这儿有更多有趣的实例,

例如当你想拼接字符串并传递给一个办法时, 或许界说一个新的引证,你只需求这么做

#set( $size = "Big" )      #set( $name = "Ben" )  

   #set($clock = "$size$name" )      The clock is $clock.

它们的输出成果是相同的. 作为最终一个实例, 当你想在你的引证中增加一个 ‘static’字符串时

, 你需求运用正式的引证 :

#set( $size = "Big" )      #set( $name = "Ben" )  

   #set($clock = "${size}Tall$name" )      The clock is $clock.

如今输出的是 ‘The clock is BigTallBen’。正式引证解析可以把 ‘$size’

和’$sizeTall’ 经过 ‘{}’ 进行区别隔.

反应

[img]http://naipan.com/neditor/themes/common/anchor.gif[/img]

假设你在这篇文档中遇见任何过错或许对Velocity用户攻略有关的主张和定见, 请发送邮件到

Velocity开发者列表 。谢谢!

[img]https://img.alicdn.com/imgextra/i2/2223466637/TB2PnMukXXXXXcvXpXXXXXXXXXX_!!2223466637.png[/img]

优质IT资源分享社区为你提供此文。

本站有大量优质Java教程视频,资料等资源,包含java基础教程,高级进阶教程等等,教程视频资源涵盖传智播客,极客学院,达内,北大青鸟,猎豹网校等等IT职业培训机构的培训教学视频,价值巨大。欢迎点击下方链接查看。

java教程视频

优质IT资源分享社区(www.itziyuan.top)
一个免费,自由,开放,共享,平等,互助的优质IT资源分享网站。
专注免费分享各大IT培训机构最新培训教学视频,为你的IT学习助力!

!!!回帖受限制请看点击这里!!!
!!!资源失效请在此版块发帖说明!!!

[PS:按 CTRL+D收藏本站网址~]

——“优质IT资源分享社区”管理员专用签名~

本版相似帖子

游客