关于Struts2中的ValueStack,ActionContext,OgnlContext的理解之一:OGNL

最新推荐文章于 2022-10-19 23:18:13 发布

影子里的句号

最新推荐文章于 2022-10-19 23:18:13 发布

阅读量1.2k

点赞数

分类专栏： javaWeb struts2 文章标签： struts2 ognl ognlcon

本文链接：https://blog.csdn.net/tssxs/article/details/11095785

版权

javaWeb 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

struts2

2 篇文章 0 订阅

订阅专栏

1.在讨论ValueStack及ActionContext之前,我们必须先从Ognl说起:

OGNL（Object Graph Navigation Language）对象图导航语言.之所以起这个名,个人认识是因为它可以使用(.)点符号的方式一级一级像向导一样的在Java代码调用对象的方法或属性.它的功能极其强大,是使用Java来实现的,它是一个极其强大的表达式引擎框架,它可以独立使用,也就是说在一般的Java Application程序中就可以使用它,使用包之前必须导入它的核心包及扩展包如下:

ognl.jar //核心包

javassist.jar //扩展包

2.以具体的实例代码来说一下关于ognl单独在Java中的使用,先建立一个javaApplication项目ognlstudy,并入加上面两个包如下:

以上是学习ognl的项目目录有两上实体类Dog,Person,两个测试类

Dog类如下:

package com.changsiyuan.ognl;

public class Dog
{
	private String name;
	private int age;
	
	public String getName()
	{
		return name;
	}

	public void setName(String name)
	{
		this.name = name;
	}
	
	public int getAge()
	{
		return age;
	}

	public void setAge(int age)
	{
		this.age = age;
	}

	public void method()
	{
		System.out.println("method of dog");
	}
	
}

Person类如下:

package com.changsiyuan.ognl;

public class Person
{
	private String name;
	private int age;
	private Dog pet;
	
	public void method()
	{
		System.out.println("the method of person");	
	}
	
	public Dog getPet()
	{
		return pet;
	}
	public void setPet(Dog pet)
	{
		this.pet = pet;
	}
	
	public String getName()
	{
		System.out.println("getName of person");
		return name;
	}
	public void setName(String name)
	{
		this.name = name;
	}
	
	public int getAge()
	{
		return age;
	}
	public void setAge(int age)
	{
		this.age = age;
	}
}

3.在Ognl表达式引擎构架下,有两种重要的概念:

第一:表达式计算所在的环境,也就是表达式的计算是基于什么样的上下文环境

第二;表达式计算也在的根,也就是说在表达式计算的环境中总能找到一个对象为根对象

在OGNL框架中:

OgnlContext:上下文OgnlContext类实现了java.utils.Map接口,指定在OgnlContext对象中存在的一个个”键:值”对的对象.也就是说OgnlContext对象实际上就是一个Map对象.来描述,可以看出他是一大堆对象,用map来实现

根对象用Root来描述,它就是一个单一的对象,也处于上下文环境中

4.在Ognl框架下,如果要表示根元素,表达式前面不用加#号,其它非根必须使用#号来与根对象加以区别, 在OGNL中,如果表达式中没有#号,那么OGNL就会去到根对象中寻找该属性对应的get方法，如果寻找的不是根对象中的属性，那么则需要以#号开头，告诉OGNL，去寻找你所指定的特定对象中的属性。

5.对于OGNL中,访问根对象时,也以直接写属性名或方法名(),也可以#对象名.属性名或#对象名.方法名()来引用,但不能”#属性名”或”#方法名()”,也不能以”对象名.属性名”或”对象名.方法名()”,要么最完全的去访问,要么最简去访问.

如果去访问一个不存在的属性或方法,则报错.

示例代码如下:OgnlTest.java

package com.changsiyuan.ognl;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import ognl.Ognl;
import ognl.OgnlContext;

public class OGNLTest
{
	public static void main(String[] args) throws Exception
	{
		Person person = new Person();
		person.setName("zhangsan");
		String abc = "abcxxxxxx";
		
		Dog dog = new Dog();
		Dog dog1 = new Dog();
		person.setPet(dog1);
		dog.setName("wangcai");
		dog1.setName("maomao");
		
		List<String> list = new ArrayList<String>();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		list.add("ddd");
		
		
		
		//使用Ognl的第一步:实质上他是一个实现了Map的接口,
		OgnlContext context = new OgnlContext();
		//第二步:放置一些对象在上下文环境中
		context.put("person", person);
		context.put("dog", dog);
		context.put("list", list);
		context.put("abc", abc);
		
		//第三步:设置其中一个对象为根
		context.setRoot(person);
		
		//第四步:使用Ognl.getValue方法把合法的Ognl表达式解析出相应的对象
		//参数1:Ognl表达式,参数2:上下文环境,参数3:根对象
		Object object1 = Ognl.getValue("name", context, context.getRoot());
		Object object2 = Ognl.getValue("#dog.name", context,context.getRoot());

		System.out.println(object1);
		System.out.println(object2);
		System.out.println("12----------------------");
                
                Object object5 = Ognl.getValue("pet.name", context,context.getRoot());//person/pet/name
                Object object6 = Ognl.getValue("#dog.name", context,context.getRoot());//dog/name
                System.out.println(object5);
                System.out.println(object6);
                System.out.println("56-----------------------");
 }

输出结果如下:

getName of person
zhangsan
wangcai
12----------------------
maomao
wangcai
56-----------------------

6.对于OGNL中,表达式什么为会能找到属性所对应的值,实质上是通过getXXX()方法来获得的,这点可以通过在某个属性的get方法中加入语句来证明.基本这一点,在Java中,大多数的类都不符合Javabean的结构,也就是说并不是每个类都针对其属性设置了setter和getter方法,那么OGNL就没有能力获得到类的属性及方法了吗?答案是否定的,OGNL表达式既可以通过getter,setter的方式来访问类的方法和属性,也可以通过一般的方法去访问一般类的属性和方法.代码如下:

                Object object7=Ognl.parseExpression("name.toUpperCase()");//把得到的字符串转调用大写;注意显示的去调用方法要加括号()
		Object object8=Ognl.getValue(object7, context,context.getRoot());
		System.out.println(object8);
		System.out.println("78-----------------------");

注意:这段应该放在OgnlTest.java类中

结果如下:

getName of person
ZHANGSAN
78-----------------------

7.对于一般类的静态方法来说,可以以类名.方法名来访问.比如:

Integer.toBinary.String(7)//转换成二进制

在ognl表达式中要使用”@类的全名@静态方法”的形式来写

          System.out.println("8-->" + Integer.toBinaryString(8));
	  Object object9=Ognl.getValue("@java.lang.Integer@toBinaryString(8)", context,context.getRoot());
	  System.out.println("8-->" + object9);
	  System.out.println("9-----------------------");

8.OGNL主要用来简化对一个对象的属性和方法的引用.只要对象纳入了OGNL框架之下.那么就完全可以不通过new一个实例的方式来引用该对象的属性和方法,用OGNL表达式就可以了.

9.对于OGNL来说,java.lang.Math是其默认类,如果调用java.lang.Math的静态方法时,无需指定类的名字,比如:@@min(4,6)

        Object object3 = Ognl.getValue("@@max(4,7)", context,context.getRoot());
	Object object4 = Ognl.getValue("@@PI", context,context.getRoot());
	System.out.println(object3);
	System.out.println(object4);

10.此外,使用OGNL表达式可以生成一个对像如:

    //以new的方式来生成一个ArrayList对象
    Object object13 = Ognl.getValue("new java.util.ArrayList()", context,context.getRoot(),ArrayList.class);
    ArrayList arrayList = (ArrayList)object13;
    arrayList.add("aaaa");//添加对象
    arrayList.add("bbbb");//添加对象
    arrayList.add("cccc");
    arrayList.add("dddd");
    context.put("arrayList",arrayList);//纳入OGNL表达的管理
   //以OGNL表达式来方法集合对象中的值
   System.out.println(Ognl.getValue("#arrayList[3]", context,context.getRoot()));
   System.out.println("13-------------------");

11.实际上,在Ognl表达中,对于数组和集合的表达更为灵活如下:

   //OGNL表达式特有的生成集合对象的方式
   Object object14 = Ognl.getValue("{'a','b','c','d','e'}", context,context.getRoot());
   //本质上为ArrayList对象
   ArrayList<String> aaa =  (ArrayList<String>) object14;
   System.out.println(aaa.size());

12.在OGNL中,处理映射(maping)时的表达式如下:

#{‘key1’:’value1’,’key2’:’value2’,’key3’:’value3’}

示例代码如下:

Object object15 = Ognl.getValue("#{'key0':'#aaa[0]','key1':'#aaa[1]','key2':'#aaa[2]','key3':'#aaa[3]','key4':'#aaa[4]'}['key0']",context,context.getRoot());
   System.out.println(object15);

13.使用Ognl表达式进行过滤运算

collection.{?expression}

xpression:这个是针对集合进行操作的表达式

例如以下语句:

//输出persons集合中的每个元素中的name的长度大于4的集合
System.out.println(Ognl.getValue("#persons.{?#this.name.length() > 4}"),context, context.getRoot());
//把OGNL上下文的arrayList对象中的等于"bbbb"的值过滤出来,是一个集合
Object object16 = Ognl.getValue("#arrayList.{?#this.equals('bbbb')}", context, context.getRoot());
System.out.println(object16);

上面的代码返回的结果都是一个集合,即使只有一个元素,那也是集合,也就是说实际上我们也可输出这些集合的长度代码如下:

//输出persons集合中的每个元素中的name的长度大于4的集合的长度
System.out.println(Ognl.getValue("#persons.{?#this.name.length() > 4}.size()"),context, context.getRoot());
//把OGNL上下文的arrayList对象中的等于"bbbb"的值过滤出来的个数是多少
Object object16 = Ognl.getValue("#arrayList.{?#this.equals('bbbb')}.size()", context, context.getRoot());
System.out.println(object16);

14.实际在上面的语句中#persons.{?#this.name.length()>4}.size()表达式中可以写成#persons.{?#this.name.length()>4}.size,也就是把size()方法的小括号取掉,就像使用属性一样去使用方法,这个就是Ognl表达为我们提供了简化对对象的操作,称之为伪属性,因为size()方法不符合JavaBean的命名规则.常见的还有isEmpty()方法.Ognl表达中,针伪属性(也就是访问某些方法可以像属性一样)如:size,isEmpty等,这是因为在集合里大多数方法命名不符合JavaBean的规则,而我们依然可以像操作属性一样去访问方法.15.Ognl表达式中,针对集合还提供了一种过滤方式(首元素和尾元素)#persons.{?#this.name.length()>4}[0]//第一个元素,这个是单个元素#persons.{^#this.name.length()>4}//满足条件的第一个元素,是集合#persons.{$#this.name.length()>4}//满足条件的最后一个元素,但是集合.代码如下:

//返回符合条件的集合的长度
System.out.println(Ognl.getValue("#persons.{?#this.name.length() > 4}.size",context, context.getRoot()));

//返回符合条件的集合的第一个元素,是一个对象
System.out.println(Ognl.getValue("#persons.{?#this.name.length() > 4}[0].getName()",context, context.getRoot()));

//返回符合条件的集合中的第一个元素,结果是一个集合
System.out.println(Ognl.getValue("#persons.{^#this.name.length() > 4}",context, context.getRoot()));

//返回符合条件的集合中的最后一个元素,结果是一个集合
ystem.out.println(Ognl.getValue("#persons.{$#this.name.length() > 4}",context, context.getRoot()));

System.out.println("18----------------");

输出结果如下:

3
person1
[com.changsiyuan.ognl.Person@22998b08]
[com.changsiyuan.ognl.Person@c3bb2b8]
18----------------

从结果可以看出取第一个和最后一个集合的形式,而当我们使用过滤(filter)操作时,通过会使用#this来代表当前正在迭代的对象(联想JavaSE中的增强for循环,都使用一个变量)

16. 使用Ognl表达式的第二种情况(投影)(projection) 形式为: Collection.{expresson} 一个集合经过投影操作后,数量(长度)和原来的集合一样,但就单个元素内容而言,其属性是原来的一个子集. 如果有一个Person类的list集合persons,总共有10元素: 对于过滤来说,过滤后的集合中数据会变货,比方只过滤name长度大于4的.也就是集合中元素的数量会变化,但每个元素的属性不会变化对于投影来说,投影后的集合中,还是10个元素,但每个元素的属性只是原来属性的一部分,比方说只投影name属性,那么投影后10个元素每个元素只包括address和age两个属性. 如下代码,表示取出集合中的每个元素的name属性,总的集合的大小是不变的

System.out.println(Ognl.getValue("#persons.{name}", context, context.getRoot()));

17.关于Ognl的总结:

<1>Ognl表达的操作分为两种过滤和投影,对应于数据库的行和列;

<2>访问某个类的静态方法用@类全名@方法名,对于Math类的静态方法可以使用@@静态方法.

<3>对于某些方法可以使用伪属性的形式来访问.

影子里的句号

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
关于Struts2中的ValueStack,ActionContext,OgnlContext的理解之一:OGNL

1.在讨论ValueStack及ActionContext之前,我们必须先从Ognl说起: OGNL（Object Graph Navigation Language）对象图导航语言.之所以起这个名,个人认识是因为它可以使用(.)点符号的方式一级一级像向导一样的在Java代码调用对象的方法或属性.它的功能极其强大,是使用Java来实现的,它是一个极其强大的表达式引擎框架,它可
复制链接

扫一扫