OGNL表达式的使用方法

定义：

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

知识点：

1.基本属性的访问

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

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

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

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

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

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

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

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

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

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

1.6 访问静态方法

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

1.7 访问静态属性

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

1.8 访问Math类的属性

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

1.9 访问普通类的构造方法

[xhtml:nogutter]  view plain copy
  1. <s:property value="new com.wj.struts2.action.model.Dog()"/>

2.访问容器

2.1 访问List

2.1.1 访问list

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

2.1.2 访问list中的某个元素

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

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

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

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

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

2.2 访问Set

2.2.1 访问set

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

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

2.3 访问Map

2.3.1 访问Map

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

2.3.2 访问Map中的某个元素

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

2.3.3 访问Map中的所有key

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

2.3.4 访问Map中的所有value

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

2.3.5 访问容器的大小

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

3.投影

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

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

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

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

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

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

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

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

4.栈

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

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

示例代码

OGNLAction.java

[java:nogutter]  view plain copy
  1. /**
  2. * OGNL表达式
  3. * @author 健
  4. */
  5. public class OGNLAction extends ActionSupport{
  6. /**
  7. * 序列化
  8. */
  9. private static final long serialVersionUID = 1L;
  10. /**
  11. * 猫
  12. */
  13. private Cat cat;
  14. /**
  15. * List
  16. */
  17. private List <Student>list;
  18. /**
  19. * Map
  20. */
  21. private Map <String,Dog>map;
  22. /**
  23. * 密码
  24. */
  25. private String password;
  26. /**
  27. * Set
  28. */
  29. private Set <Dog>set;
  30. /**
  31. * 学生
  32. */
  33. private Student student;
  34. /**
  35. * 用户名
  36. */
  37. private String username;
  38. public OGNLAction(){
  39. this.list = new ArrayList<Student>();
  40. Student student1 = new Student("zhangsan",20);
  41. Student student2 = new Student("lisi",25);
  42. Student student3 = new Student("wangwu",28);
  43. Student student4 = new Student("zhaoliu",24);
  44. Student student5 = new Student("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 = new HashSet<Dog>();
  51. Dog dog1 = new Dog("bandeng");
  52. Dog dog2 = new Dog("zhuozi");
  53. Dog dog3 = new Dog("yizi");
  54. set.add(dog1);
  55. set.add(dog2);
  56. set.add(dog3);
  57. this.map = new HashMap<String, Dog>();
  58. map.put("0001", dog1);
  59. map.put("0002", dog2);
  60. map.put("0003", dog3);
  61. }
  62. /**
  63. * 控制器
  64. * @return 跳转的页面
  65. */
  66. @Override
  67. public String execute(){
  68. return "success";
  69. }
  70. /**
  71. * 取得cat
  72. * @return cat
  73. */
  74. public Cat getCat() {
  75. return cat;
  76. }
  77. /**
  78. * 取得list
  79. * @return list
  80. */
  81. public List<Student> getList() {
  82. return list;
  83. }
  84. /**
  85. * 取得map
  86. * @return map
  87. */
  88. public Map<String, Dog> getMap() {
  89. return map;
  90. }
  91. /**
  92. * 取得password
  93. * @return password
  94. */
  95. public String getPassword() {
  96. return password;
  97. }
  98. /**
  99. * 取得set
  100. * @return set
  101. */
  102. public Set<Dog> getSet() {
  103. return set;
  104. }
  105. /**
  106. * 取得student
  107. * @return student
  108. */
  109. public Student getStudent() {
  110. return student;
  111. }
  112. /**
  113. * 取得username
  114. * @return username
  115. */
  116. public String getUsername() {
  117. return username;
  118. }
  119. /**
  120. * 设置cat
  121. * @param cat cat
  122. */
  123. public void setCat(Cat cat) {
  124. this.cat = cat;
  125. }
  126. /**
  127. * 设置list
  128. * @param list list
  129. */
  130. public void setList(List<Student> list) {
  131. this.list = list;
  132. }
  133. /**
  134. * 设置map
  135. * @param map map
  136. */
  137. public void setMap(Map<String, Dog> map) {
  138. this.map = map;
  139. }
  140. /**
  141. * 设置password
  142. * @param password password
  143. */
  144. public void setPassword(String password) {
  145. this.password = password;
  146. }
  147. /**
  148. * 设置set
  149. * @param set set
  150. */
  151. public void setSet(Set<Dog> set) {
  152. this.set = set;
  153. }
  154. /**
  155. * 设置student
  156. * @param student student
  157. */
  158. public void setStudent(Student student) {
  159. this.student = student;
  160. }
  161. /**
  162. * 设置username
  163. * @param username username
  164. */
  165. public void setUsername(String username) {
  166. this.username = username;
  167. }
  168. }

ChainAction.java

[java:nogutter]  view plain copy
  1. /**
  2. * OGNL表达式
  3. * @author 健
  4. */
  5. public class ChainAction extends ActionSupport{
  6. /**
  7. * 序列化
  8. */
  9. private static final long serialVersionUID = 1L;
  10. /**
  11. * 控制器
  12. * @return 跳转的页面
  13. */
  14. @Override
  15. public String execute(){
  16. return "success";
  17. }
  18. }

OGNLUtil.java

[java:nogutter]  view plain copy
  1. /**
  2. * 工具类
  3. * @author 健
  4. */
  5. public class OGNLUtil {
  6. /**
  7. * 静态常量
  8. */
  9. public static final String URL = "static property";
  10. /**
  11. * 静态方法
  12. * @return 字符串
  13. */
  14. public static String getString(){
  15. return "static method";
  16. }
  17. }

Cat.java

[java:nogutter]  view plain copy
  1. /**
  2. * 猫
  3. * @author 健
  4. */
  5. public class Cat {
  6. /**
  7. * 名字
  8. */
  9. private String name;
  10. /**
  11. * 朋友
  12. */
  13. private Dog friend;
  14. /**
  15. * 取得name
  16. * @return name
  17. */
  18. public String getName() {
  19. return name;
  20. }
  21. /**
  22. * 设置name
  23. * @param name name
  24. */
  25. public void setName(String name) {
  26. this.name = name;
  27. }
  28. /**
  29. * 取得friend
  30. * @return friend
  31. */
  32. public Dog getFriend() {
  33. return friend;
  34. }
  35. /**
  36. * 设置friend
  37. * @param friend friend
  38. */
  39. public void setFriend(Dog friend) {
  40. this.friend = friend;
  41. }
  42. /**
  43. * 类方法
  44. * @return 返回字符串
  45. */
  46. public String say(){
  47. return "miaomiao";
  48. }
  49. /**
  50. * 构造
  51. */
  52. public Cat(){
  53. System.out.println("cat constructor");
  54. }
  55. /**
  56. * 重写toString方法
  57. */
  58. public String toString(){
  59. return "cat name is" + this.name;
  60. }
  61. }

Dog.java

[java:nogutter]  view plain copy
  1. /**
  2. * 狗
  3. * @author 健
  4. */
  5. public class Dog {
  6. /**
  7. * 名字
  8. */
  9. private String name;
  10. /**
  11. * 构造
  12. */
  13. public Dog(){
  14. System.out.println("dog constructor");
  15. }
  16. /**
  17. * 构造
  18. */
  19. public Dog(String name){
  20. this.name = name;
  21. }
  22. /**
  23. * 取得name
  24. * @return name
  25. */
  26. public String getName() {
  27. return name;
  28. }
  29. /**
  30. * 设置name
  31. * @param name name
  32. */
  33. public void setName(String name) {
  34. this.name = name;
  35. }
  36. /**
  37. * 类方法
  38. * @return 返回字符串
  39. */
  40. public String say(){
  41. return "miaomiao";
  42. }
  43. /**
  44. * 重写toString方法
  45. */
  46. public String toString(){
  47. return "dog name is" + this.name;
  48. }
  49. }

Student.java

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

struts.xml

[xhtml:nogutter]  view plain copy
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE struts PUBLIC
  3. "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
  4. "http://struts.apache.org/dtds/struts-2.0.dtd">
  5. <struts>
  6. <!-- 配置开发模式：修改不用重启服务器 -->
  7. <constant name="struts.devMode" value="true"/>
  8. <!-- 配置允许静态方法的访问 -->
  9. <constant name="struts.ognl.allowStaticMethodAccess" value="true"/>
  10. <!-- 包含的文件 -->
  11. <include file="ognl.xml"></include>
  12. </struts>

ognl.xml

[xhtml:nogutter]  view plain copy
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE struts PUBLIC
  3. "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
  4. "http://struts.apache.org/dtds/struts-2.0.dtd">
  5. <struts>
  6. <package name="ognl" namespace="/ognl" extends="struts-default">
  7. <action name="ognl" class="com.wj.struts2.action.OGNLAction" >
  8. <result name="success">/result.jsp</result>
  9. </action>
  10. <action name="chain" class="com.wj.struts2.action.ChainAction">
  11. <result type="chain" >
  12. <param name="actionName">ognl</param>
  13. <param name="namespace">/ognl</param>
  14. </result>
  15. </action>
  16. </package>
  17. </struts>

index.jsp

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

result.jsp

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

OGNL表达式的使用方法相关推荐

  1. 技术分析之OGNL表达式概述

    1. OGNL是Object Graphic Navigation Language(对象图导航语言)的缩写* 所谓对象图,即以任意一个对象为根,通过OGNL可以访问与这个对象关联的其它对象* 通过它 ...

  2. Struts2中使用OGNL表达式语言访问静态方法和静态属性以及我遇到的问题和解决方法

    1.上一篇文章,我介绍了OGNL表达式语言,本来想在那篇文章上加上一个使用OGNL访问静态方法和静态属性的例子,但是昨天晚上我写代码时,报了一个警告,获取得到静态属性的值,却获取不到静态方法的返回值, ...

  3. 深入理解Struts2中的OGNL表达式

    Struts 2中的表达式语言 Struts 2支持以下几种表达式语言: OGNL(Object-Graph Navigation Language),可以方便地操作对象属性的开源表达式语言: JST ...

  4. 为了熟练掌握动态SQL你必须要知道Mybatis中的OGNL表达式

    前言 OGNL是个什么东西?很多刚入门Java的同学会有点陌生.但是在Structs流行的时代OGNL可是必会的数据渲染技术.它全称Object Graph Navigation Language,作 ...

  5. OGNL表达式语言中的#和$的区别

    Struts2使用标准的Context来进行OGNL表达式语言求值,OGNL的顶级对象是一个Context,这个Context对象就是一个Map类型实例,其根对象就是 ValueStack,如果需要访 ...

  6. Struts(十)：OGNL表达式（一）

    Struts2 用s:porperty标签和OGNL表达式来读取值栈中的属性值: I.值栈中的属性值: 1.对象栈:读取对象栈中的某一个对象的属性值: 2.Map栈 :request,session, ...

  7. Struts2漏洞分析之Ognl表达式特性引发的新思路

    摘要 在Ognl表达式中,会将被括号"()"包含的变量内容当做Ognl表达式执行.Ognl表达式的这一特性,引发出一种新的攻击思路.通过将恶意代码存储到变量中,然后在调用Ognl表 ...

  8. struts2教程（9）--OGNL表达式使用

    OGNL表示式使用和值栈 一.介绍 OGNL是Object Graphic Navigation Language(对象图导航语言)的缩写,它是一个开源项目. Struts2框架使用OGNL作为默认的 ...

  9. struts2的OGNL表达式(二)

    下面说说OGNL表达式的访问情况: OGNL表达式能访问:访问属性,访问方法,访问字体对象,访问静态属性和方法,访问构造方法,访问数组,访问集合 – 投影.选择(? ^ $) 1,OGNL输出常量值 ...

最新文章

  1. 文件格式 tar.gz zip zp2 zip rar
  2. tomcat服务器配置及加固
  3. APDU命令的结构和处理【转】
  4. axis2 调用webservice
  5. 全国教学交流研讨会“教学为本”主题总结
  6. 面试题36：数组中的逆序对
  7. 2评分标准多少分_突发！财政部刚刚通知！2020年中级考试题目分值及评分标准大变！...
  8. opencv python 基于分水岭算法的图像分割
  9. 解决ubuntu下不能mount windows 盘的问题
  10. 原始图像扩展_Resize Sense for Mac(图像处理软件)
  11. java高级进阶面试题
  12. 使用 DISM 工具检查并修复 Windows 系统文件
  13. BUUCTF中的reverse1
  14. 蓝桥杯练习题——数列求和
  15. 2019浙江ACM省赛部分题解-ABDEFGHIJK
  16. 12.10中兴通讯科技园研发大楼发生42岁工程师跳楼事件
  17. win10开始菜单打不开，使用startmenu.diagcab进行修复
  18. 电脑桌面上怎么找计算机,电脑自带计算器快捷键 如何快速打开电脑上的计算器...
  19. 零售行业标签类目体系
  20. Linux上使用docker运行酷Q机器人

热门文章

  1. 选股策略之MACD指标选股
  2. IntelliJ IDEA 设置背景图片
  3. 使用Arduino与A4988 驱动步进电机
  4. Nginx笔记(一)Nginx
  5. 明智而审慎地使用private继承
  6. 用户名不能包含中文和特殊符号，只能输入英文加数字
  7. ios 不显示系统的音量视图(MPVolumeView隐藏)
  8. 为什么连续性变量才有概率密度函数，而离散型只有概率呢？
  9. java广度优先算法,算法之广度优先搜索
  10. 游戏数值知识点———养成感（二）