OGNL使用详解

最新推荐文章于 2024-06-12 15:13:23 发布
最新推荐文章于 2024-06-12 15:13:23 发布
阅读量4.1k 收藏 2
点赞数
分类专栏： struts

OGNL

OGNL ( Object Graph Navigation Language )，对象图导航语言。这是一种强大的表达式语言，通过它可以非常方便的来操作对象属性。  
在 Struts2 中，OGNL 需要和 Struts2 标签库配套来使用。

OGNL context

                               |  
                               | -- application  
                               |  
                               | -- session  
                               |  
                               | -- value  stack ( root )  
context  map  ---- |  
                               | -- request  
                               |  
                               | -- parameters  
                               |  
                               | -- attr ( searches page, request, session, then application scopes )  
                               |  
Struts2 框架将 OGNL context 设置为我们的 ActionContext，并将 ValueStack 作为 OGNL 的根对象。而 Action 则置于 ValueStack 的最顶层。  
除此之外，Struts2 框架还把代表 application、request、session 对象的 Map 对象也放到 ActionContext 中，使得 Action 与 Servlet API 解耦。
名称描述
ValueStack值栈，作为 OGNL 上下文的根对象。通过 KEY 来访问，非根对象需要用 #KEY 来访问
parametersMap 类型，封装了请求中的所有参数。访问 #parameters.name 相当于调用 HttpServletRequest.getParameter( )
requestMap 类型，封装了 request 对象中的所有属性。访问 #request.name 相当于调用 HttpServletRequest.getAttribute( )
sessionMap 类型，封装了 session 对象中的所有属性。访问 #session.name 相当于调用 HttpSession.getAttribute( )
applicationMap 类型，封装了 application 对象中的所有属性。访问 #application.name 相当于调用 ServletContext.getAttribute( )
attrMap 类型，依次从 page、request、session、application 对象中检索属性的值

OGNL 访问 Action 中的数据

Action 位于值栈的栈顶位置，而值栈又是 OGNL 的根对象，因此，在 OGNL 表达式中可直接使用属性名称来访问 Action 当中的数据。如：  
<s:property value="name" />  
实际上，这里是通过调用 Action 当中的 getName( ) 方法来获取得到数据的，而不管 Action 当中是否有一个名称为 name 的属性变量。  
因此，如果需要在页面中获取得到 Action 当中的数据，你只需要为你的 Action 类编写 getXX( ) 方法就可以了。

测试环境

package fan.tutorial.model; 

import java.util.Set; 

public   class Person { 

      private String sex; 
      private String name; 
      private IDCard idcard; 
      private Set<Address> addressSet; 
      public   static   final   double VERSION = 1.0; 
     
      public Person(){} 
     
      public Person(String name, String sex, IDCard idcard, Set<Address> addressSet){ 
          this.sex = sex; 
          this.name = name; 
          this.idcard = idcard; 
          this.addressSet = addressSet; 
    } 

      public String getSex() { 
          return sex; 
    } 

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

      public String getName() { 
          return name; 
    } 

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

      public Set<Address> getAddressSet() { 
          return addressSet; 
    } 

      public   void setAddressSet(Set<Address> addressSet) { 
          this.addressSet = addressSet; 
    } 

      public IDCard getIdcard() { 
          return idcard; 
    } 

      public   void setIdcard(IDCard idcard) { 
          this.idcard = idcard; 
    } 

      public   static   double getVersion() { 
          return VERSION; 
    } 
}
package fan.tutorial.model; 

public   class IDCard { 

      private   long number; 
     
      public IDCard(){} 
     
      public IDCard(  long number){ 
          this.number = number; 
    } 

      public   long getNumber() { 
          return number; 
    } 

      public   void setNumber(  long number) { 
          this.number = number; 
    } 
}
package fan.tutorial.model; 

public   class Address { 

      private String name; 
     
      public Address(){} 
     
      public Address(String name){ 
          this.name = name; 
    } 

      public String getName() { 
          return name; 
    } 

      public   void setName(String name) { 
          this.name = name; 
    } 
}
package fan.tutorial.action; 

import java.util.Map; 
import java.util.Set; 
import java.util.List; 
import java.util.HashSet; 
import java.util.ArrayList; 
import java.util.LinkedHashMap; 
import fan.tutorial.model.IDCard; 
import fan.tutorial.model.Person; 
import fan.tutorial.model.Address; 
import com.opensymphony.xwork2.Action; 
import org.apache.struts2.interceptor.RequestAware; 
import org.apache.struts2.interceptor.SessionAware; 
import org.apache.struts2.interceptor.ApplicationAware; 

public   class DataAction   implements Action, RequestAware, SessionAware, ApplicationAware { 
     
      private String author; 
      private String subject; 
      private Person person; 
      private List<Person> personList; 
      private Map<String, String> map; 
      private Map<String, Object> request; 
      private Map<String, Object> session; 
      private Map<String, Object> application; 
      private   int[] array = {8, 0, 9, 1, 3, 4, 2, 5, 7, 6}; 

      public String execute()   throws Exception { 
         
        subject = "fan-tutorial"; 
         
        Set<Address> addressSet =   new HashSet<Address>(2); 
        addressSet.add(  new Address("广东茂名")); 
        addressSet.add(  new Address("广东广州")); 
        person =   new Person("fan", "male",   new IDCard(3115981L), addressSet); 
         
        personList =   new ArrayList<Person>(3); 
        addressSet =   new HashSet<Address>(1); 
        addressSet.add(  new Address("云南丽江")); 
        personList.add(person); 
        personList.add(  new Person("chen", "female",   new IDCard(3575982L), addressSet)); 
        addressSet =   new HashSet<Address>(1); 
        addressSet.add(  new Address("广东潮汕")); 
        personList.add(  new Person("chai", "female",   new IDCard(3115983L), addressSet)); 
         
        map =   new LinkedHashMap<String, String>(2); 
        map.put("username", "fan"); 
        map.put("password", "yun"); 
         
        request.put("message", "hey request"); 
        session.put("message", "hey session"); 
        application.put("message", "hey application"); 
         
          return SUCCESS; 
         
    } 

      public String getSubject() { 
          return subject; 
    } 

      public Person getPerson() { 
          return person; 
    } 

      public List<Person> getPersonList() { 
          return personList; 
    } 

      public   int[] getArray() { 
          return array; 
    } 

      public Map<String, String> getMap() { 
          return map; 
    } 

      public String getAuthor() { 
          return author; 
    } 

      public   void setAuthor(String author) { 
          this.author = author; 
    } 

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

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

      public   void setApplication(Map<String, Object> application) { 
          this.application = application; 
    } 
}
<  struts  > 

    <  constant   name  ="struts.ognl.allowStaticMethodAccess"   value  ="true"  /> 
   
    <  package   name  ="default"   extends  ="struts-default"  > 
      <  default-action-ref   name  ="defaultAction"     /> 
      <  action   name  ="defaultAction"  > 
        <  result   type  ="redirect"  >test?author=fan  </  result  > 
      </  action  > 
      <  action   name  ="test"   class  ="fan.tutorial.action.DataAction"  > 
        <  result  >/index.jsp  </  result  > 
      </  action  > 
    </  package  > 

</  struts  >

OGNL 访问对象属性

<  s:property   value  ="subject"  /> 
<  s:property   value  ="person.name"  /> 
<  s:property   value  ="person.idcard.number"  />

OGNL 调用方法

<  s:property   value  ="person.getName()"  /> 
<  s:property   value  ="person.name.toUpperCase()"  />

OGNL 调用静态属性

<  s:property   value  ="@fan.tutorial.model.Person@VERSION"  />

OGNL 调用静态方法

<!--   在 struts.xml 中添加下面这行配置   --> 
<!--   <constant name="struts.ognl.allowStaticMethodAccess" value="true"/>   --> 
<  s:property   value  ="@fan.tutorial.model.Person@getVersion()"  />

OGNL 调用构造方法

<  s:property   value  ="new fan.tutorial.model.Address('广东茂名').name"  />

OGNL 使用索引访问数组和列表

<  s:property   value  ="array[0]"  /> 
<  s:property   value  ="personList[0].name"  />

OGNL 操作符运算

<  s:property   value  ="array[0] + 1"  /> 
<  s:property   value  ="array[0] - 1"  /> 
<  s:property   value  ="array[0] * 2"  /> 
<  s:property   value  ="array[0] / 2"  /> 
<  s:property   value  ="array[0] % 3"  />

OGNL 逻辑运算符

<  s:set   name  ="x"   value  ="5"  /> 
<  s:property   value  ="#x in array"  /> 
<  s:property   value  ="#x not in array"  /> 
<  s:property   value  ="#x > array[0]"  /> 
<  s:property   value  ="#x >= array[0]"  /> 
<  s:property   value  ="#x < array[0]"  /> 
<  s:property   value  ="#x <= array[0]"  /> 
<  s:property   value  ="#x == array[0]"  /> 
<  s:property   value  ="#x != array[0]"  />

OGNL 访问命名对象 ( parameters、request、session、application、attr )

<  s:property   value  ="#parameters.author"  /> 
<  s:property   value  ="#request.message"  /> 
<  s:property   value  ="#session.message"  /> 
<  s:property   value  ="#application.message"  /> 
<  s:property   value  ="#attr.message"  />

OGNL 访问集合的伪属性

类型伪属性伪属性对应的 Java 方法
List
Set
Map		size
isEmpty		List.size()        List.isEmpty()
Set.size()        Set.isEmpty()
Map.size()       Map.isEmpty()
List
Set		iteratorList.iterator()
Set.iterator()
Mapkeys
values		Map.keySet()
Map.values()
Iteratornext
hasNext		Iterator.next()
Iterator.hasNext()
<  s:property   value  ="personList.size"  /> 
<  s:property   value  ="personList.isEmpty"  /> 
<  s:property   value  ="map.keys"  /> 
<  s:property   value  ="map.values"  /> 
<  s:property   value  ="personList.iterator.hasNext"  /> 
<  s:property   value  ="personList.iterator.next.name"  /> 
<  s:property   value  ="person.addressSet.iterator.hasNext"  /> 
<  s:property   value  ="person.addressSet.iterator.next.name"  />

OGNL 迭代集合

类型伪属性伪属性的作用描述
IteratorStatusindex当前元素的索引
IteratorStatusfirst当前元素是否是集合的第一个元素
IteratorStatuslast当前元素是否是集合的最后一个元素
IteratorStatuscount当前迭代元素的数量，count = index + 1
IteratorStatusevenindex + 1 是否为偶数
IteratorStatusoddindex + 1 是否为奇数
<  table  > 
    <  tr   align  ="center"  > 
      <  td   width  ="2%"  >索引  </  td  > 
      <  td   width  ="5%"  >值  </  td  > 
      <  td   width  ="8%"  >当前迭代的数量  </  td  > 
      <  td   width  ="8%"  >迭代奇偶性  </  td  > 
      <  td   width  ="8%"  >集合第一个元素  </  td  > 
      <  td   width  ="8%"  >集合最后一个元素  </  td  > 
    </  tr  > 
    <  s:iterator   value  ="array"   var  ="a"   status  ="status"  > 
      <  tr   align  ="center"  > 
        <  td  > 
          <  s:property   value  ="#status.index"  /> 
        </  td  > 
        <  td  > 
          <  s:property  /> 
        </  td  > 
        <  td  > 
          <  s:property   value  ="#status.count"  /> 
        </  td  > 
        <  td  > 
          <  s:if   test  ="#status.even"  >偶  </  s:if  > 
          <  s:if   test  ="#status.odd"  >奇  </  s:if  > 
        </  td  > 
        <  td  > 
          <  s:if   test  ="#status.first"  >是  </  s:if  > 
          <  s:else  >否  </  s:else  > 
        </  td  > 
        <  td  > 
          <  s:if   test  ="#status.last"  >是  </  s:if  > 
          <  s:else  >否  </  s:else  > 
        </  td  > 
      </  tr  > 
    </  s:iterator  > 
</  table  >

OGNL 投影

如果把集合中的数据想象成是数据库表中的数据，那么，投影就是从这张表中选取某一列所构成的一个新的集合。投影的语法：collection.{expression}
<  s:property   value  ="personList.{name}"  />

OGNL 过滤

OGNL 过滤也称为选择，就是把满足 OGNL 表达式的结果选择出来构成一个新的集合。  
过滤的语法：collection.{?expression} 或 collection.{^expression} 或 collection.{$expression}
符号作用
?选取与逻辑表达式匹配的所有结果
^选取与逻辑表达式匹配的第一个结果
$选择与逻辑表达式匹配的最后一个结果
#this代表当前迭代的元素
<  s:property   value  ="array.{?#this > 5}"  /> 
<  s:property   value  ="array.{^#this > 5}"  /> 
<  s:property   value  ="array.{$#this > 5}"  />

OGNL 投影和过滤

<  s:property   value  ="personList.{?#this.sex.equals('female')}.{name}"  /> 
<  s:property   value  ="personList.{^#this.sex.equals('female')}.{name}"  /> 
<  s:property   value  ="personList.{$#this.sex.equals('female')}.{name}"  />

OGNL %{ } 语法

对于 ${ } 也许你并不会陌生，${ } 是 EL 表达式的语法，这里的 %{ } 是 OGNL 表达式的语法。  
也许你开始困惑，上面示例不是都在使用 OGNL 表达式吗？！没见 %{ } 出现过啊！好眼力！凡是属于 OGNL 表达式的串，你都可以使用 %{ } 来将它们包裹住，但这不是必须的。例如 <s:property value="expression" /> 中的 expression 在任何时候都是被当做 OGNL 表达式来处理的。
<  s:property   value  ="subject"  />    <!--   subject被OGNL进行表达式求值输出   --> 
<  s:property   value  ="i love java so much"  />    <!--   什么都不输出   -->
第2行之所以什么都不输出，是因为执行时环境把 i love java so much 这个字符串也当做是一个 OGNL 表达式来处理了，但在 OGNL 上下文中并找不到与这个 KEY 对应的值，因此什么都没有输出。  
这是由于 <s:property /> 标签的 value 属性是 Object 类型引起的，凡是 Object 类型的标签属性的值，都会被当做是一个 OGNL 表达式来处理。  
这种情况下的解决办法是：使用单引号将它们引起来，表明这是一个普通的字符串，而不是 OGNL 表达式。
<  s:property   value  ="'subject'"  />    <!--   输出 subject   --> 
<  s:property   value  ="'i love java so much'"  />    <!--   输出 i love java so much   -->
再如 <s:textfield value="expression" /> 中的 expression 什么时候被当做 OGNL 表达式来处理就要取决于你是否使用了 %{ } 语法，如果使用了，那么它就是一个 OGNL 表达式，如果没有使用，那么它就只是一个普通的字符串而已。
<  s:textfield   value  ="author"  />           <!--   author被当做普通字符串原样输出   --> 
<  s:textfield   value  ="%{author}"  />        <!--   author被OGNL进行表达式求值输出   --> 
<  s:textfield   value  ="person.name"  />      <!--   person.name被当做普通字符串原样输出   --> 
<  s:textfield   value  ="%{person.name}"  />   <!--   person.name被OGNL进行表达式求值输出   -->
这是由于 <s:textfield /> 标签的 value 属性是 String 类型引起的，凡是非 Object 类型的标签属性的值，是不会被当做一个 OGNL 表达式来处理的，  
除非你使用了 %{ expression } 语法，执行时环境才会将 expression 当做是一个 OGNL 表达式来处理。  
只有当你理解了上面的2个案例，你才能正确的使用 OGNL 表达式。  
实际上规则非常简单，当标签属性的类型为 Object 类型时，标签属性的值就会被当做是一个 OGNL 表达式来处理，因此可省略 %{} ；  
当标签属性的类型为 String 类型时，除非你使用了 %{ } 语法告诉执行时环境这是一个 OGNL 表达式，否则，标签属性的值会被当做是一个普通的字符串来处理。
Varose
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OGNL的使用
wcxy_study的博客
11-19 221
对象导航图语言（Object Graph Navigation Language），是应用于Java中的一个开源的表达式语言（Expression Language），它被集成在Struts2等框架中，作用是对数据进行访问，它拥有类型转换、访问对象方法、操作集合对象等功能。 作用： 1、支持对象方法调用 2、支持静态方法调用和值访问 3、支持复值操作和表达式串联 4、访问OGNL上下文和Actio...
MyBatis中OGNL的使用教程详解
08-30
当在SQL字符串中使用`${}`时，MyBatis会使用OGNL解析其中的表达式。例如： ```xml select id,name,... from country != null and name != ''"> name like '${'%' + name + '%'}' ``` 注意，使用...
struts2中ognl表达式的理解和用法
07-27
NULL 博文链接：https://laz383310051.iteye.com/blog/754884
Struts2 OGNL使用详解
loup的专栏
07-22 417
OGNL OGNL ( Object Graph Navigation Language )，对象图导航语言。这是一种强大的表达式语言，通过它可以非常方便的来操作对象属性。  在 Struts2 中，OGNL 需要和 Struts2 标签库配套来使用。 OGNL context                                |                     
一文全解：OGNL表达式以及Mybatis中的OGNL表达式
最新发布
five-five
06-12 2816
OGNL（Object-Graph Navigation Language）是一种用于在Java中访问和操作对象图的表达式语言。它提供了一种简洁、灵活的方式来遍历和操作复杂的对象结构，而无需编写大量的代码。OGNL表达式可以用于各种场景，如Web应用、批处理任务、测试等。OGNL表达式是一种强大的工具，尤其在Mybatis中能够极大地简化动态SQL的编写。它的简洁语法和强大功能，使得开发者能够高效地处理复杂的对象操作。然而，在使用OGNL表达式时，也要注意性能和安全性的问题，合理使用表达式，避免潜在的风险。
OGNL的用法
iteye_9973的博客
04-14 95
OGNL是通常要结合Struts 2的标志一起使用，如&lt;s:property value="xx" /&gt; 等。大家经常遇到的问题是#、%和$这三个符号的使用。下面我想通过例子讲述这个问题： 首先新建名为Struts2_OGNL的Web工程，配置开发环境。之前很多朋友在使用Struts 2的过程中都遇到乱码问题。当然乱码问题由来已久，而且涉及多方面的知识，所以并非三言两语可以说明白...
ognl用法
飞鸿的博客
05-18 314
1.       首先创建一个web项目，然后创建其余组件。2.       导入struts包。3.       编辑struts.xml.4.  建立Book类。类中必须要求构造方法。5.  建立ognlAction类6.  新建ognl.jsp编辑struts.xml.&lt;?xml version="1.0" encoding="UTF-8" ?&gt; &lt;!DOCTYPE str...
OGNL表达式详解[定义].pdf
10-11
在Struts2中，OGNL通常与Struts2的标签结合使用，比如`<s:property value="xx"/>`，这个标签会根据`xx`这个OGNL表达式来获取或设置对象的属性值。 在实际开发中，常常会遇到关于`#`、`%`和`$`的使用问题。`#`在OGNL...
OGNL表达式详解
06-30
使用Struts2时，利用ognl表达式在页面获取后台参数值
Struts2 OGNL表达式实例详解
08-29
Struts2 OGNL表达式实例详解 Struts2 OGNL表达式实例详解主要介绍了Struts2 OGNL表达式实例详解，相关实例代码，需要的朋友可以参考。Object Graph Navigation Language（对象图导航语言），就是用点来访问成员变量...
ognl表达式java使用案例详解(测试通过)
01-09
本案例提供ognl使用详解，测试通过，只需解压放入自己WEB项目中，执行struts_ognl包内java文件即可（未提供jia包，若需要可以联系留言发至邮箱），若测试不好可以联系本人提供指导. Struts 2默认的表达式语言是OGNL...
struts2中OGNL的一些概念及原理说明
11-18
关于struts2中ognl的说明、原理及使用，对于初学者进阶是个不错的参考
OGNL表达式的基本用法
Kato_op的博客
05-11 3135
OGNL表达式的基本用法 借助 s:property标签输出内容到浏览器 s:property的作用 写法： &lt;%--导入标签库--%&gt; &lt;%@ taglib uri="/struts-tags" prefix="s" %&gt; &lt;%--要想使用 OGNL 表达式，需要借助 struts2 的标签--%&gt; &lt;s:property...
OGNL在Struts2中的应用
皓月星辰
08-10 299
在上篇讲述OGNL基础知识的博客中，我们可以得到如下知识点： 1、OGNL表达式需要放置到OgnlContext中才能得到正确地解析、解释和执行； 2、OgnlContext类实现了Map接口，所以可以使用put方法向里面放置元素且每个OgnlContext有且最多只能有一个根对象； 3、Ognl表达式中访问根对象的属性时，无需"#"，普通对象则需要； 上面知识了解后，咱们再来聊聊Stru...
struts2中的ognl应用
秃头俱乐部
06-28 235
目录ognl的简介ognl的应用 ognl的简介 1、什么是ognl OGNL是Object-Graph Navigation Language的缩写， 它是一种功能强大的表达式语言，通过它简单一致的表达式语法， 可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图， 实现字段类型转化等功能。它使用相同的表达式去存取对象的属性。 2、Struts 2默认的表达式语言是O...
OGNL表达式用法详解
热门推荐
木子李的博客
11-06 1万+
表达式通常用来访问页面中的各种变量,进行结果输出. struts2中共支持以下几种表达式语言(默认的是OGNL)： (1)OGNL：可以方便地操作对象属性的开源表达式语言； (2)JSTL：(JSP Standard Tag Library)：JSP2.0集成的标准表达式语言； (3)Groovy：基于Java平台的动态语言，它具有时下比较流行的动态语言的一些特性； (4)Velocit...
struts之ognl
weixin_43939301的博客
06-28 436
初识ognl         OGNL的全称是Object Graph Navigation Language(对象图导航语言)，它是一种强大的表达式语言;OgnlContext(ongl上下文)其实就是Map,OgnlContext=根对象(1)+非根对象(N);非根对象要通过"#key"访问，根对象可以省略"#ke...
Struts2中的OGNL详解
LK-T.O.P的博客
01-26 667
首先了解下OGNL的概念： OGNL是Object Graph Navigation Language(对象图导航语言)，是一种功能强大的表达式语言，它通过简单一致的语法，可以任意存取对象的属性或者调用对象的方法，能够遍历整个对象的结构图，实现对象属性类型的转换等功能。 此外，还得先需弄懂OGNL的一些知识： 1.OGNL表达式的计算是围绕OGNL上下文进行的。 OGNL上下文实际上就是一
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值