OGNL使用详解一：原理与常用语法方式

OGNL使用详解一：原理与常用语法方式

OGNL：Object-Graph Navigation Language，一种功能强大的表达式语言（Expression Language，简称为EL），通过它简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。它使用相同的表达式去存取对象的属性。

以上关于OGNL的定义是在百度百科中的描述，其实通俗的讲，就是ognl的context对象解析一个ognl字符串，返回相应的结果。

简单讲一下OGNL的几个重要的概念：
1.OgnlContext：它实现了Map接口，以key-value键值对形式存在，不同于普通map的是，里面存在唯一的叫做根的对象（root）,可以通过程序设定上下文中哪个对象是根对象。
2.root对象：root对象与普通对象都是OgnlContext中的元素，但是OgnlContext默认取根对象，如果是非根对象，需要在ognl表达式前加"#"。

3.OgnlContext里面默认就放了四个对象：request，application，session，parameters。
4.OgnlContext的根对象在初始化时是空的

这里需要提一句，OGNL本身和Struts2没有任何关系，经常听到有人说OGNL是Struts2的，对此很无语。仅仅是Struts2支持OGNL，并且在此基础上增加了一些东西。

由于语法过于复杂，以下用一个demo项目来做演示：

第一步：新建一个Java Project

第二步：引入两个ognl需要的jar：ognl.3.0.6.jar,javassist-3.11.0.jar包。

第三步：加入两个bean：

package ognl.bean;

/**
*
* @author wangjian
*
*/
public class Dog {
private String name;

private String[] friends;

public String[] getFriends() {
return friends;
}

public void setFriends(String[] friends) {
this.friends = friends;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}

package ognl.bean;

/**
*
* @author wangjian
*
*/
public class Person {
private String name;

private Dog dog;

public Person() {
super();
}

public Person(String name) {
this.name = name;
}

public Dog getDog() {
return dog;
}

public void setDog(Dog dog) {
this.dog = dog;
}

public String getName() {
System.out.println("getName invoked!");

return name;
}

public void setName(String name) {
this.name = name;
}
}

第四步：编写OGNL语法测试类：

package ognl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import ognl.bean.Dog;
import ognl.bean.Person;

/**
*
* @author wangjian
*
*/
public class OGNLTest {
public static void main(String[] args) throws OgnlException {

Person person = new Person();
person.setName("Steven");

Dog dog2 = new Dog();
dog2.setName("hello world");

person.setDog(dog2);

Dog dog = new Dog();
dog.setName("hello world your sister");

OgnlContext context = new OgnlContext();

// 把对象以键值对形式放进去
context.put("person", person);
context.put("dog", dog);

// 设定这个OGNL的根root是person对象
context.setRoot(person);

// 解析一个表达式（取跟对象的属性的时候，无需加#，直接写属性名字，默认从根对象中取属性）
Object object = Ognl.parseExpression("name");

System.out.println(object);

Object object2 = Ognl.getValue(object, context, context.getRoot());

System.out.println(object2);

System.out.println("----------------------------");

// #表示取的不是根对象，表示取context里面存的person对象里面的name属性
Object object3 = Ognl.parseExpression("#person.name");

System.out.println(object3);

Object object4 = Ognl.getValue(object3, context, context.getRoot());

System.out.println(object4);

System.out.println("----------------------------");

// #表示取的不是根对象，表示取context里面存的dog对象里面的name属性
Object object5 = Ognl.parseExpression("#dog.name");

System.out.println(object5);

Object object6 = Ognl.getValue(object5, context, context.getRoot());

System.out.println(object6);

System.out.println("----------------------------");

// 属性后买年可以直接调String的方法
Object object7 = Ognl.parseExpression("name.toUpperCase().length()");

System.out.println(object7);

Object object8 = Ognl.getValue(object7, context, context.getRoot());

System.out.println(object8);

System.out.println("----------------------------");

// 调用ONGL的静态方法时用两个@@符号：@表示类名@表示方法名
Object object9 = Ognl.parseExpression("@java.lang.Integer@toBinaryString(10)");

System.out.println(object9);

Object object10 = Ognl.getValue(object9, context, context.getRoot());

System.out.println(object10);

System.out.println("----------------------------");

// 调用ONGL的静态方法时用两个@@符号：不写类名，默认是java.lang.Math类，@@直接写Math类里面的方法
Object object11 = Ognl.parseExpression("@@min(4, 10)");

System.out.println(object11);

Object object12 = Ognl.getValue(object11, context, context.getRoot());

System.out.println(object12);

System.out.println("----------------------------");

// new一个LinkedList
Object object13 = Ognl.parseExpression("new java.util.LinkedList()");

System.out.println(object13);

Object object14 = Ognl.getValue(object13, context, context.getRoot());

System.out.println(object14);

System.out.println("----------------------------");

// 一个字符串集合（外面用双引号了，里面就用单引号），
Object object15 = Ognl.getValue("{'aa', 'bb', 'cc', 'dd'}", context,context.getRoot());

System.out.println(object15);

System.out.println("----------------------------");

// 一个字符串集合（OGNL中，集合与数组是等同的），取第三个元素
Object object16 = Ognl.getValue("{'aa', 'bb', 'cc', 'dd'}[2]", context,context.getRoot());

System.out.println(object15);

System.out.println("----------------------------");

dog.setFriends(new String[] { "aa", "bb", "cc" });
// dog对象的friends数组
Object object17 = Ognl.getValue("#dog.friends", context,context.getRoot());

System.out.println(object17);

System.out.println("----------------------------");

dog.setFriends(new String[] { "aa", "bb", "cc" });
// dog对象的friends数组的第二个元素
Object object18 = Ognl.getValue("#dog.friends[1]", context,context.getRoot());

System.out.println(object18);

List<String> list = new ArrayList<String>(Arrays.asList("hello","world", "hello world"));

context.put("list", list);

System.out.println(Ognl.getValue("#list", context, context.getRoot()));
System.out.println(Ognl.getValue("#list[1]", context, context.getRoot()));

System.out.println("----------------------------");

// OGNL的映射（Map）:#{}表示这是一个映射Map,这里的#与取非根元素的#不同，仅仅表示这是一个映射Map而已
System.out.println(Ognl.getValue("#{'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}",context, context.getRoot()));
// OGNL返回映射中某key对应的value
System.out.println(Ognl.getValue("#{'key1': 'value1', 'key2': 'value2', 'key3': 'value3', 'key4': 'value4'}['key3']",context, context.getRoot()));

System.out.println("----------------------------");

List<Person> persons = new ArrayList<Person>(Arrays.asList(new Person("doctor"), new Person("worker"), new Person("student")));

context.put("persons", persons);

// 过滤:collection.{?开头
// expression},对一个集合进行过滤，返回过滤后结果(OGNL提供了伪属性，"#persons.{? #this.name.length() > 4}.size"也可以）
System.out.println(Ognl.getValue("#persons.{? #this.name.length() > 4}", context,context.getRoot()));
System.out.println(Ognl.getValue("#persons.{? #this.name.length() > 4}.size()", context,context.getRoot()));
System.out.println(Ognl.getValue("#persons.{? #this.name.length() > 4}[0].name", context,context.getRoot()));

// 过滤（filtering）,获取到过滤后的集合中的第一个元素^, collection.{^ expression}
System.out.println(Ognl.getValue("#persons.{^ #this.name.length() > 4}", context,context.getRoot()));

// 过滤（filtering）,获取到过滤后的集合中的第一个元素$, collection.{$ expression}
System.out.println(Ognl.getValue("#persons.{$ #this.name.length() > 4}", context,context.getRoot()));

System.out.println("----------------------------");

// 投影（projection）, collection. {expression}
System.out.println(Ognl.getValue("#persons.{name}", context,context.getRoot()));

System.out.println("----------------------------");

System.out.println(Ognl.getValue("#persons.{#this.name.length() <= 5 ? 'Hello World' : #this.name}",context, context.getRoot()));

}
}