OGNL

最新推荐文章于 2019-01-08 11:00:01 发布

baother0

最新推荐文章于 2019-01-08 11:00:01 发布

阅读量988

点赞数

分类专栏： struts

本文链接：https://blog.csdn.net/xiao_niu_1/article/details/8869821

版权

struts 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

package ognl;

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



public class OgnlTest {
	public static void main(String[] args) throws Exception {
		Employee ee = new Employee ();
		ee.setName("employee");
		Manager mm = new Manager ();
		mm.setName("manager");
		OgnlContext context = new OgnlContext();
		context.setRoot(ee);
		context.put("mm", mm);
		String employeeName = (String)Ognl.getValue("name", context,context.getRoot());
		System.out.println(employeeName);//employee
		String managerName = (String)Ognl.getValue("#mm.name", context,context.getRoot());
		System.out.println(managerName);//manager
		literal();
		System.out.println("----------------------------------------");
		accessJavaBean();
		System.out.println("----------------------------------------");
		test();
		System.out.println("------------------------------------------");
		test2();
		System.out.println("-------------------------------------------");
		test3();
		System.out.println("-------------------------------------------");
		test4();
		System.out.println("-------------------------------------------");
		test5();
	}
	public static void literal () throws OgnlException {
		Employee ee = new Employee ();
		ee.setName("employee");
		Manager mm = new Manager ();
		mm.setName("manager");
		OgnlContext context = new OgnlContext();
		context.setRoot(ee);
		context.put("mm", mm);
		String iteral = (String) Ognl.getValue("'name'", context,context.getRoot());
		System.out.println(iteral);//name
		String iteral2 = (String)Ognl.getValue("'say \"hello world\"'", context,context.getRoot());
		System.out.println(iteral2);//say "hello world"
		String operation1 = (String)Ognl.getValue("name,#mm.name", context,context.getRoot());
		System.out.println(operation1);//manager
		ArrayList list1 = (ArrayList)Ognl.getValue("{\"zhagnlei\",false}", context,context.getRoot());
		boolean bool = (Boolean)list1.get(1);
		System.out.println(bool);//false
		boolean result1 = (Boolean)Ognl.getValue("name in{'employee',34}", context,context.getRoot());
		System.out.println(result1);//true
		
	}
	
	public static void accessJavaBean () throws OgnlException {
		Address address = new Address ();
		address.setCountry("china");
		address.setCity("beijing");
		address.setStreet("shangdi");
		Employee ee = new Employee ();
		ee.setName("zhangsan");
		ee.setAddress(address);
		OgnlContext context = new OgnlContext ();
		context.setRoot(ee);
		String username = (String)Ognl.getValue("name", context, context.getRoot());//对应的java代码ee.getName();
		System.out.println(username);//zhangsan
		String street = (String)Ognl.getValue("address.street", context,context.getRoot());//对应的java代码ee.getAddress().getStreet();
		System.out.println(street);//shangdi
		//调用方法：
		String upperCase = (String)Ognl.getValue("name.toUpperCase()", context,context.getRoot());
		System.out.println(upperCase);//ZHANGSAN
		Ognl.getValue("invoke('zhangleiya')", ee);
		//静态方法和静态变量
		int min = (Integer)Ognl.getValue("@@max(4,5)",null);
		System.out.println(min);//5
		
		double pi = (Double)Ognl.getValue("@@PI",null);
		System.out.println(pi);//3.141592653589793
		//创建对象
		ArrayList list = (ArrayList)Ognl.getValue("new java.util.ArrayList()", null);
		list.add("zhanglei");
		list.add(3);
		System.out.println(list);//[zhanglei, 3]
	}
	
	public static void test () throws Exception {
		Employee ee = new Employee ();
		Ognl.setValue("name", ee, "zhanglei");
		System.out.println(ee.getName());
	}
	
	public static void test2 ()throws Exception {
		System.out.println("test2");
		Employee ee = new Employee ();
		ee.setName("lisi");
		String []interests = new String[]{"Game","coding","read","make money"};
		ee.setInterests(interests);
		//按索引访问
		String interest = (String) Ognl.getValue("interests[0]", ee);
		System.out.println(interest);//Game
		//按索引设值
		Ognl.setValue("interests[0]",ee,"baother");
		System.out.println(Ognl.getValue("interests[0]", ee));
		int size = (Integer)Ognl.getValue("interests.length", ee);
		System.out.println(size);
	}
	
	public static void test3 () throws Exception {
		Message message = new Message ();
		message.setMessage("no1", "lisi");
		//有setMessage方法和getMessage方法
		Ognl.setValue("message['no1']", message, "zhangsan");
		System.out.println(Ognl.getValue("message['no1']", message));
		//没有setMessage方法和getMessage方法
		Message2 message2 = new Message2();
		Ognl.setValue("message.first", message2, "helloworld");
		String result = (String)Ognl.getValue("message.first", message2);
		System.out.println(result);
		//效果是一样的
	}
	public static void test4 () throws Exception{
		//创建列表
		List<Object> lists = (List<Object>) Ognl.getValue("{'zhangsan','lisi',new java.util.Date()}",null);
		System.out.println(lists.get(2));//Thu May 02 14:29:31 CST 2013
		//可以通过索引访问
		System.out.println(Ognl.getValue("{1,2,3,4}[2]", null));
		//创建map
		HashMap<String,Object> map = (HashMap<String,Object>)Ognl.getValue("#{'first':'zhangsan','second':'lisi'}", null);
		System.out.println(map);
		int size = (Integer)Ognl.getValue("#{'first':'zhangsan','second':'lisi'}.size", null);
		System.out.println(size);
		String name = (String)Ognl.getValue("#{'first':'zhangsan','second':'lisi'}.first", null);
		System.out.println(name);
		String name2 = (String)Ognl.getValue("#{'first':'zhangsan','second':'lisi'}['first']", null);
		System.out.println(name2);
	}
	
	public static void test5 () throws OgnlException {
		List<Employee> employees = new ArrayList<Employee>();
		Employee ee1 = new Employee ();
		ee1.setName("zhangsan");
		Employee ee2 = new Employee ();
		ee2.setName("hello");
		employees.add(ee1);
		employees.add(ee2);
		A a = new A ();
		a.setEmployees(employees);
		System.out.println(Ognl.getValue("employees.{name}", a));
		
	}
}

/**
 * Ognl表达式的计算机都是围绕OGNL上下文来进行的，ognl上下文实际上就是一个Map对象，
 * 由ognl.OgnlContext类(实现了java.util.Map接口)来表示。ognl上下文可以包含一个或多个JavaBean
 * 对象，在这些对象中有一个特殊的，这个对象就是上下文的根对象。如果在写表达式的时候，没有指定
 * 使用上下文中的哪一个对象，那么根对象将被假定为表达式所依据的对象。
 */


/****
 * 
 * OGNL表达式的基础单元就是导航链(navigation chain)，通常称为"链(chain)"。
 * 最简单的链有下列3部分组成：
 * 属性名：name
 * 
 * 方法调用：manager.hashcode(),
 * 
 * 数组索引:emails[0]
 * 
 * 
 */
/***
 * 
 * 常量：
 * ->字符常量，数值常量，布尔常量,null常量
 * 操作符：
 * ->逗号(,):类似于c语言中的逗号表达方式
 * ->{}:用于创建列表。
 * ->in和not in：判断一个值是否在集合中
 * 
 */
/***
 * 访问JavaBean的属性
 * 最常用的表达式就是范围javaBean的属性
 */
/***
 * 调用方法
 * 访问JavaBean的属性就是进行方法调用(调用属性的getter方法),
 * 不过，并不是所有的方法都符合getXxx（）和setXxx（）形式，OGNL提供了调用任何方法的能力。
 * 如果你要employee对象的name属性的值转化成大写形式，可以使用表达式：name.toUpperCase()。
 */

/***
 * 
 * 调用静态方法和静态字段
 * @class@method(args)//调用静态方法
 * @class@field//访问静态字段
 * 注意：class必须给出完整的类名.
 */

/***
 * 
 * 调用构造函数
 * OGNL支持对构造函数的调用，从而创建一个新的对象。你可以现在java中一样使用new 操作符来创建一个对象，不同的是
 * ，你必须使用完整的限定类名（带包名的类）.eg:new java.util.ArrayList(),而不是new ArrayList().
 * 
 */

/***
 *索引访问
 *数组和列表索引：
 *在ognl中，数组和列表可以大致看成是一致的。用数据索引访问方式也使用与访问列表中的元素
 *array[0],list[0]。表达式：{'zhangsan','wangwu','lisi'}[1]访问列表中的第二个元素即：wangwu,
 *对应的java代码为list.get(1),如果索引超过范围，抛出IndexOutOfBoundsException
 *
 *JavaBean的索引属性
 *JavaBean支持索引属性的概念，索引属性就是获取和设置数组时使用的属性。要使用索引属性，需要提供二对getter/setter
 *方法，一对用于数组，一对用于数据中的元素。语法如下：
 *public PropertyType[] getPropertyName()
 *public void setPropertyName (PropertyType[]values)
 *public PropertyType getPropertyName (int index);
 *public void setPropertyName (int index,PropertyType value)
 *
 *OGNL对象索引属性
 *JavaBean的索引只能使用整型作为索引，Ognl扩展了索引的概念。可以使用任意对象来作为索引。
 *可以使用任意对象来作为索引。
 *当发现一个可能的对象索引是，OGNL按照下列的方式签名参照方法样式：
 *public PropertyType getPropertyName (IndexType index)
 *public void setPropertyName(IndexType index,PropertyType value)
 *Servlet API中的session
 *public Object getAttribute(String name)
 *public void setAttribute (String name,Object value)
 *下面的OGNL表达式可以在session中获得或者设置foo属性(attribute)
 *session.attribute["foo"]
 *
 */

/**
 * 对集合的操作
 * 因为数组和列表的操作方式比较相似，所以通常也把数组归纳为集合。
 * 创建列表：
 * {'zhanglei','lisi',new Date()}
 * 创建数组：
 * 表达式：new int[]{1,2,3};Ognl中创建数组和Java语言中创建数组是类似的。可以使用索引来访问.数组的属性可以直接访问array.length
 * 创建map
 * Map使用特殊的语法来实现
 * #{'key1':'value1','key2','value2'}
 * eg:#{'first','zhangsan','second','lisi','third','wangwu'}
 * 相当于：Map map = new HashMap ();
 * 				map.put ("first","zhangsan");
 * 			return map;
 * 如果想要创建指定的map类型：使用#@java.util.LinkedMap@{'first','zhangsan','second','lisi','third','wangwu'}
 * 可以通过key访问：map['first'], #{'first':'zhangsan','second':'lisi'}["first"]
 * 集合的伪元素


 * Java集合api中很多常用的方法，如：size()，isEmpty()等。这些方法不符合JavaBean对于属性property访问器方法的
 * 命名要求getxxx setxxxx.所以不能像访问javaBean一样来访问这些方法。
 * eg:list.size
 * 投影（projection）
 * OGNL提供了简单的方式在一个集合中对每一个元素调用相同的方法，或者抽取相同的属性，请将结果保存在一个新的集合中。
 * 这个称之为投影，以数据库术语来说就是一张表中选择的子集。
 * #employees.{name}
 * 将返回所有顾客的名字的列表
 * 在投影期间,使用#this变量来引用迭代中的当前元素
 * objects:{#this instanceof String ? #this:#this.toString()}
 *选择：
 *OGNL 提供了一个简单的方式来使用表达式从集合中选择元素，并将结果保存到新的集合中。成为选择。类比：数据库的select name from employee where id < 34;
 *返回雇员薪水大于3000的所有的列表
 *#employee.{?#this.salary > 3000}
 *?选取匹配选择逻辑的所有的元素
 *^选取匹配选择逻辑的第一个元素
 *$选取匹配选择逻辑的最后一个元素
 */

/***
 * 
 * 
 * OGNL 的类型转换:可以将一个对象转换转换成不同的类型。
 * 在表达式计算过程中，ognl可以根据需要自动对某个对象进行类型转换。
 * eg:要将对象转换成Boolean类型，如果对象时Number,非0为true，其他为false。
 * Character '0'->false other->true
 * null->false other->true
 */

/**
 * struts2:
 * 值栈（ValueStack）
 * struts2将OGNL上下文设置为Struts2中的ActionContext(内部仍然使用的是OgnlContext),
 * 并将值栈作为OGNL的根对象。可以在值栈中放值，删除值，查询值。
 * 
 *


 */
class Employee {
	private String name;
	private Address address;
	private String interests[];
	
	public String[] getInterests() {
		return interests;
	}
	public void setInterests(String[] interests) {
		this.interests = interests;
	}
	//可以不提供
	public void setInterests (int i,String interest) {
		System.out.println("exe");
		this.interests[i] = interest;
	}
	//可以不提供，因为数组可以直接的按索引访问
	public String getInterests (int i) {
		return this.interests[i];
	}
	public Address getAddress() {
		return address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	public void invoke (String name) {
		System.out.println(name+"invoke!");
	}
}

class Message {
	public Map<String,Object> message = new HashMap<String,Object> ();
	public void setMessage (String key,String value) {
		message.put(key, value);
	}
	public Object getMessage (String key) {
		return message.get(key);
	}
}

class Message2 {
	public Map<String,Object> message = new HashMap<String,Object> ();
}
class Manager {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}
class Address {
	private String country;
	private String city;
	private String street;
	public String getCountry() {
		return country;
	}
	public void setCountry(String country) {
		this.country = country;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public String getStreet() {
		return street;
	}
	public void setStreet(String street) {
		this.street = street;
	}
	
}
//只为演示
class A {
	private List<Employee> employees;

	public List<Employee> getEmployees() {
		return employees;
	}

	public void setEmployees(List<Employee> employees) {
		this.employees = employees;
	}
	
}