通过实例深入学习Java的Struts框架中的OGNL表达式使用_java

Struts 2默认的表达式语言是OGNL，原因是它相对其它表达式语言具有下面几大优势：
1. 支持对象方法调用，如xxx.doSomeSpecial()；
2. 支持类静态的方法调用和值访问，表达式的格式为@[类全名（包括包路径）]@[方法名 | 值名]，例如：@java.lang.String@format('foo %s', 'bar')或@tutorial.MyConstant@APP_NAME；
3. 支持赋值操作和表达式串联，如price=100, discount=0.8, calculatePrice()，这个表达式会返回80；
4. 访问OGNL上下文（OGNL context）和ActionContext；
5. 操作集合对象。
下面我们来看OGNL使用的几个例子：

示例：上下文环境中使用OGNL

public class OGNL1
{
  public static void main(String[] args)
  {
    /* 创建一个上下文Context对象，它是用保存多个对象一个环境 对象 */
    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"); 

    /* person4不放入到上下文环境中 */
    Person person4 = new Person();
    person4.setName("zhaoliu"); 

    /* 将person1、person2、person3添加到环境中（上下文中） */
    context.put("person1", person1);
    context.put("person2", person2);
    context.put("person3", person3); 

    try
    {
      /* 获取根对象的"name"属性值 */
      Object value = Ognl.getValue("name", context, person2);
      System.out.println("ognl expression \"name\" evaluation is : " + value); 

      /* 获取根对象的"name"属性值 */
      Object value2 = Ognl.getValue("#person2.name", context, person2);
      System.out.println("ognl expression \"#person2.name\" evaluation is : " + value2); 

      /* 获取person1对象的"name"属性值 */
      Object value3 = Ognl.getValue("#person1.name", context, person2);
      System.out.println("ognl expression \"#person1.name\" evaluation is : " + value3); 

      /* 将person4指定为root对象，获取person4对象的"name"属性，注意person4对象不在上下文中 */
      Object value4 = Ognl.getValue("name", context, person4);
      System.out.println("ognl expression \"name\" evaluation is : " + value4); 

      /* 将person4指定为root对象，获取person4对象的"name"属性，注意person4对象不在上下文中 */
      Object value5 = Ognl.getValue("#person4.name", context, person4);
      System.out.println("ognl expression \"person4.name\" evaluation is : " + value5); 

      /* 获取person4对象的"name"属性，注意person4对象不在上下文中 */
      // Object value6 = Ognl.getValue("#person4.name", context, person2);
      // System.out.println("ognl expression \"#person4.name\" evaluation is : " + value6); 

    }
    catch (OgnlException e)
    {
      e.printStackTrace();
    }
  }
} 

class Person
{
  private String name; 

  public String getName()
  {
    return name;
  } 

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

控制台输出：

ognl expression "name" evaluation is : lisi
ognl expression "#person2.name" evaluation is : lisi
ognl expression "#person1.name" evaluation is : zhangsan
ognl expression "name" evaluation is : zhaoliu
ognl.OgnlException: source is null for getProperty(null, "name")
  at ognl.OgnlRuntime.getProperty(OgnlRuntime.java:2296)
  at ognl.ASTProperty.getValueBody(ASTProperty.java:114)
  at ognl.SimpleNode.evaluateGetValueBody(SimpleNode.java:212)
  at ognl.SimpleNode.getValue(SimpleNode.java:258)
  at ognl.ASTChain.getValueBody(ASTChain.java:141)
  at ognl.SimpleNode.evaluateGetValueBody(SimpleNode.java:212)
  at ognl.SimpleNode.getValue(SimpleNode.java:258)
  at ognl.Ognl.getValue(Ognl.java:494)
  at ognl.Ognl.getValue(Ognl.java:596)
  at ognl.Ognl.getValue(Ognl.java:566)
  at com.beliefbetrayal.ognl.OGNL1.main(OGNL1.java:53)

对于使用上下文的OGNL，若不指定从哪一个对象中查找"name"属性，则OGNL直接从根对象(root)查找，若指定查找对象(使用'#'号指定，如#person1),则从指定的对象中查找，若指定对象不在上下文中则会抛出异常，换句话说就是是#person1.name形式指定查找对象则必须要保证指定对象在上下文环境中。

示例：使用OGNL调用方法

public class OGNL2
{
  public static void main(String[] args)
  {
    /* OGNL提供的一个上下文类，它实现了Map接口 */
    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);
    }
    catch (OgnlException e)
    {
      e.printStackTrace();
    }
  }
} 

class People
{
  private String name; 

  public String getName()
  {
    return name;
  } 

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

控制台输出：

people1 name length is :8
people2 name upperCase is :LISI
people1 name.charAt(5) is :s
min(4,10) is :4
E is :2.718281828459045

使用OGNL调用方法也十分简单，对于成员方法调用，只需要给出方法的名称+()，若有参数，直接写在括号内，与一般调用Java方法一致。对于静态方法的调用，需要使用如下格式：@ClassName@method，对于静态变量需要使用如下格式：@ClassName@field。

示例：使用OGNL操作集合

public class OGNL3
{
  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); 

    /* 获得classroom的students集合 */
    Object collection = Ognl.getValue("students", context, context.getRoot());
    System.out.println("students collection is ：" + collection); 

    /* 获得classroom的students集合 */
    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); 

    /* 创建Map集合 */
    Object createMapCollection = Ognl.getValue("#{'key1':'value1','key2':'value2'}", context, context.getRoot());
    System.out.println(createMapCollection); 

  }
} 

class Classroom
{
  private List<String> students = new ArrayList<String>(); 

  public List<String> getStudents()
  {
    return students;
  } 

  public void setStudents(List<String> students)
  {
    this.students = students;
  }
} 

class Student
{
  private Map<String , Object> contactWays = new HashMap<String , Object>(); 

  public Map<String , Object> getContactWays()
  {
    return contactWays;
  } 

  public void setContactWays(Map<String , Object> contactWays)
  {
    this.contactWays = contactWays;
  }
}

控制台的输出：

students collection is ：[zhangsan, lisi, wangwu, zhaoliu, qianqi]
first student is : zhangsan
students collection size is :5
--------------------------飘逸的分割线--------------------------
mapCollection is :{homeNumber=110, mobilePhone=112, companyNumber=119}
the first element of contactWays is :110
--------------------------飘逸的分割线--------------------------
[aa, bb, cc, dd]
{key1=value1, key2=value2}

OGNL不仅可以操作集合对象，还可以创建集合对象，对集合操作与对属性的操作没什么不同，需要注意的是OGNL认为List与Array是一样的。使用OGNL创建List集合时使用{}，创建Map对象时使用#{}。

示例：使用OGNL过滤集合与投影集合

public class OGNL4
{
  public static void main(String[] args) throws Exception
  {
    OgnlContext context = new OgnlContext(); 

    Humen humen = new Humen();
    humen.setName("qiuyi");
    humen.setSex("n");
    humen.setAge(22);
    humen.getFriends().add(new Humen("zhangsan" , "n" , 22));
    humen.getFriends().add(new Humen("lisi" , "f" , 21));
    humen.getFriends().add(new Humen("wangwu" , "n" , 23));
    humen.getFriends().add(new Humen("zhaoliu" , "n" , 22));
    humen.getFriends().add(new Humen("qianqi" , "n" , 22));
    humen.getFriends().add(new Humen("sunba" , "f" , 20));
    humen.getFriends().add(new Humen("yangqiu" , "f" , 25)); 

    context.put("humen", humen);
    context.setRoot(humen); 

    /* OGNL过滤集合的语法为：collection.{? expression} */
    Object filterCollection = Ognl.getValue("friends.{? #this.name.length() > 7}", context, context.getRoot());
    System.out.println("filterCollection is :" + filterCollection); 

    System.out.println("--------------------------飘逸的分割线--------------------------"); 

    /* OGNL投影集合的语法为：collection.{expression} */
    Object projectionCollection = Ognl.getValue("friends.{name}", context, context.getRoot());
    System.out.println("projectionCollection is :" + projectionCollection);
  }
} 

class Humen
{
  private String name;
  private String sex;
  private int age;
  private List<Humen> friends = new ArrayList<Humen>(); 

  public Humen()
  { 

  } 

  public Humen(String name , String sex , int age)
  {
    this.name = name;
    this.sex = sex;
    this.age = age;
  } 

  public String getName()
  {
    return name;
  } 

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

  public String getSex()
  {
    return sex;
  } 

  public void setSex(String sex)
  {
    this.sex = sex;
  } 

  public int getAge()
  {
    return age;
  } 

  public void setAge(int age)
  {
    this.age = age;
  } 

  public List<Humen> getFriends()
  {
    return friends;
  } 

  public void setFriends(List<Humen> friends)
  {
    this.friends = friends;
  } 

  @Override
  public String toString()
  {
    return "Humen [name=" + name + ", sex=" + sex + ", age=" + age + "]";
  }
}

控制台输出：

filterCollection is :[Humen [name=zhangsan, sex=n, age=22]]
--------------------------飘逸的分割线--------------------------
projectionCollection is :[zhangsan, lisi, wangwu, zhaoliu, qianqi, sunba, yangqiu]

OGNL可以对集合进行过滤与投影操作，过滤的语法为collection.{? expression}，其中使用"#this"表示集合当前对象（可以与for-each循环比较）。投影的语法为collection.{expression}。投影和过滤可以看做是数据库中对表取列和取行的操作。

一些常见问题
平时使用Struts2标签时会出现一些很奇特的问题，对于OGNL不了解的人可能对问题的出现无能为力或者就算解决了问题也不知道是如何解决的。下面总结一些使用Struts2标签容易出现的困惑：

问题一：#,%{},$符号

在Struts2标签属性中经常会出现"#"或者"%{}"的符号出现，通过上面OGNL表达式基础的介绍，知道了OGNL上下文中有且仅有一个根对象。Struts2为我们定义了许多明明对象，他们分别是"ValueStack"，"Parameters"，"Session"，"Request"， "Appliction"，"Attr"，其中"ValueStack"被设置为上下文的根对象。访问非根对象必须加上"#"号，这就是出现"#"的原因。Struts2中的标的处理类，并不是所有都将标签的属性作为OGNL表达式来看待，有时候我们需要设置动态地值，则必须告诉标签的处理类该字符串按照OGNL表达式来处理，%{}符号的作用就是告诉标签的处理类将它包含的字符串按照OGNL表达式处理。 "$"符号用于XML文件中用于获取动态值，与%{}作用类似。

问题二：%{}符号的影响

Struts2的标签几十几百个，要记住哪一个标签的处理类将标签的属性作为OGNL表达式是一件很困难的事情，在不清楚处理类的处理方式时怎么办，%{}对于标签处理类来说，若处理类将属性值作为普通字符串则%{}符号包含的字符串当做OGNL表达式，若处理类将属性值作为OGNL表达式来处理，则直接忽略%{}符号。换句话说，不清楚处理方式的话，可以都使用%{}符号。

问题三：标签是如何获得数据

下面是ValueStack的官方描述：

ValueStack allows multiple beans to be pushed in and dynamic EL expressions to be evaluated against it. When evaluating an expression, the stack will be searched down the stack, from the latest objects pushed in to the earliest, looking for a bean with a getter or setter for the given property or a method of the given name (depending on the expression being evaluated).

大致意思：ValueStack允许保存多个bean（也就是Action），并且可以使用表达式语言获得他们。当评估一个表达式，ValueStack将会从栈顶到栈底的方向被搜索一遍，对于给定的属性名称寻找bean的getter或setter方法或寻找给定的方法。

每当一个请求到达Action时，Struts2会将Action对象推入ValueStack中。

<body>
  username:<s:property value="username"/><br />
  -------------------诡异的分割线-------------------<br />
  username:<%= ((HelloWorldAction)ActionContext.getContext().getValueStack().peek()).getUsername() %><br />
 </body>

页面显示结果：

username:zhangsan
-------------------诡异的分割线-------------------
username:zhangsan

可以看到标签取值与用Java代码取值的结果相同，明显标签的取值方式更简练简洁。OGNL表达式"username"表示了从根对象ValueStack中取出属性username的值。它会从栈顶到栈底遍历ValueStack，直到找某一个Action中的"username"属性。

总结OGNL的使用方法：

1.访问属性
名字属性获取:

<s:property value="user.username"/><br>

地址属性获取:

<s:property value="user.address.addr"/><br>

2.访问方法
调用值栈中对象的普通方法：

<s:property value="user.get()"/><br>

3.访问静态属性和方法
调用Action中的静态方法：

<s:property value="@struts.action.LoginAction@get()"/>

调用JDK中的类的静态方法：

<s:property value="@java.lang.Math@floor(44.56)"/><br>

调用JDK中的类的静态方法(同上)：

 <s:property value="@@floor(44.56)"/><br>

调用JDK中的类的静态方法：

<s:property value="@java.util.Calendar@getInstance()"/><br>

调用普通类中的静态属性：

<s:property value="@struts.vo.Address@TIPS"/><br>

访问构造方法
调用普通类的构造方法: 

<s:property value="new struts.vo.Student('李晓红' , '美女' , 3 , 25).username"/>

 

4.访问数组
获取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>

 

5.访问集合 – 投影、选择(? ^ $)
利用选择获取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>

集合的伪属性
OGNL能够引用集合的一些特殊的属性,这些属性并不是JavaBeans模式,例如size(),length()等等. 当表达式引用这些属性时,OGNL会调用相应的方法,这就是伪属性.

6.Lambda   :[…]
格式：:[…]
使用Lambda表达式计算阶乘:

<s:property value="#f = :[#this==1?1:#this*#f(#this-1)] , #f(4)"/><br>

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

获取Paraments对象的属性：<s:property value="#parameters.username"/>

8.OGNL中%的使用
用%{}可以取出存在值堆栈中的Action对象,直接调用它的方法.

例如你的Action如果继承了ActionSupport .那么在页面标签中，用%{getText('key')}的方式可以拿出国际化信息.

9.OGNL中$的使用

“$”有两个主要的用途

  1. 用于在国际化资源文件中，引用OGNL表达式
  2. 在Struts 2配置文件中，引用OGNL表达式

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索java
， struts
ognl
，以便于您获取更多的相关知识。

时间： 2024-09-15 06:26:27

通过实例深入学习Java的Struts框架中的OGNL表达式使用_java的相关文章

详解Java的Struts框架以及相关的MVC设计理念_java

struts简介Struts是Apache软件基金会(ASF)赞助的一个开源项目.它最初是jakarta项目中的一个子项目,并在2004年3月成为ASF的顶级项目.它通过采用JavaServlet/JSP技术,实现了基于JavaEEWeb应用的MVC设计模式的应用框架,是MVC经典设计模式中的一个经典产品. Struts发展历史 Struts是作为ApacheJakarta项目的组成部分,项目的创立者希望通过对该项目的研究,改进和提高JavaServerPages.servlet.标签库以及面向

在Java的Struts框架中ONGL表达式的基础使用入门_java

首先了解下OGNL的概念:OGNL是Object-Graph Navigation Language的缩写,全称为对象图导航语言,是一种功能强大的表达式语言,它通过简单一致的语法,可以任意存取对象的属性或者调用对象的方法,能够遍历整个对象的结构图,实现对象属性类型的转换等功能. 此外,还得先需弄懂OGNL的一些知识: 1.OGNL表达式的计算是围绕OGNL上下文进行的. OGNL上下文实际上就是一个Map对象,由ognl.OgnlContext类表示.它里面可以存放很多个JavaBean对象.它

详解Java的Struts框架中栈值和OGNL的使用_java

值栈:值栈是一个集合中的几个对象保持下列对象提供的顺序: 值栈可以通过JSP,Velocity或者Freemarker的标签.有各种不同的标签在单独的章节中,我们将学习,用于获取和设置Struts 2.0 的值栈. ValueStack的对象里面可以得到动作如下: ActionContext.getContext().getValueStack() 一旦拥有了值对象,就可以用下面的方法来操纵该对象: OGNL:对象图形导航语言(OGNL)是一个功能强大的表达式语言是用来参考值栈上的数据和操纵.

Java的Struts框架中的主题模板和国际化设置_Mysql

主题模板 如果不指定一个主题,然后Struts2中会使用默认的XHTML主题.例如Struts 2中选择标签: <s:textfield name="name" label="Name" /> 生成HTML标记: <tr> <td class="tdLabel"> <label for="empinfo_name" class="label">Name:<

Java的Struts框架简介与环境配置教程_java

Struts2是流行和成熟的基于MVC设计模式的Web应用程序框架. Struts2不只是Struts1下一个版本,它是一个完全重写的Struts架构. WebWork框架开始以Struts框架为基础,其目标是提供一个加强和改进框架Struts来使web开发的开发人员更容易. 一段时间后,WebWork框架和Struts社区联手打造的著名的Struts2框架. Struts 2框架的特点: 这里有一些强大的功能,可能会迫使你考虑Struts2: POJO表单和POJO动作 - Struts2的S

Java的Struts框架中的if/else标签使用详解_java

这些标签执行可在每一种语言找到的一种基本条件流程. 'If'标签可用于本身或与"Else If''标签和/或单/多'Else'标签,如下图所示: <s:if test="%{false}"> <div>Will Not Be Executed</div> </s:if> <s:elseif test="%{true}"> <div>Will Be Executed</div>

Java的Struts框架中&amp;lt;results&amp;gt;标签的使用方法_java

<results>标签在Struts2的MVC框架的视图中所扮演的角色.动作是负责执行业务逻辑.执行业务逻辑后,接下来的步骤是使用<results>标签显示的视图. 经常有一些附带导航规则的结果.例如,如果在操作方法是对用户进行验证,有三种可能的结果. (一)成功登录:(二)不成功的登录,用户名或密码错误:(三)帐户锁定. 在这种情况下的动作方法将被配置呈现的结果有三种可能的结果字符串和三个不同的看法.我们已经看到在前面的例子. 但是,Struts2 不配合使用JSP作为视图技术.

Java的Struts框架中Action的编写与拦截器的使用方法_java

Struts2 Action/动作动作是Struts2框架的核心,因为他们的任何MVC(模型 - 视图 - 控制器)框架.每个URL将被映射到一个特定的动作,它提供了来自用户的请求提供服务所需的处理逻辑. 但动作也提供其他两个重要的能力.首先,操作从请求数据的传输中起着重要的作用,通过向视图,无论是一个JSP或其它类型的结果.二,动作必须协助的框架,在确定结果应该渲染视图,在响应该请求将被退回. 创建动作:在Struts2的动作,唯一的要求是必须有一个无参数的方法返回String或结果的对象,必

深入解析Java的Struts框架中的控制器DispatchAction_java

Struts中的表单处理器为ActionForm,而struts中的控制器主要是Action,以及DispatchAction控制器等. Action 在struts中,所有的用户都会经过ActionServlet的处理,而实际的工作是交给Action对象来处理的,ActionServlet可以从配置文件中创建ActionMapping对象,从ActionMapping对象中找到对应使用的Action,然后将用户请求转交给Action. 对Struts一个ActionMapping只能生成一个A