1.OGNL表达式介绍：
OGNL是Object-Graph Navigation Language的缩写，它是一种功能强大的表达式语言，通过它简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。它使用相同的表达式去存取对象的属性。这样可以更好的取得数据。
OGNL可以让我们用非常简单的表达式访问对象层，例如，当前环境的根对象为user1，则表达式person.address[0].province可以访问到user1的person属性的第一个address的province属性。
这种功能是模板语言的一个重要补充，象jsp2.0,velocity,jelly等等，都有类似的功能，但是ognl比它们完善得多，而且以一个独立的lib出现，方便我们构建自己的框架。
webwork2和现在的Struts2.x中使用OGNL取代原来的EL来做界面数据绑定，所谓界面数据绑定，也就是把界面元素（例如一个textfield,hidden)和对象层某个类的某个属性绑定在一起，修改和显示自动同步。
和struts1.x的formbean相比，这样做的好处非常明显：在webwork中不需要为每个页面专门写formbean，可以直接利用对象层的对象。例如在对象设计中，我们的User和Person是分开的，而一个注册用户界面需要填写两者的内容，在webwork中，就可以保持后台的对象结构，把属于用户属性的界面元素用user.person.xxx绑定，把属于账号属性的界面元素用user.xxx绑定。
2.OGNL表达式用法
OGNL支持各种纷繁复杂的表达式。但是最最基本的表达式的原型，是将对象的引用值用点串联起来，从左到右，每一次表达式计算返回的结果成为当前对象，后面部分接着在当前对象上进行计算，一直到全部表达式计算完成，返回最后得到的对象。OGNL则针对这条基本原则进行不断的扩充，从而使之支持对象树、数组、容器的访问，甚至是类似SQL中的投影选择等操作。
1. 基本对象树的访问
对象树的访问就是通过使用点号将对象的引用串联起来进行。
例如：xxxx，xxxx.xxxx，xxxx. xxxx. xxxx. xxxx. xxxx
2. 对容器变量的访问
对容器变量的访问，通过#符号加上表达式进行。
例如：#xxxx，#xxxx. xxxx，#xxxx.xxxxx. xxxx. xxxx. xxxx
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("xxxxxx/")
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.{? #txxx.xxx != null}将获得某个group中user的name不为空的user的列表。
3.OGNL表达式案例
OGNL是通常要结合Struts 2的标志一起使用。主要是#、%和$这三个符号的使用。使用方法如下：
新建名为Struts2_OGNL的Web工程
#”主要有三种用途：
访问OGNL上下文和Action上下文，#相当于ActionContext.getContext()；下表有几个ActionContext中有用的属性： 名称 作用 例子
parameters 包含当前HTTP请求参数的Map #parameters.id[0]作用相当于request.getParameterValues("id").get(0);
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属性，直到找到为止
用于过滤和投影（projecting)集合，如books.{?#this.price<100}；
构造Map，如#{'foo1':'bar1', 'foo2':'bar2'}。
下面让我们它们的具体写法，首先是Action类代码：
package tutorial.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 tutorial.model.Book;
import com.opensymphony.xwork2.ActionSupport;
public class OgnlAction extends ActionSupport implements ServletRequestAware, SessionAware, ServletContextAware {
private static final long serialVersionUID = 1L;
private HttpServletRequest request;
private Map session;
private ServletContext application;
private List books;
public void setServletRequest(HttpServletRequest request) {
this.request = request;
}
@SuppressWarnings("unchecked")
public void setSession(Map session) {
this.session = session;
}
public void setServletContext(ServletContext application) {
this.application = application;
}
public List getBooks() {
return books;
}
@Override
public String execute() {
request.setAttribute("userName", "Max From request");
session.put("userName", "Max From session");
application.setAttribute("userName", "Max From application");
books = new LinkedList();
books.add(new Book("978 0735619678", "Code Complete, Second Edition", 32.99));
books.add(new Book("978 0596007867", "The Art of Project Management", 35.96));
books.add(new Book("978 0201633610", "Design Patterns: Elements of Reusable Object-Oriented Software", 43.19));
books.add(new Book("978 0596527341", "Information Architecture for the World Wide Web: Designing Large-Scale Web Sites", 25.19));
books.add(new Book("978 0735605350", "Software Estimation: Demystifying the Black Art", 25.19));
return SUCCESS;
}
}以上代码分别在request、session和application的范围内添加“userName”属性，然后再在JSP页面使用OGNL将其取回。
下面是Ognl.jsp的代码，内容如下：
访问OGNL上下文和Action上下文
parameters.userName: request.userName: session.userName: application.userName: attr.userName:
用于过滤和投影（projecting)集合
Books more than $35
<s:iterator value="books.{?#this.price > 35}">
<s:property value="title" /> - $<s:property value="price" /><br>
</s:iterator>
The price of "Code Complete, Second Edition" is:
构造Map
The value of key "foo1" is
清单3 WebContent/Ognl.jsp 以上代码值得注意的是“”，因为“books.{?#this.title=='Code Complete, Second Edition'}.{price}”返回的值是集合类型，所以要用“[索引]”来访问其值。 最后是Struts 2的配置文件struts.xml，内容如下：
/Ognl.jsp
“%”符号的用途是在标志的属性为字符串类型时，计算OGNL表达式的值。
“$”有两个主要的用途，用于在国际化资源文件中，引用OGNL表达式。在Struts 2和i18n中配置文件
4.OGNL常用表达式：
1. 当使用OGNL调用静态方法的时候，需要按照如下语法编写表达式：
@package.classname@methodname(parameter)
2. 对于OGNL来说，java.lang.Math是其的默认类，如果调用java.lang.Math的静态方法时，无需指定类的名字，比如：@@min(4, 10);
3. 对于OGNL来说，数组与集合是一样的，都是通过下标索引来去访问的。
获取List:<s:property value="testList"/><br>
获取List中的某一个元素(可以使用类似于数组中的下标获取List中的内容):
<s:property value="testList[0]"/><br>
获取Set:<s:property value="testSet"/><br>
获取Set中的某一个元素(Set由于没有顺序，所以不能使用下标获取数据):
<s:property value="testSet[0]"/><br> ×
获取Map:<s:property value="testMap"/><br>
获取Map中所有的键:<s:property value="testMap.keys"/><br>
获取Map中所有的值:<s:property value="testMap.values"/><br>
获取Map中的某一个元素(可以使用类似于数组中的下标获取List中的内容):
<s:property value="testMap['m1']"/><br>
获取List的大小:<s:property value="testSet.size"/><br>
4. 使用OGNL来处理映射（Map）的语法格式如下所示：
#{‘key1’: ‘value1’, ‘key2’: ‘value2’, ‘key3’: ‘value3’};
5. 过滤（filtering）：collection.{? expression}
6. OGNL针对集合提供了一些伪属性（如size，isEmpty），让我们可以通过属性的方式来调用方法（本质原因在于集合当中的很多方法并不符合JavaBean的命名规则），但我么你依然还可以通过调用方法来实现与伪属性相同的目的。
7. 过滤（filtering），获取到集合中的第一个元素：collection.{^ expression}
8. 过滤（filtering），获取到集合中的最后一个元素：collection.{& expression}
9. 在使用过滤操作时，我们通常都会使用#this，该表达式用于代表当前正在迭代的集合中的对象（联想增强的for循环）
10. 投影（projection）：collection.{expression}
11. 过滤与投影之间的差别：类比于数据库中的表，过滤是取行的操作，而投影是取列的操作。 具体举例如下：
利用选择获取List中成绩及格的对象:<s:property value="stus.{?#this.grade>=60}"/><br>
利用选择获取List中成绩及格的对象的username:
<s:property value="stus.{?#this.grade>=60}.{username}"/><br>
利用选择获取List中成绩及格的第一个对象的username:
<s:property value="stus.{?#this.grade>=60}.{username}[0]"/><br>
利用选择获取List中成绩及格的第一个对象的username:
<s:property value="stus.{^#this.grade>=60}.{username}"/><br>
利用选择获取List中成绩及格的最后一个对象的username:
<s:property value="stus.{$#this.grade>=60}.{username}"/><br>
利用选择获取List中成绩及格的第一个对象然后求大小:
<s:property value="stus.{^#this.grade>=600}.{username}.size"/><br>
12． 在Struts2中，根对象就是ValueStack。在Struts2的任何流程当中，ValueStack中的最顶层对象一定是Action对象。
13. parameters，#parameters.username
request, #request.username
session, #session.username
application, #application.username
attr, #attr.username
以上几个对象叫做“命名对象”。
14. 访问静态方法或是静态成员变量的改进。
@vs@method
15. 关于Struts2标签库属性值的%与#号的关系：
1）. 如果标签的属性值是OGNL表达式，那么无需加上%{}。
2）. 如果标签的属性值是字符串类型，那么在字符串当中凡是出现的%{}都会被解析成OGNL表达式，解析完毕后再与其他的字符串进行拼接构造出最后的字符串值。
3）. 我们可以在所有的属性值上加%{}，这样如果该属性值是OGNL表达式，那么标签处理类就会将%{}忽略掉。
最后一起用代码说话，简单的看一下ognl操作的示例：
1）上下文环境中使用OGNL
public static void main(String[] args)
{
Map<String , Object> context = new HashMap<String , Object>();
Person person1 = new Person();
person1.setName("zhangsan");
Person person2 = new Person();
person2.setName("lisi");
Person person3 = new Person();
person3.setName("wangwu");
Person person4 = new Person();
person4.setName("zhaoliu");
context.put("person1", person1);
context.put("person2", person2);
context.put("person3", person3);
try
{
Object value = Ognl.getValue("name", context, person2);
System.out.println("ognl expression \"name\" evaluation is : " + value);
Object value2 = Ognl.getValue("#person2.name", context, person2);
System.out.println("ognl expression \"#person2.name\" evaluation is : " + value2);
Object value3 = Ognl.getValue("#person1.name", context, person2);
System.out.println("ognl expression \"#person1.name\" evaluation is : " + value3);
Object value4 = Ognl.getValue("name", context, person4);
System.out.println("ognl expression \"name\" evaluation is : " + value4);
Object value5 = Ognl.getValue("#person4.name", context, person4);
System.out.println("ognl expression \"person4.name\" evaluation is : " + value5);
// Object value6 = Ognl.getValue("#person4.name", context, person2);
// System.out.println("ognl expression \"#person4.name\" evaluation is : " + value6);
}2）使用OGNL调用方法
public static void main(String[] args)
{
OgnlContext context = new OgnlContext();
People people1 = new People();
people1.setName("zhangsan");
People people2 = new People();
people2.setName("lisi");
People people3 = new People();
people3.setName("wangwu");
context.put("people1", people1);
context.put("people2", people2);
context.put("people3", people3);
context.setRoot(people1);
try
{
Object value = Ognl.getValue("name.length()", context, context.getRoot());
System.out.println("people1 name length is :" + value);
Object upperCase = Ognl.getValue("#people2.name.toUpperCase()", context, context.getRoot());
System.out.println("people2 name upperCase is :" + upperCase);
Object invokeWithArgs = Ognl.getValue("name.charAt(5)", context, context.getRoot());
System.out.println("people1 name.charAt(5) is :" + invokeWithArgs);
Object min = Ognl.getValue("@java.lang.Math@min(4,10)", context, context.getRoot());
System.out.println("min(4,10) is :" + min);
Object e = Ognl.getValue("@java.lang.Math@E", context, context.getRoot());
System.out.println("E is :" + e);
}3）使用OGNL操作集合
public static void main(String[] args) throws Exception
{
OgnlContext context = new OgnlContext();
Classroom classroom = new Classroom();
classroom.getStudents().add("zhangsan");
classroom.getStudents().add("lisi");
classroom.getStudents().add("wangwu");
classroom.getStudents().add("zhaoliu");
classroom.getStudents().add("qianqi");
Student student = new Student();
student.getContactWays().put("homeNumber", "110");
student.getContactWays().put("companyNumber", "119");
student.getContactWays().put("mobilePhone", "112");
context.put("classroom", classroom);
context.put("student", student);
context.setRoot(classroom);
Object collection = Ognl.getValue("students", context, context.getRoot());
System.out.println("students collection is ：" + collection);
Object firstStudent = Ognl.getValue("students[0]", context, context.getRoot());
System.out.println("first student is : " + firstStudent);
Object size = Ognl.getValue("students.size()", context, context.getRoot());
System.out.println("students collection size is :" + size);
System.out.println("--------------------------飘逸的分割线--------------------------");
Object mapCollection = Ognl.getValue("#student.contactWays", context, context.getRoot());
System.out.println("mapCollection is :" + mapCollection);
Object firstElement = Ognl.getValue("#student.contactWays['homeNumber']", context, context.getRoot());
System.out.println("the first element of contactWays is :" + firstElement);
System.out.println("--------------------------飘逸的分割线--------------------------");
Object createCollection = Ognl.getValue("{'aa','bb','cc','dd'}", context, context.getRoot());
System.out.println(createCollection);
Object createMapCollection = Ognl.getValue("#{'key1':'value1','key2':'value2'}", context, context.getRoot());
System.out.println(createMapCollection);
}
}