Struts2 如何使用OGNL表达式（三十八）

1.OGNL是Object Graph Navitagtion Language,对象导航语言） 是一种功能强大的EL（Expression Language,表达式语言）。通过OGNL，可以使用简单一直的表达式语法，存储对象的任意属性，调用对象的方法，遍历整个对象的结果图和实现字段类型转换等功能。

2.OGNL表达式有如下几个特点：
A： 将视图元素好模型对象绑定在一起
B: 将表格元素同Swing TableModel 对应起来。
C: 将Web页面元素同后台服务业务对象对应起来

3.OGNL表达式的基础单元是导航连(Navigation chain),通常简称为链。最简单的链有如下部分组成：属性名，方法调用， 数组索引。

4.例如：有一本书 book,它有多个作者（author），每个作者都有个年龄（age）.如果使用OGNl表达式获取这本书的第一个作者的年龄，并将年龄转换为字符串类型。则这个OGNL表达式为：
book.author[0].age.toString().
在这个OGNL表达式中，author[0]即为数组索引，age 为属性名，toString() 为方法。

[b][color=red]5.OGNL提供的常量类型：[/color][/b]

1.字符串常量
  指以 单引号 '' 或 双引号 “” 括起来的字符串。 例如：‘HuiZhi’  和 “HuiZhi”。
在OGNL中可以使用单引号 来界定字符串常量，这点和Java不相同。但是如果一个字符串只有一个字符组成，则必须使用 双引号。
  例如 ：可以使用 “H”，却不能使用‘H’。

2.字符常量
   指以单引号括起来的字符，例如‘H’
  “H”与 ‘H’ 前者是字符串常量，后者是字符常量。

3.数值常量
  指 int long float double BigDecimal BigInteger 类型常量
  这些常量的指定形式如下：
  例如： 123 指定了int 类型常量
  例如： 123l 或者 1234L 指定long类型的常量 
  例如： 123.4f  指定float 类型常量
  例如：123.4 或者 123.4D 或者123.4d 指定double类型的常量
  例如：123B 或者 123b 指定 BigDecimal类型常量
  例如： 123H 或者 123h  指定BigInteger 类型的常量
   （数值后面的字母不区分大小写，例如 123l 和 123L 都正确）
  布尔常量  true 和  false
  null 常量

[b][color=red]6.OGNL 操作符[/color][/b]

1.逗号（，）操作符
  逗号操作符用来分隔两个或多个独立的表达式，而整个表达式的值取值于最后一个表达式。例如 表达式 1+1，2+2 
  由于整个表达式的取值于最后一个表达式，所以该表达式的值为2+2 即为 4.

2.花括号“｛｝” 操作符
  花括号操作符用来创建列表，例如表达式：
  ｛“xiaoqi”,"xiaoxue","candy"｝.

3.in 和 not in 操作符
  in 和 not in 操作符用来判断一个值是否存在于一个指定的集合中。
  例如：
    userName in｛“xiaoqi”，“candy”，“xiaoxue”｝ 和 
    userName not in ｛“xiaoqi”，“xiaoxue”，“candy”｝

4.除了上面的操作符，OGNL还支持所有的java操作符(> < = >=)

[b][color=red]===========7.OGNL提供调用任何方法的能力。========[/color][/b]
例如调用javabean的属性的getXXX() 方法，调用静态方法 或者 静态字段，调用构造方法。

[color=red]---1.访问JavaBean的属性。也就是调用JavaBean的属性的getXXX()方法---[/color]

  如果 OGNL上下文的根对象是一个Book类的实例对象book，则可以使用如下的OGNL表达式获取图书作者的姓名：
　　book.getAuthor().getName()

[color=red]---------2.调用静态方法和静态字段--------[/color]

  OGNL支持调用类中的静态方法和静态字段。调用的语法格式如下：
  @class@method
  @class@field
  例如：要将一个字符串123 转换成int类型数字的123，可以使用如下的代码，
     @java.lang.Integer@parseInt("123")
  其中 java.lang.Integer是类名，parseInt()是方法名。
  其中类名必须完整，例如java.lang.Integer.不能只写Integer。而如果省略类    名，则默认类为 java.lang.Math.例如 调用 java.lang.Math类的max()方法。可以
直接使用如下格式。@@max(123,345).
  调用静态字段。例如 调用 java.lang.Math类中的PI字段，代码如下
  @java.lang.Math@PI 或者 @@PI

[color=red]--------3.调用构造方法--------[/color]

  OGNL还支付调用构造方法，使用new 关键字创建对象
  例如  创建一个Date对象，代码如下：
  new java.util.Date().
  这的类名也必须完整给出。

[b][color=red]===========8.索引的访问===========[/color][/b]
OGNL支持数组和列表索引，javabean的索引属性和OGNL对象索引属性。

[color=red]--------- 1 访问 数组和列表索引-------------[/color]

    new String[]{"a","b","c"}
    则访问数组中第二个元素的OGNL表达式：
    new String[]{"a","b","c"}[1].
  在OGNL中，使用列表索引与是哟in个数组索引一样，例如如下表格:  {"aa","bb","ccc"} 
则访问该列表的的二个元素的OGNL表达式为:
 {"aa","bb","ccc"}[1].

[color=red]--------- 2.javaBean的索引属性----------[/color]

   JavaBean的索引属性就是获取和这是数组时使用的属性。使用索引属性需要提供俩对setXX()和getXX()方法。其中，一对用于数组，另一对用户数组中的元素。
  使用索引属性的语法格式如下：
  public PropetyType[] getPropertyName()
  public void setPropertyName(PropertyType[] values)
  public Property getPropertyName(int index)
  public void setPropertyName(int index,PropertyType value)

  例如 创建一个索引属性 str 内容如下：
  private String[] str;
  public String[] getStr(){return str;}
  public void setStr(String[] str){this.str=str;}
  public String getStr(int i){return str[i];}
  public void setStr(int i,String newStr){str[i]=newStr;}
  则 如下OGNL表达式：
　　str[1] 可用用来调用getStr(1),获取数组的第二个元素值。
  而如果是设置，则该表达式可以调用setStr(1,value)方法，设置数组的第儿歌元素值。

[color=red]---------3.OGNL对象索引属性-----------[/color]

  OGNL扩展了索引属性的概念，可是使用任意的对象来作为索引。这与javaBean不同。JavaBean的索引属性只能使用整形作为索引。
  例如：session对象有如下设置和获取属性attribute的方法：
  public void setAttribute(String name,Object value)
  public Object getAttribute(String name)
  可以使用如下表达式在sessino中设置一个attribute属性userName：
  session.attribute["userName"]

[b][color=red]======9.使用OGNL操作集合================[/color][/b]
创建列表，创建数组，创建Map

[color=red]---------------1.创建列表--------------[/color]

就是使用花括号｛｝将元素括起来，多个元素之间使用 逗号 （，）都好隔开，例如 下面的OGNL表达式
｛“aaa”，“bbb”，“ccc”｝
列表元素的访问方式，例如访问第一个元素
｛“aa”，“bb”，“cc”｝[0]

[color=red]----------2.创建数组---------[/color]

需要使用new 关键字，例如下面代码
new String[]{"a","b","v"}
OGNL也支持如下方式new String[3]，创建一个含有 3个元素的数组，但是没有指明数组的元素，则数组中的元素默认都是空字符串。
数组元素的访问方式，例如访问第一个元素
new String[]{"a","c","v"}[0]

[color=red]--------3.创建Map------------[/color]

需要使用#｛｝操作符和 key—value键值对。语法格式如下
#｛"key1":"valu1","key2":"value2","key3":"value2","key4":"value4"...｝
例如：
#｛"admin":"xiaoqi","manager":"xiaoxue","operator":"candy"｝

Map元素的访问方式，录入访问的key为admin的元素
#｛"admin":"xiaoqi","manager":"xiaoxue","operator":"candy"｝["admin"]
或者
#｛"admin":"xiaoqi","manager":"xiaoxue","operator":"candy"｝.admin

[b][color=red]=========10.使用集合的伪属性========[/color][/b]
[table]
|集合类型|方法调研那个示例代码|伪属性|OGNL表达似乎
|List|list.iterator(),list.size()|iterator,size|list.iterator, lise.size
|Set|set.isEmpty(),set.iterator()|iterator,isEmpty|set.iterator,set.isEmpty
|Map|map.keySet(),map.values()|keys,values|map.keys,map.values
|Iterator|iterator.next(),iterator.hasNext()|next,hasNext|iterator.next,iterator.hasNext
|Enumeration|enum.nextElement(),
enum.hasMoreElements()|next或nextElement,hasNext或hasMoreElements|enum.next或next.nextElement,enum.hasNext 或enum.hasMoreElements
[/table]

[b][color=red]==========投影===============[/color][/b]

在OGNL中，投影是指在一个集合中对每个元素调用相同的方法，或者抽取相同的属性，并将结果保存为一个新的集合。
例如有如下列表：｛1，2，3，4，5｝
现在通过投影，将上面列表中的每个元素都从整形换成字符类型，从而组成了一个新的列表。
如下代码：
｛1，2，3，4，5｝.｛#this.toString()｝
则得到新的列表如下：
｛"1","2","3","4","5"｝

[b][color=red]==============选择================[/color][/b]

在LGNL中，选择是指使用表达式从集合中选择某些元素，并将这些元素保存到新的集合中。
例如有如下列表：
｛1，2，3，4，5｝
现在通过选择，将上面的列表中大于2的元素选择出来，保存到新的列表中，如下代码：
｛1，2，3，4，5｝,{?#this>2}
则新的列表如下：
｛3，4，5｝

[color=red]============Struts2 ValueStack=============[/color]
[color=red]-------值栈 ValueStack--------[/color]

Struts2在OGNL之上提供了的最大附加特性就是支持 值栈 ValueStack.在OGNL上下文中只能存在一个根对象,而Struts2的值栈允许存储多个虚拟根对象。Struts2将OGNL上下设置为Strus2的ActionContext，并将值栈最为OGNL的根对象。
例如：　值栈中有两个对象，Book对象book和Song对象song,对这两个对象的说明如下：
book有两个属性，图书名name和图书价格 price。
song有两个属性，歌曲名称name和歌曲内容lyrics
book先入栈，song后入栈。

这时在OGNL上下文中，如果访问book的price属性 
表达式如下：price
如果访问song的lyrics属性，表达式为 lyrics
如果访问book的name属性 表达式为:name
如果反问song的name，则表达式必须指明对象，如下:
song.name （因为此时OGML上下文中存储了两个name，所以 后面的需要明确指定。）

[color=red]-------[N]语法--------[/color]

[N].propertyName语法，可以用来指定从值栈中的位置N开始，向下查找对象的指定属性（propertyName）.其中N是从0开始的整数。
例如： 值栈中有 3个对象，User1，User2，User3 他们都有name属性。如果使用[N].peopertyName语法。则
访问第一个对象user1的name属性，可以使用如下表达式[0].name
访问第二个对象user2的name属性，可以使用如下表达式[1].name
访问第三个对象user3的name属性，可以使用如下表达式[2].name

[color=red]-------top--------[/color]

top:关键字用于获取栈顶对象
例如。要获取值栈中的user2对象，可以使用如下表达式:
[1].top
访问user2的name属性可以使用如下表达式
[1].top.name

[b][color=red]==============命名对象================[/color][/b]

Struts2还提供了一些命名对象，这些对象没有存在值栈中，而是保存的ActionContext中。而访问这些对象要使用#标记，而这些命名对象都是Map类型
Struts2提供的命名对象如下：

1.parameters:用来访问请求参数。例如#parameters["name"] 或者 #parameters.name.相当于request.getParameter("name").

2.request: 用来访问request属性，例如#request['login']或#request.login。相当于request.getAttribute("login").

3.session:用来访问session的属性，例如 #session['login']或 #session.login,相当于 session.getAttribute('login').

4.application: 用来访问application的属性，例如：#application['login']或#application.login,相当于application.attribute("login");

5.attr:用来访问PageContext.如果PageContext不可用，则一次搜索request，session，application。例如：#attr['login'] 或 #attr.login

[b][color=red]--------使用命名对象实例------------[/color][/b]
1.action

package com.sh.action;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.struts2.ServletActionContext;

import com.opensymphony.xwork2.ActionSupport;

public class MyOgnlAction extends ActionSupport {

	@Override
	public String execute() throws Exception {
		HttpServletRequest request=ServletActionContext.getRequest();
		request.setAttribute("sameName", "myRequest");

		HttpSession session=request.getSession();
		session.setAttribute("sameName", "mySession");

		ServletContext appliaction=ServletActionContext.getServletContext();
		appliaction.setAttribute("sameName", "myApplication");

		return SUCCESS;
	}
}

2.ognl.jsp

 <body>
    <center>
    ===============使用Struts2的命名空间====================<br/>
	 访问request请求属性:<s:property value="#request.sameName"/><br/>
	 访问session属性：<s:property value="#session.sameName"/><br/>
	 访问application属性:<s:property value="#application.sameName"/><br/>
	访问PageContext属性:<s:property value="#attr.sameName"/><br/>
    </center>
  </body>

3.struts.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
	"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
	"http://struts.apache.org/dtds/struts-2.3.dtd">

<struts> 
     <!-- 定义国际化资源文件的基本名称 -->
	<constant name="struts.custom.i18n.resources" value="com.sh.action.package"/>
    <constant name="struts.i18n.encoding" value="utf-8"/>
    <package name="/user" extends="struts-default">
    	<action name="myOgnlAction" class="com.sh.action.MyOgnlAction">
			<result name="success">/ognl.jsp</result>    	
    	</action>
    </package>
</struts>

4.访问
---http://localhost:8080/Struts2_Ognl/myOgnlAction.action
--可以看到 attr获取的值为myRequest 说明 如果PageContext不存在就会一次搜索request session application

[b][color=red]==================使用OGNL=================[/color][/b]

OGNL（Object Graph Navigation Language）对象导航语言，是一种方便的操作对象属性的开源表达式语言，目的就是避免在Jsp页面中出现过多的<% %>,实现页面与后台代码分离。在应用中经常遇到的问题是 “#” “$” "%" 这个三个符号

1.“#”
   访问OGNL上下文和Action上下文，用于过滤和投影集合，
   例如:books.{?#this.price<100}

2."$"符号
   在国际化资源文件中使用OGNL表达式，
   例如年龄在${min}和 ${max}之间。
   在Struts2配置文件中使用OGNL表达式。

3."%"符号
   当标签的属性为字符串类型时，计算OGNL表达式的值。

1.OGNLAction java

package com.sh.action;

import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;

import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.SessionAware;
import org.apache.struts2.util.ServletContextAware;

import com.opensymphony.xwork2.ActionSupport;
import com.sh.pojo.News;

public class OGNLAction extends ActionSupport 
implements ServletRequestAware,SessionAware,ServletContextAware {
	private HttpServletRequest request;
	private Map session;
	private ServletContext application;

	private List<News> newsList;
	public void setServletRequest(HttpServletRequest arg0) {
		this.request=arg0;
	}

	public void setSession(Map<String, Object> arg0) {
		// TODO Auto-generated method stub
		session=arg0;
	}

	public void setServletContext(ServletContext arg0) {
		// TODO Auto-generated method stub
		application=arg0;
	}

	public List<News> getNewsList() {
		return newsList;
	}

	@SuppressWarnings("unchecked")
	public String execute() throws Exception {
		request.setAttribute("userName", "userName from request");
		session.put("userName", "userName from session");
		application.setAttribute("userName", "userName from application");
		newsList=new LinkedList<News>();
		News new1=new News();
		new1.setNid(1);
		new1.setNtitle("the first news title");
		new1.setNcontent("the first news content");
		new1.setNtime("2012-08-08");
		newsList.add(new1);

		News new2=new News();
		new1.setNid(2);
		new1.setNtitle("the second news title");
		new1.setNcontent("the second news content");
		new1.setNtime("2012-08-18");
		newsList.add(new2);

		News new3=new News();
		new1.setNid(3);
		new1.setNtitle("the three news title");
		new1.setNcontent("the three news content");
		new1.setNtime("2012-08-28");
		newsList.add(new3);

		return super.execute();
	}		
}

2.struts.xml

    	<action name="ognlAction" class="com.sh.action.OGNLAction">
    		<result>/index.jsp</result>
    	</action>

3.index.jsp

<body>

    <center>
    	<h3>访问OGNL上下文和Action上下文</h3>
    	request.userName :<s:property value="#request.userName"/>

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

    	application.userName :<s:property value="#application.userName"/>

    	<hr/>
    	<h3>用于过滤和投影集合</h3>
    	[list]
    	 <s:iterator value="newsList">
    	 	<s:property value="nid"/>. <s:property value="ntitle"/><br/>
    	 </s:iterator>
    	 [/list]
    	 ID是“1”的新闻标题：<s:property value="newsList.{?#this.nid==1}.{ntitle}[0]"/>
    	 <hr/>
    	 <h3>构造Map</h3>
    	 <s:set name="books" value="#{'book1':'23','book2':'55','book3':'66'}"/>
    	 book1的价格是：<s:property value="#books['book1']"/>
    	 <hr/>
    	 <h3>%用途</h3>
    	 <s:url value="#books['book1']"/>:
    	 <s:url value="%{#books['book1']}"/>


    	<hr/>
    	<h3>$使用</h3>
    	request.userName:${requestScope.userName}

    	session.userName:${sessionScope.userName}

    	application.userName:${applicationScope.userName}

    	<hr/>

    </center>
  </body>

4.访问
---http://localhost:8080/Struts2_Ognl/ognlAction.action