OGNL

OGNL —— 完美的催化剂

         为了解决数据从View层传递到Controller层时的不匹配性，Struts2采纳
了XWork的OGNL方案。并且在OGNL的基础上，构建了OGNLValueStack的机制，从而
比较完美的解决了数据流转中的不匹配性。

         OGNL（Object Graph Navigation Language），是一种表达式语言。使
用这种表达式语言，你可以通过某种表达式语法，存取Java对象树中的任意属性、
调用Java对象树的方法、同时能够自动实现必要的类型转化。如果我们把表达式看
做是一个带有语义的字符串，那么OGNL无疑成为了这个语义字符串与Java对象之间
沟通的桥梁。

如何使用OGNL

让我们先研究一下OGNL的API，他来自于Ognl的静态方法：

Java代码 

/**  
* Evaluates the given OGNL expression tree to insert a value into the
object graph  
* rooted at the given root object.  The default context is set for the
given  
* context and root via <CODE>addDefaultContext()</CODE>.  
*  
* @param tree the OGNL expression tree to evaluate, as returned by
parseExpression()  
* @param context the naming context for the evaluation  
* @param root the root object for the OGNL expression  
* @param value the value to insert into the object graph  
* @throws MethodFailedException if the expression called a method which
failed  
* @throws NoSuchPropertyException if the expression referred to a
nonexistent property  
* @throws InappropriateExpressionException if the expression can't be
used in this context  
* @throws OgnlException if there is a pathological environmental problem  
*/  
public static void setValue( Object tree, Map context, Object root,
Object value ) throws OgnlException  



我们可以看到，OGNL的API其实相当简单，你可以通过传递三个参数来实现OGNL的
一切操作。而这三个参数，被我称为OGNL的三要素。



简单的API，就已经能够完成对各种对象树的读取和设值工作了。这也体现出OGNL
的学习成本非常低。

在上面的测试用例中，需要特别强调进行区分的，是在针对不同内容进行取值或者
设值时，OGNL表达式的不同。

Struts2 Reference 写道
The framework uses a standard naming context to evaluate OGNL
expressions. The top level object dealing with OGNL is a Map (usually
referred as a context map or context). OGNL has a notion of there being
a root (or default) object within the context. In expression, the
properties of the root object can be referenced without any special
"marker" notion. References to other objects are marked with a pound
sign (#).


上面这段内容摘自Struts2的Reference，我把这段话总结为以下2条规则：

A） 针对根对象（Root Object）的操作，表达式是自根对象到被访问对象的某个
链式操作的字符串表示。
B） 针对上下文环境（Context）的操作，表达式是自上下文环境（Context）到被
访问对象的某个链式操作的字符串表示，但是必须在这个字符串的前面加上#符
号，以表示与访问根对象的区别。


    上面的这点区别咋看起来非常容易理解，不过一旦放到特定的环境中，就会显
示出其重要性，它可以解释很多Struts2在页面展示上取值的各种复杂的表达式的
现象。这一点在下一篇文章中会进行具体的分析。

OGNL三要素

我把传入OGNL的API的三个参数，称之为OGNL的三要素。OGNL的操作实际上就是围
绕着这三个参数而进行的。

1. 表达式（Expression）

      表达式是整个OGNL的核心，所有的OGNL操作都是针对表达式的解析后进行
的。表达式会规定此次OGNL操作到底要干什么。

我们可以看到，在上面的测试中，name、department.name等都是表达式，表示取
name或者department中的name的值。OGNL支持很多类型的表达式，之后我们会看到
更多。

2. 根对象（Root Object）

       根对象可以理解为OGNL的操作对象。在表达式规定了“干什么”以后，你还
需要指定到底“对谁干”。

      在上面的测试代码中，user就是根对象。这就意味着，我们需要对user这个
对象去取name这个属性的值（对user这个对象去设置其中的department中的name属
性值）。

3. 上下文环境（Context）

     有了表达式和根对象，我们实际上已经可以使用OGNL的基本功能。例如，根
据表达式对根对象进行取值或者设值工作。

      不过实际上，在OGNL的内部，所有的操作都会在一个特定的环境中运行，这
个环境就是OGNL的上下文环境（Context）。说得再明白一些，就是这个上下文环
境（Context），将规定OGNL的操作“在哪里干”。

         OGNL的上下文环境是一个Map结构，称之为OgnlContext。上面我们提到
的根对象（Root Object），事实上也会被加入到上下文环境中去，并且这将作为
一个特殊的变量进行处理，具体就表现为针对根对象（Root Object）的存取操作
的表达式是不需要增加#符号进行区分的。

       OgnlContext不仅提供了OGNL的运行环境。在这其中，我们还能设置一些自
定义的parameter到Context中，以便我们在进行OGNL操作的时候能够方便的使用这
些parameter。不过正如我们上面反复强调的，我们在访问这些parameter时，需要
使用#作为前缀才能进行。

OGNL与模板

    我们在尝试了OGNL的基本操作并了解了OGNL的三要素之后，或许很容易把OGNL
的操作与模板联系起来进行比较。在很多方面，他们也的确有着相似之处。

对于模板，会有一些普通的输出元素，也有一些模板语言特殊的符号构成的元素，
这些元素一旦与具体的Java对象融合起来，就会得到我们需要的输出结果。

而OGNL看起来也是非常的类似，OGNL中的表达式就雷同于模板语言的特殊符号，目
的是针对某些Java对象进行存取。而OGNL与模板都将数据与展现分开，将数据放到
某个特定的地方，具体来说，就是Java对象。只是OGNL与模板的语法结构不完全相
同而已。

深入浅出OGNL

在了解了OGNL的API和基本操作以后，我们来深入到OGNL的内部来看看，挖掘一些
更加深入的知识。

OGNL表达式

        OGNL支持各种纷繁复杂的表达式。但是最最基本的表达式的原型，是将对
象的引用值用点串联起来，从左到右，每一次表达式计算返回的结果成为当前对
象，后面部分接着在当前对象上进行计算，一直到全部表达式计算完成，返回最后
得到的对象。OGNL则针对这条基本原则进行不断的扩充，从而使之支持对象树、数
组、容器的访问，甚至是类似SQL中的投影选择等操作。

接下来我们就来看看一些常用的OGNL表达式：

1. 基本对象树的访问

对象树的访问就是通过使用点号将对象的引用串联起来进行。

例如：name，department.name，user.department.factory.manager.name

2. 对容器变量的访问

对容器变量的访问，通过#符号加上表达式进行。

例如：#name，#department.name，#user.department.factory.manager.name

3. 使用操作符号

OGNL表达式中能使用的操作符基本跟Java里的操作符一样，除了能使用 +, -, *,
/, ++, --, ==, !=, = 等操作符之外，还能使用 mod, in, not in等。

4. 容器、数组、对象

OGNL支持对数组和ArrayList等容器的顺序访问：

例如：group.users[0]

同时，OGNL支持对Map的按键值查找：

例如：#session['mySessionPropKey']

不仅如此，OGNL还支持容器的构造的表达式：

例如：{"green", "red", "blue"}构造一个List，#{"key1" : "value1", "key2"
: "value2", "key3" : "value3"}构造一个Map

你也可以通过任意类对象的构造函数进行对象新建：

例如：new java.net.URL("http://localhost/")

5. 对静态方法或变量的访问

要引用类的静态方法和字段，他们的表达方式是一样的@class@member或者
@class@method(args)：

例
如：@com.javaeye.core.Resource@ENABLE，@com.javaeye.core.Resource@getAllResources

6. 方法调用

直接通过类似Java的方法调用方式进行，你甚至可以传递参数：

例如：user.getName()，group.users.size()，group.containsUser(#requestUser)

7. 投影和选择



OGNL支持类似数据库中的投影（projection） 和选择（selection）。

投影就是选出集合中每个元素的相同属性组成新的集合，类似于关系数据库的字段
操作。投影操作语法为 collection.{XXX}，其中XXX 是这个集合中每个元素的公
共属性。

例如：group.userList.{username}将获得某个group中的所有user的name的列表。

选择就是过滤满足selection 条件的集合元素，类似于关系数据库的纪录操作。选
择操作的语法为：collection.{X YYY}，其中X 是一个选择操作符，后面则是选择
用的逻辑表达式。而选择操作符有三种：
? 选择满足条件的所有元素
^ 选择满足条件的第一个元素
$ 选择满足条件的最后一个元素

例如：group.userList.{? #this.name != null}将获得某个group中user的name不
为空的user的列表。

上述的所有的表达式，只是对OGNL所有表达式的大概的一个概括，除此之外，OGNL
还有更多的表达式，例如lamba表达式等等。最具体的表达式的文档，大家可以参
考OGNL自带的文档：

http://www.ognl.org/2.6.9/Documentation/html/LanguageGuide/apa.html

在撰写时，我也参考了potain同学的XWork教程以及一些网络上的一些文章，特此
列出：

http://www.lifevv.com/java/doc/20071018173750030.html

http://blog.csdn.net/ice_fire2008/archive/2008/05/12/2438817.aspx

OGNLContext

    OGNLContext就是OGNL的运行上下文环境。OGNLContext其实是一个Map结构，
如果查看一下它的源码，就会发现，它其实实现了java.utils.Map的接口。当你在
调用OGNL的取值或者设值的方法时，你可能会自己定义一个Context，并且将它传
递给方法。事实上，你所传递进去的这个Context，会在OGNL内部被转化成
OGNLContext，而你传递进去的所有的键值对，也会被OGNLContext接管维护，这里
有点类似一个装饰器，向你屏蔽了一些其内部的实现机理。

        在OGNLContext的内部维护的东西很多，其中，我挑选2个比较重要的提一
下。一个是你在调用方法时传入的Context，它会被维护在OGNL内部，并且作为存
取变量的基础依据。另外一个，是在Context内部维护了一个key为root的值，它将
规定在OGNLContext进行计算时，哪个元素被指定为根对象。其在进行存取时，将
会被特殊对待。

this指针

    我们知道，OGNL表达式是以点进行串联的一个字符串链式表达式。而这个表达
式在进行计算的时候，从左到右，每一次表达式计算返回的结果成为当前对象，并
继续进行计算，直到得到计算结果。每次计算的中间对象都会放在一个叫做this的
变量里面这个this变量就称之为this指针。

例如：group.userList.size().(#this+1).toString()

在这个例子中，#this其实就是group.userList.size()的计算结构。

      使用this指针，我们就可以在OGNL表达式中进行一些简单的计算，从而完成
我们的计算逻辑，而this指针在lamba表达式的引用中尤为广泛，有兴趣的读者可
以深入研究OGNL自带的文档中lamba表达式的章节。

默认行为和类型转化

在我们所讲述的所有的OGNL的操作中，实际上，全部都忽略了OGNL内部帮助你完成
的很多默认行为和类型转化方面的工作。

我们来看一下OGNL在进行操作初始化时候的一个函数签名：



/**  
* Appends the standard naming context for evaluating an OGNL expression  
* into the context given so that cached maps can be used as a context.  
*  
* @param root the root of the object graph  
* @param context the context to which OGNL context will be added.  
* @return Context Map with the keys <CODE>root</CODE> and
<CODE>context</CODE>  
*         set appropriately  
*/  
public static Map addDefaultContext( Object root, ClassResolver
classResolver, TypeConverter converter, MemberAccess memberAccess, Map
context );  
可以看到，在初始化时，OGNL还需要额外初始化一个类型转化的接口和一些其他的
信息。只不过这些默认行为，由OGNL的内部屏蔽了。

一旦需要自己定义针对某个特定类型的类型转化方式，你就需要实现
TypeConverter接口，并且在OGNL中进行注册。

同时，如果需要对OGNL的许多默认行为做出改变，则需要通过设置OGNL的全局环境
变量进行。
 
 

OGNL是Object Graph Navigation Language的简称，详细相关的信息可以参
考：http://www.ognl.org <http://www.ognl.org/>。这里我们只涉及Struts2框
架中对OGNL的基本支持。

 

 

Struts 2默认的表达式语言是OGNL，原因是它相对其它表达式语言具有下面几大优势：

 1. 支持对象方法调用，如xxx.doSomeSpecial()；
 2. 支持类静态的方法调用和值访问，表达式的格式为@[类全名（包括包路
    径）]@[方法名 | 值名]，例如：@java.lang.String@format('foo %s',
    'bar')或@tutorial.MyConstant@APP_NAME；
 3. 支持赋值操作和表达式串联，如price=100, discount=0.8,
    calculatePrice()，这个表达式会返回80；
 4. 访问OGNL上下文（OGNL context）和ActionContext；
 5. 操作集合对象。

 

#、%和$这三个符号的使用：

 

“#”主要有三种用途：

 1. 访问OGNL上下文和Action上下文，#相当于ActionContext.getContext()；下
    表有几个ActionContext中有用的属性：
    名称     作用     例子
    parameters     包含当前HTTP请求参数的Map     #parameters.id[0]作用相当于
    request.getParameter("id")
    request     包含当前HttpServletRequest的属性（attribute)的Map
    #request.userName相当于request.getAttribute("userName")
    session     包含当前HttpSession的属性（attribute）的Map
    #session.userName相当于session.getAttribute("userName")
    application     包含当前应用的ServletContext的属性（attribute）的Map
    #application.userName相当于application.getAttribute("userName")
    attr     用于按request > session > application顺序访问其属性
    （attribute）     #attr.userName相当于按顺序在以上三个范围（scope）内读
    取userName属性，直到找到为止

 2. 用于过滤和投影（projecting)集合，如books.{?#this.price<100}；
 3. 构造Map，如#{'foo1':'bar1', 'foo2':'bar2'}。

“%”符号的用途是在标志的属性为字符串类型时，计算OGNL表达式的值。例如在
Ognl.jsp中加入以下代码：

<hr />
<h3>%的用途</h3>
<p><s:url value="#foobar['foo1']" /></p>
<p><s:url value="%{#foobar['foo1']}" /></p>

 

OGNL是一个对象，属性的查询语言。在OGNL中有一个类型为Map的Context（称为上
下文），在这个上下文中有一个根元素（root），对根元素的属性的访问可以直接
使用属性名字，但是对于其他非根元素属性的访问必须加上特殊符号#。

 

在Struts2中上下文为ActionContext，根元素位Value Stack（值堆栈，值堆栈代
表了一族对象而不是一个对象，其中Action类的实例也属于值堆栈的一个）。
ActionContext中的内容如下图：

 

              |--application

              |

              |--session

context map---|

              |--value stack(root)

              |

              |--request

              |

              |--parameters

              |

              |--attr (searches page, request, session, then application
scopes)
 
|–request
|
|–application
|
context map—|–OgnlValueStack(root) [ user, action, OgnlUtil, ... ]
|
|–session
|
|–attr
|
|–parameters

            

因为Action实例被放在Value Stack中，而Value Stack又是根元素（root）中的一
个，所以对Action中的属性的访问可以不使用标记#，而对其他的访问都必须使用#
标记。

 

我们可以使用”#requet”访问HttpServletRequest对象, “#session”访问
HttpSession对象，但请注意”根对象”是什么？是ValueStack!
那么ValueStack是什么？值栈。也就是一组对象的堆栈。也就是说，在struts2
中，根对象不是我们通常的一个对象，而是一组对象。我们可以push新的对象到值
栈中，也可以弹出值栈的栈顶对象。如上图所示，假设我们将user对象push到值栈
中，那么如下的表达式将与之前我们见过的表达式一样，具有相同的结果：
Java代码

name // 取用户的姓名
age // 取用户年龄
birthday // 取用户生日
customer.name // 取用户所属客户的名称
#request.parameters // 取请求参数

也就是说，我们使用name这个表达式的时候，ONGL会取”根对象”的name属性，但现
在根对象是ValueStack！那么访问 ValueStack的name属性意味着什么呢？这意味
着: ValueStack会先查看栈顶元素是否有name属性，如果有就返回该属性值，否则
取出栈顶下的元素，继续查看，直到栈底为止。

以上就是OGNL表达式的核心概念，你理解了吗？下一步，你需要了进一步了解OGNL
的语法，以发掘其更强大的功能

 

引用Action的属性

<s:property value="postalCode"/>

ActionContext中的其他非根（root）元素的属性可以按照如下的方式访问：

<s:property value="#session.mySessionPropKey"/> or

<s:property value="#session["mySessionPropKey"]"/> or

<s:property value="#request["mySessionPropKey"]/>

 

Action类可以使用ActionContext中的静态方法来访问ActionContext。

ActionContext.getContext().getSession().put("mySessionPropKey",
mySessionObject);


 

OGNL与Collection（Lists，Maps，Sets）

 


生成List的语法为: {e1,e2,e3}.

<s:select label="label" name="name"

list="{'name1','name2','name3'}" value="%{'name2'}" />

上面的代码生成了一个HTML Select对象，可选的内容
为： name1，name2，name3，默认值为：name2。

 

生成Map的语法为：#{key1:value1,key2:value2}.

<s:select label="label" name="name"

list="#{'foo':'foovalue', 'bar':'barvalue'}" />

上面的代码生成了一个HTML Select对象,foo名字表示的内容为：foovalue，bar名
字表示的内容为：barvalue。

 

对于集合，OGNL提供了两个元素符：in和not in，其中in判断某个元素是否在指定
集合中；not in则用于判断某个元素是否不在指定集合中。

判断一个对象是否在List内存在：

<s:if test="'foo' in {'foo','bar'}">

   muhahaha

</s:if>

<s:else>

   boo

</s:else>

 

<s:if test="'foo' not in {'foo','bar'}">

   muhahaha

</s:if>

<s:else>

   boo

</s:else>

 

取得一个List的一部分：

? – 所有满足选择逻辑的对象

^ -   第一个满足选择逻辑的对象

$ -   最后一个满足选择逻辑的对象

例如：

person.relatives.{? #this.gender == 'male'}

上述代码取得这个人（person）所有的男性（this.gender==male）的亲戚(relatives)

 

 


Lambda 表达式

 


OGNL支持简单的Lambda表达式语法，使用这些语法可以建立简单的lambda函数。

 

例如：

Fibonacci:

if n==0 return 0;

elseif n==1 return 1;

else return fib(n-2)+fib(n-1);

fib(0) = 0

fib(1) = 1

fib(11) = 89

 

OGNL的Lambda表达式如何工作呢？

Lambda表达式必须放在方括号内部，#this表示表达式的参数。例如：

<s:property value="#fib =:[#this==0 ? 0 : #this==1 ? 1 :
#fib(#this-2)+#fib(#this-1)], #fib(11)" />

 

#fib =:[#this==0 ? 0 : #this==1 ? 1 : #fib(#this-2)+#fib(#this-1)]定义了
一个Lambda表达式，

#fib(11) 调用了这个表达式。

 

所以上述代码的输出为：89

 

在JSP2.1中#被用作了JSP EL（表达式语言）的特殊记好，所以对OGNL的使用可能
导致问题，

一个简单的方法是禁用JSP2.1的EL特性，这需要修改web.xml文件：

<jsp-config>

    <jsp-property-group>

      <url-pattern>*.jsp</url-pattern>

      <el-ignored>true</el-ignored>

    </jsp-property-group>

</jsp-config>


 

 

*4.6**节 Tag 语法*

代码示例：

*表达式*

   

*含义*

<p>Username: ${user.username}</p>

   

一个在标准上下文中的JavaBean对象，可以适用Freemarker，Velocity,JSTL EL等
（不是OGNL）。

<s:textfield name="username"/>

   

在Value Stack中的一个username属性。

<s:url id="es" action="Hello">

<s:param name="request_locale">

    es

</s:param>

</s:url>

<s:a href="%{es}">Espanol</s:a>

   

引用Value Stack中属性的另外一种方法。

<s:property

name="#session.user.username" />

   

Session中的user对象的username属性。

<s:select

label="FooBar" name="foo"

list="#{'username':'trillian',

    'username':'zaphod'}" />

   

一个简单的静态Map，和put("username","trillian")一样

 

 

 


Struts2在OGNL基础上的增强


　　１、值栈(ValueStack)
　　　　Struts2将OGNL上下文设置为Struts2中的ActionContext(内部使用的仍然
是OgnlContext)，并将值栈设为OGNL的根对象。
　　　　我们知道，OGNL上下文中的根对象可以直接访问，不需要使用任何特殊的
“标记”，而引用上下文中的其他对象则需要使用“#”来标记。由于值栈是上下文中
的根对象，因此可以直接访问。那么对于值栈中的对象该如何访问呢？Struts2提
供了一个特殊的OGNLPropertyAccessor，它可以自动查找栈内的所有对象(从栈顶
到栈底)，直接找到一个具有你所查找的属性的对象。也就是说，对于值栈中的任
何对象都可以直接访问，而不需要使用 “#”。
　　　　假设值栈中有两个对象：student和employee，两个对象都有name属
性，student有学号属性number，而 employee有薪水属性salary。employee先入
栈，student后入栈，位于栈顶，那么对于表达式name,访问的就是student 的name
属性，因为student对象位于栈顶；表达式salary，访问的就是employee的salary
属性。正如你所见，访问值栈中的对象属性或方法，无须指明对象，也不用“#”，
就好像值栈中的对象都是OGNL上下文中的根对象一样。这就是Struts2在OGNL基础
上做出的改进。
　　２、[N]语法
　　　　如上所述，如果想要访问employee的name属性，应该如何写表达式呢？我
们可以使用[N].xxx(N是从0开始的整数)这样的语法来指定从哪一个位置开始向下
查找对象的属性，表达式[1].name访问的就是employee对象的name属性。
　　　　在使用[N].xxx语法时，要注意位置序号的含义，它并不是表示“获取栈中
索引为N的对象”，而是截取从位置N开始的部分栈。
　　３、top关键字
　　　　top用于获取栈顶的对象，结合[N].xxx语法，我们就可以获取栈中任意位
置的对象。
　　　　如：[0].top,[1].top等
　　４、访问静态成员
　　　　除了使用标准的OGNL表达式访问静态字段和静态方法外，Struts2还允许
你不指定完整的类名，而是通过“vs”前缀来调用保存在栈中的静态字段和静态方法。
　　　　@vs@FOO_PROPERTY
　　　　@vs@someMethod()
　　　　@vs1@someMethod()
　　　　vs表示ValueStack，如果只有vs，那么将使用栈顶对象的类；如果在vs后
面跟上一个数字，那么将使用栈中指定位置处的对象类。
　　５、值栈中的Action实例
　　　　Struts2框架总是把Action实例放在栈顶。因为Action在值栈中，而值栈
又是OGNL中的根，所以引用Action的属性可以省略“#”标记，这也是为什么我们在
结果页面中可以直接访问Action的属性的原因。
　　６、Struts2中的命名对象
　　　　Struts2还提供了一些命名对象，这些对象没有保存在值栈中，而是保存
在ActionContext中，因此访问这些对象需要使用“#”标记。这些命名对象都是Map
类型。
　　　parameters
　　　　用于访问请求参数。如：#parameters['id']或#parameters.id，相当于
调用了HttpServletRequest对象的getParameter()方法。
　　　　注意，parameters本质上是一个使用HttpServletRequest对象中的请求参
数构造的Map对象，一量对象被创建(在调用Action实例之前就已经创建好了)，它
和HttpServletRequest对象就没有了任何关系。
　　　request
　　　　用于访问请求属性。如：#request['user']或#request.user，相当于调
用了HttpServletRequest对象的getAttribute()方法。
　　　session
　　　　用于访问session属性。如：#session['user']或#session.user，相当于
调用了HttpSession对象的getAttribute()方法。
　　　application
　　　　用于访问application属性。如：#application['user']
或#application.user，相当于调用了ServletContext的getAttribute()方法。
　　　attr
　　　　如果PageContext可用，则访问PageContext，否则依次搜索request、
session和application对象。

 

PS:

在JSP 2.1 下 # 被加入了 JSP EL.中。这可能导致一些应用OGNL#号操作的程序出
问题，下面是一种快速修复的方法是在web.xml中加上jsp-config的标签，这适用
于一些支持JSP 2.1 EL表达式的容器，如GlassFish.

<jsp-config>
<jsp-property-group>
<url-pattern>*.jsp</url-pattern>
<el-ignored>true</el-ignored>
</jsp-property-group>
</jsp-config>

 


      struts中#、%和$这三个符号的使用方法 </blog/737141>

*文章分类:Java编程 <http://www.javaeye.com/blogs/category/java>*

一、"＃"的用法
   1、 访问OGNL上下文和Action上下文，#相当于ActionContext.getContext()；
下表有几个ActionContext中有用的属性： 

        parameters  包含当前HTTP请求参数的Map #parameters.id[0]作用相当
于request.getParameter("id")

       request 包含当前HttpServletRequest的属性（attribute)的Map
#request.userName相当于request.getAttribute("userName")

       session 包含当前HttpSession的属性（attribute）的Map
#session.userName相当于session.getAttribute("userName")

       application 包含当前应用的ServletContext的属性（attribute）的Map
#application.userName相当于application.getAttribute("userName")

       attr 用于按request > session > application顺序访问其属性
（attribute） #attr.userName相当于按顺序在以上三个范围（scope）内读取
userName属性，直到找到为止

     2、用于过滤和投影（projecting)集合，如books.{?#this.price<100}；

     3、构造Map，如#{'foo1':'bar1', 'foo2':'bar2'}。

二、"%"的用法

    “%”符号的用途是在标志的属性为字符串类型时，计算OGNL表达式的值。例如
在Ognl.jsp中加入以下代码：

    <h3>%的用途</h3>
    <p><s:url value="#foobar['foo1']" /></p>
    <p><s:url value="%{#foobar['foo1']}" /></p>

三、"$"的用法

    1、用于在国际化资源文件中，引用OGNL表达式

    2、在Struts 2配置文件中，引用OGNL表达式

     例如：
         <action name="AddPhoto" class="addPhoto">
            <interceptor-ref name="fileUploadStack" />           
            <result type="redirect">ListPhotos.action?     
albumId=${albumId}</result>
        </action>