ognl 详解

57 阅读 0 评论 38 点赞

我是靠谱客的博主瘦瘦春天，最近开发中收集的这篇文章主要介绍ognl 详解，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

在进行Struts2的标签库介绍之前，有必要着重对OGNL（Object Graph Navigating Language）对象导航语言做一详细解析。因为在之后的演示代码中经常会用到一些有关OGNL的代码，为了不让读者一头雾水，也为了更好学习 Struts2的标签库。因此笔者把OGNL当作学习Struts2标签库的基础知识来介绍。让大家学习Struts2的基础打得更加扎实点。
技术要点
本节代码对OGNL一些常用特性进行分析，用演示代码演示这些特性。
   常用特性介绍。
   OGNL在Struts2中页面中的应用。
   OGNL特殊符号介绍。
演示代码
利用OGNL进行应用的页面：

Java代码  

 <!--------------------文件名：ognl.jsp------------------->  
 <%@ taglib prefix="s" uri="/struts-tags" %>  
 <body>  
    <!--  OGNL显示request、response中的值  -->   
     <h3 align="left">Session和Request值</h3>  
     request.materialName: <s:property value="#request.materialName" /><br/>  
     session.materialName: <s:property value="#session.get('materialName')" /><br/>  
    
   <!--  OGNL显示条件表达式过滤的数据  -->  
     <h3 align="left">根据条件显示数据</h3>  
     <p>价格小于50元的建材</p>  
     <ul>  
         <s:iterator value="materials.{?#this.mainbid <50}">  
             <li><s:property value="materialName"/> 建材价格是 <s:property value="mainbid"/>元!</li>  
         </s:iterator>  
     </ul>  
     <p> "人造石台面" 的库存数量是: <s:property value="materials.{?#this.materialName=='人造石台面'}.{mount}[0]"/></p>  
     
    <!--  OGNL新建Map类型数据集合，显示子元素值  -->  
     <h3 align="left">Map数据显示</h3>  
     <s:set name="frank" value="#{'material':'欧龙无苯油漆(六度)', 'mount':'500'}" />  
     <p>供销商frank手里还有建材 <s:property value="#frank['material']" /></p>  
     <p>库存量为<s:property value="#frank['mount']" /></p>    
 </body>  

struts.xml文件配置：

Java代码  

 <!----------------文件名：struts.xml-------------------------->  
 <package name="C05.2" extends="struts-default">  
     <!-- 创建Action -->  
         <action name="ognl" class="action.OgnlExampleAction">  
 <result name="success">/jsp/ognl.jsp</result>  
 </action>       
 </package>  

OGNL示例Action代码：

Java代码  

 <!-------------------文件名：OgnlExampleAction.java------------------>  
 public class OgnlExampleAction extends ActionSupport {  
 //设置request、response参数和需要显示的数据集合定义  
 private HttpServletRequest request;  
     private HttpSession session;  
     private List<Material> materials;  
   
 public String  execute() throws Exception {  
     request = ServletActionContext.getRequest();  
     session=request.getSession();  
     //设置request、session存放值  
     request.setAttribute("materialName","人造石台面 From request");  
         session.setAttribute("materialName","欧龙无苯油漆(六度) From session");  
          
         //初始化数据集合，集合类型为List  
         materials = new ArrayList<Material>();  
         materials .add(new Material("欧龙无苯油漆(六度)", 100, 2000));  
         materials .add(new Material("6*10mm门套线红影木夹板饰面(单面)", 20, 2900));  
         materials .add(new Material("人造石台面", 56, 800));  
 return SUCCESS;  
 }  
 //setter，getter方法  
 public HttpServletRequest getRequest() {  
 return request;  
 }  
   
 public void setRequest(HttpServletRequest request) {  
 this.request = request;  
 }  
   
 …………  
 }  

材料数据类：

Java代码  

 <!--------------文件名：Material.java------------------>  
 //材料对象  
 public class Material {  
 //材料名  
 private String materialName;  
 //材料价格  
 private int mainbid;  
 //材料数量  
 private int mount;  
   
 //构造初始化数据  
 public Material(String materialName, int mainbid, int mount) {  
 super();  
 this.materialName = materialName;  
 this.mainbid = mainbid;  
 this.mount = mount;  
 }  
 //setter，getter方法  
 public String getMaterialName() {  
 return materialName;  
 }  
   
 public void setMaterialName(String materialName) {  
 this.materialName = materialName;  
 }  
 ………  
 }  

运行效果图如图5.1所示。

图5.1 OGNL运行示例效果图
代码解释
（1）Struts2中将应用范围里的数据以及Action处理的数据都存储在一个区域里。在Struts2中叫做“valueStack”，中文名为“值栈”。而OGNL就是从“值栈”取出数据，并在某些条件下进行数据过滤和计算的表达式语言。在Struts2中值栈作为OGNL的根对象，从值栈中取出自己需要的数据，而且值栈存取数据是按照先入后出的概念。因此查询数据时候往往是值栈中最顶部的数据先被查询出来。更加需要指出的是在值栈中也可以使用索引，可以在指定的索引位置开始搜索数据。
在OGNL中如果搜索的数据不是值栈里存储的数据，而且其他对象中，特别是Struts2的ActionContext中的对象，则在访问这些对象时候，前面要加“#”。比如ognl.jsp中访问session和request对象时候代码中在request和session之前就有“#”。
对于数据集合类型，如果根据条件查询该集合里的数据，形成子集合的时候，常用的OGNL还有“？”、“^”、“$”。此三个符号中“？”是取得所有符合条件的数据时使用。“^”是取这些符合条件的数据中索引中第一个或第一条数据。而“$”则正好相反，是取得最后一个或最后一条数据。
在OGNL中，还有lamuda表达式和很多计算公式的表达式，笔者认为如果坚持松耦合理念的话，最好不要使用。毕竟OGNL更多使用在MVC模式中view和comtrol两层，而计算公式等OGNL知识更多的和业务逻辑联系关联比较大，所以本书就不做过多介绍。
（2）本示例中，首先创建了建筑材料的模型对象。其中有材料名、材料价格、材料库存量三个属性。在OgnlExampleAction中做了两件事情，一件事情是在request、session中各放入key为“materialName”的值。另一件事情是初始化三个材料对象，将这些对象放在 List类型的数据集合中。
然后在struts.xml中对OgnlExampleAction做定义，将其导航到ognl.jsp中。在该jsp中，读者参看其代码。首先将request、session中“materialName”的值用OGNL取出。因为request、session都不是值栈，所以在它们名字之前都以“#”开头。在代码中将之前List类型的数据集合中所有材料价格小于50的数据显示出来。这里用了“？”也就是之前所说去取符合条件的数据集时使用。
在取材料名为“人造石台面”的材料库存量时候，OGNL先利用条件过滤得到符合条件的材料对象集然后用“{}”去取库存量属性，再取该子集中第一个索引，这里索引次序和Java中相同，也是从“0”开始表明集合中第一个元素。
在ognl.jsp中,OGNL也新建了一个Map对象，然后定义了该对象中的key和value。OGNL对于显示Map对象中某个key的值采取ognl.jsp代码中所示。“[]”中写key的名字，并用‘’包含。
（3）OGNL中经常会有“#”、“%”、“$”三个符号。一般“#”都是像前文所述代表那些非值栈的对象。还有就是ognl.jsp中创建 Map对象时候用到。而“%”则是显示对象中的值。至于“$”则是用来显示属性文件中定义的值。比如某属性文件中定义了“kkk=10”则在 Struts2的struts.xml或者JSP文件中用“${kkk}”则系统会读取“10”这个值作为显示值。

Struts2中的OGNL表达式

分类： Java Web 2012-11-30 10:44 2098人阅读评论(1) 收藏举报

浅析值栈
ValueStack对象相当于一个栈，它贯穿整个Action的生命周期，每个Action类的对象实例都会拥有一个ValueStack对象
当Struts2接收到一个*.action请求后，并不是直接调用Action方法，而是先将Action类的相应属性放到ValueStack对象的顶层节点
值栈也位于内存中，它也是和parameters、request、session、application、attr对象放在一起的
值栈属于ONGL Context里面的根对象。也就是说它位于整个内存中最最重要的地方，所以叫根对象
根对象和另外五个对象是有区别的，根对象可以省写#号，比如<s:property value="user.username"/>
值栈的生命周期与request请求相关，每次请求产生一个值栈。默认所有的Action会被自动放到值栈里

服务器跳转时共用值栈
假设从一个Action11通过服务器跳转到Action22的话，就意味着这两个Action是共享一个值栈的，因为一次请求只使用一个值栈
这时内存中情况是这样的：首先接收到Action11请求后，会产生一个值栈，在栈顶存放Action11对象以及它所有的属性
然后经过服务器跳转到Action22，这时就会把Action22对象压入值栈的栈顶位置，此时Action11对象以及它的所有属性就位于栈底了

取值过程
栈的特征是后进先出。于是首先到栈顶的对象里查找是否存在这个属性，如果栈顶的Action22对象中不存在这个属性的话
它就会继续向下寻找直至栈底对象，一直查找是否存在这个属性
如果最后找到该属性的话，那么就会在JSP页面中通过<s:property value="username"/>输出属性值
如果在Action22和Action11都有一个同名的同类型的username属性的话，那么将输出Action22中的属性值
因为它是先从栈顶开始寻找属性的，值栈的特征就是后进先出，但有个前提：请求过程是通过服务器跳转的

三个语法
假设此时想要获取Action11中的username属性的话，就可以使用值栈的Top语法或者N语法
使用Top语法获取值栈中的第二个对象的属性：<s:property value="[1].top.username"/>
使用 N 语法获取值栈中的第二个对象的属性：<s:property value="[1].username"/>
另外值栈还有一个@语法，例如使用@语法调用Action中的静态方法：<s:property value="@vs@getVOMethod()"/>
@vs@get()等价于@vs1@getVOMethod()，指的是栈顶对象的静态getVOMethod()方法
同理@vs2@getVOMethod()就是取值栈中第二个对象的静态getVOMethod()方法

客户端跳转时使用各自的值栈
假如中间某一个步骤中出现了客户端跳转的话，那么两个Action所使用的就是两个不同的值栈了
所以在Action22中就不能再使用Action11中的属性了，在最后跳转到的JSP页面中也就无法获取Action11的属性了
也即从Action22跳转到JSP页面时使用的是redirect的话，那么最后值栈中是没有任何的Action对象的
这个时候我们可以通过链接传参，比如<result type="redirect">test.jsp?netname=${username}</result>
意思就是取出Action22中的username属性作为参数，通过浏览器地址栏传递到JSP页面中
然后使用OGNL中的#号获取Paraments对象的属性，即<s:property value="#parameters.netname"/>就可以取到值了
辅助参考：http://blog.csdn.net/jadyer/archive/2010/09/16/5887509.aspx

手工向值栈中压入对象
正常情况下值栈保存的是Action对象，而我们也可以直接往值栈中添加其它对象，这时可以在Action中添加如下代码
向值栈中添加对象：ActionContext.getContext.getValueStack().push(new Student("沈浪",22));
而且我们手工往值栈中添加的Student对象会位于栈顶。这是因为Struts2会首先初始化Action，然后才能调用它的方法
初始化Action的时候，便把Action放到值栈中了，然后在执行它的execute()方法时，就又往值栈中添加了Student对象

浅析OGNL
OGNL是Object-Graph Navigation Language的缩写，是一种功能强大的表达式语言
通过它简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能
OGNL用得最多的地方就是和Struts2的标签绑定，也可以在配置文件中通过${}使用OGNL表达式

OGNL中$号的使用
1..在国际化资源文件中，引用OGNL表达式
2..在struts.xml文件中，引用OGNL表达式

OGNL中%号的使用
1..使用%{}可以取出保存在值堆栈中的Action对象，直接调用它的方法
2..如果Action继承了ActionSupport，那么在页面标签中可以使用%{getText('key')}获取国际化信息
辅助参考：http://blog.csdn.net/jadyer/archive/2010/09/16/5887545.aspx

OGNL中#号的使用
OGNL中的#号可以取出堆栈上下文中存放的对象

名称	作用	例子
attr	用于按request>>session>>application顺序访问其属性	#attr.userName相当于按顺序从三个范围读取userName属性直到找到为止
request	包含当前HttpServletRequest的属性的Map	#request.userName相当于request.getAttribute("userName")
session	包含当前HttpSession的属性的Map	#session.userName相当于session.getAttribute("userName")
application	包含当前应用的ServletContext的属性的Map	#application.userName相当于application.getAttribute("userName")
parameters	包含当前HTTP请求参数的Map	#parameters.id[0]相当于request.getParameter("id")

获取Action中的属性值或者Action中的对象的某某属性值
利用<s:property/>标签可以直接获取Action中的引用类型user里面的username属性
同样可以通过user.address.addr获取user中引用类型address中的addr属性的值
像这种一层一层往下传递的访问方式，即所谓的导航，也就是一步步的往下调用

调用Action的对象里面的普通方法
默认的会把Action放到值栈里面，而值栈在访问的时候，并不需要值栈的名字
当我们调用<s:property value="user.getVOMethod()"/>的时候
它会自动到值栈里面查找Action对象里面有没有user对象，然后它就发现有user
然后它就再找user里面有没有getVOMethod()方法，然后它发现有，于是调用getVOMethod()
实际上调用User中的getVOMethod()方法的过程与获取表单中的姓名密码的方式都是相同的
都是到值栈里面查找，找是否存在user对象，如果存在，接着查找user中是否存在某某属性或方法

调用Action中的静态方法
同样我们也可以在JSP页面中写一个OGNL表达式调用Action中的静态方法
调用Action中的静态方法时，与调用user对象的getVOMethod()方法的过程，是截然不同的
此时value的写法是固定的，以@开头，后面跟上具体的包名，然后@加上静态方法
比如<s:property value="@com.jadyer.action.LoginAction@getStatic()"/>
另外user对象是LoginAction中的一个属性，这个属性会自动的放到值栈里面
而值栈调用的时候，不用加上@或者包名等等，所以直接user.getVOMethod()就可以了

调用JDK类中的静态方法
可以使用<s:property value="@@floor(46.58)"/>输出floor()的执行结果
这就意味着如果不在@@中指定类的话，默认的就表示java.lang.Math类
当前大多数情况下，我们都不会省略这个类，都会写全了的，然后在后面加上静态方法

集合的伪属性
OGNL能够引用集合的一些特殊的属性，这些属性并不是JavaBean模式，例如size()、length()
当表达式引用这些属性时，OGNL会调用相应的方法，这就是伪属性
比如获取List的大小：<s:property value="testList.size"/>
      List的伪属性：size、isEmpty、iterator
       Set的伪属性：size、isEmpty、iterator
       Map的伪属性：size、isEmpty、keys、values
  Iterator的伪属性：next、hasNext
Enumeration伪属性：next、hasNext、nextElement、hasMoreElements

获取集合中元素的实质就是调用它的toString()方法
它还可以直接获取集合中的元素，事实上是在调用集合的toString()方法
所以我们可以根据实际情况通过重写集合的toString()方法来实现个性化输出
甚至它还可以像访问数组那样，直接testList[2]获取集合中的元素
但这种方法只适用于List，不适用于Map。因为Map的索引是key，不是数值
另外，由于HashSet中的元素是没有顺序的，所以也不能用下标获取单个元素

Lambda表达式
补充一下：使用Lambda表达式可以在OGNL中书写递归式子，在帮助中对它有很详细的说明
打开帮助中的//struts-2.0.14-all//struts-2.0.14//docs//index.html页面
在左侧的Documentation下面点击Guides链接，然后在这个页面中点击OGNL
最后跳转到//struts-2.0.14-all//struts-2.0.14//docs//docs//ognl.html
将这个页面右侧的下拉条拖放到最下面，就会看到它的说明了，它举的例子如下所示
<s:property value="#fib =:[#this==0 ? 0 : #this==1 ? 1 : #fib(#this-2)+#fib(#this-1)], #fib(11)" />
Lambda表达式的语法是:[...] ，中括号前面有一个冒号，所有东西都在中括号里面写
也就是说我们只要看到一个冒号跟着一个中括号，就表示这里使用的是Lambda表达式
#this指的是表达式的参数
所以这个例子可以这样理解：先判断这个参数是否等于零，如果等于零，那么它的值最后就是零
如果参数不等于零，就再判断它是否等于壹。如果参数等于壹，那么它的值最后就是壹
如果参数不等于壹，就继续调用#fib。注意这里已经用中括号将整体的值赋给了fib
实际上很少能够用得到Lambda表达式

利用投影获取属性
利用投影获取List中对象的username属性时，其中{}表示的是一个集合
stus.{username}就表示将suts中所有的username属性取出组成一个新的列表

利用选择获取属性
OGNL表达式是很灵活的，可以同时使用选择技术与投影技术获取属性
使用选择技术时，#this代表当前元素，问号?是把所有满足条件的元素都取出来
上箭头^是开始的意思，所以stus.{^#this.grade>=60}.{username}输出的是[张三]
注意，此时输出文本中包含中括号，这表示它是一个列表
而stus.{?#this.grade>=60}.{username}[0]输出的是张三，是字符串，二者是不同的
美元符号$是结束的意思，所以stus.{$#this.grade>=60}.{username}输出的是[王五]
这三个符合：问号、上箭头、美元符所返回的都是List

补充
1..当OGNL取不到值的时候，它不会报错，而是什么都不显示
2..<s:property value="[0]"/>返回的是ValueStack中从上至下的所有的Object
    <s:property value="[1]"/>返回的是ValueStack中从上至下的第二个Object
3..<s:property value="[0].username"/>返回的是成员变量username的值
    假设ValueStack中存在两个Action的话，如果第一个Action如果没有username变量
    那么它会继续找第二个Action。那么在什么情况下ValueStack中会存在两个Action呢
    答案是在struts.xml中配置的是从一个Action通过<result type="chain">跳转到另一个Action
4..<constant name="struts.ognl.allowStaticMethodAccess" value="true"/>
    在Struts2.1.6中必须设置struts.ognl.allowStaticMethodAccess为true之后
    才允许使用OGNL访问静态方法。而在Struts2.0.11则无需设置，即可直接访问

下面是OGNL测试的工程代码，这是一个Struts2.0.11应用

首先是web.xml文件

[xhtml] view plaincopy
 <?xmlversion="1.0"encoding="UTF-8"?> 
 <web-app version="2.5"  
     xmlns="http://java.sun.com/xml/ns/javaee"  
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  
     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"> 
     <filter> 
         <filter-name>struts2</filter-name> 
         <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class> 
     </filter> 
     <filter-mapping> 
         <filter-name>struts2</filter-name> 
         <url-pattern>/*</url-pattern> 
     </filter-mapping> 
     <welcome-file-list> 
         <welcome-file>login.jsp</welcome-file> 
     </welcome-file-list>   
 </web-app> 

[xhtml] view plaincopy
 <?xml version="1.0" encoding="UTF-8"?>  
 <web-app version="2.5"   
     xmlns="http://java.sun.com/xml/ns/javaee"   
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
     <filter>  
         <filter-name>struts2</filter-name>  
         <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>  
     </filter>  
     <filter-mapping>  
         <filter-name>struts2</filter-name>  
         <url-pattern>/*</url-pattern>  
     </filter-mapping>  
     <welcome-file-list>  
         <welcome-file>login.jsp</welcome-file>  
     </welcome-file-list>    
 </web-app>  

然后是用于输入用户名和密码等信息的测试页面login.jsp

[xhtml] view plaincopy
 <%@ page language="java"pageEncoding="UTF-8"%> 
 <h1>这是测试OGNL使用的登录页面</h1> 
 <h3><fontcolor="red">提示：</font>程序设定的用户名和密码各为<fontcolor="blue"><strong>admin</strong></font>和<fontcolor="blue"><strong>jadyer</strong></font></h3> 
 <h3><fontcolor="red">注意：</font>用户名和密码不正确时将停留在页面不动</h3> 
 <formaction="<%=request.getContextPath()%>/login.action"method="POST"> 
     <%--这里user.username匹配的是LoginAction中的引用类型user里面的username属性--%> 
     <%--查看标签库说明的话，就知道name中指定的是对象。这里它不是字符串，而是OGNL表达式--%> 
     姓名：<inputtype="text"name="user.username"><br> 
     密码：<inputtype="text"name="user.password"><br> 
     地址：<inputtype="text"name="user.address.addr"><br> 
     <inputtype="submit"value="测试OGNL的输出"> 
 </form> 

[xhtml] view plaincopy
 <%@ page language="java" pageEncoding="UTF-8"%>  
 <h1>这是测试OGNL使用的登录页面</h1>  
 <h3><font color="red">提示：</font>程序设定的用户名和密码各为<font color="blue"><strong>admin</strong></font>和<font color="blue"><strong>jadyer</strong></font></h3>  
 <h3><font color="red">注意：</font>用户名和密码不正确时将停留在页面不动</h3>  
 <form action="<%=request.getContextPath()%>/login.action" method="POST">  
     <%--这里user.username匹配的是LoginAction中的引用类型user里面的username属性--%>  
     <%--查看标签库说明的话，就知道name中指定的是对象。这里它不是字符串，而是OGNL表达式--%>  
     姓名：<input type="text" name="user.username"><br>  
     密码：<input type="text" name="user.password"><br>  
     地址：<input type="text" name="user.address.addr"><br>  
     <input type="submit" value="测试OGNL的输出">  
 </form>  

然后是用于显示OGNL处理结果的loginSuc.jsp页面

[xhtml] view plaincopy
 <%@ page language="java"pageEncoding="UTF-8"%> 
 <%@ taglib prefix="s"uri="/struts-tags"%> 
 <h1>这是使用OGNL输出的结果页面</h1> 
 <table border="9"> 
     <tr> 
         <tdalign="right">获取姓名属性：</td> 
         <tdalign="left"><s:propertyvalue="user.username"/></td> 
         <%-- 另外还有两种写法也是可以正常输出值栈中对象的普通属性的 --%> 
         <%-- <s:propertyvalue="user['username']"/> --%> 
         <%-- <s:propertyvalue="user[/"username/"]"/> --%> 
         <%-- 但是如果写成下面这种形式的话，就什么都不会输出了 --%> 
         <%-- <s:propertyvalue="user[username]"/> --%> 
     </tr> 
     <tr> 
         <tdalign="right">获取地址属性：</td> 
         <tdalign="left"><s:propertyvalue="user.address.addr"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">调用值栈中的对象的普通方法：</td> 
         <tdalign="left"><s:propertyvalue="user.getVOMethod()"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">调用值栈中Action的普通方法：</td> 
         <tdalign="left"><s:propertyvalue="getCommon()"/></td> 
     </tr> 
 </table> 
 <hr/> 
 <table border="9"> 
     <tr> 
         <tdalign="right">获取普通类的静态属性：</td> 
         <tdalign="left"><s:propertyvalue="@com.jadyer.vo.Address@TIPS"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">访问普通类的构造方法：</td> 
         <tdalign="left"><s:propertyvalue="new com.jadyer.vo.Student('张小三',22).username"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">调用Action中的静态方法：</td> 
         <tdalign="left"><s:propertyvalue="@com.jadyer.action.LoginAction@getStatic()"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">调用JDK中的类的静态方法：</td> 
         <tdalign="left"><s:propertyvalue="@java.util.Calendar@getInstance().time"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">调用JDK中的类的静态方法：</td> 
         <tdalign="left"><s:propertyvalue="@java.lang.Math@floor(46.58)"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">调用JDK中的类的静态方法：</td> 
         <tdalign="left"><s:propertyvalue="@@floor(46.58)"/></td> 
     </tr> 
 </table> 
 <hr/> 
 <tableborder="9"> 
     <tr> 
         <tdalign="right">获取List中的所有元素：</td> 
         <tdalign="left"><s:propertyvalue="testList"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">获取Set中的所有元素：</td> 
         <tdalign="left"><s:propertyvalue="testSet"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">获取Map中的所有元素：</td> 
         <tdalign="left"><s:propertyvalue="testMap"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">获取Map中的某个元素：</td> 
         <tdalign="left"><s:propertyvalue="testMap['m22']"/></td> 
         <%-- 另外还有两种写法也是可以正常获取Map中的某个具体元素的 --%> 
         <%-- <s:propertyvalue="testMap.m22"/> --%> 
         <%-- <s:propertyvalue="testMap[/"m22/"]"/> --%> 
     </tr> 
     <tr> 
         <tdalign="right">获取Set中的某个元素：</td> 
         <%-- 由于Set中的元素是无顺序的，所以不能使用下标获取数据，所以这里什么也得不到 --%> 
         <tdalign="left"><s:propertyvalue="testSet[2]"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">获取List中的某个元素：</td> 
         <tdalign="left"><s:propertyvalue="testList[2]"/></td> 
     </tr> 
 </table> 
 <hr/> 
 <table border="9"> 
     <tr> 
         <tdalign="right">获取List的大小：</td> 
         <tdalign="left"><s:propertyvalue="testList.size"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">获取Set的大小：</td> 
         <tdalign="left"><s:propertyvalue="testSet.size"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">获取Map的大小：</td> 
         <tdalign="left"><s:propertyvalue="testMap.size"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">获取Map中所有的键：</td> 
         <tdalign="left"><s:propertyvalue="testMap.keys"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">获取Map中所有的值：</td> 
         <tdalign="left"><s:propertyvalue="testMap.values"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">Lambda计算4的阶乘：</td> 
         <tdalign="left"><s:propertyvalue="#f= :[#this==1?1 : #this*#f(#this-1)],#f(4)"/></td> 
     </tr> 
 </table> 
 <hr/> 
 <tableborder="9"> 
     <tr> 
         <tdalign="right">获取List中的所有对象：</td> 
         <tdalign="left"><s:propertyvalue="stus"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">利用投影获取List中对象的名字：</td> 
         <tdalign="left"><s:propertyvalue="stus.{username}"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">利用投影获取List中第二个对象的名字：</td> 
         <%-- 使用<s:propertyvalue="stus[1].{username}"/>获取到的值为：[李四] --%> 
         <%-- 二者的区别在于：后者比前者多了一个中括号 --%> 
         <tdalign="left"> 
             <s:propertyvalue="stus.{username}[1]"/>       
             <s:propertyvalue="stus[1].{username}"/> 
         </td> 
     </tr> 
     <tr> 
         <tdalign="right">利用选择获取List中成绩及格的所有对象：</td> 
         <tdalign="left"><s:propertyvalue="stus.{?#this.grade>=60}"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">利用选择获取List中成绩及格的第一个对象：</td> 
         <tdalign="left"><s:propertyvalue="stus.{^#this.grade>=60}"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">利用选择获取List中成绩及格的最后一个对象：</td> 
         <tdalign="left"><s:propertyvalue="stus.{$#this.grade>=60}"/></td> 
     </tr> 
 </table> 
 <hr/> 
 <tableborder="9"> 
     <tr> 
         <tdalign="right">利用选择获取List中成绩及格的所有对象的名字：</td> 
         <tdalign="left"><s:propertyvalue="stus.{?#this.grade>=60}.{username}"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">利用选择获取List中成绩及格的第二个对象的名字：</td> 
         <tdalign="left"><s:propertyvalue="stus.{?#this.grade>=60}.{username}[1]"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">利用选择获取List中成绩及格的第一个对象的名字：</td> 
         <tdalign="left"><s:propertyvalue="stus.{^#this.grade>=60}.{username}"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">利用选择获取List中成绩及格的最后一个对象的名字：</td> 
         <tdalign="left"><s:propertyvalue="stus.{$#this.grade>=60}.{username}"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">利用选择获取List中成绩及格的第一个对象然后求大小：</td> 
         <tdalign="left"><s:propertyvalue="stus.{^#this.grade>=60}.{username}.size"/></td> 
     </tr> 
 </table> 
 <hr/> 
 <table border="9"> 
     <tr> 
         <tdalign="right">利用OGNL中的#号获取attr中的属性：</td> 
         <tdalign="left"><s:propertyvalue="#attr.BB"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">利用OGNL中的#号获取request范围中的属性：</td> 
         <tdalign="left"><s:propertyvalue="#request.req"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">利用OGNL中的#号获取session范围中的属性：</td> 
         <tdalign="left"><s:propertyvalue="#session.ses"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">利用OGNL中的#号获取Paraments对象的属性：</td> 
         <tdalign="left"><s:propertyvalue="#parameters.netname"/></td> 
     </tr> 
     <tr> 
         <tdalign="right">使用&#60;&#37;=request.getParameter&#40;""&#41;&#37;&#62;或者&#36;&#123;param.name&#125;获取链接参数值：</td> 
         <tdalign="left"> 
             ${param.netname}       
             <%=request.getParameter("netname")%> 
         </td> 
     </tr> 
     <tr> 
         <tdalign="right">查看值栈中的信息：</td> 
         <tdalign="left"><s:debug/></td> 
     </tr> 
 </table> 

[xhtml] view plaincopy
 <%@ page language="java" pageEncoding="UTF-8"%>  
 <%@ taglib prefix="s" uri="/struts-tags"%>  
 <h1>这是使用OGNL输出的结果页面</h1>  
 <table border="9">  
     <tr>  
         <td align="right">获取姓名属性：</td>  
         <td align="left"><s:property value="user.username"/></td>  
         <%-- 另外还有两种写法也是可以正常输出值栈中对象的普通属性的 --%>  
         <%-- <s:property value="user['username']"/> --%>  
         <%-- <s:property value="user[/"username/"]"/> --%>  
         <%-- 但是如果写成下面这种形式的话，就什么都不会输出了 --%>  
         <%-- <s:property value="user[username]"/> --%>  
     </tr>  
     <tr>  
         <td align="right">获取地址属性：</td>  
         <td align="left"><s:property value="user.address.addr"/></td>  
     </tr>  
     <tr>  
         <td align="right">调用值栈中的对象的普通方法：</td>  
         <td align="left"><s:property value="user.getVOMethod()"/></td>  
     </tr>  
     <tr>  
         <td align="right">调用值栈中Action的普通方法：</td>  
         <td align="left"><s:property value="getCommon()"/></td>  
     </tr>  
 </table>  
 <hr/>  
 <table border="9">  
     <tr>  
         <td align="right">获取普通类的静态属性：</td>  
         <td align="left"><s:property value="@com.jadyer.vo.Address@TIPS"/></td>  
     </tr>  
     <tr>  
         <td align="right">访问普通类的构造方法：</td>  
         <td align="left"><s:property value="new com.jadyer.vo.Student('张小三',22).username"/></td>  
     </tr>  
     <tr>  
         <td align="right">调用Action中的静态方法：</td>  
         <td align="left"><s:property value="@com.jadyer.action.LoginAction@getStatic()"/></td>  
     </tr>  
     <tr>  
         <td align="right">调用JDK中的类的静态方法：</td>  
         <td align="left"><s:property value="@java.util.Calendar@getInstance().time"/></td>  
     </tr>  
     <tr>  
         <td align="right">调用JDK中的类的静态方法：</td>  
         <td align="left"><s:property value="@java.lang.Math@floor(46.58)"/></td>  
     </tr>  
     <tr>  
         <td align="right">调用JDK中的类的静态方法：</td>  
         <td align="left"><s:property value="@@floor(46.58)"/></td>  
     </tr>  
 </table>  
 <hr/>  
 <table border="9">  
     <tr>  
         <td align="right">获取List中的所有元素：</td>  
         <td align="left"><s:property value="testList"/></td>  
     </tr>  
     <tr>  
         <td align="right">获取Set中的所有元素：</td>  
         <td align="left"><s:property value="testSet"/></td>  
     </tr>  
     <tr>  
         <td align="right">获取Map中的所有元素：</td>  
         <td align="left"><s:property value="testMap"/></td>  
     </tr>  
     <tr>  
         <td align="right">获取Map中的某个元素：</td>  
         <td align="left"><s:property value="testMap['m22']"/></td>  
         <%-- 另外还有两种写法也是可以正常获取Map中的某个具体元素的 --%>  
         <%-- <s:property value="testMap.m22"/> --%>  
         <%-- <s:property value="testMap[/"m22/"]"/> --%>  
     </tr>  
     <tr>  
         <td align="right">获取Set中的某个元素：</td>  
         <%-- 由于Set中的元素是无顺序的，所以不能使用下标获取数据，所以这里什么也得不到 --%>  
         <td align="left"><s:property value="testSet[2]"/></td>  
     </tr>  
     <tr>  
         <td align="right">获取List中的某个元素：</td>  
         <td align="left"><s:property value="testList[2]"/></td>  
     </tr>  
 </table>  
 <hr/>  
 <table border="9">  
     <tr>  
         <td align="right">获取List的大小：</td>  
         <td align="left"><s:property value="testList.size"/></td>  
     </tr>  
     <tr>  
         <td align="right">获取Set的大小：</td>  
         <td align="left"><s:property value="testSet.size"/></td>  
     </tr>  
     <tr>  
         <td align="right">获取Map的大小：</td>  
         <td align="left"><s:property value="testMap.size"/></td>  
     </tr>  
     <tr>  
         <td align="right">获取Map中所有的键：</td>  
         <td align="left"><s:property value="testMap.keys"/></td>  
     </tr>  
     <tr>  
         <td align="right">获取Map中所有的值：</td>  
         <td align="left"><s:property value="testMap.values"/></td>  
     </tr>  
     <tr>  
         <td align="right">Lambda计算4的阶乘：</td>  
         <td align="left"><s:property value="#f= :[#this==1?1 : #this*#f(#this-1)],#f(4)"/></td>  
     </tr>  
 </table>  
 <hr/>  
 <table border="9">  
     <tr>  
         <td align="right">获取List中的所有对象：</td>  
         <td align="left"><s:property value="stus"/></td>  
     </tr>  
     <tr>  
         <td align="right">利用投影获取List中对象的名字：</td>  
         <td align="left"><s:property value="stus.{username}"/></td>  
     </tr>  
     <tr>  
         <td align="right">利用投影获取List中第二个对象的名字：</td>  
         <%-- 使用<s:property value="stus[1].{username}"/>获取到的值为：[李四] --%>  
         <%-- 二者的区别在于：后者比前者多了一个中括号 --%>  
         <td align="left">  
             <s:property value="stus.{username}[1]"/>        
             <s:property value="stus[1].{username}"/>  
         </td>  
     </tr>  
     <tr>  
         <td align="right">利用选择获取List中成绩及格的所有对象：</td>  
         <td align="left"><s:property value="stus.{?#this.grade>=60}"/></td>  
     </tr>  
     <tr>  
         <td align="right">利用选择获取List中成绩及格的第一个对象：</td>  
         <td align="left"><s:property value="stus.{^#this.grade>=60}"/></td>  
     </tr>  
     <tr>  
         <td align="right">利用选择获取List中成绩及格的最后一个对象：</td>  
         <td align="left"><s:property value="stus.{$#this.grade>=60}"/></td>  
     </tr>  
 </table>  
 <hr/>  
 <table border="9">  
     <tr>  
         <td align="right">利用选择获取List中成绩及格的所有对象的名字：</td>  
         <td align="left"><s:property value="stus.{?#this.grade>=60}.{username}"/></td>  
     </tr>  
     <tr>  
         <td align="right">利用选择获取List中成绩及格的第二个对象的名字：</td>  
         <td align="left"><s:property value="stus.{?#this.grade>=60}.{username}[1]"/></td>  
     </tr>  
     <tr>  
         <td align="right">利用选择获取List中成绩及格的第一个对象的名字：</td>  
         <td align="left"><s:property value="stus.{^#this.grade>=60}.{username}"/></td>  
     </tr>  
     <tr>  
         <td align="right">利用选择获取List中成绩及格的最后一个对象的名字：</td>  
         <td align="left"><s:property value="stus.{$#this.grade>=60}.{username}"/></td>  
     </tr>  
     <tr>  
         <td align="right">利用选择获取List中成绩及格的第一个对象然后求大小：</td>  
         <td align="left"><s:property value="stus.{^#this.grade>=60}.{username}.size"/></td>  
     </tr>  
 </table>  
 <hr/>  
 <table border="9">  
     <tr>  
         <td align="right">利用OGNL中的#号获取attr中的属性：</td>  
         <td align="left"><s:property value="#attr.BB"/></td>  
     </tr>  
     <tr>  
         <td align="right">利用OGNL中的#号获取request范围中的属性：</td>  
         <td align="left"><s:property value="#request.req"/></td>  
     </tr>  
     <tr>  
         <td align="right">利用OGNL中的#号获取session范围中的属性：</td>  
         <td align="left"><s:property value="#session.ses"/></td>  
     </tr>  
     <tr>  
         <td align="right">利用OGNL中的#号获取Paraments对象的属性：</td>  
         <td align="left"><s:property value="#parameters.netname"/></td>  
     </tr>  
     <tr>  
         <td align="right">使用&#60;&#37;=request.getParameter&#40;""&#41;&#37;&#62;或者&#36;&#123;param.name&#125;获取链接参数值：</td>  
         <td align="left">  
             ${param.netname}        
             <%=request.getParameter("netname")%>  
         </td>  
     </tr>  
     <tr>  
         <td align="right">查看值栈中的信息：</td>  
         <td align="left"><s:debug/></td>  
     </tr>  
 </table>  

然后是struts.xml文件

[xhtml] view plaincopy
 <?xmlversion="1.0"encoding="UTF-8"?> 
 <!DOCTYPE struts PUBLIC 
     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" 
     "http://struts.apache.org/dtds/struts-2.0.dtd"> 
 <struts> 
     <packagename="ognl"extends="struts-default"> 
         <actionname="login"class="com.jadyer.action.LoginAction"> 
             <resultname="input">/login.jsp</result> 
             <resultname="success">/loginSuc.jsp?netname=hongyu</result> 
             <!-- 
             <resultname="success"type="redirect">/loginSuc.jsp?netname=hongyu</result> 
             <resultname="success"type="redirect">/loginSuc.jsp?netname=${user.username}</result>  
              --> 
         </action> 
     </package> 
 </struts> 

[xhtml] view plaincopy
 <?xml version="1.0" encoding="UTF-8"?>  
 <!DOCTYPE struts PUBLIC  
     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"  
     "http://struts.apache.org/dtds/struts-2.0.dtd">  
 <struts>  
     <package name="ognl" extends="struts-default">  
         <action name="login" class="com.jadyer.action.LoginAction">  
             <result name="input">/login.jsp</result>  
             <result name="success">/loginSuc.jsp?netname=hongyu</result>  
             <!--  
             <result name="success" type="redirect">/loginSuc.jsp?netname=hongyu</result>  
             <result name="success" type="redirect">/loginSuc.jsp?netname=${user.username}</result>   
              -->  
         </action>  
     </package>  
 </struts>  

接着是用到的三个VO类

[java] view plaincopy
 package com.jadyer.vo; 
 publicclass User { 
     private String username; 
     private String password; 
     private Address address; 
     /* 三个属性的setter和getter略 */ 
     public String getVOMethod(){ 
         return"这是User类中的一个普通方法"; 
     } 
 } 
  
  
 package com.jadyer.vo; 
 publicclass Address { 
     //如果将TIPS设为private的话，loginSuc.jsp中就无法获取它的属性值了 
     //事实上将一个静态的final属性设为private是毫无意义的 
     //因为既然设置成了静态，那么就是供他人调用的，如果再设成private的话，别的地方根本就无法调用了 
     //即使OGNL再怎么强大，它也不可能违反Java的规则，所以不要将静态的属性设为私有 
     publicstaticfinal String TIPS = "玄玉加油!!"; 
     //addr属性的setter和getter略 
     private String addr; 
 } 
  
  
 package com.jadyer.vo; 
 publicclass Student { 
     private String username; 
     privateint grade; 
     /* 两个属性的setter和getter略 */ 
      
     //只要是重写一个类的构造方法，就必须要为这个类保留空的构造方法 
     //因为框架默认的都会去调用无参的空的构造方法 
     public Student(){}; 
     public Student(String username,int grade){ 
         this.username = username; 
         this.grade = grade; 
     } 
     @Override 
     public String toString() { 
         //如果不重写它的toString()方法的话，默认调用toString()将输出【类型+@+内存地址的哈希值】 
         return"{学生姓名：" + username +"，成绩：" + grade + "}"; 
     } 
 } 

[java] view plaincopy
 package com.jadyer.vo;  
 public class User {  
     private String username;  
     private String password;  
     private Address address;  
     /* 三个属性的setter和getter略 */  
     public String getVOMethod(){  
         return "这是User类中的一个普通方法";  
     }  
 }  
   
   
 package com.jadyer.vo;  
 public class Address {  
     //如果将TIPS设为private的话，loginSuc.jsp中就无法获取它的属性值了  
     //事实上将一个静态的final属性设为private是毫无意义的  
     //因为既然设置成了静态，那么就是供他人调用的，如果再设成private的话，别的地方根本就无法调用了  
     //即使OGNL再怎么强大，它也不可能违反Java的规则，所以不要将静态的属性设为私有  
     public static final String TIPS = "玄玉加油!!";  
     //addr属性的setter和getter略  
     private String addr;  
 }  
   
   
 package com.jadyer.vo;  
 public class Student {  
     private String username;  
     private int grade;  
     /* 两个属性的setter和getter略 */  
       
     //只要是重写一个类的构造方法，就必须要为这个类保留空的构造方法  
     //因为框架默认的都会去调用无参的空的构造方法  
     public Student(){};  
     public Student(String username,int grade){  
         this.username = username;  
         this.grade = grade;  
     }  
     @Override  
     public String toString() {  
         //如果不重写它的toString()方法的话，默认调用toString()将输出【类型+@+内存地址的哈希值】  
         return "{学生姓名：" + username + "，成绩：" + grade + "}";  
     }  
 }  

最后是用来提供OGNL测试的数据的LoginAction.java

[java] view plain copy print ?

 package com.jadyer.action; 
  
 import java.util.ArrayList; 
 import java.util.HashMap; 
 import java.util.HashSet; 
 import java.util.List; 
 import java.util.Map; 
 import java.util.Set; 
  
 import org.apache.struts2.interceptor.RequestAware; 
 import org.apache.struts2.interceptor.SessionAware; 
  
 import com.jadyer.vo.Student; 
 import com.jadyer.vo.User; 
 import com.opensymphony.xwork2.ActionSupport; 
  
 @SuppressWarnings({"serial","unchecked"}) 
 publicclass LoginActionextends ActionSupport implements RequestAware,SessionAware { 
     private User user; 
     private List testList = new ArrayList(); 
     private Set testSet =new HashSet(); 
     private Map testMap = new HashMap(); 
     private List stus = new ArrayList(); 
      
     /* 以上五个属性的setter和getter略 */ 
      
     private Map request; 
     private Map session; 
     publicvoid setRequest(Map request) { 
         this.request = request; 
     } 
     publicvoid setSession(Map session) { 
         this.session = session; 
     } 
      
     publicstatic String getStatic(){ 
         return"这是LoginAction中的一个静态方法"; 
     } 
     public String getCommon(){ 
         return"这是LoginAction中的一个普通方法"; 
     } 
      
     @Override 
     public String execute() throws Exception { 
         if(user.getUsername().trim().equalsIgnoreCase("admin") && user.getPassword().equals("jadyer")){ 
             testList.add("list11"); 
             testList.add("list22"); 
             testList.add("list33"); 
             testList.add("list44"); 
             testList.add("list55"); 
              
             testSet.add("set11"); 
             testSet.add("set22"); 
             testSet.add("set33"); 
             testSet.add("set22"); 
             testSet.add("set11"); 
              
             testMap.put("m11", "map11"); 
             testMap.put("m22","map22"); 
             testMap.put("m33", "map33"); 
             testMap.put("m44","map44"); 
             testMap.put("m55", "map55"); 
              
             stus.add(new Student("张三",88)); 
             stus.add(new Student("李四",77)); 
             stus.add(new Student("王五",66)); 
             stus.add(new Student("马六",55)); 
              
             request.put("req","这是通过OGNL中的#号获取的request属性范围的值"); 
             session.put("ses", "这是通过OGNL中的#号获取的session属性范围的值"); 
             request.put("BB","这是通过OGNL中的#号获取的request属性范围的BB"); 
             session.put("BB", "这是通过OGNL中的#号获取的session属性范围的BB"); 
             return SUCCESS; 
         }else{ 
             return INPUT; 
         } 
     } 
 }