FreeMarker 学习

来源：互联网发布：智能仓库管理系统java 编辑：程序博客网时间：2024/06/07 07:00

FreeMarker概述

FreeMarker是一个模板引擎，一个基于模板生成文本输出的通用工具，使用纯Java编写

FreeMarker被设计用来生成HTML Web页面，特别是基于MVC模式的应用程序

虽然FreeMarker具有一些编程的能力，但通常由Java程序准备要显示的数据，由FreeMarker生成页面，通过模板显示准备的数据（如下图）

FreeMarker不是一个Web应用框架，而适合作为Web应用框架一个组件

FreeMarker与容器无关，因为它并不知道HTTP或Servlet；FreeMarker同样可以应用于非Web应用程序环境

FreeMarker更适合作为Model2框架（如Struts）的视图组件，你也可以在模板中使用JSP标记库

FreeMarker是免费的

FreeMarker不是一个Web应用框架，而适合作为Web应用框架一个组件

l FreeMarker与容器无关，因为它并不知道HTTP或Servlet；FreeMarker同样可以应用于非Web应用程序环境

l FreeMarker更适合作为Model2框架（如Struts）的视图组件，你也可以在模板中使用JSP标记库

l FreeMarker是免费的

1、通用目标

l 能够生成各种文本：HTML、XML、RTF、Java源代码等等

l 易于嵌入到你的产品中：轻量级；不需要Servlet环境

l 插件式模板载入器：可以从任何源载入模板，如本地文件、数据库等等

l 你可以按你所需生成文本：保存到本地文件；作为Email发送；从Web应用程序发送它返回给Web浏览器

2、强大的模板语言

l 所有常用的指令：include、if/elseif/else、循环结构

l 在模板中创建和改变变量

l 几乎在任何地方都可以使用复杂表达式来指定值

l 命名的宏，可以具有位置参数和嵌套内容

l 名字空间有助于建立和维护可重用的宏库，或者将一个大工程分成模块，而不必担心名字冲突

l 输出转换块：在嵌套模板片段生成输出时，转换HTML转义、压缩、语法高亮等等；你可以定义自己的转换

3、通用数据模型

l FreeMarker不是直接反射到Java对象，Java对象通过插件式对象封装，以变量方式在模板中显示

l 你可以使用抽象（接口）方式表示对象（JavaBean、XML文档、SQL查询结果集等等），告诉模板开发者使用方法，使其不受技术细节的打扰

4、为Web准备

l 在模板语言中内建处理典型Web相关任务（如HTML转义）的结构

l 能够集成到Model2 Web应用框架中作为JSP的替代

l 支持JSP标记库

l 为MVC模式设计：分离可视化设计和应用程序逻辑；分离页面设计员和程序员

5、智能的国际化和本地化

l 字符集智能化（内部使用UNICODE）

l 数字格式本地化敏感

l 日期和时间格式本地化敏感

l 非US字符集可以用作标识（如变量名）

l 多种不同语言的相同模板

6、强大的XML处理能力

l <#recurse> 和<#visit>指令（2.3版本）用于递归遍历XML树

l 在模板中清楚和直觉的访问XML对象模型

FreeMarker设计指南(1)

1、快速入门

（1）模板 + 数据模型 = 输出

l FreeMarker基于设计者和程序员是具有不同专业技能的不同个体的观念

l 他们是分工劳动的：设计者专注于表示——创建HTML文件、图片、Web页面的其它可视化方面；程序员创建系统，生成设计页面要显示的数据

l 经常会遇到的问题是：在Web页面（或其它类型的文档）中显示的信息在设计页面时是无效的，是基于动态数据的

l 在这里，你可以在HTML（或其它要输出的文本）中加入一些特定指令，FreeMarker会在输出页面给最终用户时，用适当的数据替代这些代码

l 下面是一个例子：

<html>

<head>

<title>Welcome!</title>

</head>

<body>

<h1>Welcome ${user}!</h1>

<p>Our latest product:

<a href="${latestProduct.url}">${latestProduct.name}</a>!

</body>

</html>

l 这个例子是在简单的HTML中加入了一些由${…}包围的特定代码，这些特定代码是FreeMarker的指令，而包含FreeMarker的指令的文件就称为模板（Template）

l 至于user、latestProduct.url和latestProduct.name来自于数据模型（data model）

l 数据模型由程序员编程来创建，向模板提供变化的信息，这些信息来自于数据库、文件，甚至于在程序中直接生成

l 模板设计者不关心数据从那儿来，只知道使用已经建立的数据模型

l 下面是一个可能的数据模型：

(root)

+- user = "Big Joe"

+- latestProduct

+- url = "products/greenmouse.html"

+- name = "green mouse"

l 数据模型类似于计算机的文件系统，latestProduct可以看作是目录，而user、url和name看作是文件，url和name文件位于latestProduct目录中（这只是一个比喻，实际并不存在）

l 当FreeMarker将上面的数据模型合并到模板中，就创建了下面的输出：

<html>

<head>

<title>Welcome!</title>

</head>

<body>

<h1>Welcome Big Joe!</h1>

<p>Our latest product:

<a href="products/greenmouse.html">green mouse</a>!

</body>

</html>

（2）数据模型

l 典型的数据模型是树型结构，可以任意复杂和深层次，如下面的例子：

(root)

+- animals

| |

| +- mouse

| | |

| | +- size = "small"

| | |

| | +- price = 50

| |

| +- elephant

| | |

| | +- size = "large"

| | |

| | +- price = 5000

| |

| +- python

| |

| +- size = "medium"

| |

| +- price = 4999

+- test = "It is a test"

+- whatnot

+- because = "don't know"

l 类似于目录的变量称为hashes，包含保存下级变量的唯一的查询名字

l 类似于文件的变量称为scalars，保存单值

l scalars保存的值有两种类型：字符串（用引号括起，可以是单引号或双引号）和数字（不要用引号将数字括起，这会作为字符串处理）

l 对scalars的访问从root开始，各部分用“.”分隔，如animals.mouse.price

l 另外一种变量是sequences，和hashes类似，只是不使用变量名字，而使用数字索引，如下面的例子：

(root)

+- animals

| |

| +- (1st)

| | |

| | +- name = "mouse"

| | |

| | +- size = "small"

| | |

| | +- price = 50

| |

| +- (2nd)

| | |

| | +- name = "elephant"

| | |

| | +- size = "large"

| | |

| | +- price = 5000

| |

| +- (3rd)

| |

| +- name = "python"

| |

| +- size = "medium"

| |

| +- price = 4999

+- whatnot

+- fruits

+- (1st) = "orange"

+- (2nd) = "banana"

l 这种对scalars的访问使用索引，如animals[0].name

（3）模板

l 在FreeMarker模板中可以包括下面三种特定部分：

Ø ${…}：称为interpolations，FreeMarker会在输出时用实际值进行替代

Ø FTL标记（FreeMarker模板语言标记）：类似于HTML标记，为了与HTML标记区分，用#开始（有些以@开始，在后面叙述）

Ø 注释：包含在<#--和-->（而不是）之间

l 下面是一些使用指令的例子：

Ø if指令

<#if animals.python.price < animals.elephant.price>

Pythons are cheaper than elephants today.

<#else>

Pythons are not cheaper than elephants today.

</#if>

Ø list指令

<p>We have these animals:

<tr><th>Name<th>Price

<#list animals as being>

<tr><td>${being.name}<td>${being.price} Euros

</#list>

</table>

输出为：

<p>We have these animals:

<tr><th>Name<th>Price

<tr><td>mouse<td>50 Euros

<tr><td>elephant<td>5000 Euros

<tr><td>python<td>4999 Euros

</table>

Ø include指令

<html>

<head>

</head>

<body>

<p>Blah blah...

<#include "/copyright_footer.html">

</body>

</html>

Ø 一起使用指令

<p>We have these animals:

<tr><th>Name<th>Price

<#list animals as being>

<tr>

<td>

<#if being.size = "large"><b></#if>

${being.name}

<#if being.size = "large"></b></#if>

<td>${being.price} Euros

</#list>

</table>

FreeMarker设计指南(3)

3、模板

（1）整体结构

l 模板使用FTL（FreeMarker模板语言）编写，是下面各部分的一个组合：

Ø 文本：直接输出

Ø Interpolation：由${和}，或#{和}来限定，计算值替代输出

Ø FTL标记：FreeMarker指令，和HTML标记类似，名字前加#予以区分，不会输出

Ø 注释：由<#--和-->限定，不会输出

l 下面是以一个具体模板例子

：

<html>[BR]

<head>[BR]

<title>Welcome!</title>[BR]

</head>[BR]

<body>[BR]

<#-- Greet the user with his/her name -->[BR]

<h1>Welcome ${user}!</h1>[BR]

<p>We have these animals:[BR]

<ul>[BR]

<#list animals as being>[BR]

<li>${being.name} for ${being.price} Euros[BR]

</#list>[BR]

</ul>[BR]

</body>[BR]

</html>

l [BR]是用于换行的特殊字符序列

l 注意事项：

Ø FTL区分大小写，所以list是正确的FTL指令，而List不是；${name}和${NAME}是不同的

Ø Interpolation只能在文本中使用

Ø FTL标记不能位于另一个FTL标记内部，例如：

<#if <#include 'foo'>='bar'>...</if>

Ø 注释可以位于FTL标记和Interpolation内部，如下面的例子：

<h1>Welcome ${user <#-- The name of user -->}!</h1>[BR]

<p>We have these animals:[BR]

<ul>[BR]

<#list <#-- some comment... --> animals as <#-- again... --> being>[BR]

...

Ø 多余的空白字符会在模板输出时移除

（2）指令

l 在FreeMarker中，使用FTL标记引用指令

l 有三种FTL标记，这和HTML标记是类似的：

Ø 开始标记：<#directivename parameters>

Ø 结束标记：</#directivename>

Ø 空内容指令标记：<#directivename parameters/>

l 有两种类型的指令：预定义指令和用户定义指令

l 用户定义指令要使用@替换#，如<@mydirective>...</@mydirective>（会在后面讲述）

l FTL标记不能够交叉，而应该正确的嵌套，如下面的代码是错误的：

<ul>

<#list animals as being>

<li>${being.name} for ${being.price} Euros

<#if use = "Big Joe">

(except for you)

</#list>

</#if> <#-- WRONG! -->

</ul>

l 如果使用不存在的指令，FreeMarker不会使用模板输出，而是产生一个错误消息

l FreeMarker会忽略FTL标记中的空白字符，如下面的例子：

<#list[BR]

animals as[BR]

being[BR]

>[BR]

${being.name} for ${being.price} Euros[BR]

</#list >

l 但是，<、</和指令之间不允许有空白字符

（3）表达式

l 直接指定值

Ø 字符串

n 使用单引号或双引号限定

n 如果包含特殊字符需要转义，如下面的例子：

${"It's /"quoted/" and

this is a backslash: //"}

${'It/'s "quoted" and

this is a backslash: //'}

输出结果是：

It's "quoted" and

this is a backslash: /

It's "quoted" and

this is a backslash: /

n 下面是支持的转义序列：

转义序列

含义

双引号(u0022)

单引号(u0027)

反斜杠(u005C)

换行(u000A)

Return (u000D)

Tab (u0009)

Backspace (u0008)

Form feed (u000C)

{

/xCode

4位16进制Unicode代码

n 有一类特殊的字符串称为raw字符串，被认为是纯文本，其中的/和{等不具有特殊含义，该类字符串在引号前面加r，下面是一个例子：

${r"${foo}"}

${r"C:/foo/bar"}

输出的结果是：

${foo}

C:/foo/bar

Ø 数字

n 直接输入，不需要引号

n 精度数字使用“.”分隔，不能使用分组符号

n 目前版本不支持科学计数法，所以“1E3”是错误的

n 不能省略小数点前面的0，所以“.5”是错误的

n 数字8、+8、08和8.00都是相同的

Ø 布尔值

n true和false，不使用引号

Ø 序列

n 由逗号分隔的子变量列表，由方括号限定，下面是一个例子：

<#list ["winter", "spring", "summer", "autumn"] as x>

${x}

</#list>

输出的结果是：

winter

spring

summer

autumn

n 列表的项目是表达式，所以可以有下面的例子：

[2 + 2, [1, 2, 3, 4], "whatnot"]

n 可以使用数字范围定义数字序列，例如2..5等同于[2, 3, 4, 5]，但是更有效率，注意数字范围没有方括号

n 可以定义反递增的数字范围，如5..2

Ø 散列（hash）

n 由逗号分隔的键/值列表，由大括号限定，键和值之间用冒号分隔，下面是一个例子：

{"name":"green mouse", "price":150}

n 键和值都是表达式，但是键必须是字符串

l 获取变量

Ø 顶层变量： ${variable}，变量名只能是字母、数字、下划线、$、@和#的组合，且不能以数字开头

Ø 从散列中获取数据

n 可以使用点语法或方括号语法，假设有下面的数据模型：

(root)

+- book

| |

| +- title = "Breeding green mouses"

| |

| +- author

| |

| +- name = "Julia Smith"

| |

| +- info = "Biologist, 1923-1985, Canada"

+- test = "title"

下面都是等价的：

book.author.name

book["author"].name

book.author.["name"]

book["author"]["name"]

n 使用点语法，变量名字有顶层变量一样的限制，但方括号语法没有该限制，因为名字是任意表达式的结果

Ø 从序列获得数据：和散列的方括号语法语法一样，只是方括号中的表达式值必须是数字；注意：第一个项目的索引是0

Ø 序列片断：使用[startIndex..endIndex]语法，从序列中获得序列片断（也是序列）；startIndex和endIndex是结果为数字的表达式

Ø 特殊变量：FreeMarker内定义变量，使用.variablename语法访问

l 字符串操作

Ø Interpolation（或连接操作）

n 可以使用${..}（或#{..}）在文本部分插入表达式的值，例如：

${"Hello ${user}!"}

${"${user}${user}${user}${user}"}

n 可以使用+操作符获得同样的结果

${"Hello " + user + "!"}

${user + user + user + user}

n ${..}只能用于文本部分，下面的代码是错误的：

<#if ${isBig}>Wow!</#if>

<#if "${isBig}">Wow!</#if>

应该写成：

<#if isBig>Wow!</#if>

Ø 子串

n 例子（假设user的值为“Big Joe”）：

${user[0]}${user[4]}

${user[1..4]}

结果是（注意第一个字符的索引是0）：

ig J

l 序列操作

Ø 连接操作：和字符串一样，使用+，下面是一个例子：

<#list ["Joe", "Fred"] + ["Julia", "Kate"] as user>

- ${user}

</#list>

输出结果是：

- Joe

- Fred

- Julia

- Kate

l 散列操作

Ø 连接操作：和字符串一样，使用+，如果具有相同的key，右边的值替代左边的值，例如：

<#assign ages = {"Joe":23, "Fred":25} + {"Joe":30, "Julia":18}>

- Joe is ${ages.Joe}

- Fred is ${ages.Fred}

- Julia is ${ages.Julia}

输出结果是：

- Joe is 30

- Fred is 25

- Julia is 18

l 算术运算

Ø ＋、－、×、／、％，下面是一个例子：

${x * x - 100}

${x / 2}

${12 % 10}

输出结果是（假设x为5）：

-75

2.5

Ø 操作符两边必须是数字，因此下面的代码是错误的：

${3 * "5"} <#-- WRONG! -->

Ø 使用+操作符时，如果一边是数字，一边是字符串，就会自动将数字转换为字符串，例如：

${3 + "5"}

输出结果是：

Ø 使用内建的int（后面讲述）获得整数部分，例如：

${(x/2)?int}

${1.1?int}

${1.999?int}

${-1.1?int}

${-1.999?int}

输出结果是（假设x为5）：

-1

l 比较操作符

Ø 使用=（或==，完全相等）测试两个值是否相等，使用!= 测试两个值是否不相等

Ø =和!=两边必须是相同类型的值，否则会产生错误，例如<#if 1 = "1">会引起错误

Ø Freemarker是精确比较，所以对"x"、"x "和"X"是不相等的

Ø 对数字和日期可以使用<、<=、>和>=，但不能用于字符串

Ø 由于Freemarker会将>解释成FTL标记的结束字符，所以对于>和>=可以使用括号来避免这种情况，例如<#if (x > y)>

Ø 另一种替代的方法是，使用lt、lte、gt和gte来替代<、<=、>和>=

l 逻辑操作符

Ø &&（and）、||（or）、!（not），只能用于布尔值，否则会产生错误

Ø 例子：

<#if x < 12 && color = "green">

We have less than 12 things, and they are green.

</#if>

<#if !hot> <#-- here hot must be a boolean -->

It's not hot.

</#if>

l 内建函数

Ø 内建函数的用法类似访问散列的子变量，只是使用“?”替代“.”，下面列出常用的一些函数

Ø 字符串使用的：

n html：对字符串进行HTML编码

n cap_first：使字符串第一个字母大写

n lower_case：将字符串转换成小写

n upper_case：将字符串转换成大写

n trim：去掉字符串前后的空白字符

Ø 序列使用的：

n size：获得序列中元素的数目

Ø 数字使用的：

n int：取得数字的整数部分（如-1.9?int的结果是-1）

Ø 例子（假设test保存字符串"Tom & Jerry"）：

${test?html}

${test?upper_case?html}

输出结果是：

Tom & Jerry

TOM & JERRY

l 操作符优先顺序

操作符组

操作符

后缀

[subvarName] [subStringRange] . (methodParams)

一元

+expr、-expr、!

内建

乘法

*、 / 、%

加法

+、-

关系

<、>、<=、>=（lt、lte、gt、gte）

相等

==（=）、!=

逻辑and

逻辑or

数字范围

（4）Interpolation

l Interpolation有两种类型：

Ø 通用Interpolation：${expr}

Ø 数字Interpolation：#{expr}或#{expr; format}

l 注意：Interpolation只能用于文本部分

l 通用Interpolation

Ø 插入字符串值：直接输出表达式结果

Ø 插入数字值：根据缺省格式（由#setting指令设置）将表达式结果转换成文本输出；可以使用内建函数string格式化单个Interpolation，下面是一个例子：

<#setting number_format="currency"/>

<#assign answer=42/>

${answer}

${answer?string} <#-- the same as ${answer} -->

${answer?string.number}

${answer?string.currency}

${answer?string.percent}

输出结果是：

$42.00

4,200%

Ø 插入日期值：根据缺省格式（由#setting指令设置）将表达式结果转换成文本输出；可以使用内建函数string格式化单个Interpolation，下面是一个使用格式模式的例子：

${lastUpdated?string("yyyy-MM-dd HH:mm:ss zzzz")}

${lastUpdated?string("EEE, MMM d, ''yy")}

${lastUpdated?string("EEEE, MMMM dd, yyyy, hh:mm:ss a '('zzz')'")}

输出的结果类似下面的格式：

2003-04-08 21:24:44 Pacific Daylight Time

Tue, Apr 8, '03

Tuesday, April 08, 2003, 09:24:44 PM (PDT)

Ø 插入布尔值：根据缺省格式（由#setting指令设置）将表达式结果转换成文本输出；可以使用内建函数string格式化单个Interpolation，下面是一个例子：

<#assign foo=true/>

${foo?string("yes", "no")}

输出结果是：

yes

l 数字Interpolation的#{expr; format}形式可以用来格式化数字，format可以是：

Ø mX：小数部分最小X位

Ø MX：小数部分最大X位

Ø 例子：

<#-- If the language is US English the output is: -->

<#assign x=2.582/>

<#assign y=4/>

#{x; M2} <#-- 2.58 -->

#{y; M2} <#-- 4 -->

#{x; m1} <#-- 2.6 -->

#{y; m1} <#-- 4.0 -->

#{x; m1M2} <#-- 2.58 -->

#{y; m1M2} <#-- 4.0 -->

FreeMarker设计指南(4)

4、杂项

（1）用户定义指令

l 宏和变换器变量是两种不同类型的用户定义指令，它们之间的区别是宏是在模板中使用macro指令定义，而变换器是在模板外由程序定义，这里只介绍宏

l 基本用法

Ø 宏是和某个变量关联的模板片断，以便在模板中通过用户定义指令使用该变量，下面是一个例子：

<#macro greet>

<font size="+2">Hello Joe!</font>

</#macro>

Ø 作为用户定义指令使用宏变量时，使用@替代FTL标记中的#

<@greet></@greet>

Ø 如果没有体内容，也可以使用：

<@greet/>

l 参数

Ø 在macro指令中可以在宏变量之后定义参数，如：

<#macro greet person>

<font size="+2">Hello ${person}!</font>

</#macro>

Ø 可以这样使用这个宏变量：

<@greet person="Fred"/> and <@greet person="Batman"/>

输出结果是：

<font size="+2">Hello Fred!</font>

and <font size="+2">Hello Batman!</font>

Ø 宏的参数是FTL表达式，所以下面的代码具有不同的意思：

<@greet person=Fred/>

Ø 这意味着将Fred变量的值传给person参数，该值不仅是字符串，还可以是其它类型，甚至是复杂的表达式

Ø 宏可以有多参数，下面是一个例子：

<#macro greet person color>

<font size="+2" color="${color}">Hello ${person}!</font>

</#macro>

Ø 可以这样使用该宏变量：

<@greet person="Fred" color="black"/>

Ø 其中参数的次序是无关的，因此下面是等价的：

<@greet color="black" person="Fred"/>

Ø 只能使用在macro指令中定义的参数，并且对所有参数赋值，所以下面的代码是错误的：

<@greet person="Fred" color="black" background="green"/>

<@greet person="Fred"/>

Ø 可以在定义参数时指定缺省值，如：

<#macro greet person color="black">

<font size="+2" color="${color}">Hello ${person}!</font>

</#macro>

Ø 这样<@greet person="Fred"/>就正确了

Ø 宏的参数是局部变量，只能在宏定义中有效

l 嵌套内容

Ø 用户定义指令可以有嵌套内容，使用<#nested>指令执行指令开始和结束标记之间的模板片断

Ø 例子：

<#macro border>

<#nested>

</tr></td></table>

</#macro>

这样使用该宏变量：

<@border>The bordered text</@border>

输出结果：

The bordered text

</tr></td></table>

Ø <#nested>指令可以被多次调用，例如：

<#macro do_thrice>

<#nested>

</#macro>

<@do_thrice>

Anything.

</@do_thrice>

输出结果：

Anything.

Ø 嵌套内容可以是有效的FTL，下面是一个有些复杂的例子：

<@border>

<ul>

<@do_thrice>

</@do_thrice>

</ul>

</@border>

输出结果：

<ul>

<li><font size="+2">Hello Joe!</font>

</ul>

</tr></td></table>

Ø 宏定义中的局部变量对嵌套内容是不可见的，例如：

<#macro repeat count>

<#local y = "test">

<#list 1..count as x>

${y} ${count}/${x}: <#nested>

</#list>

</#macro>

<@repeat count=3>${y?default("?")} ${x?default("?")} ${count?default("?")}</@repeat>

输出结果：

test 3/1: ? ? ?

test 3/2: ? ? ?

test 3/3: ? ? ?

l 在宏定义中使用循环变量

Ø 用户定义指令可以有循环变量，通常用于重复嵌套内容，基本用法是：作为nested指令的参数传递循环变量的实际值，而在调用用户定义指令时，在<@…>开始标记的参数后面指定循环变量的名字

Ø 例子：

<#macro repeat count>

<#list 1..count as x>

<#nested x, x/2, x==count>

</#list>

</#macro>

<@repeat count=4 ; c, halfc, last>

${c}. ${halfc}<#if last> Last!</#if>

</@repeat>

输出结果：

1. 0.5

2. 1

3. 1.5

4. 2 Last!

Ø 指定的循环变量的数目和用户定义指令开始标记指定的不同不会有问题

n 调用时少指定循环变量，则多指定的值不可见

n 调用时多指定循环变量，多余的循环变量不会被创建

（2）在模板中定义变量

l 在模板中定义的变量有三种类型：

Ø plain变量：可以在模板的任何地方访问，包括使用include指令插入的模板，使用assign指令创建和替换

Ø 局部变量：在宏定义体中有效，使用local指令创建和替换

Ø 循环变量：只能存在于指令的嵌套内容，由指令（如list）自动创建；宏的参数是局部变量，而不是循环变量

l 局部变量隐藏（而不是覆盖）同名的plain变量；循环变量隐藏同名的局部变量和plain变量，下面是一个例子：

<#assign x = "plain">

1. ${x} <#-- we see the plain var. here -->

<@test/>

6. ${x} <#-- the value of plain var. was not changed -->

<#list ["loop"] as x>

7. ${x} <#-- now the loop var. hides the plain var. -->

<#assign x = "plain2"> <#-- replace the plain var, hiding does not mater here -->

8. ${x} <#-- it still hides the plain var. -->

</#list>

9. ${x} <#-- the new value of plain var. -->

<#macro test>

2. ${x} <#-- we still see the plain var. here -->

<#local x = "local">

3. ${x} <#-- now the local var. hides it -->

<#list ["loop"] as x>

4. ${x} <#-- now the loop var. hides the local var. -->

</#list>

5. ${x} <#-- now we see the local var. again -->

</#macro>

输出结果：

1. plain

2. plain

3. local

4. loop

5. local

6. plain

7. loop

8. loop

9. plain2

l 内部循环变量隐藏同名的外部循环变量，如：

<#list ["loop 1"] as x>

${x}

<#list ["loop 2"] as x>

${x}

<#list ["loop 3"] as x>

${x}

</#list>

${x}

</#list>

${x}

</#list>

输出结果：

loop 1

loop 2

loop 3

loop 2

loop 1

l 模板中的变量会隐藏（而不是覆盖）数据模型中同名变量，如果需要访问数据模型中的同名变量，使用特殊变量global，下面的例子假设数据模型中的user的值是Big Joe：

<#assign user = "Joe Hider">

${user} <#-- prints: Joe Hider -->

${.globals.user} <#-- prints: Big Joe -->

（3）名字空间

l 通常情况，只使用一个名字空间，称为主名字空间

l 为了创建可重用的宏、变换器或其它变量的集合（通常称库），必须使用多名字空间，其目的是防止同名冲突

l 创建库

Ø 下面是一个创建库的例子（假设保存在lib/my_test.ftl中）：

<#macro copyright date>

<br>Email: ${mail}</p>

</#macro>

<#assign mail = "jsmith@acme.com">

Ø 使用import指令导入库到模板中，Freemarker会为导入的库创建新的名字空间，并可以通过import指令中指定的散列变量访问库中的变量：

<#import "/lib/my_test.ftl" as my>

<#assign mail="fred@acme.com">

${my.mail}

${mail}

输出结果：

<br>Email: jsmith@acme.com</p>

jsmith@acme.com

fred@acme.com

可以看到例子中使用的两个同名变量并没有冲突，因为它们位于不同的名字空间

l 可以使用assign指令在导入的名字空间中创建或替代变量，下面是一个例子：

<#import "/lib/my_test.ftl" as my>

${my.mail}

<#assign mail="jsmith@other.com" in my>

${my.mail}

l 输出结果：

jsmith@acme.com

jsmith@other.com

l 数据模型中的变量任何地方都可见，也包括不同的名字空间，下面是修改的库：

<#macro copyright date>

</#macro>

<#assign mail = "${user}@acme.com">

假设数据模型中的user变量的值是Fred，则下面的代码：

<#import "/lib/my_test.ftl" as my>

${my.mail}

l 输出结果：

Freemarker - 几个比较实用的例子 - -

用Freemarker做模本语言有一段时间了，列出几个和JSP或者Velocity相比起来比较方便的用途，目的是引诱更多的人跳上Freemarker这个贼船，

1. String内置的JavaScript转换： js_string
用途：用于JavaScript转义，转换',",换行等特殊字符
模板:

<script>
alert("${errorMessage?js_string}");
</script>

输出:
<script>
alert("Readonly/'s pet name is /"Cross Bone/"");
</script>

2.内置的默认值处理：default
用途: 用于处理默认值
模本:

User: ${userLogin.name?default("Anonymous")}
<td>${(employee.department.manager.name)?default(" ")}</td>

输出:

User: Anonymous
<td> </td>

注，可以对整个对象树加上()，再用内置处理器这种方便的做法，偶也是最近刚学会的，以前一直用很傻的方法做.....

3. Sequence内置的计数器: xxx_index
用途：显示序号
模板:
<#list employees as e>
${e_index}. ${e.name}
</#list>
输出:
1. Readonly
2. Robbin

4. Sequence内置的分段器: chunk
用途：某些比较BT的排版需求
模板:

<#assign seq = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']>
<#list seq?chunk(4) as row>
<ul>
<li><#list row as cell>${cell} </#list></li>
</ul>
</#list>

<#list seq?chunk(4, '-') as row>
<tr>
<td><#list row as cell>${cell} </#list></td>
</tr>
</#list>

输出:

<ul>
<li>a</li>
<li>b</li>
<li>c</li>
<li>d</li>
</ul>
<ul>
<li>e</li>
<li>f</li>
<li>g</li>
<li>h</li>
</ul>
<ul>
<li>i</li>
<li>j</li>
</ul>

<tr>
<td>a</td>
<td>b</td>
<td>c</td>
<td>d</td>
</tr>
<tr>
<td>e</td>
<td>f</td>
<td>g</td>
<td>h</td>
</tr>
<tr>
<td>i</td>
<td>j</td>
<td>-</td>
<td>-</td>
</tr>

FreeMarker概述

FreeMarker是一个模板引擎，一个基于模板生成文本输出的通用工具，使用纯Java编写
Template + data model = output
Hello world
FreeMarkerTest.java

import java.io.StringWriter;import java.util.HashMap;import java.util.Locale;

import freemarker.template.Configuration;import freemarker.template.Template;

publicclass FreeMarkerTest {

        publicstaticvoid main(String[] args){
               FreeMarkerTest test = new FreeMarkerTest();
               test.sayHello("Hermit");
        }

        publicvoid sayHello(String name){
               Configuration freemarkerCfg = new Configuration();
               freemarkerCfg.setClassForTemplateLoading(this.getClass(), "/");

               freemarkerCfg.setEncoding(Locale.getDefault(), "UTF-8");
               Template template;
               Locale.setDefault(Locale.ENGLISH);
               try{
                       template = freemarkerCfg.getTemplate("Hello.ftl");
                       template.setEncoding("UTF-8");
                       HashMap root = newHashMap();
                       root.put("user", name);

                       StringWriter writer = newStringWriter();
                       template.process(root, writer);
                       System.out.println(writer.toString());
               }catch(Exception e){
                       e.printStackTrace();
               }}

}

Hello.ftl

Hello ${user}!

输出

Hello Hermit!

空值的处理

在我们的程序中难免会碰到值为空的时候，如果用一个空值直接去替换模板中的标记，freemarker会毫不犹豫的抛出异常，并把错误信息直接写到输出结果里。为了对付这种情况我们有两种写法

模板

Hello ${user!}!
Hello ${user?if_exists}
Hello ${user!'your name'}!
Hello ${user?default('your name')}

程序

test.sayHello(null);

输出

Hello !
Hello your name!
Hello
Hello your name

freemarker国际化模板

freemarker支持多语言国际化，只要把模板名称按照java资源文件的写法就可以了,也就是name_语言_国家地区.ftl 如果找不到对应的语言，就会用默认语言的模板。

程序

import java.io.StringWriter;import java.util.HashMap;import java.util.Locale;

import freemarker.template.Configuration;import freemarker.template.Template;

publicclass FreeMarkerTest {

        publicstaticvoid main(String[] args){
               FreeMarkerTest test = new FreeMarkerTest();
               test.sayHello("hermit",Locale.CHINA);
               test.sayHello("hermit",Locale.ENGLISH);
        }

        publicvoid sayHello(String name,Locale locale){
               Configuration freemarkerCfg = new Configuration();
               freemarkerCfg.setClassForTemplateLoading(this.getClass(), "/");

               freemarkerCfg.setEncoding(Locale.getDefault(), "UTF-8");
               Template template;
               Locale.setDefault(Locale.ENGLISH);
               try{
                       template = freemarkerCfg.getTemplate("Hello.ftl",locale);
                       template.setEncoding("UTF-8");
                       HashMap root = newHashMap();
                       root.put("user", name);

                       StringWriter writer = newStringWriter();
                       template.process(root, writer);
                       System.out.println(writer.toString());
               }catch(Exception e){
                       e.printStackTrace();
               }
         }

}

默认语言模版:Hello.ftl

Hello ${user!}!
中文模版:Hello_zh_CN.ftl
你好 ${user!}!

输出

你好 hermit!
Hello hermit!

在struts项目中使用freemarker

1、引入freemarker.jar

2、web.xml加入


        <servlet><servlet-name>freemarker</servlet-name><servlet-class>
                       freemarker.ext.servlet.FreemarkerServlet
               </servlet-class>

               
             <init-param>
                <param-name>TemplatePath</param-name>
                <param-value>/</param-value>
             </init-param>
             <init-param>
                <param-name>NoCache</param-name>
                <param-value>true</param-value>
             </init-param>
             <init-param>
                <param-name>ContentType</param-name>
                <param-value>text/html</param-value>
             </init-param>

               <init-param><param-name>template_update_delay</param-name><param-value>0</param-value>

</init-param><init-param><param-name>default_encoding</param-name>
<param-value>utf-8</param-value></init-param>
<init-param><param-name>locale</param-name><param-value>en_US</param-value></init-param>
<init-param><param-name>number_format</param-name><param-value>0.##########</param-value></init-param>

               <load-on-startup>1</load-on-startup></servlet>

        <servlet-mapping><servlet-name>freemarker</servlet-name><url-pattern>*.ftl</url-pattern></servlet-mapping>

3、一个示例页面

<html><head><title>Say Hello</title><METAHTTP-EQUIV="Content-Type"CONTENT="text/html; charset=utf-8"></head><body><h1>Hello ${user}!</h1></body></html>

我们完全可以用freemarker的模板取代JSP页面。用freemarker的模板看起更简洁，可读性更强。比如现在struts2的UI标签就是用freemarker做的。

freemarker用struts标签做国际化

示例模板

<#assign html =JspTaglibs["/WEB-INF/struts-html.tld"]><#assign bean =JspTaglibs["/WEB-INF/struts-bean.tld"]><#assign logic =JspTaglibs["/WEB-INF/struts-logic.tld"]>

FreeMarker Struts Example </title><metahttp-equiv ="Content-type"content ="text/html; charset=utf-8"></ head ><body><@bean.message key ="hello" arg0 ="hermit"/></body></html>

主要是引入标签的时候要这样写：

<#assign html =JspTaglibs["/WEB-INF/struts-html.tld"]>

freemarker直接使用资源文件进行多语言国际化

程序

import java.io.StringWriter;import java.util.HashMap;import java.util.Locale;import java.util.ResourceBundle;

import freemarker.ext.beans.BeansWrapper;import freemarker.ext.beans.ResourceBundleModel;import freemarker.template.Configuration;import freemarker.template.Template;

publicclass FreeMarkerTest {

        publicstaticvoid main(String[] args){
               FreeMarkerTest test = new FreeMarkerTest();
               test.sayHello("hermit",Locale.CHINA);
               test.sayHello("hermit",Locale.ENGLISH);
        }

        publicvoid sayHello(String name,Locale locale){
               Configuration freemarkerCfg = new Configuration();
               freemarkerCfg.setClassForTemplateLoading(this.getClass(), "/");

               freemarkerCfg.setEncoding(Locale.getDefault(), "UTF-8");
               Template template;
               Locale.setDefault(Locale.ENGLISH);
               try{
                       template = freemarkerCfg.getTemplate("Hello.ftl");
                       template.setEncoding("UTF-8");
                       HashMap root = newHashMap();
                       root.put("user", name);
                       ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle("ApplicationResources",locale);
                       ResourceBundleModel rsbm = new ResourceBundleModel(RESOURCE_BUNDLE,new BeansWrapper());
                       root.put("bundle", rsbm);
                       StringWriter writer = newStringWriter();
                       template.process(root, writer);
                       System.out.println(writer.toString());
               }catch(Exception e){
                       e.printStackTrace();
               }}

}

模板

${bundle("hello","hermit")}

默认语言资源文件

hello=Hello {0}/!

中文资源文件

hello=你好 {0}/!

输出

你好 hermit!
Hello hermit!

关键的地方就是用ResourceBundleModel把ResourceBundle转换一下。

常用的2种加载模板的方式

普通java类根据当前class上下文环境加载模板

cfg.setClassForTemplateLoading(this.getClass(), "/");

在web项目中根据servlet上下文环境加载模板

cfg.setServletContextForTemplateLoading(this.getServlet().getServletContext(), "/");

jsp body源代码：

Java code

<body>

<jsp:include page="/html/top.html" flush="true"></jsp:include>

<jsp:include page="/html/channel.html" flush="true"></jsp:include>

<jsp:include page="/html/center.html" flush="true"></jsp:include>

<jsp:include page="/html/index_link.html" flush="true"></jsp:include>

<jsp:include page="/html/bottom.html" flush="true"></jsp:include>

</div>

</body>

整个网站首页的基本结构是通过jsp的include标签将所有通过freemarker生成的静态页面组织起来。后台控制各个部分的静态页生成。这样做将首页进行了拆分，便于了静态页面的维护，当我们需要生成“友情链接”部分的时候就只生成友情链接部分，而不需要将整个页面都从新生成一次。

使用freemarker。

Java code

/**

* 生成静态页面主方法

* @param context ServletContext

* @param data 一个Map的数据结果集

* @param templatePath ftl模版路径

* @param targetHtmlPath 生成静态页面的路径

public static void crateHTML(ServletContext context,Map<String,Object> data,String templatePath,String targetHtmlPath){

Configuration freemarkerCfg = new Configuration();

//加载模版

freemarkerCfg.setServletContextForTemplateLoading(context, "/");

freemarkerCfg.setEncoding(Locale.getDefault(), "UTF-8");

try {

//指定模版路径

Template template = freemarkerCfg.getTemplate(templatePath,"UTF-8");

template.setEncoding("UTF-8");

//静态页面路径

String htmlPath = context.getRealPath("/html")+"/"+targetHtmlPath;

File htmlFile = new File(htmlPath);

Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(htmlFile), "UTF-8"));

//处理模版

template.process(data, out);

out.flush();

out.close();

} catch (Exception e) {

e.printStackTrace();

}

其实很简单，只要Google一下就有很多这方面的代码。我也是Google的代码然后自己再根据实际情况修改。简单说明一下参数： ServletContext ：这个不用说了吧。做java web的应该都知道，只不过struts2中这样获取ServletActionContext.getServletContext()

Map <String,Object> data : 模版的数据来源。freemarker通过一个Map给ftl模版送数据。

现在已友情链接为列子详细介绍静态页面如何生成。其他模块以此类推。

String templatePath : ftl所在的路径。我这里相对于网站的一个相对路径然后通过ServerContext获取绝对路径。

String targetHtmlPath : 最后生成静态页的路径：我这里相对于网站的一个相对路径然后通过ServerContext获取绝对路径。

友情链接根据这段代码 <jsp:include page="/html/index_link.html" flush="true"> </jsp:include>我们需要freemarker生成一个index_link.html文件。友情链接数据来源通过数据库查询获取。

然后再写一个方法专门生成友情链接静态页面：

Java code

/**

* 生成友情链接的静态页index_link.html

* @param context

* @param data

public static void createIndexFriendLink(ServletContext context,Map<String,Object> data){

crateHTML(context,data,"index_link.ftl","index_link.html");

}

此方法调用上面的createHTML方法。然后根据以上方法我们就可以再Struts2的action里面从数据库查询数据放入map调用createIndexFriendLink()方法生成静态页了。

这是action中的一个方法:

Java code

/**

* 生成友情链接静态页index_link.html

* @return

public String createLink(){

//权限验证

if(! this.isAccess())

return "error";

try{

//得到友情链接

List links = friendLinkDAO.findAll();

//准备数据

HashMap<String,Object> data = new HashMap<String,Object>();

data.put("links", links);

//调用静态页面方法

HTML.createIndexFriendLink(ServletActionContext.getServletContext(), data);

addActionMessage("静态页面生成成功！");

return "message";

}catch(Exception e){

e.printStackTrace();

return "failure";

}

List links = friendLinkDAO.findAll();通过spring注入action的hiberate DAO获取数据给list然后通过以下代码
HashMap <String,Object> data = new HashMap <String,Object>();
data.put("links", links);
准备数据调用createIndexFriendLink()方法。
以下是：ftl模版源码：

Java code

<#if links?size != 0>

<#list links as link>

<a href="${link.linkUrl}" target="_blank" title="${link.linkName}">${link.linkName}</a>

</#list>

</div>

<#else>

</#if>

这样友情链接静态页就生成了。然后其他静态页依此葫芦画瓢。

总结：虽然静态页访问速度快，但实现起来毕竟还是不叫麻烦了，维护也是一个麻烦事情。如果您的站点更新速度快那么就需要在你的后台数据更新部分调用相应的createHTML方法实时的生成静态页面。如果更新速度不慢可以在后台手动更新或者利用操作系统的定时任务功能去执行你的静态页面生成程序。www.361pt.com这个网站我是才用了这两种方式。

2.实现替换
假设
3.更新问题
下面就讨论一下如何更新生成静态文件，其实从上面实现中你可以看到，很简单的就是将生成的静态文件删除即可，至于什么时候删除，要看你的需求了。我能想到的几种情况如下
当用来生成页面的数据更新时
如果不需要很提供时时的数据可以定时更新
永远不更新
----------------------------------------------------------------------------------------------------

JSP生成静态HTML页面范例

先建立一个模本页面:template.htm

<Html>
<head>
<title>###title###</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<LINK href="../Css.css" rel=stylesheet type=text/css>
</head>
<body>
<table width="500" border="0" align="center" cellpadding="0" cellspacing="2">
<tr>
<td align="center">###title###</td>
</tr>
<tr>
<td align="center">作者：###author###  </td>
</tr>
<tr>
<td>###content###
</td>
</tr>
</table>
</body>
</html>

=========================================
再写一个jsp页面: buildhtml.jsp

<%@ page contentType="text/html; charset=gb2312" import="Java.util.*,java.io.*"%>
<%
try{
String title="jsp生成静态html文件";
String content="小样，还搞不定你？";
String editer="webjxcom";
String filePath = "";
filePath = request.getRealPath("/")+"template.htm";
out.print(filePath);
String templateContent="";
FileInputStream fileinputstream = new FileInputStream(filePath);//读取模块文件
int lenght = fileinputstream.available();
byte bytes[] = new byte[lenght];
fileinputstream.read(bytes);
fileinputstream.close();
templateContent = new String(bytes);
out.print(templateContent);
templateContent=templateContent.replaceAll("###title###",title);
templateContent=templateContent.replaceAll("###content###",content);
templateContent=templateContent.replaceAll("###author###",editer);//替换掉模块中相应的地方
out.print(templateContent);
// 根据时间得文件名
Calendar calendar = Calendar.getInstance();
String fileame = String.valueOf(calendar.getTimeInMillis()) +".html";
fileame = request.getRealPath("/")+fileame;//生成的html文件保存路径
FileOutputStream fileoutputstream = new FileOutputStream(fileame);//建立文件输出流
out.print("文件输出路径:<br>");
out.print(fileame);
byte tag_bytes[] = templateContent.getBytes();
fileoutputstream.write(tag_bytes);
fileoutputstream.close();
}
catch(Exception e){
out.print(e.toString());
}
%>