xwork.xml

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN"
"http://www.opensymphony.com/xwork/xwork-1.0.dtd">

<xwork>
 <include file="webwork-default.xml"></include>
 <package name="default" extends="webwork-default">
  <action name="register" class="userAction" method="register">
   <result name="success">/register_success.jsp</result> 
   <result name="invalid.token">/repeaterror.jsp</result>
   <interceptor-ref name="params"></interceptor-ref>
   <interceptor-ref name="token"></interceptor-ref>
  </action>
 </package>

<include file="xwork-blogArticle.xml" />
</xwork>

xwork-blogArticle.xml

<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.0//EN"
"http://www.opensymphony.com/xwork/xwork-1.0.dtd">

<xwork>
 <package name="blogArticle" extends="blog" namespace="/blogArticle">  

<action name="searchBook" class="bookAction" method="searchBook">
   <result name="success">/jsp/searchBook_result.jsp</result>
 </action>

</package>
</xwork>

访问地址:http://localhost:8080/webworApp/blogArticle/searchBook.action

快速入门

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

FreeMarker基于设计者和程序员是具有不同专业技能的不同个体的观念他们是分工劳动的：
设计者专注于表示——创建HTML文件、图片、Web页面的其它可视化方面；
程序员创建系统，生成设计页面要显示的数据。
经常会遇到的问题是：在Web页面（或其它类型的文档）中显示的信息在设计页面时是无效的，是基于动态数据的。在这里，你可以在HTML（或其它要输出的文本）中加入一些特定指令，FreeMarker会在输出页面给最终用户时，用适当的数据替代这些代码。

先来解释一下freemaker的基本语法了，
<# ... > 中存放所有freemaker的内容，之外的内容全部原样输出。
<@ ... /> 是函数调用
两个定界符内的内容中，第一个符号表示指令或者函数名，其后的跟随参数。freemaker提供的控制包括如下：
<#if condition><#elseif condition><#else> 条件判断
<#list hash_or_seq as var> 遍历hash表或者collection（freemaker称作sequence）的成员
<#macro name param1 param2 ... ><#nested param> 宏，无返回参数
<#function name param1 param2><#return val>函数，有返回参数
var?member_function(...) 用函数对var进行转换，freemaker称为build-ins。实际内部实现类似member_function(var, ...)
stringA[M .. N] 取子字符串，类似substring(stringA, M, N)
{key:value, key2:value2 ...} 直接定义一个hash表
[item0, item1, item2 ...] 直接定义一个序列
hash0[key0] 存取hash表中key对应的元素
seq0[5] 存取序列指定下标的元素
<@function1 param0 param1 ... /> 调用函数function1
<@macro0 param0 param1 ; nest_param0 nest_param1 ...> nest_body </@macro> 调用宏，并处理宏的嵌套
<#assign var = value > 定义变量并初始化
<#local var = value> 在 macro 或者 function 中定义局部变量并初始化
<#global var = value > 定义全局变量并初始化
${var} 输出并替换为表达式的值
<#visit xmlnode> 调用macro匹配xmlnode本身及其子节点
<#recurse xmlnode> 调用macro匹配xmlnode的子节点

下面是一个例子：

  


  
Welcome ${user}!

  
Our latest product:
  ${latestProduct.name}!

  

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

(root)
  |
  +- user = "Big Joe"
  |
  +- latestProduct
      |
      +- url = "products/greenmouse.html"
      |
      +- name = "green mouse"

2、数据模型

（1）基础

在快速入门中介绍了在模板中使用的三种基本对象类型：scalars、hashes 和sequences，其实还可以有其它更多的能力：

• scalars：存储单值

• hashes：充当其它对象的容器，每个都关联一个唯一的查询名字

• sequences：充当其它对象的容器，按次序访问

• 方法：通过传递的参数进行计算，以新对象返回结果

• 用户自定义FTL标记：宏和变换器

通常每个变量只具有上述的一种能力，但一个变量可以具有多个上述能力，如下面的例子：

(root)
 |
 +- mouse = "Yerri"
     |
     +- age = 12
     |
     +- color = "brown">  

${mouse}       <#-- use mouse as scalar -->
${mouse.age}   <#-- use mouse as hash -->
${mouse.color} <#-- use mouse as hash -->  

Yerri
12
brown  

（2）Scalar变量

Scalar变量存储单值，可以是：

• 字符串：简单文本，在模板中使用引号（单引号或双引号）括起

• 数字：在模板中直接使用数字值

• 日期：存储日期/时间相关的数据，可以是日期、时间或日期-时间（Timestamp）；通常情况，日期值由程序员加到数据模型中，设计者只需要显示它们

• 布尔值：true或false，通常在<#if …>标记中使用

（3）hashes 、sequences和集合

有些变量不包含任何可显示的内容，而是作为容器包含其它变量，者有两种类型：

• hashes：具有一个唯一的查询名字和它包含的每个变量相关联

• sequences：使用数字和它包含的每个变量相关联，索引值从0开始

集合变量通常类似sequences，除非无法访问它的大小和不能使用索引来获得它的子变量；集合可以看作只能由<#list …>指令使用的受限sequences

（4）方法

方法变量通常是基于给出的参数计算值。

下面的例子假设程序员已经将方法变量avg放到数据模型中，用来计算数字平均值：

The average of 3 and 5 is: ${avg(3, 5)}
The average of 6 and 10 and 20 is: ${avg(6, 10, 20)}
The average of the price of python and elephant is: 
    ${avg(animals.python.price, animals.elephant.price)}

（5）宏和变换器

宏和变换器变量是用户自定义指令（自定义FTL标记），会在后面讲述这些高级特性

（6）节点

节点变量表示为树型结构中的一个节点，通常在XML处理中使用，会在后面的专门章节中讲

3、模板

（1）整体结构

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

• 文本：直接输出
• Interpolation：由${和}，或#{和}来限定，计算值替代输出
• FTL标记：FreeMarker指令，和HTML标记类似，名字前加#予以区分，不会输出
• 注释：由<#--和-->限定，不会输出

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

  


  <#-- Greet the user with his/her name -->
  
Welcome ${user}!

  
We have these animals:
  

  <#list animals as being>
    
${being.name} for ${being.price} Euros
  </#list>
  


  

注意事项：

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

• Interpolation只能在文本中使用

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

<#if <＃i nclude 'foo'>='bar'>...

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

Welcome ${user <#-- The name of user -->}!

We have these animals:

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

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

（2）指令

在FreeMarker中，使用FTL标记引用指令。有三种FTL标记，这和HTML标记是类似的：

• 开始标记：<#directivename parameters>

• 结束标记：</#directivename>

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

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

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

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

<#list animals as being>
  
${being.name} for ${being.price} Euros
  <#if use = "Big Joe">
     (except for you)
</#list>
</#if> <#-- WRONG! -->
  

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

<#list
  animals       as
     being
>
${being.name} for ${being.price} Euros
</#list    >  

（3）表达式

直接指定值

• 字符串

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

${"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: \ 

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

${r"${foo}"}

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

${foo}

C:\foo\bar  

• 数字

直接输入，不需要引号

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

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

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

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

• 布尔值

true和false，不使用引号

• 序列

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

<#list ["winter", "spring", "summer", "autumn"] as x>
${x}
</#list> 

winter
spring
summer
autumn

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

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

• 散列（hash）

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

获取变量

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

• 从散列中获取数据

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

(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"]

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

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

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

字符串操作

• Interpolation（或连接操作）

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

${"Hello ${user}!"}

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

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

${user + user + user + user}

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

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

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

• 子串

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

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

${user[1..4]}

BJ

ig J 

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

<#list ["Joe", "Fred"] + ["Julia", "Kate"] as user>
- ${user}
</#list>

- Joe
- Fred
- Julia
- Kate

• 连接操作：和字符串一样，使用+，如果具有相同的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  

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

${x * x - 100}
${x / 2}
${12 % 10}

-75
2.5
2  

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

${3 + "5"}  

35

${(x/2)?int}
${1.1?int}
${1.999?int}
${-1.1?int}
${-1.999?int}

2
1
1
-1
-1

• 比较操作符

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

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

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

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

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

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

• 逻辑操作符

&&（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>  

• 内建函数

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

• • 字符串使用的：

html：对字符串进行HTML编码

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

lower_case：将字符串转换成小写

upper_case：将字符串转换成大写

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

• • 序列使用的：

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

• • 数字使用的：

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

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

${test?html}
${test?upper_case?html}

Tom & Jerry
TOM & JERRY  

• 操作符优先顺序

（4）Interpolation

Interpolation有两种类型：

1. 通用Interpolation：${expr}

1. 数字Interpolation：#{expr}或#{expr; format}

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

• 通用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
$42.00
42
$42.00
4,200%

${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)

<#assign foo=true/>
${foo?string("yes", "no")}

yes

• 数字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  -->  

4、杂项

（1）用户定义指令

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

• 基本用法

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

<#macro greet>
  Hello Joe!
</#macro>  

<@greet></@greet>

<@greet/>

• 参数

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

<#macro greet person>
  Hello ${person}!
</#macro> 

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

  Hello Fred!

 and   Hello Batman!

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

<@greet person=Fred/>

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

<#macro greet person color>
  Hello ${person}!
</#macro> 

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

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

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

<#macro greet person color="black">
  Hello ${person}!
</#macro>  

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

• 嵌套内容

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

例子：

<#macro border>
  

<#nested>

</#macro>  

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

  

The bordered text

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

<#macro do_thrice>
  <#nested>
  <#nested>
  <#nested>
</#macro>
<@do_thrice>
  Anything.
</@do_thrice>  

  Anything.
  Anything.
  Anything. 

  


Hello Joe!
Hello Joe!
Hello Joe!

  

<#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: ? ? ?

<#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!

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

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

<#assign user = "Joe Hider">
${user}          <#-- prints: Joe Hider -->
${.globals.user} <#-- prints: Big Joe -->  

<#macro copyright date>
  
Copyright (C) ${date} Julia Smith. All rights reserved.
  
Email: ${mail}

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

<#import "/lib/my_test.ftl" as my>
<#assign mail="fred@acme.com">
<@my.copyright date="1999-2002"/>
${my.mail}
${mail}  

  
Copyright (C) 1999-2002 Julia Smith. All rights reserved.
  
Email: jsmith@acme.com

jsmith@acme.com
fred@acme.com  

<#import "/lib/my_test.ftl" as my>
${my.mail}
<#assign mail="jsmith@other.com" in my>
${my.mail}  

jsmith@acme.com
jsmith@other.com  

<#macro copyright date>
  
Copyright (C) ${date} ${user}. All rights reserved.

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

<#import "/lib/my_test.ftl" as my>
<@my.copyright date="1999-2002"/>
${my.mail}   

  
Copyright (C) 1999-2002 Fred. All rights reserved.

Fred@acme.com   


补充（静态方法的调用）：

方法1：
##定义配置文件 freemarkerstatic.properties 
_Validator=com.longyou.util.Validator 
_Functions=com.longyou.util.Functions 
_EscapeUtils=com.longyou.util.EscapeUtils 
/调用代码 
${_Functions.toUpperCase("Hello")}<br> 
${_EscapeUtils.escape("狼的原野")}

方法2：
${stack.findValue("@package.ClassName@method")}


补充：常用语法

EG.一个对象BOOK

1.输出 ${book.name}

空值判断：${book.name?if_exists },

${book.name?default(‘xxx’)}//默认值xxx

${ book.name!"xxx"}//默认值xxx

日期格式：${book.date?string('yyyy-MM-dd')}

数字格式：${book?string.number}--20

${book?string.currency}--<#-- $20.00 -->

${book?string.percent}—<#-- 20% -->

插入布尔值：

<#assign foo=ture />

${foo?string("yes","no")} <#-- yes -->

2．逻辑判断

a:

<#if condition>...

<#elseif condition2>...

<#elseif condition3>......

<#else>...

其中空值判断可以写成<#if book.name?? >

b:

<#switch value>

<#case refValue1>

...

<#break>

<#case refValue2>

...

<#break>

...

<#case refValueN>

...

<#break>

<#default>

...

3．循环读取

<#list sequence as item>

...

空值判断<#if bookList?size = 0>

e.g.

<#list employees as e>

${e_index}. ${e.name}

输出:

1. Readonly

2. Robbin

目前给我的感受

1、移植性强

2、代码量少

3、操作简洁

4、可扩展性强

5、可维护性好

       。。。

昨天修改新版竞猜Ask部分的首页,在发布的测试环境能正常运行,在我的测试环境里以前都ok,昨天上午突然不行了, Tapestry提示是空指针错误,可服务器没有任何异常提示,可见没有发生数据库访问上的sql异常,今天来了之后才发现,原来是DAO实现类的与之对应的那个方法,此方法调用的另外一个方法时,由于查不到此条件的数据,当时没考虑直接给它返回了一个null值,然后之个null返回到调用方法里是由于是一个对象,这个null对象再调用此模型的setter方法时便出现了潜在的空指针错误.由于此空指针错误不是在访问数据库时引起的,所以服务器没有报错,而是页面直接报错.由此以后再写方法时,思维要更加严密,考虑不周全,就可能为项目在以后的使用中埋下隐患.

1，action控制文件
package com.test;

import com.opensymphony.xwork.Action;

public class HelloAction implements Action{
	
	String greeting;

	public String getGreeting() {
		return greeting;
	}

	public String execute() throws Exception {
		
		greeting = "hello lunzi!!!  你好啊!!! haha";
		greeting = new String(greeting.getBytes("gbk"));	
		return SUCCESS;
	}
	
}
2，webwork配置文件[xwork.xml]
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE xwork PUBLIC "-//OpenSymphony Group//XWork 1.1.1//EN" 

"http://www.opensymphony.com/xwork/xwork-1.1.1.dtd">
<xwork>
	<include file="webwork-default.xml" />
	<package name="default" extends="webwork-default">

		
		<action name="hello"
			class="com.test.HelloAction">
			
			<result name="success" type="dispatcher">
				<param name="location">/getTest.jsp</param>
			</result>
			<interceptor-ref name="model-driven" />
			<interceptor-ref name="params" />
			<interceptor-ref name="validationWorkflowStack" />
		
		</action>
	</package>
</xwork>
3，应用配置文件[web.xml]
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" 
	xmlns="http://java.sun.com/xml/ns/j2ee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
	http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

  <servlet>
     <servlet-name>webwork</servlet-name>
        <servlet-

class>com.opensymphony.webwork.dispatcher.ServletDispatcher</servlet-class>
  </servlet>	

  <servlet-mapping>
     <servlet-name>webwork</servlet-name>
     <url-pattern>*.action</url-pattern>
  </servlet-mapping>

  <listener>
     <listener-class>
	org.springframework.web.context.ContextLoaderListener
     </listener-class>
  </listener>	

</web-app>
4，结果页[getTest.jsp]
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%@taglib prefix="ww" uri="/WEB-INF/webwork.tld"%>
<html>
  <body>
    <ww:property value="greeting" />
 
  </body>
</html>
5,请求地址http://localhost:8080/mywebwork/hello.action
6,效果如下图：