OGNL的学习指南

最新推荐文章于 2020-04-23 16:43:07 发布
最新推荐文章于 2020-04-23 16:43:07 发布
阅读量117 收藏
点赞数
文章标签： java 数据库 测试

为了解决数据从View层传递到Controller层时的不匹配性，Struts2采纳了XWork的OGNL方案。并且在OGNL的基础上，构建了OGNLValueStack的机制，从而比较完美的解决了数据流转中的不匹配性。

OGNL（Object Graph Navigation Language），是一种表达式语言。使用这种表达式语言，你可以通过某种表达式语法，存取Java对象树中的任意属性、调用Java对象树的方法、同时能够自动实现必要的类型转化。如果我们把表达式看做是一个带有语义的字符串，那么OGNL无疑成为了这个语义字符串与Java对象之间沟通的桥梁。

如何使用OGNL

让我们先研究一下OGNL的API，他来自于Ognl的静态方法：

Java代码
  2. /**
  3. *EvaluatesthegivenOGNLexpressiontreetoextractavaluefromthegivenroot
  4. *object.Thedefaultcontextissetforthegivencontextandrootvia
  5. *<CODE>addDefaultContext()</CODE>.
  6. *
  7. *@paramtreetheOGNLexpressiontreetoevaluate,asreturnedbyparseExpression()
  8. *@paramcontextthenamingcontextfortheevaluation
  9. *@paramroottherootobjectfortheOGNLexpression
  10. *@returntheresultofevaluatingtheexpression
  11. *@throwsMethodFailedExceptioniftheexpressioncalledamethodwhichfailed
  12. *@throwsNoSuchPropertyExceptioniftheexpressionreferredtoanonexistentproperty
  13. *@throwsInappropriateExpressionExceptioniftheexpressioncan'tbeusedinthiscontext
  14. *@throwsOgnlExceptionifthereisapathologicalenvironmentalproblem
  15. */
  16. publicstaticObjectgetValue(Objecttree,Mapcontext,Objectroot)throwsOgnlException;
  18. /**
  19. *EvaluatesthegivenOGNLexpressiontreetoinsertavalueintotheobjectgraph
  20. *rootedatthegivenrootobject.Thedefaultcontextissetforthegiven
  21. *contextandrootvia<CODE>addDefaultContext()</CODE>.
  22. *
  23. *@paramtreetheOGNLexpressiontreetoevaluate,asreturnedbyparseExpression()
  24. *@paramcontextthenamingcontextfortheevaluation
  25. *@paramroottherootobjectfortheOGNLexpression
  26. *@paramvaluethevaluetoinsertintotheobjectgraph
  27. *@throwsMethodFailedExceptioniftheexpressioncalledamethodwhichfailed
  28. *@throwsNoSuchPropertyExceptioniftheexpressionreferredtoanonexistentproperty
  29. *@throwsInappropriateExpressionExceptioniftheexpressioncan'tbeusedinthiscontext
  30. *@throwsOgnlExceptionifthereisapathologicalenvironmentalproblem
  31. */
  32. publicstaticvoidsetValue(Objecttree,Mapcontext,Objectroot,Objectvalue)throwsOgnlException
Java代码
  1. /**
  2. *EvaluatesthegivenOGNLexpressiontreetoextractavaluefromthegivenroot
  3. *object.Thedefaultcontextissetforthegivencontextandrootvia
  4. *<CODE>addDefaultContext()</CODE>.
  5. *
  6. *@paramtreetheOGNLexpressiontreetoevaluate,asreturnedbyparseExpression()
  7. *@paramcontextthenamingcontextfortheevaluation
  8. *@paramroottherootobjectfortheOGNLexpression
  9. *@returntheresultofevaluatingtheexpression
  10. *@throwsMethodFailedExceptioniftheexpressioncalledamethodwhichfailed
  11. *@throwsNoSuchPropertyExceptioniftheexpressionreferredtoanonexistentproperty
  12. *@throwsInappropriateExpressionExceptioniftheexpressioncan'tbeusedinthiscontext
  13. *@throwsOgnlExceptionifthereisapathologicalenvironmentalproblem
  14. */
  15. publicstaticObjectgetValue(Objecttree,Mapcontext,Objectroot)throwsOgnlException;
  17. /**
  18. *EvaluatesthegivenOGNLexpressiontreetoinsertavalueintotheobjectgraph
  19. *rootedatthegivenrootobject.Thedefaultcontextissetforthegiven
  20. *contextandrootvia<CODE>addDefaultContext()</CODE>.
  21. *
  22. *@paramtreetheOGNLexpressiontreetoevaluate,asreturnedbyparseExpression()
  23. *@paramcontextthenamingcontextfortheevaluation
  24. *@paramroottherootobjectfortheOGNLexpression
  25. *@paramvaluethevaluetoinsertintotheobjectgraph
  26. *@throwsMethodFailedExceptioniftheexpressioncalledamethodwhichfailed
  27. *@throwsNoSuchPropertyExceptioniftheexpressionreferredtoanonexistentproperty
  28. *@throwsInappropriateExpressionExceptioniftheexpressioncan'tbeusedinthiscontext
  29. *@throwsOgnlExceptionifthereisapathologicalenvironmentalproblem
  30. */
  31. publicstaticvoidsetValue(Objecttree,Mapcontext,Objectroot,Objectvalue)throwsOgnlException



我们可以看到，OGNL的API其实相当简单，你可以通过传递三个参数来实现OGNL的一切操作。而这三个参数，被我称为OGNL的三要素。

那么运用这个API，我们能干点什么呢？跑个测试看看结果：

Java代码
  2. /**
  3. *@authorDownpour
  4. */
  5. publicclassUser{
  7. privateIntegerid;
  9. privateStringname;
  11. privateDepartmentdepartment=newDepartment();
  13. publicUser(){
  15. }
  17. //setterandgetters
  18. }
  20. //=========================================================================
  22. /**
  23. *@authorDownpour
  24. */
  25. publicclassDepartment{
  27. privateIntegerid;
  29. privateStringname;
  31. publicDepartment(){
  33. }
  35. //setterandgetters
  36. }
  38. //=========================================================================
  40. /**
  41. *@authorDownpour
  42. */
  43. publicclassOGNLTestCaseextendsTestCase{
  45. /**
  46. *
  47. *@throwsException
  48. */
  49. @SuppressWarnings("unchecked")
  50. @Test
  51. publicvoidtestGetValue()throwsException{
  53. //Createrootobject
  54. Useruser=newUser();
  55. user.setId(1);
  56. user.setName("downpour");
  58. //Createcontext
  59. Mapcontext=newHashMap();
  60. context.put("introduction","Mynameis");
  62. //Testtodirectlygetvaluefromrootobject,withnocontext
  63. Objectname=Ognl.getValue(Ognl.parseExpression("name"),user);
  64. assertEquals("downpour",name);
  66. //Testtogetvalue(parameter)fromcontext
  67. ObjectcontextValue=Ognl.getValue(Ognl.parseExpression("#introduction"),context,user);
  68. assertEquals("Mynameis",contextValue);
  70. //Testtogetvalueandparameterfromrootobjectandcontext
  71. Objecthello=Ognl.getValue(Ognl.parseExpression("#introduction+name"),context,user);
  72. assertEquals("Mynameisdownpour",hello);
  74. }
  76. /**
  77. *
  78. *@throwsException
  79. */
  80. @SuppressWarnings("unchecked")
  81. @Test
  82. publicvoidtestSetValue()throwsException{
  84. //Createrootobject
  85. Useruser=newUser();
  86. user.setId(1);
  87. user.setName("downpour");
  89. //Setvalueaccordingtotheexpression
  90. Ognl.setValue("department.name",user,"dev");
  91. assertEquals("dev",user.getDepartment().getName());
  93. }
  96. }
Java代码
  1. /**
  2. *@authorDownpour
  3. */
  4. publicclassUser{
  6. privateIntegerid;
  8. privateStringname;
  10. privateDepartmentdepartment=newDepartment();
  12. publicUser(){
  14. }
  16. //setterandgetters
  17. }
  19. //=========================================================================
  21. /**
  22. *@authorDownpour
  23. */
  24. publicclassDepartment{
  26. privateIntegerid;
  28. privateStringname;
  30. publicDepartment(){
  32. }
  34. //setterandgetters
  35. }
  37. //=========================================================================
  39. /**
  40. *@authorDownpour
  41. */
  42. publicclassOGNLTestCaseextendsTestCase{
  44. /**
  45. *
  46. *@throwsException
  47. */
  48. @SuppressWarnings("unchecked")
  49. @Test
  50. publicvoidtestGetValue()throwsException{
  52. //Createrootobject
  53. Useruser=newUser();
  54. user.setId(1);
  55. user.setName("downpour");
  57. //Createcontext
  58. Mapcontext=newHashMap();
  59. context.put("introduction","Mynameis");
  61. //Testtodirectlygetvaluefromrootobject,withnocontext
  62. Objectname=Ognl.getValue(Ognl.parseExpression("name"),user);
  63. assertEquals("downpour",name);
  65. //Testtogetvalue(parameter)fromcontext
  66. ObjectcontextValue=Ognl.getValue(Ognl.parseExpression("#introduction"),context,user);
  67. assertEquals("Mynameis",contextValue);
  69. //Testtogetvalueandparameterfromrootobjectandcontext
  70. Objecthello=Ognl.getValue(Ognl.parseExpression("#introduction+name"),context,user);
  71. assertEquals("Mynameisdownpour",hello);
  73. }
  75. /**
  76. *
  77. *@throwsException
  78. */
  79. @SuppressWarnings("unchecked")
  80. @Test
  81. publicvoidtestSetValue()throwsException{
  83. //Createrootobject
  84. Useruser=newUser();
  85. user.setId(1);
  86. user.setName("downpour");
  88. //Setvalueaccordingtotheexpression
  89. Ognl.setValue("department.name",user,"dev");
  90. assertEquals("dev",user.getDepartment().getName());
  92. }
  95. }



我们可以看到，简单的API，就已经能够完成对各种对象树的读取和设值工作了。这也体现出OGNL的学习成本非常低。

在上面的测试用例中，需要特别强调进行区分的，是在针对不同内容进行取值或者设值时，OGNL表达式的不同。

Struts2 Reference 写道
The framework uses a standard naming context to evaluate OGNL expressions. The top level object dealing with OGNL is a Map (usually referred as a context map or context). OGNL has a notion of there being a root (or default) object within the context. In expression, the properties of the root object can be referenced without any special "marker" notion. References to other objects are marked with a pound sign (#).


上面这段内容摘自Struts2的Reference，我把这段话总结为以下2条规则：
A） 针对根对象（Root Object）的操作，表达式是自根对象到被访问对象的某个链式操作的字符串表示。
B） 针对上下文环境（Context）的操作，表达式是自上下文环境（Context）到被访问对象的某个链式操作的字符串表示，但是必须在这个字符串的前面加上#符号，以表示与访问根对象的区别。

上面的这点区别咋看起来非常容易理解，不过一旦放到特定的环境中，就会显示出其重要性，它可以解释很多Struts2在页面展示上取值的各种复杂的表达式的现象。这一点在下一篇文章中会进行具体的分析。

OGNL三要素
我把传入OGNL的API的三个参数，称之为OGNL的三要素。OGNL的操作实际上就是围绕着这三个参数而进行的。
1. 表达式（Expression）
表达式是整个OGNL的核心，所有的OGNL操作都是针对表达式的解析后进行的。表达式会规定此次OGNL操作到底要干什么。
我们可以看到，在上面的测试中，name、department.name等都是表达式，表示取name或者department中的name的值。OGNL支持很多类型的表达式，之后我们会看到更多。

2. 根对象（Root Object）
根对象可以理解为OGNL的操作对象。在表达式规定了“干什么”以后，你还需要指定到底“对谁干”。
在上面的测试代码中，user就是根对象。这就意味着，我们需要对user这个对象去取name这个属性的值（对user这个对象去设置其中的department中的name属性值）。


3. 上下文环境（Context）
有了表达式和根对象，我们实际上已经可以使用OGNL的基本功能。例如，根据表达式对根对象进行取值或者设值工作。


不过实际上，在OGNL的内部，所有的操作都会在一个特定的环境中运行，这个环境就是OGNL的上下文环境（Context）。说得再明白一些，就是这个上下文环境（Context），将规定OGNL的操作“在哪里干”。


OGNL的上下文环境是一个Map结构，称之为OgnlContext。上面我们提到的根对象（Root Object），事实上也会被加入到上下文环境中去，并且这将作为一个特殊的变量进行处理，具体就表现为针对根对象（Root Object）的存取操作的表达式是不需要增加#符号进行区分的。


OgnlContext不仅提供了OGNL的运行环境。在这其中，我们还能设置一些自定义的parameter到Context中，以便我们在进行OGNL操作的时候能够方便的使用这些parameter。不过正如我们上面反复强调的，我们在访问这些parameter时，需要使用#作为前缀才能进行。

OGNL与模板

我们在尝试了OGNL的基本操作并了解了OGNL的三要素之后，或许很容易把OGNL的操作与模板联系起来进行比较。在很多方面，他们也的确有着相似之处。

对于模板，会有一些普通的输出元素，也有一些模板语言特殊的符号构成的元素，这些元素一旦与具体的Java对象融合起来，就会得到我们需要的输出结果。

而OGNL看起来也是非常的类似，OGNL中的表达式就雷同于模板语言的特殊符号，目的是针对某些Java对象进行存取。而OGNL与模板都将数据与展现分开，将数据放到某个特定的地方，具体来说，就是Java对象。只是OGNL与模板的语法结构不完全相同而已。

深入浅出OGNL
在了解了OGNL的API和基本操作以后，我们来深入到OGNL的内部来看看，挖掘一些更加深入的知识。

OGNL表达式
OGNL支持各种纷繁复杂的表达式。但是最最基本的表达式的原型，是将对象的引用值用点串联起来，从左到右，每一次表达式计算返回的结果成为当前对象，后面部分接着在当前对象上进行计算，一直到全部表达式计算完成，返回最后得到的对象。OGNL则针对这条基本原则进行不断的扩充，从而使之支持对象树、数组、容器的访问，甚至是类似SQL中的投影选择等操作。
接下来我们就来看看一些常用的OGNL表达式：
1. 基本对象树的访问
对象树的访问就是通过使用点号将对象的引用串联起来进行。

例如：name，department.name，user.department.factory.manager.name

2. 对容器变量的访问
对容器变量的访问，通过#符号加上表达式进行。
例如：#name，#department.name，#user.department.factory.manager.name

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("http://localhost/")

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.{? #this.name != null}将获得某个group中user的name不为空的user的列表。

上述的所有的表达式，只是对OGNL所有表达式的大概的一个概括，除此之外，OGNL还有更多的表达式，例如lamba表达式等等。最具体的表达式的文档，大家可以参考OGNL自带的文档：

http://www.ognl.org/2.6.9/Documentation/html/LanguageGuide/apa.html

在撰写时，我也参考了potain同学的XWork教程以及一些网络上的一些文章，特此列出：

http://www.lifevv.com/java/doc/20071018173750030.html

http://blog.csdn.net/ice_fire2008/archive/2008/05/12/2438817.aspx

OGNLContext

OGNLContext就是OGNL的运行上下文环境。OGNLContext其实是一个Map结构，如果查看一下它的源码，就会发现，它其实实现了java.utils.Map的接口。当你在调用OGNL的取值或者设值的方法时，你可能会自己定义一个Context，并且将它传递给方法。事实上，你所传递进去的这个Context，会在OGNL内部被转化成OGNLContext，而你传递进去的所有的键值对，也会被OGNLContext接管维护，这里有点类似一个装饰器，向你屏蔽了一些其内部的实现机理。

在OGNLContext的内部维护的东西很多，其中，我挑选2个比较重要的提一下。一个是你在调用方法时传入的Context，它会被维护在OGNL内部，并且作为存取变量的基础依据。另外一个，是在Context内部维护了一个key为root的值，它将规定在OGNLContext进行计算时，哪个元素被指定为根对象。其在进行存取时，将会被特殊对待。

this指针

我们知道，OGNL表达式是以点进行串联的一个字符串链式表达式。而这个表达式在进行计算的时候，从左到右，每一次表达式计算返回的结果成为当前对象，并继续进行计算，直到得到计算结果。每次计算的中间对象都会放在一个叫做this的变量里面这个this变量就称之为this指针。

例如：group.userList.size().(#this+1).toString()

在这个例子中，#this其实就是group.userList.size()的计算结构。

使用this指针，我们就可以在OGNL表达式中进行一些简单的计算，从而完成我们的计算逻辑，而this指针在lamba表达式的引用中尤为广泛，有兴趣的读者可以深入研究OGNL自带的文档中lamba表达式的章节。

默认行为和类型转化
在我们所讲述的所有的OGNL的操作中，实际上，全部都忽略了OGNL内部帮助你完成的很多默认行为和类型转化方面的工作。
我们来看一下OGNL在进行操作初始化时候的一个函数签名：

Java代码
  2. /**
  3. *AppendsthestandardnamingcontextforevaluatinganOGNLexpression
  4. *intothecontextgivensothatcachedmapscanbeusedasacontext.
  5. *
  6. *@paramroottherootoftheobjectgraph
  7. *@paramcontextthecontexttowhichOGNLcontextwillbeadded.
  8. *@returnContextMapwiththekeys<CODE>root</CODE>and<CODE>context</CODE>
  9. *setappropriately
  10. */
  11. publicstaticMapaddDefaultContext(Objectroot,ClassResolverclassResolver,TypeConverterconverter,MemberAccessmemberAccess,Mapcontext);
Java代码
  1. /**
  2. *AppendsthestandardnamingcontextforevaluatinganOGNLexpression
  3. *intothecontextgivensothatcachedmapscanbeusedasacontext.
  4. *
  5. *@paramroottherootoftheobjectgraph
  6. *@paramcontextthecontexttowhichOGNLcontextwillbeadded.
  7. *@returnContextMapwiththekeys<CODE>root</CODE>and<CODE>context</CODE>
  8. *setappropriately
  9. */
  10. publicstaticMapaddDefaultContext(Objectroot,ClassResolverclassResolver,TypeConverterconverter,MemberAccessmemberAccess,Mapcontext);



可以看到，在初始化时，OGNL还需要额外初始化一个类型转化的接口和一些其他的信息。只不过这些默认行为，由OGNL的内部屏蔽了。

一旦需要自己定义针对某个特定类型的类型转化方式，你就需要实现TypeConverter接口，并且在OGNL中进行注册。

同时，如果需要对OGNL的许多默认行为做出改变，则需要通过设置OGNL的全局环境变量进行。

上述的这些内容，有些会在后面的章节涉及，有兴趣的读者，也可以参阅OGNL的源码和OGNL的文档寻求帮助

iteye_11539
关注
学习OGNL语法
Java客学习室
04-18 945
原文链接：http://www.yiidian.com/struts2/struts2-ognl.html 1 OGNL简介 OGNL 的全称是对象图导航语言（ Object-Graph Navigation Language），它是一种功能强大的开源表达式语言，使用这种表达式语言，可以通过某种表达式语法，存储Java对象的任意属性，调用Java 对象的方法，同时能够自动实现必要的类型转换。如果把...
OGNL
qq_44271884的博客
06-28 150
1. OGNL 概念 1.1 OGNL的全称是Object Graph Navigation Language(对象图导航语言)，它是一种强大的表达式语言 1.2 OgnlContext(ongl上下文)其实就是Map （教室、老师、学生）有根对象和非根对象，OgnlContext=根对象(有且只有一个)+非根对象(N个) 非根对象要通过"#key"访问，根对象可以省略"#key"注1：conte...
struts2.0学习笔记五(struts2.0的ognl表达式)
baobeituping的专栏
03-12 160
OGNL —— 完美的催化剂 为了解决数据从View层传递到Controller层时的不匹配性，Struts2采纳了XWork的OGNL方案。并且在OGNL的基础上，构建了OGNLValueStack的机制，从而比较完美的解决了数据流转中的不匹配性。 OGNL（Object Graph Navigation Language），是一种表达式语言。使用这种表达式语言，你可以通过某种表达式语法，存取J...
OGNL学习笔记
每天都得进步一点点
08-16 477
 OGNL学习笔记 OGNL介绍: 1.OGNL(Object Graph Nvigation Language)，对象图导航语言 2.OgnlContext(ognl上下文对象),存在唯一的叫根的的对象root,可以通过程序设定上下文当中哪个对象作为根对象 3.在OGNL中，如果表达式没有使用#号，那么OGNL会从根对象中寻找该属性对应的get方法，如果寻找的不是根对象中的属性，那
OGNL学习
张晓鉴Allen的博客
11-04 226
坚持每天写博文，积累下开发中的点点滴滴 什么是OGNL？ OGNL是Object Graphic Navigation Language（对象图导航语言）的缩写， 它是一个开源项目。 Struts2框架使用OGNL作为默认的表达式语言。 功能比EL强的N倍. OGNL仅仅只是一种表达式语言而已,使用它必须结合Struts2的标签. 讲解OGNL比先了解ValueStack(值栈),St
OGNL.rar_ognl api_ognl._ognl源码_ognl源码分析_ongl download
最新发布
09-21
OGNL源码分析对于学习和调试OGNL至关重要。通过源码，你可以了解OGNL如何解析复杂的对象图导航表达式，如何查找和访问对象的属性，以及如何处理方法调用和集合操作。例如，`ExpressionParser`类负责将字符串表达式...
OGNL jar包及源码
01-31
1. OGNL官方文档：提供了详细的语法和使用指南，是学习OGNL的基础。 2. Struts框架文档：阐述了OGNL在Struts中的具体应用和配置。 3. 开源社区讨论和示例：通过参与社区讨论，查看示例代码，可以更好地理解和掌握...
ognl源码和ognl帮助文档.rar
03-27
此外，提供的帮助文档将指导你了解OGNL的所有语法特性、最佳实践和使用示例。 在Struts2框架中，OGNL是默认的表示层语言，用于视图与模型之间的数据绑定。它使得视图可以直接引用模型中的数据，简化了MVC架构中的...
ognl源码及API
04-22
总之，这个压缩包中的ognl源码和API文档是一份宝贵的资源，对于想要深入理解ognl工作原理或者需要优化使用ognl的开发者来说，它们将提供无价的指导。通过研究源码，你可以探索ognl的底层实现，而API文档则可以帮助你...
Ognl学习
beckham
11-24 734
  User user1 = new User("张三","11111") ; User user2 = new User("李四","22222") ; list1.add(user1) ; list1.add(user2) ; 前台页面的显示：获取list的对象 获取list的对象的属性 获
OGNL学习（一）
J﹀行天下~
08-04 92
OGNL即对象导航图语言，是表达式语言的一种。通常用来绑定JAVA对象的属性，用一个表达式就可以读取和设置对应JAVA对象的属性，可以用来沟通WEB组件和业务逻辑的模型部分。 OGNL的常量声明： 1.字符串常量的声明: 即可以使用单引号,而且还可以使用双引号,拥有JAVA语言的全部转意字符 2.字符常量的声明: 和JAVA语言一样,使用单引号,同样可以使用全部的转意字符 3.数值常量的声明: ...
Ognl学习资料
Yao_yaowei的博客
06-20 364
OGNL 1、 Ognl(Object Graph Navigation Language) 对象图导航语言 它是一种功能强大的表达式语言，通过它简单一致的表达式语法，可以存取对象的 任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。 它使用相同的表达式去存取对象的属性。这样可以更好的取得数据。 OGNL 可以让我们用非常简单的表达式访问对象层，例如，当前环境的根对
OGNL基础学习
c1776167012的博客
04-23 226
一.什么是OGNL? Object-Graph Navigation Language(对象图导航语言),是一种功能强大的表达式语言（EL）用在就是jsp中，通过简单一致的表达式语法存取对象的属性，调用对象的方法，遍历对象的结构图，实现字段类型转化等功能。 下面只是关于OGNL的简单介绍，若想学好它，请去http://commons.apache.org/proper/commons-ognl/i...
OGNL框架学习(一)
Anvil的专栏
01-05 1308
原文：http://yunzhongzi.javaeye.com/blog/141390 OGNL是Object-Graph Navigation Language的缩写，它是一种功能强大的表达式语言（Expression Language，简称为EL），通过它简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。     开源框架OGNL就是基于该表达式语言的一个实现，你可以从http://www.ognl.org得到ognl.jar,源码和一些文档。
OGNL学习总结
05-17 136
下面几个javaBean的getXXX()和setXXX()方法省略 Address.java   public class Address { private String homeAddress; private String companyAddress; ......... }    Pet.java   package dong.application.ogn...
OGNL(Object-Graph Navigation Language)
掘客DIGGKR
12-04 125
[size=medium]OGNL(Object-Graph Navigation Language) 对象图形导航语言 自定义Action中有一个成员变量User user,可以自己new，Private User user = new User(). 也可以在url地址中传递user.xx,但是这时在User中必须有一个无参的构造方法。 jsp中样例代码： ...
OGNL语言指南----表达式
rancedxk的专栏
07-23 170
转自：http://hi.baidu.com/gacmotor/blog/item/b73fc5558497b2153b293550.html   构造集合 List 要创建一个对象的list，则用大括号括起表达式的列队。而作为方法的参数，这些表达式不能够使用逗号运算符，除非它用小括号括起。例子： name in { null,"Untitled" }   这是测试name属...
OGNL语言指南：Java对象导航的利器
这个中文版的OGNL指南是学习和应用OGNL的重要资源，特别是对于那些需要在Java项目中进行深度对象交互和数据绑定的开发者来说。通过理解和掌握这些内容，开发者可以更加有效地利用OGNL来简化代码，提高程序的可读性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值