OGNL表达式

在学习Struts2中的OGNL和值栈的时候，遇到了OGNL，看了一些后还是发下对这个OGNL 完全模糊，在此节单独对OGNL进行学习。

目的是学完后知道OGNL是来干嘛的？可以怎么使用。

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

OGNL我们看到最多的就是和Struts2的标签结合使用，但其实OGNL离开了Struts2也是可以的，只是用在Struts2中，就必须和标签库结合才能使用。

这篇文章就先讲讲OGNL不结合Struts2的一些用法，下篇文章再讲OGNL在Struts2中的用法。

1.OgnlContext类和Ognl类的介绍

在类中使用OGNL表达式，和两个类息息相关，分别是OgnlContext类和Ognl类。

Ognl类：This class provides static methods for parsing and interpreting OGNL expressions.根据官方解释，这个类是提供一些静态方法去解析表达式。

OgnlContext：This class defines the execution context for an OGNL expression.该类定义OGNL表达式的执行上下文。

public class OgnlContext extends Object implements Map {}

OgnlContext类实现了Map接口，所以它也是一个Map，可以通过put方法往该上下文环境中放元素。该上下文环境中，有两种对象：根对象和普通对象。我们可以使用它的setRoot方法设置根对象。根对象只能有一个，而普通对象则可以有多个。因为它实现了java.utils.Map 的接口。OgnlContext（ognl上下文）=根对象(1个)+非根对象(n个)，非根对象要通过"#key"访问，根对象可以省略"#key"。

2.Ognl获取普通对象和根对象的方法

在上下文环境中，有根对象和普通的对象，两者的获取方式有所不同：获取根对象的属性值，可以直接使用属性名作为表达式，也可以使用#对象名.属性名的方式；获取普通对象的属性值，则必须使用#对象名.属性名的方式获取。（可以将普通对象设置为根对象，但只能有一个根对象，后面设置的根对象会覆盖前面的根对象）下面举例说明。

package OGNL;

import java.util.List;

public class School {
    
    private String name;
    private List<Teacher> teachers;
    
    
    public School() {
        super();
    }
    
    
    public School(String name, List<Teacher> teachers) {
        super();
        this.name = name;
        this.teachers = teachers;
    }


    /**
     * @return the name
     */
    public String getName() {
        return name;
    }
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
    /**
     * @return the teachers
     */
    public List<Teacher> getTeachers() {
        return teachers;
    }
    /**
     * @param teachers the teachers to set
     */
    public void setTeachers(List<Teacher> teachers) {
        this.teachers = teachers;
    }    
    

}

package OGNL;

public class Teacher {
    
    private String name;
    private String gender;
    private int age;    
    
    
    public Teacher() {
        super();
    }
    
    public Teacher(String name, String gender, int age) {
        super();
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
    /**
     * @return the name
     */
    public String getName() {
        return name;
    }
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
    /**
     * @return the gender
     */
    public String getGender() {
        return gender;
    }
    /**
     * @param gender the gender to set
     */
    public void setGender(String gender) {
        this.gender = gender;
    }
    /**
     * @return the age
     */
    public int getAge() {
        return age;
    }
    /**
     * @param age the age to set
     */
    public void setAge(int age) {
        this.age = age;
    }        

}

package OGNL;

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

import ognl.Ognl;
import ognl.OgnlContext;
import ognl.OgnlException;

public class Test {
    
    public static void main(String args[]) throws OgnlException{
        
        //定义一个老师对象
        Teacher t1 = new Teacher("zhangsan","男",30);        
        List<Teacher> teachers =new ArrayList<Teacher>();
        teachers.add(t1);
        
        //定义一个学校对象
        School sc = new School("China", teachers);
        
        //创建一个OgnlContext对象
        OgnlContext context  = new OgnlContext();
        
        //将老师和学校放入上下文环境中
        context.put("t1", t1);
        context.put("sc", sc);
        
        //未设置根对象之前，根对象为null
        System.out.println("0000:"+context.getRoot());
        
        //设置学校为根对象
        context.setRoot(sc);
        System.out.println("1111:"+context.getRoot());
        //若继续设置根对象，会覆盖前面的根对象
        //context.setRoot(t1);
        
        //获取根对象属性
        //获取根对象的属性值，可以直接使用属性名作为表达式，也可以使用#对象名.属性名的方式；
        Object expression = Ognl.parseExpression("name");
        //Object expression = Ognl.parseExpression("#sc.name");
        
        Object result = Ognl.getValue(expression, context, context.getRoot());
        // 获取根对象的信息,使用#获取上下文中的属性值时，必须使用带Map context参数getValue方法，指定上下文环境
        // 获取根对象的信息,直接获取，没有使用#，则可以使用不带Map context参数getValue方法
        Object result1 = Ognl.getValue(expression, context.getRoot());
        System.out.println("2222:"+result);
        System.out.println("2222:"+result1);
        
        //获取普通对象的属性值，则必须使用#对象名.属性名的方式获取
        expression = Ognl.parseExpression("#t1.name");
        result = Ognl.getValue(expression, context, context.getRoot());
        System.out.println("3333:"+result);
    }

}

运行测试代码：这种方法通过属性来获取属性值

0000:null
1111:OGNL.School@11028347
2222:China
2222:China
3333:zhangsan

总结：

1.根对象只能有一个，当你尝试设置多个的时候，后面的会覆盖前面的。
2.访问根对象中的属性，可以直接使用属性名，或者#对象名.属性名，但不能使用对象名.属性名，不然它会认为这是根对象中的一个属性叫对象名，然后访问这个属性的名叫属性名的属性值。

3.不使用#获取根对象中的属性值时， 使用getValue方法可以不指定上下文环境，因为第三个参数已经得到了根对象，它指定去根对象中找。如果获取普通对象的属性，则必须在getValue方法中指定上下文环境，因为你不知道它找不到。
4.通过根对象间接获取普通对象的属性时，比如List集合，使用下标去获取

3.Ognl访问非静态方法、静态方法、静态字段的方法

Ognl不但可以访问我们自己定义的类的属性和方法，还可以访问Java API中的静态方法和静态字段。

package OGNL;

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

import ognl.Ognl;
import ognl.OgnlContext;
import ognl.OgnlException;

public class Test {
    
    public static void main(String args[]) throws OgnlException{
        
        //定义一个老师对象
        Teacher t1 = new Teacher("zhangsan","男",30);        
        List<Teacher> teachers =new ArrayList<Teacher>();
        teachers.add(t1);
        
        //定义一个学校对象
        School sc = new School("China", teachers);
        
        //创建一个OgnlContext对象
        OgnlContext context  = new OgnlContext();
        
        //将老师和学校放入上下文环境中
        context.put("t1", t1);
        context.put("sc", sc);
        
        //未设置根对象之前，根对象为null
        System.out.println("根对象:"+context.getRoot());
        
        //设置学校为根对象
        context.setRoot(sc);
        System.out.println("设置根对象:"+context.getRoot());
        //若继续设置根对象，会覆盖前面的根对象
        //context.setRoot(t1);
        
        //获取根对象属性
        //获取根对象的属性值，可以直接使用属性名作为表达式，也可以使用#对象名.属性名的方式；
        Object expression = Ognl.parseExpression("name");
        //Object expression = Ognl.parseExpression("#sc.name");
        
        Object result = Ognl.getValue(expression, context, context.getRoot());
        // 获取根对象的信息,使用#获取上下文中的属性值时，必须使用带Map context参数getValue方法，指定上下文环境
        // 获取根对象的信息,直接获取，没有使用#，则可以使用不带Map context参数getValue方法
        Object result1 = Ognl.getValue(expression, context.getRoot());
        System.out.println("获取根对象的属性值:"+result);
        System.out.println("获取根对象的属性值:"+result1);
        
        //获取普通对象的属性值，则必须使用#对象名.属性名的方式获取
        expression = Ognl.parseExpression("#t1.name");
        result = Ognl.getValue(expression, context, context.getRoot());
        System.out.println("获取普通对象的属性值:"+result);
        
        //调用根对象中的方法
        expression = Ognl.parseExpression("getName()");
        expression = Ognl.parseExpression("#sc.getName()");
        result = Ognl.getValue(expression, context, context.getRoot());
        System.out.println("调用根对象中的方法:"+result);
        
        //调用普通对象中的方法
        expression  = Ognl.parseExpression("#t1.getAge()");
        result = Ognl.getValue(expression, context, context.getRoot());
        System.out.println("调用普通对象中的方法:"+result);
        expression  = Ognl.parseExpression("#t1.getName().length()");
        result = Ognl.getValue(expression, context, context.getRoot());
        System.out.println("调用普通对象中的方法:"+result);
        
        //调用根对象中的静态方法
        expression = Ognl.parseExpression("test00()");
        expression = Ognl.parseExpression("#sc.test00()");
        result = Ognl.getValue(expression, context, context.getRoot());
        System.out.println("调用根对象中的静态方法:"+result);
        
        //调用API中的静态方法
        expression = Ognl.parseExpression("@java.lang.Math@floor(4.5)");
        result = Ognl.getValue(expression, context, context.getRoot());
        System.out.println("调用API中的静态方法:"+result);
        
        //调用API中的静态属性
        expression = Ognl.parseExpression("@java.lang.Math@PI");
        result = Ognl.getValue(expression, context, context.getRoot());
        System.out.println("调用API中的静态属性:"+result);
        
    }

}

在school.java中新加了一个静态函数：

    public static String test00(){
        
        return "thank you";        
    }

运行上面的测试code:

根对象:null
设置根对象:OGNL.School@11028347
获取根对象的属性值:China
获取根对象的属性值:China
获取普通对象的属性值:zhangsan
调用根对象中的方法:China
调用普通对象中的方法:30
调用普通对象中的方法:8
调用根对象中的静态方法:thank you
调用API中的静态方法:4.0
调用API中的静态属性:3.141592653589793.

所以到此我们可以看到OGNL实际上就是提供另一种方式来调用对象的任意属性和方法。

4.Ognl获取数组、集合、Map中元素的方法

Ognl表达式可以创建实例对象，以及获取实例对象中的属性，下面我们看看怎么通过Ognl创建一个集合、map以及通过Ognl获取里面的元素。

package OGNL;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import ognl.Ognl;
import ognl.OgnlContext;
import ognl.OgnlException;

public class Test02 {

    public static void main(String[] args) throws OgnlException {
        
        OgnlContext context = new OgnlContext();
        
        // 通过Ognl可以创建java的实例对象，只有是类的完整路径
        Object expression = Ognl.parseExpression("new java.util.ArrayList()");
        Object result = Ognl.getValue(expression, context, context.getRoot());
        System.out.println("Ognl创建实例："+result);
        
        //注意这种自定义的类，一定要填写类的完整路径
        expression = Ognl.parseExpression("new OGNL.Teacher('zhangsan','男',30)");
        result = Ognl.getValue(expression, context, context.getRoot());
        System.out.println("Ognl创建实例："+result);
        
        // 通过Ognl可以创建一个初始化的List 
        expression = Ognl.parseExpression("{'a', 'b', 'c', 'd'}"); 
        //expression = Ognl.parseExpression("['a', 'b', 'c', 'd']"); //这个报错
        result = Ognl.getValue(expression, context, context.getRoot()); 
        System.out.println("Ognl初始化List:"+result);
        
        // 通过Ognl可以创建一个初始化的Map，注意此时得加上#符号
        expression = Ognl.parseExpression("#{'a':'aa', 'b':'bb', 'c':'cc', 'd':'dd'}");
        // 创建指定类型的Map
        // expression = Ognl.parseExpression("#@java.util.TreeMap@{'a':'aa', 'b':'bb', 'c':'cc', 'd':'dd'}");
        result = Ognl.getValue(expression, context, context.getRoot());
        System.out.println("Ognl初始化Map:"+result);
        
        // 通过Ognl访问数组中的元素 
        String[] name1 = {"liu", "xu"}; 
        context.put("name1", name1); 
        // 直接通过数组名+下标 
        expression = Ognl.parseExpression("#name1[1]"); 
        result = Ognl.getValue(expression, context, context.getRoot()); 
        System.out.println("通过Ognl访问数组中的元素:"+result);
        
        // 通过Ognl访问集合中的元素 
        List<String> name2 = new ArrayList<String>(); 
        Collections.addAll(name2, name1); //将name1中的数据copy到name2中。
        context.put("name2", name2); 
        // 直接通过集合名+下标
        expression = Ognl.parseExpression("#name2[0]"); 
        result = Ognl.getValue(expression, context, context.getRoot()); 
        System.out.println("通过Ognl访问集合中的元素:"+result);
        
        // 通过Ognl访问Map中的元素         
        Map<Integer, String> name3 = new HashMap<Integer, String>(); 
        name3.put(1, "liu"); 
        name3.put(2, "xu"); 
        context.put("name3", name3); 
        // 直接通过map名+key 
        expression = Ognl.parseExpression("#name3[1]"); 
        result = Ognl.getValue(expression, context, context.getRoot()); 
        System.out.println("通过Ognl访问Map中的元素 :"+result);    

    }

}

运行结果：

Ognl创建实例：[]
Ognl创建实例：OGNL.Teacher@2aaf7cc2
Ognl初始化List:[a, b, c, d]
Ognl初始化Map:{a=aa, b=bb, c=cc, d=dd}
通过Ognl访问数组中的元素:xu
通过Ognl访问集合中的元素:liu
通过Ognl访问Map中的元素 :liu

注意点
1.创建集合不用加#，创建map要加#。
2.创建类的一个对象，要使用类的完整路径。
3.要创建带有初始化值的指定类型的List或Map，可以这样#@java.util.TreeMap@{‘key’:’value’,’key’:’value’,……}。

OGNL还有其他用法。这里不再细说。通过上面的例子，我们可以看出，OGNL大概作用是什么：就是用来获取对象的属性和方法。

记住OGNL的表达式、根对象、上下文OgnlContext.

上面的例子中我们可以看到，都是直接调用了OgnlContext这个类，创建了context，我们用OGNL的时候，第二个参数就是context, 第三个参数就是context,getRoot()。

实际上这个上下文环境我们是可以自定义的，根对象我们也是可以自定义的。我们来看看下面的例子：

package OGNL;

public class Address {
    
    private String city;
    private String Street;
    /**
     * @return the city
     */
    public String getCity() {
        return city;
    }
    /**
     * @param city the city to set
     */
    public void setCity(String city) {
        this.city = city;
    }
    /**
     * @return the street
     */
    public String getStreet() {
        return Street;
    }
    /**
     * @param street the street to set
     */
    public void setStreet(String street) {
        Street = street;
    }
}


package OGNL;

public class User {
    
    private String name;
    private int age;
    private String password;
    private Address address;
    /**
     * @return the name
     */
    public String getName() {
        return name;
    }
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
    /**
     * @return the age
     */
    public int getAge() {
        return age;
    }
    /**
     * @param age the age to set
     */
    public void setAge(int age) {
        this.age = age;
    }
    /**
     * @return the password
     */
    public String getPassword() {
        return password;
    }
    /**
     * @param password the password to set
     */
    public void setPassword(String password) {
        this.password = password;
    }
    /**
     * @return the address
     */
    public Address getAddress() {
        return address;
    }
    /**
     * @param address the address to set
     */
    public void setAddress(Address address) {
        this.address = address;
    }
}

package OGNL;

import java.util.HashMap;

import ognl.Ognl;
import ognl.OgnlException;

public class Test03 {

    public static void main(String[] args) throws OgnlException {
        
        User user = new User();
        user.setName("zhangsan");
        
        //将user对象作为OGNL的根，编写OGNL表达式来获取user对象中的各种属性值
        //直接编写属性名，即获取user对象中的属性值
        String name = (String) Ognl.getValue("name", new HashMap(), user);
        System.out.println("0000:"+name);
        
        //获取javaBean中另一个对象的属性值，用xxx.yyy
        Address ads = new Address();
        ads.setCity("baoding");
        user.setAddress(ads);
        String result = (String) Ognl.getValue("address.city", new HashMap(), user);
        System.out.println("1111:"+result);
        
        //对JavaBean中的属性进行赋值操作
        Ognl.getValue("name='zhaosi'", new HashMap(), user);
        System.out.println("2222:"+user.getName());
        Ognl.getValue("setName('wangwu')", new HashMap(), user);
        System.out.println("3333:"+user.getName());
        //上面是两种赋值方式：
        /*1：属性=value
            Ognl.getValue("name='zhaosi'", new HashMap(), user);        
        2：setName(value)
            Ognl.getValue("setName('wangwu')", new HashMap(), user);
        */
    }

}

运行结果：

0000:zhangsan
1111:baoding
2222:zhaosi
3333:wangwu

可以看到这个例子中直接将user作为对象去使用。并且上下文环境直接是新建了一个HashMap。

上面两个例子都是讲解OGNL基本用法，主要区别就在于第二个例子中，都是将对象直接作为根对象去使用。没有用到OgnlContext这个类。

 https://www.cnblogs.com/whgk/p/6600393.html

https://blog.csdn.net/a_helloword/article/details/80432364-----参考博客

作者：全网第一菜
来源：CSDN
原文：https://blog.csdn.net/a_helloword/article/details/80432364