- 浏览: 23704 次
- 性别:
- 来自: 成都
最新评论
一、OGNL表达式基础知识
1. 示例:第一个OGNL程序
2. 示例:上下文环境中使用OGNL
3. 示例:使用OGNL调用方法
4. 示例:使用OGNL操作集合
5. 示例:使用OGNL过滤集合与投影集合
二、OGNL与Struts2
OGNL表达式
OGNL,全称为Object-Graph Navigation Language,它是一个功能强大的表达式语言,用来获取和设置Java对象的属性,它旨在提供一个更高的更抽象的层次来对Java对象图进行导航。
OGNL表达式的基本单位是"导航链",一般导航链由如下几个部分组成:
属性名称(property)
方法调用(method invoke)
数组元素
所有的OGNL表达式都基于当前对象的上下文来完成求值运算,链的前面部分的结果将作为后面求值的上下文。例如:names[0].length()。
示例:第一个OGNL程序
控制台输出:zhangsan
可以看到我们正确的取得了person对象的name属性值,该getValue声明如下:
public static <T> T getValue(String expression,Object root)throws OgnlException
Convenience method that combines calls to parseExpression and getValue.
Parameters:
expression - the OGNL expression to be parsed
root - the root object for the OGNL expression
Returns:
the result of evaluating the expression
OGNL会根据表达式从根对象(root)中提取值。
示例:上下文环境中使用OGNL
控制台输出:
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调用方法
控制台输出:
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操作集合
控制台的输出:
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过滤集合与投影集合
控制台输出:
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
Struts 2支持以下几种表达式语言:
1. OGNL(Object-Graph Navigation Language),可以方便地操作对象属性的开源表达式语言;
2. JSTL(JSP Standard Tag Library),JSP 2.0集成的标准的表达式语言;
3. Groovy,基于Java平台的动态语言,它具有时下比较流行的动态语言(如Python、Ruby和Smarttalk等)的一些起特性;
4. Velocity,严格来说不是表达式语言,它是一种基于Java的模板匹配引擎,具说其性能要比JSP好。
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. 操作集合对象。
——————————————以上内容引用自http://www.blogjava.net/max/archive/2007/04/28/114417.html
平时使用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"属性。
个人学习心得,难免有错误遗漏,欢迎指正讨论!
原文链接:http://www.cnblogs.com/beliefbetrayal/archive/2012/02/11/2347244.html
相关优秀文章:http://blog.csdn.net/it_man/article/details/6000655
1. 示例:第一个OGNL程序
2. 示例:上下文环境中使用OGNL
3. 示例:使用OGNL调用方法
4. 示例:使用OGNL操作集合
5. 示例:使用OGNL过滤集合与投影集合
二、OGNL与Struts2
OGNL表达式
OGNL,全称为Object-Graph Navigation Language,它是一个功能强大的表达式语言,用来获取和设置Java对象的属性,它旨在提供一个更高的更抽象的层次来对Java对象图进行导航。
OGNL表达式的基本单位是"导航链",一般导航链由如下几个部分组成:
属性名称(property)
方法调用(method invoke)
数组元素
所有的OGNL表达式都基于当前对象的上下文来完成求值运算,链的前面部分的结果将作为后面求值的上下文。例如:names[0].length()。
示例:第一个OGNL程序
public class OGNL1 { public static void main(String[] args) { /* 创建一个Person对象 */ Person person = new Person(); person.setName("zhangsan"); try { /* 从person对象中获取name属性的值 */ Object value = Ognl.getValue("name", person); System.out.println(value); } catch (OgnlException e) { e.printStackTrace(); } } } class Person { private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } }
控制台输出:zhangsan
可以看到我们正确的取得了person对象的name属性值,该getValue声明如下:
public static <T> T getValue(String expression,Object root)throws OgnlException
Convenience method that combines calls to parseExpression and getValue.
Parameters:
expression - the OGNL expression to be parsed
root - the root object for the OGNL expression
Returns:
the result of evaluating the expression
OGNL会根据表达式从根对象(root)中提取值。
示例:上下文环境中使用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
Struts 2支持以下几种表达式语言:
1. OGNL(Object-Graph Navigation Language),可以方便地操作对象属性的开源表达式语言;
2. JSTL(JSP Standard Tag Library),JSP 2.0集成的标准的表达式语言;
3. Groovy,基于Java平台的动态语言,它具有时下比较流行的动态语言(如Python、Ruby和Smarttalk等)的一些起特性;
4. Velocity,严格来说不是表达式语言,它是一种基于Java的模板匹配引擎,具说其性能要比JSP好。
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. 操作集合对象。
——————————————以上内容引用自http://www.blogjava.net/max/archive/2007/04/28/114417.html
平时使用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"属性。
个人学习心得,难免有错误遗漏,欢迎指正讨论!
原文链接:http://www.cnblogs.com/beliefbetrayal/archive/2012/02/11/2347244.html
相关优秀文章:http://blog.csdn.net/it_man/article/details/6000655
发表评论
-
struts2 OGNL
2014-09-22 16:15 432一、"#"的用法 1、 访问OGN ... -
struts2返回json
2013-02-26 16:41 716基于struts2返回json数据,除了常规方式,还有一种就是 ... -
struts2中应用ajax
2012-08-27 00:12 721前台: <script type="text ... -
通过对servlet和JSP的调优提升程序性能
2012-08-24 01:10 623本文讲述了调整JSP和Servlet的一些非常实用的方法,它可 ... -
struts2.0 配置文件、常量配置详解
2012-08-22 00:47 721常量默认放在:struts2-core-2.1.6/org.a ... -
Struts 2的拦截器(Interceptor)
2012-08-22 00:20 728什么是拦截器 拦截器,在AOP(Aspect-Oriente ...
相关推荐
### JS:ognl表达式详解 #### 一、OGNL表达式概述 OGNL (Object-Graph Navigation Language) 是一种强大的表达式语言,用于获取和设置 Java 对象的属性。它最初是由 John Rose 和 Luke Blanshard 开发,并被广泛...
Struts2是一个流行的Java Web...通过深入学习OGNL表达式原理,开发者能够更好地利用Struts2框架,提高Web应用的开发效率和可维护性。对于那些希望在Struts2开发中更进一步的人来说,熟悉和掌握OGNL是必不可少的技能。
Struts2是一个流行的Java web应用程序框架,它极大地简化了MVC(模型-视图-控制器)架构的实现。...如果你想要深入学习Struts2和OGNL,可以参考给出的博客链接,或者查阅官方文档和其他相关的技术资源。
在深入学习Struts2 OGNL表达式时,了解以下几点至关重要: 1. **OGNL基础语法**:包括变量引用、属性访问、集合操作、方法调用等。 2. **Struts2动作和结果**:如何在配置文件中使用OGNL定义Action和结果。 3. **...
OGNL(Object-Graph Navigation Language)是一种强大的表达式语言,常用于Java应用程序,特别是Web开发中的框架,如Struts 2。...通过深入学习,你可以更好地驾驭这门表达式语言,为你的Web应用开发带来便利。
通过深入学习OGNL的源码,开发者可以更好地定制和优化Struts2应用,提升性能,增强安全性,并能解决遇到的特定问题。这是一项值得投入时间和精力的任务,特别是对于那些希望在Web开发领域有深入理解的人来说。
### 精通Struts2中的OGNL表达式 在深入探讨Struts2框架的核心功能时,理解并熟练掌握OGNL(Object-Graph Navigation Language)表达式的应用是至关重要的一步。OGNL是一种强大的表达式语言,它允许开发者通过简洁、...
在Struts2中,不安全的OGNL表达式可能导致代码注入攻击,因此在生产环境中应严格控制OGNL表达式的使用,避免用户输入的数据直接参与OGNL解析。 视频课程`41_尚学堂马士兵_Struts2_OGNL_6.avi`、`42_尚学堂马士兵_...
在本案例中,我们将深入探讨OGNL表达式的用法及其在Struts2中的应用。 首先,OGNL是一种灵活的表达式语言,允许开发者访问和操作对象图。它的核心特性包括属性访问、方法调用、集合操作、类型转换等。例如,`user....
OGNL(Object-Graph Navigation Language)是一种强大的表达式语言,用于获取和设置Java对象的属性。...通过深入学习和实践,开发者能够有效地利用OGNL进行数据绑定和表达式计算,提升代码的可读性和效率。
Struts2是一个流行的Java web应用程序...学习OGNL不仅可以提高在Struts2中的开发效率,还能为其他使用OGNL的项目提供参考。如果你对某个特定部分有更深入的兴趣,例如表达式解析或安全防护,可以进一步探索相关源码。
OGNL (Object-Graph Navigation Language) 是一种强大的表达式语言,用于获取和设置 Java 对象的属性。...对于想要深入了解 Struts2 和 OGNL 工作原理的开发者来说,研究这个源码包将是一个宝贵的学习资源。
Struts2是一个流行的Java Web应用程序框架,它极大地简化了MVC(模型-视图-控制器)架构的实现。...通过实践这个“Struts2 OGNL用法项目”,你可以深入学习OGNL的强大功能,并提升在Struts2框架下的开发能力。
### Struts2中OGNL的使用详解 ...理解并熟练掌握OGNL的使用,对于深入学习和高效开发基于Struts2的应用程序至关重要。通过本文对OGNL在Struts2中的应用场景和使用技巧的介绍,希望能帮助开发者更好地利用这一强大工具。
总结,"OGNL表达式2讲"是一个深入学习OGNL表达式的资源,涵盖了OGNL的基本语法、与标签的配合、集合操作、上下文访问以及安全性考虑。通过案例学习,有助于开发者更好地理解和应用OGNL在实际项目中的功能。记得下载...
“$”符号在Struts2中主要用作OGNL表达式的起始标记,在模板文件(如JSP页面)中,它用于指示Struts2框架应该解析为OGNL表达式。 1. **模板文件中的应用**: - 示例:`reg.ageRange = $ {min} 到 $ {max}` - 解释...
深入学习这些源代码,开发者不仅可以了解OGNL的内部工作机制,还能提升对Struts2框架的理解,从而更好地设计和调试应用程序。同时,这也有助于学习其他类似的表达式语言或脚本引擎,因为很多概念和设计模式都是通用...
Struts 2 的核心技术基础是WebWork,它在Struts 1的基础上进行了许多改进,如更强大的表达式语言(OGNL)、拦截器机制、更简单的配置等。WebWork的这些特性被集成到Struts 2中,使得Struts 2成为了一个高效且易用的...
"struts2对Ognl的封装--PropertyAccessor"这个主题主要涉及Struts2框架如何处理OGNL表达式,特别是如何通过PropertyAccessor接口来访问和操作对象的属性。 首先,我们来了解什么是OGNL。OGNL是Struts2的核心组件之...
Struts2是一个流行的Java Web应用程序框架,它极大地简化了MVC(模型-视图-控制器)架构的实现。在Struts2中,OGNL(Object-Graph ...通过阅读提供的"Struts2 OGNL.htm"文件,你可以进一步学习OGNL的详细用法和示例。