OGNL表达式的使用方法

最新推荐文章于 2022-10-09 09:00:49 发布
最新推荐文章于 2022-10-09 09:00:49 发布
阅读量145 收藏
点赞数
文章标签： java xhtml

OGNL表达式的使用方法

定义：

OGNL是对象图导航语言（即该表达式访问的是对象及对象的属性）

知识点：

1.基本属性的访问

1.1 访问值栈中action的普通属性

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="username"/>

1.2 访问值栈中对象的普通属性

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="student.age"/>

1.3 访问值栈中对象(对象包含对象)的普通属性

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="cat.friend.name"/>

1.4 访问值栈中对象的普通方法

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="cat.friend.say().length()"/>

1.5 访问值栈中action的普通方法

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="execute()"/>

1.6 访问静态方法

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="@com.wj.struts2.util.OGNLUtil@getString()"/>

1.7 访问静态属性

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="@com.wj.struts2.util.OGNLUtil@URL"/>

1.8 访问Math类的属性

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="@@max(5,3)"/>

1.9 访问普通类的构造方法

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="newcom.wj.struts2.action.model.Dog()"/>

2.访问容器

2.1 访问List

2.1.1 访问list

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="list"/>

2.1.2 访问list中的某个元素

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="list[2]"/>

2.1.3 访问list中某个元素属性的集合

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="list.{no}"/>

2.1.4 访问list中某个元素的属性

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="list[2].no"/>

2.2 访问Set

2.2.1 访问set

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="set"/>

2.2.2 访问set中的某个元素（不可访问，set无顺序）

2.3 访问Map

2.3.1 访问Map

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="map"/>

2.3.2 访问Map中的某个元素

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="map['key']"/>

2.3.3 访问Map中的所有key

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="map.keys"/>

2.3.4 访问Map中的所有value

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="map.values"/>

2.3.5 访问容器的大小

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="map.size()"/>

3.投影

3.1 通过投影访问list中年龄为25的学生的姓名

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="list.{?#this.age==25}[0].{no}[0]"/>

3.2 通过投影访问list中年龄大于25的集合中的首元素的姓名

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="list.{^#this.age>20}.{no}"/>

3.3 通过投影访问list中年龄大于25的集合中的尾元素的姓名

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="list.{$#this.age>20}.{no}"/>

3.4 通过投影判断list中年龄大于25的集合是否为空

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="list.{?#this.age>25}==null"/>

4.栈

用[]来访问栈中的元素，注意：[0]表示从栈中的开始位置进行遍历其中的元素

[xhtml:nogutter] view plain copy
  1. <s:propertyvalue="[1][0].execute()"/>

示例代码

OGNLAction.java

[java:nogutter] view plain copy
  1. /**
  2. *OGNL表达式
  3. *@author健
  4. */
  5. publicclassOGNLActionextendsActionSupport{
  6. /**
  7. *序列化
  8. */
  9. privatestaticfinallongserialVersionUID=1L;
  10. /**
  11. *猫
  12. */
  13. privateCatcat;
  14. /**
  15. *List
  16. */
  17. privateList<Student>list;
  18. /**
  19. *Map
  20. */
  21. privateMap<String,Dog>map;
  22. /**
  23. *密码
  24. */
  25. privateStringpassword;
  26. /**
  27. *Set
  28. */
  29. privateSet<Dog>set;
  30. /**
  31. *学生
  32. */
  33. privateStudentstudent;
  34. /**
  35. *用户名
  36. */
  37. privateStringusername;
  38. publicOGNLAction(){
  39. this.list=newArrayList<Student>();
  40. Studentstudent1=newStudent("zhangsan",20);
  41. Studentstudent2=newStudent("lisi",25);
  42. Studentstudent3=newStudent("wangwu",28);
  43. Studentstudent4=newStudent("zhaoliu",24);
  44. Studentstudent5=newStudent("xiaotaoqi",18);
  45. list.add(student1);
  46. list.add(student2);
  47. list.add(student3);
  48. list.add(student4);
  49. list.add(student5);
  50. this.set=newHashSet<Dog>();
  51. Dogdog1=newDog("bandeng");
  52. Dogdog2=newDog("zhuozi");
  53. Dogdog3=newDog("yizi");
  54. set.add(dog1);
  55. set.add(dog2);
  56. set.add(dog3);
  57. this.map=newHashMap<String,Dog>();
  58. map.put("0001",dog1);
  59. map.put("0002",dog2);
  60. map.put("0003",dog3);
  61. }
  63. /**
  64. *控制器
  65. *@return跳转的页面
  66. */
  67. @Override
  68. publicStringexecute(){
  69. return"success";
  70. }
  71. /**
  72. *取得cat
  73. *@returncat
  74. */
  75. publicCatgetCat(){
  76. returncat;
  77. }
  78. /**
  79. *取得list
  80. *@returnlist
  81. */
  82. publicList<Student>getList(){
  83. returnlist;
  84. }
  85. /**
  86. *取得map
  87. *@returnmap
  88. */
  89. publicMap<String,Dog>getMap(){
  90. returnmap;
  91. }
  92. /**
  93. *取得password
  94. *@returnpassword
  95. */
  96. publicStringgetPassword(){
  97. returnpassword;
  98. }
  99. /**
  100. *取得set
  101. *@returnset
  102. */
  103. publicSet<Dog>getSet(){
  104. returnset;
  105. }
  106. /**
  107. *取得student
  108. *@returnstudent
  109. */
  110. publicStudentgetStudent(){
  111. returnstudent;
  112. }
  113. /**
  114. *取得username
  115. *@returnusername
  116. */
  117. publicStringgetUsername(){
  118. returnusername;
  119. }
  120. /**
  121. *设置cat
  122. *@paramcatcat
  123. */
  124. publicvoidsetCat(Catcat){
  125. this.cat=cat;
  126. }
  127. /**
  128. *设置list
  129. *@paramlistlist
  130. */
  131. publicvoidsetList(List<Student>list){
  132. this.list=list;
  133. }
  134. /**
  135. *设置map
  136. *@parammapmap
  137. */
  138. publicvoidsetMap(Map<String,Dog>map){
  139. this.map=map;
  140. }
  141. /**
  142. *设置password
  143. *@parampasswordpassword
  144. */
  145. publicvoidsetPassword(Stringpassword){
  146. this.password=password;
  147. }
  148. /**
  149. *设置set
  150. *@paramsetset
  151. */
  152. publicvoidsetSet(Set<Dog>set){
  153. this.set=set;
  154. }
  155. /**
  156. *设置student
  157. *@paramstudentstudent
  158. */
  159. publicvoidsetStudent(Studentstudent){
  160. this.student=student;
  161. }
  162. /**
  163. *设置username
  164. *@paramusernameusername
  165. */
  166. publicvoidsetUsername(Stringusername){
  167. this.username=username;
  168. }
  169. }

ChainAction.java

[java:nogutter] view plain copy
  1. /**
  2. *OGNL表达式
  3. *@author健
  4. */
  5. publicclassChainActionextendsActionSupport{
  6. /**
  7. *序列化
  8. */
  9. privatestaticfinallongserialVersionUID=1L;
  11. /**
  12. *控制器
  13. *@return跳转的页面
  14. */
  15. @Override
  16. publicStringexecute(){
  17. return"success";
  18. }
  19. }

OGNLUtil.java

[java:nogutter] view plain copy
  1. /**
  2. *工具类
  3. *@author健
  4. */
  5. publicclassOGNLUtil{
  6. /**
  7. *静态常量
  8. */
  9. publicstaticfinalStringURL="staticproperty";
  10. /**
  11. *静态方法
  12. *@return字符串
  13. */
  14. publicstaticStringgetString(){
  15. return"staticmethod";
  16. }
  17. }

Cat.java

[java:nogutter] view plain copy
  1. /**
  2. *猫
  3. *@author健
  4. */
  5. publicclassCat{
  6. /**
  7. *名字
  8. */
  9. privateStringname;
  10. /**
  11. *朋友
  12. */
  13. privateDogfriend;
  14. /**
  15. *取得name
  16. *@returnname
  17. */
  18. publicStringgetName(){
  19. returnname;
  20. }
  21. /**
  22. *设置name
  23. *@paramnamename
  24. */
  25. publicvoidsetName(Stringname){
  26. this.name=name;
  27. }
  28. /**
  29. *取得friend
  30. *@returnfriend
  31. */
  32. publicDoggetFriend(){
  33. returnfriend;
  34. }
  35. /**
  36. *设置friend
  37. *@paramfriendfriend
  38. */
  39. publicvoidsetFriend(Dogfriend){
  40. this.friend=friend;
  41. }
  42. /**
  43. *类方法
  44. *@return返回字符串
  45. */
  46. publicStringsay(){
  47. return"miaomiao";
  48. }
  49. /**
  50. *构造
  51. */
  52. publicCat(){
  53. System.out.println("catconstructor");
  54. }
  55. /**
  56. *重写toString方法
  57. */
  58. publicStringtoString(){
  59. return"catnameis"+this.name;
  60. }
  61. }

Dog.java

[java:nogutter] view plain copy
  1. /**
  2. *狗
  3. *@author健
  4. */
  5. publicclassDog{
  6. /**
  7. *名字
  8. */
  9. privateStringname;
  10. /**
  11. *构造
  12. */
  13. publicDog(){
  14. System.out.println("dogconstructor");
  15. }
  16. /**
  17. *构造
  18. */
  19. publicDog(Stringname){
  20. this.name=name;
  21. }
  22. /**
  23. *取得name
  24. *@returnname
  25. */
  26. publicStringgetName(){
  27. returnname;
  28. }
  29. /**
  30. *设置name
  31. *@paramnamename
  32. */
  33. publicvoidsetName(Stringname){
  34. this.name=name;
  35. }
  36. /**
  37. *类方法
  38. *@return返回字符串
  39. */
  40. publicStringsay(){
  41. return"miaomiao";
  42. }
  43. /**
  44. *重写toString方法
  45. */
  46. publicStringtoString(){
  47. return"dognameis"+this.name;
  48. }
  49. }

Student.java

[java:nogutter] view plain copy
  1. /**
  2. *学生类
  3. *@author健
  4. */
  5. publicclassStudent{
  6. /**
  7. *学号
  8. */
  9. privateStringno;
  10. /**
  11. *年龄
  12. */
  13. privateintage;
  14. /**
  15. *构造方法
  16. */
  17. publicStudent(){
  18. System.out.println("进入学生类的构造方法");
  19. }
  20. /**
  21. *构造方法
  22. */
  23. publicStudent(Stringno,intage){
  24. this.age=age;
  25. this.no=no;
  26. }
  27. /**
  28. *取得no
  29. *@returnno
  30. */
  31. publicStringgetNo(){
  32. returnno;
  33. }
  34. /**
  35. *设置no
  36. *@paramnono
  37. */
  38. publicvoidsetNo(Stringno){
  39. this.no=no;
  40. }
  41. /**
  42. *取得age
  43. *@returnage
  44. */
  45. publicintgetAge(){
  46. returnage;
  47. }
  48. /**
  49. *设置age
  50. *@paramageage
  51. */
  52. publicvoidsetAge(intage){
  53. this.age=age;
  54. }
  55. /**
  56. *重写toString方法
  57. */
  58. publicStringtoString(){
  59. return"Student:"+this.no+","+this.age;
  60. }
  61. }

struts.xml

[xhtml:nogutter] view plain copy
  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <!DOCTYPEstrutsPUBLIC
  3. "-//ApacheSoftwareFoundation//DTDStrutsConfiguration2.0//EN"
  4. "http://struts.apache.org/dtds/struts-2.0.dtd">
  6. <struts>
  7. <!--配置开发模式：修改不用重启服务器-->
  8. <constantname="struts.devMode"value="true"/>
  9. <!--配置允许静态方法的访问-->
  10. <constantname="struts.ognl.allowStaticMethodAccess"value="true"/>
  11. <!--包含的文件-->
  12. <includefile="ognl.xml"></include>
  13. </struts>

ognl.xml

[xhtml:nogutter] view plain copy
  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <!DOCTYPEstrutsPUBLIC
  3. "-//ApacheSoftwareFoundation//DTDStrutsConfiguration2.0//EN"
  4. "http://struts.apache.org/dtds/struts-2.0.dtd">
  6. <struts>
  7. <packagename="ognl"namespace="/ognl"extends="struts-default">
  8. <actionname="ognl"class="com.wj.struts2.action.OGNLAction">
  9. <resultname="success">/result.jsp</result>
  10. </action>
  11. <actionname="chain"class="com.wj.struts2.action.ChainAction">
  12. <resulttype="chain">
  13. <paramname="actionName">ognl</param>
  14. <paramname="namespace">/ognl</param>
  15. </result>
  16. </action>
  17. </package>
  18. </struts>

index.jsp

[xhtml:nogutter] view plain copy
  1. <%@pagelanguage="java"import="java.util.*"pageEncoding="UTF-8"%>
  2. <%@tagliburi="/struts-tags"prefix="s"%>
  3. <%
  4. Stringpath=request.getContextPath();
  5. StringbasePath=request.getScheme()+"://"
  6. +request.getServerName()+":"+request.getServerPort()
  7. +path+"/";
  8. %>
  9. <!DOCTYPEHTMLPUBLIC"-//W3C//DTDHTML4.01Transitional//EN">
  10. <html>
  11. <head>
  12. <basehref="<%=basePath%>">
  14. <title>Struts2_OGNL</title>
  15. <metahttp-equiv="pragma"content="no-cache">
  16. <metahttp-equiv="cache-control"content="no-cache">
  17. <metahttp-equiv="expires"content="0">
  18. <metahttp-equiv="keywords"content="keyword1,keyword2,keyword3">
  19. <metahttp-equiv="description"content="Thisismypage">
  20. <!--
  21. <linkrel="stylesheet"type="text/css"href="styles.css"mce_href="styles.css">
  22. -->
  23. </head>
  25. <body>
  26. <div>
  27. 访问基本元素
  28. <li><ahref="ognl/ognl?username=wangjian&password=123456"mce_href="ognl/ognl?username=wangjian&password=123456">1.访问值栈中action的普通属性</a></li>
  29. <li><ahref="ognl/ognl?student.age=20&student.no=0001"mce_href="ognl/ognl?student.age=20&student.no=0001">2.访问值栈中对象的普通属性</a></li>
  30. <li><ahref="ognl/ognl?cat.friend.name=oudy"mce_href="ognl/ognl?cat.friend.name=oudy">3.访问值栈中对象(对象包含对象)的普通属性</a></li>
  31. <li><ahref="ognl/ognl?cat.friend.name=oudy"mce_href="ognl/ognl?cat.friend.name=oudy">4.访问值栈中对象的普通方法</a></li>
  32. <li><ahref="ognl/ognl"mce_href="ognl/ognl">5.访问值栈中action的普通方法</a></li>
  33. <li><ahref="ognl/ognl"mce_href="ognl/ognl">6.访问静态方法</a></li>
  34. <li><ahref="ognl/ognl"mce_href="ognl/ognl">7.访问静态属性</a></li>
  35. <li><ahref="ognl/ognl"mce_href="ognl/ognl">8.访问Math类的属性</a></li>
  36. <li><ahref="ognl/ognl"mce_href="ognl/ognl">9.访问普通类的构造方法</a></li>
  37. </div>
  39. <br>
  40. <br>
  41. <div>
  42. 访问容器<br>
  43. （一）访问List<br>
  44. <li><ahref="ognl/ognl"mce_href="ognl/ognl">1.访问list</a></li>
  45. <li><ahref="ognl/ognl"mce_href="ognl/ognl">2.访问list中的某个元素</a></li>
  46. <li><ahref="ognl/ognl"mce_href="ognl/ognl">3.访问list中某个元素属性的集合</a></li>
  47. <li><ahref="ognl/ognl"mce_href="ognl/ognl">4.访问list中某个元素的属性</a></li><br>
  48. （二）访问Set<br>
  49. <li><ahref="ognl/ognl"mce_href="ognl/ognl">1.访问set</a></li>
  50. <li><ahref="ognl/ognl"mce_href="ognl/ognl">2.访问set中的某个元素（不可访问，set无顺序）</a></li><br>
  51. （三）访问Map<br>
  52. <li><ahref="ognl/ognl"mce_href="ognl/ognl">1.访问Map</a></li>
  53. <li><ahref="ognl/ognl"mce_href="ognl/ognl">2.访问Map中的某个元素</a></li>
  54. <li><ahref="ognl/ognl"mce_href="ognl/ognl">3.访问Map中的所有key</a></li>
  55. <li><ahref="ognl/ognl"mce_href="ognl/ognl">4.访问Map中的所有value</a></li>
  56. <li><ahref="ognl/ognl"mce_href="ognl/ognl">5.访问容器的大小</a></li>
  57. <br>
  58. </div>
  59. <br>
  60. <br>
  61. <div>
  62. 投影<br>
  63. <li><ahref="ognl/ognl"mce_href="ognl/ognl">1.通过投影访问list中年龄为25的学生的姓名</a></li>
  64. <li><ahref="ognl/ognl"mce_href="ognl/ognl">2.通过投影访问list中年龄大于25的集合中的首元素的姓名</a></li>
  65. <li><ahref="ognl/ognl"mce_href="ognl/ognl">3.通过投影访问list中年龄大于25的集合中的尾元素的姓名</a></li>
  66. <li><ahref="ognl/ognl"mce_href="ognl/ognl">4.通过投影判断list中年龄大于25的集合是否为空</a></li><br>
  67. </div>
  68. <br>
  69. <br>
  70. <div>
  71. 栈<br>
  72. <li><ahref="ognl/chain"mce_href="ognl/chain">用[]来访问栈中的元素，注意：[1]表示从栈中的开始位置进行遍历其中的元素</a></li>
  73. </div>
  74. </body>
  75. </html>

result.jsp

[xhtml:nogutter] view plain copy
  1. <%@pagelanguage="java"import="java.util.*"pageEncoding="UTF-8"%>
  2. <%@tagliburi="/struts-tags"prefix="s"%>
  3. <%
  4. Stringpath=request.getContextPath();
  5. StringbasePath=request.getScheme()+"://"
  6. +request.getServerName()+":"+request.getServerPort()
  7. +path+"/";
  8. %>
  9. <!DOCTYPEHTMLPUBLIC"-//W3C//DTDHTML4.01Transitional//EN">
  10. <html>
  11. <head>
  12. <basehref="<%=basePath%>">
  14. <title>Struts2_OGNL</title>
  15. <metahttp-equiv="pragma"content="no-cache">
  16. <metahttp-equiv="cache-control"content="no-cache">
  17. <metahttp-equiv="expires"content="0">
  18. <metahttp-equiv="keywords"content="keyword1,keyword2,keyword3">
  19. <metahttp-equiv="description"content="Thisismypage">
  20. <!--
  21. <linkrel="stylesheet"type="text/css"href="styles.css"mce_href="styles.css">
  22. -->
  23. </head>
  25. <body>
  26. 访问值栈中action的普通属性：<br>
  27. <li>username：<s:propertyvalue="username"/></li>
  28. <li>password：<s:propertyvalue="password"/></li>
  29. <br>
  30. ----------------------------------------
  31. <br>
  32. 访问值栈中对象的普通属性<br>
  33. <li>student：<s:propertyvalue="student"/></li>
  34. <li>no：<s:propertyvalue="student.no"/></li>
  35. <li>age：<s:propertyvalue="student.age"/></li>
  36. <br>
  37. ----------------------------------------
  38. <br>
  39. 访问值栈中对象(对象包含对象)的普通属性<br>
  40. <li>friendName：<s:propertyvalue="cat.friend.name"/></li>
  41. <br>
  42. ----------------------------------------
  43. <br>
  44. 访问值栈中对象的普通方法<br>
  45. <li>method01：<s:propertyvalue="cat.friend.say().length()"/></li>
  46. <li>method02：<s:propertyvalue="cat.say()"/></li>
  47. <br>
  48. ----------------------------------------
  49. <br>
  50. 访问值栈中action的普通方法<br>
  51. <li>method：<s:propertyvalue="execute()"/></li>
  52. <br>
  53. ----------------------------------------
  54. <br>
  55. 访问静态方法<br>
  56. <li>staticmethod：<s:propertyvalue="@com.wj.struts2.util.OGNLUtil@getString()"/></li>
  57. <br>
  58. ----------------------------------------
  59. <br>
  60. 访问静态属性<br>
  61. <li>staticproperty：<s:propertyvalue="@com.wj.struts2.util.OGNLUtil@URL"/></li>
  62. <br>
  63. ----------------------------------------
  64. <br>
  65. 访问静态属性<br>
  66. <li>Mathmethod：<s:propertyvalue="@@max(5,3)"/></li>
  67. <br>
  68. ----------------------------------------
  69. <br>
  70. 访问普通类的构造方法<br>
  71. <li>Constructermethod：<s:propertyvalue="newcom.wj.struts2.action.model.Dog()"/></li>
  72. <br>
  73. ----------------------------------------
  74. <br>
  75. <br>
  76. <br>
  77. 访问容器<br>
  78. （一）访问List<br>
  79. <li>1.访问list----<s:propertyvalue="list"/></li>
  80. <li>2.访问list中的某个元素----<s:propertyvalue="list[2]"/></li>
  81. <li>3.访问list中某个元素属性的集合----<s:propertyvalue="list.{no}"/></li>
  82. <li>4.访问list中某个元素的属性----<s:propertyvalue="list[2].no"/></li><br>
  83. （二）访问Set<br>
  84. <li>1.访问set----<s:propertyvalue="set"/></li>
  85. <li>2.访问set中的某个元素（不可访问，set无顺序）----<s:propertyvalue="set[1]"/></li><br>
  86. （三）访问Map<br>
  87. <li>1.访问Map----<s:propertyvalue="map"/></li>
  88. <li>2.访问Map中的某个元素----<s:propertyvalue="map['0001']"/></li>
  89. <li>3.访问Map中的所有key----<s:propertyvalue="map.keys"/></li>
  90. <li>4.访问Map中的所有value----<s:propertyvalue="map.values"/></li>
  91. <li>5.访问容器的大小----<s:propertyvalue="map.size()"/></li>
  92. <br>
  93. ----------------------------------------
  94. <br>
  95. <br>
  96. <br>
  97. <div>
  98. 投影<br>
  99. <li>1.通过投影访问list中年龄为25的学生的姓名----<s:propertyvalue="list.{?#this.age==25}[0].{no}[0]"/></li>
  100. <li>2.通过投影访问list中年龄大于25的集合中的首元素的姓名----<s:propertyvalue="list.{^#this.age>20}.{no}"/></li>
  101. <li>3.通过投影访问list中年龄大于25的集合中的尾元素的姓名----<s:propertyvalue="list.{$#this.age>20}.{no}"/></li>
  102. <li>4.通过投影判断list中年龄大于25的集合是否为空----<s:propertyvalue="list.{?#this.age>25}==null"/></li><br>
  103. </div>
  104. ----------------------------------------
  105. <br>
  106. <br>
  107. <br>
  108. <div>
  109. 栈<br>
  110. <li>用[]来访问栈中的元素，注意：[0]中0表示从栈中的开始位置进行遍历其中的元素----<s:propertyvalue="[1][0].execute()"/></li>
  111. </div>
  114. <s:debug></s:debug>
  115. </body>
  116. </html>

北漂小混混
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Struts2 OGNL表达式实例详解
08-29
主要介绍了Struts2 OGNL表达式实例详解，相关实例代码，需要的朋友可以参考。
ognl表达式语法（取值，赋值，调用方法，调用静态方法，创建对象List，Map）
qq_41566772的博客
01-22 1840
准备：创建一个User实体 public class User { private String name; private Integer age; public User(String name, Integer age) { super(); this.name = name; this.age = age; } public String getName() { ...
OGNL表达式用法详解
木子李的博客
11-06 1万+
表达式通常用来访问页面中的各种变量,进行结果输出. struts2中共支持以下几种表达式语言(默认的是OGNL)： (1)OGNL：可以方便地操作对象属性的开源表达式语言； (2)JSTL：(JSP Standard Tag Library)：JSP2.0集成的标准表达式语言； (3)Groovy：基于Java平台的动态语言，它具有时下比较流行的动态语言的一些特性； (4)Velocit...
Ognl表达式基本原理和使用方法
lisheng19870305的专栏
11-24 2186
1.Ognl表达式语言 1.1.概述 OGNL表达式 OGNL是Object Graphic Navigation Language(对象图导航语言)的缩写，他是一个开源项目。Struts框架使用OGNL作为默认的表达式语言。OGNL优势 支持对象方法调用，如：×××.doSomeSpecial(); 支持类静态的方法调用和值访问，表达式的格式 @[类全名（包括包路径）]@[方法名 | 值名]，例如： @java.lang.String@format('foo %s', 'bar') 或@tut.
OGNL表达式的使用
9r3y的专栏
12-30 502
OGNL的使用 OGNL的使用 访问Action中的普通属性: 访问Action中的对象属性: 访问Action中的Set属性: 访问Action中的List属性: 访问Action中的Map属性的键: 访问Action中的Map属性的值: 访问Action中的Map属性的指定键对应的值: 访问Action中的Ma
OGNL的基本语法与用法
Tianyi_0801i的博客
10-21 6962
OGNL表达式的基本语法和基本用法 一．OGNL中的#、%和$符号 #、%和$符号在OGNL表达式中经常出现，而这三种符号也是开发者不容易掌握和理解的部分。在这里我们简单介绍它们的相应用途。 1．#符号的三种用法 1）访问非根对象属性，例如示例中的#session.msg表达式，由于Struts 2中值栈被视为根对象，所以访问其他非根对象时，需要加#前缀。实际上，#相当于ActionContext...
Struts2 使用OGNL表达式
06-01
NULL 博文链接：https://chaoyi.iteye.com/blog/2158731
Mybatis利用OGNL表达式处理动态sql的方法教程
08-30
主要给大家介绍了关于Mybatis利用OGNL表达式处理动态sql的方法教程的相关资料，文中通过示例代码介绍的非常详细，对大家具有一定的参考学习价值，需要的朋友们下面跟着小编一起来学习学习吧。
ognl表达式java使用案例详解(测试通过)
01-09
本案例提供ognl使用详解，测试通过，只需解压放入自己WEB项目中，执行struts_ognl包内java文件即可（未提供jia包，若需要可以联系留言发至邮箱），若测试不好可以联系本人提供指导. Struts 2默认的表达式语言是OGNL...
OGNL表达式语言学习
03-20
NULL 博文链接：https://huguifuture.iteye.com/blog/761843
Struts2中的OGNL详解
热门推荐
Java高知社区
10-07 9万+
首先了解下OGNL的概念： OGNL是Object-Graph Navigation Language的缩写，全称为对象图导航语言，是一种功能强大的表达式语言，它通过简单一致的语法，可以任意存取对象的属性或者调用对象的方法，能够遍历整个对象的结构图，实现对象属性类型的转换等功能。 此外，还得先需弄懂OGNL的一些知识： 1.OGNL表达式的计算是围绕OGNL上下文进行的。 OGNL上下
Ognl表达式的一些用法
qq_43191053的博客
09-18 715
OGNL表达式介绍 OGNL是Object-Graph Navigation Language的缩写，它是一种功能强大的表达式语言（Expression Language，简称为EL），通过它简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。它使用相同的表达式去存取对象的属性。　　　　　　　　　　　　　　　　-------百度百科 ...
OGNL 表达式
m0_49261516的博客
10-09 7594
mybatis的OGNL表达式
Java.lang.OutOfMemoryError: unable to create new native thread (server responded connection closed)
just_a_litte_body的博客
12-01 330
ERROR ExceptionMappingInterceptor Method "ajaxGetList" failed for object com.story.mp.action.app.AppIndexLayoutAction@26ba4dd5 ognl.MethodFailedException: Method "ajaxGetList" failed for object com.story.mp.action.app.AppIndexLayoutAction@26ba4dd5 [java..
OGNL表达式遍历List集合
追梦少年ing
04-01 6702
最近在做项目时遇到一个问题，本来要实现功能的话很简单，用jsp的就可以实现，但是我认为这样的话前端页面就有了一段java代码，不是很好，然后我就想用OGNL表达式来实现。首先先描述一下我要实现的功能。                  我的数据库中有一个产品表，对应有一个属性表，这里的属性表指的是产品的属性信息。比如有鞋子这种产品，那么我们购买时就会选择号码、颜色这些参数信息，我有看过有些网
OGNL表示式
波仔Blog's
04-15 510
使用struts2中的ognl表达式调用类方法(转)struts2 2009-04-14 17:56:39 阅读94 评论0 字号：大中小 struts标签中value都会被解析，如， 会被解析成getFoo()我想问一下，还有没有其它的属性会解析？另外就是我试这个时，发现form.r并没有被解析？换成才可以。 Struts2的OGNL表达式中三个符号的用法。OGNL表
OGNL表达式的基本用法
Kato_op的博客
05-11 3046
OGNL表达式的基本用法 借助 s:property标签输出内容到浏览器 s:property的作用 写法： &lt;%--导入标签库--%&gt; &lt;%@ taglib uri="/struts-tags" prefix="s" %&gt; &lt;%--要想使用 OGNL 表达式，需要借助 struts2 的标签--%&gt; &lt;s:property...
mybatis OGNL表达式
最新发布
06-06
OGNL（Object-Graph Navigation Language，对象图导航语言）是一个强大的表达式语言，可以用于Java的各种应用程序中，包括Struts、Java...在使用OGNL表达式时，需要注意语法的正确性和安全性，以避免可能的安全漏洞。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值