精华内容
下载资源
问答
  • OGNL

    千次阅读 2019-09-18 23:30:52
    OGNLOGNL的概述EL表达式与OGNL的比较 OGNL的概述 OGNL中文名对象图导航语言,是一个比EL表达式更加强大很多倍的语言 EL表达式与OGNL的比较 EL:从域对象中获取数据,从EL的11个对象中获取数据 OGNL:可以调用对象的...

    OGNL的概述

    OGNL中文名对象图导航语言,是一个比EL表达式更加强大很多倍的语言

    EL表达式与OGNL的比较

    EL:从域对象中获取数据,从EL的11个对象中获取数据
    OGNL:可以调用对象的方法,可以获取Struts2的值栈数据

    OGNL的java环境入门

    OGNL调用对象的方法

    1. 获得context对象
    2. 获得根对象
    3. 执行对象的方法
    	public void demo1() throws OgnlException {
            //获得context
            OgnlContext context = new OgnlContext();
            //获得根对象
            Object root = context.getRoot();
            //执行表达式
            Object value = Ognl.getValue("'helloword'.length()", context, root);
            System.out.println(value);
        }
    

    OGNL访问对象的静态资源

    访问静态资源的表达式:
    @类名@调用的方法

     	public void demo2() throws OgnlException {
            //获得context
            OgnlContext context = new OgnlContext();
            //获得根对象
            Object root = context.getRoot();
            //执行表达式:@类名@方法名
            Object value = Ognl.getValue("@java.lang.Math@random()", context, root);
            System.out.println(value);
        }
    

    将数据存入root访问

    1. 创建一个实体类,生成get和set方法,以及有参无参
    2. 获得context对象
    3. 将数据存入root
    4. 获取根对象root
    5. 获取值
    	public void demo3() throws OgnlException {
            //获得context
            OgnlContext context = new OgnlContext();
            //执行表达式
            context.setRoot(new User("aaa","21231"));
            //获得根对象
            Object root = context.getRoot();
            Object username = Ognl.getValue("username", context, root);
            Object password = Ognl.getValue("password", context, root);
            System.out.println(username+"..."+password);
        }
    

    将数据存入context访问

    1. 获得context对象
    2. 获得根对象root
    3. 向context中存入数据
    4. 执行表达式,注意执行表达式时,键需要加上#
    	public void demo4() throws OgnlException {
            //获得context
            OgnlContext context = new OgnlContext();
            //获得根对象
            Object root = context.getRoot();
            context.put("name","张三");
            Object value = Ognl.getValue("#name", context, root);
            System.out.println(value);
        }
    

    OGNL的Struts2环境入门

    导包

    <%@ taglib prefix="s" uri="/struts-tags" %>
    

    OGNL调用对象的方法

    	<s:property value="'hello world'.length()"></s:property>
    

    OGNL访问对象的静态资源

    1. 配置struts.xml,修改常量struts.ognl.allowStaticMethodAccess的值,因为struts2默认是关闭静态资源访问的功能的

      <constant name="struts.ognl.allowStaticMethodAccess" value="true"></constant>
      
    2. 访问静态资源

      <s:property value="@java.lang.Math@random()"></s:property>
      

    注意: 有的时候在struts.xml里配置常量的时候没有效果,我们也可以在web.xml里面配置常量的值

     	<filter>
            <filter-name>struts</filter-name>
            <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
            <init-param>
                <param-name>struts.ognl.allowStaticMethodAccess</param-name>
                <param-value>true</param-value>
            </init-param>
        </filter>
    
        <filter-mapping>
            <filter-name>struts</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>
    

    值站(ValueStack)

    值站的概述

    • 值站其实类似于一个容器(Struts2的框架当中的数据都会保存在ValueStack中,在任何地方都可以取,可以在页面上取,可以在action中取,可以在配置文件中取,而request只能在页面中取)
    • ValueStack是一个接口,OgnlValueStack是它的实现类
    • ValueStack贯穿了整个action的生命周期(意思是有一个Action实例,就会有一个ValueStack对象)

    值站的内部结构

    • ValueStack中有两个主要的区域
      • root区域:其实就是一个ArrayList,里面一般放置一些对象。获取root的数据是不需要加#
      • context区域:其实就是一个Map,里面放置的是web开发常用的对象数据的引用,获取context数据需要加#
        • request
        • session
        • application
        • parameters
        • attr
    • 操作值栈,通常指的是操作ValueStack中的root区域。

    查看值栈的结构:

    <%@taglib prefix="s" uri="/struts-tags" %>
    
        <s:debug></s:debug>
    

    值栈的操作

    保存数据到值栈中的root以及获取root值栈的数据

    方式一:
    1. 创建一个全局变量,并生成get方法
    2. 给全局变量赋值
    3. 前端获取数据

    代码实现:
    前端:

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%@taglib prefix="s" uri="/struts-tags" %>
    <html>
    <head>
        <title>Title</title>
    </head>
    <body>
        <s:debug></s:debug>
        <s:property value="user.username"></s:property>
        <s:property value="user.password"></s:property>
    </body>
    </html>
    

    后端:

    public class ValueStackDemo1 extends ActionSupport {
        public User getUser() {
            return user;
        }
    
        private User user;
        @Override
        public String execute() throws Exception {
            user = new User("张三","2222");
            return SUCCESS;
        }
    }
    

    结果展示:
    在这里插入图片描述
    点击Debug:
    在这里插入图片描述

    方式二:
    1. 获取valueStack对象
    2. 创建对象给对象赋值
    3. 将值压入值栈中

    代码实现:
    前端获取数据

    	<s:debug></s:debug>
    	<s:property value="username"></s:property>
        <s:property value="password"></s:property>
        <s:property value="name"></s:property>
    

    后端:

    	 User user = new User("张三","2222");
    	 ValueStack valueStack = ActionContext.getContext().getValueStack();
    	 valueStack.push(user);
    	 //set一般用来传集合
         valueStack.set("name","李四");
    

    保存数据到值栈中的context以及获取context值栈的数据

    后端存储数据:

    		ServletActionContext.getRequest().setAttribute("name","张三");
            ServletActionContext.getRequest().getSession().setAttribute("name","李四");
            ServletActionContext.getServletContext().setAttribute("name","王五");
    

    前端获取数据(EL表达式可以获取到request对象的值):

    	<s:property value="#request.name"></s:property>
        <s:property value="#session.name"></s:property>
        <s:property value="#application.name"></s:property>
        ${name}
    

    OGNL中的特殊字符

    #号

    1. 获取context的数据

    2. 构建map集合
      例如:
      使用s:iterator 标签遍历list集合{‘aa’,‘bb’,‘cc’},结果表示使用i和#i都可以取到值

      <s:iterator value="{'aa','bb','cc'}" var="i">
          <s:property value="i"></s:property> -- <s:property value="#i"></s:property> <br />
      </s:iterator>
      

      在这里插入图片描述
      使用s:iterator 标签遍历map集合#{‘aa’:‘11’,‘bb’:‘22’,‘cc’:‘33’},结果表示使用key–value和#i.key–i.value都可以取到值

      	<s:iterator value="#{'aa':'11','bb':'22','cc':'33'}" var="i">
      	    <s:property value="key"></s:property> -- <s:property value="value"></s:property> <br />
      	
      	    <s:property value="#i.key"></s:property> -- <s:property value="#i.value"></s:property> <br />
      	</s:iterator>
      

      在这里插入图片描述

    demo
    比较下面两个代码的区别:

    <s:radio list="{'',''}" name="sex" label="性别" /> <br />
    
    <s:radio list="#{'1':'','2':''}" name="sex2" label="性别" /> <br>
    

    %号

    • 强制解析成OGNL,在有些标签中是不识别OGNL的,需要使用%强制解析
      demo:

      <%
          request.setAttribute("name","张三");
      %>
      
      姓名:<s:textfield name="text" value="%{#request.name}"></s:textfield>
      
    • 强制不解析OGNL表达式,在有些标签遇到OGNL表达式会自动解析,使用%可以让其不解析

      <s:property value="%{'#request.name'}"></s:property>
      

    $号

    • 在配置文件中使用OGNL

    • 属性文件:

      demo

      user.welcome=欢迎,${#session.user.username}
      
    • xml文件

      demo
      配置文件下载

      	<action name="download" class="xxx.DownloadAction">
      		<result type="stream">
      			<param name="Content-Type">文件类型</param>
      			<param name="Content-Disposition">attachment;filename=${文件名}</param>
      		</result>
      	</action>
      
    展开全文
  • Ognl

    2019-06-28 23:49:20
    目录ognl简介ognl在struts的应用案列1(OgnlContext)案列2(ValueStack) ognl简介 OGNL: ① :OGNL的全称是Object Graph Navigation Language(对象图导航语言),它是一种强大的表达式语言。 ② :OgnlContext(ongl上...

    ognl简介

    OGNL:
    :OGNL的全称是Object Graph Navigation Language(对象图导航语言),它是一种强大的表达式语言。
    :OgnlContext(ongl上下文)其实就是Map。

    ognl在struts的应用

    OgnlContext(ongl上下文)其实就是Map集合(一个上下文中只有一个根对象), OgnlContext=根对象(1)+非根对象(N),

    根对象和非根对象的理解(区别):
    1.一个上下文中只有一个根对象
    2.取根对象的值,只需要直接通过根对象属性即可
    3.非根对象取值必须通过指定的上下文容器中的#key.属性去取。

    注意:
    ActionContext一次请求创建一次
    值栈取值从上往下,取到为止,如果已经拿到,不再往下找。

    ValueStack
    先进后出的数据结构(堆栈),弹夹 push/pop

    使用ValueStack作为根对象,是因为放到值栈中的对象都可视为根对象

    首先我们来运行一下代码,看会是有什么现象

    package com.liuting.web;
    
    import javax.servlet.http.HttpServletRequest;
    
    import org.apache.struts2.ServletActionContext;
    import org.apache.struts2.interceptor.ServletRequestAware;
    
    import com.opensymphony.xwork2.ActionContext;
    import com.opensymphony.xwork2.ModelDriven;
    
    import entity.Cal;
    
    public class HelloAction implements ModelDriven<Cal>,ServletRequestAware{
    	private Cal cal1=new Cal();
    	private Cal cal2;
    	private String sex;
    	private	HttpServletRequest req;
    	private String num1;
    	
    	public String getNum1() {
    		return num1;
    	}
    
    	public void setNum1(String num1) {
    		this.num1 = num1;
    	}
    
    	public Cal getCal2() {
    		return cal2;
    	}
    
    	public void setCal2(Cal cal2) {
    		this.cal2 = cal2;
    	}
    
    	public String getSex() {
    		return sex;
    	}
    
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    
    	public String add() {
    		System.out.println("调用add方法");
    		return "rs";
    	}
    	
    	public String del() {
    		System.out.println("调用del方法");
    		return "rs";
    	}
    	/**
    	 * implements modelDriven   接受参数值
    	 * @return
    	 */
    
    	public String accept1() {
    		System.out.println("cal1"+cal1);
    		System.out.println("num1:"+num1);
    	/*	req.setAttribute("cal1", cal1);*/
    		//非注入耦合
    		HttpServletRequest request = ServletActionContext.getRequest();
    		request.setAttribute("cal1", cal1);
    		
    		/* 非注入解耦
    		ActionContext context = ActionContext.getContext();
    		context.get("xxxxxxxxxxxxxxxxx");
    		*/
    		return "rs";
    	}
    	
    	/**
    	 * 类实例、属性名             接受参数值
    	 * @return
    	 */
    	public String accept2() {
    		System.out.println("cal2"+cal2);
    		return "rs";
    	}
    
    	/**
    	 * set/get              接受参数值
    	 * @return
    	 */
    	public String accept3() {
    		System.out.println(sex);
    		return "rs";
    	}
    	@Override
    	public Cal getModel() {
    		// TODO Auto-generated method stub
    		return cal1;
    	}
    
    	@Override
    	public void setServletRequest(HttpServletRequest req) {
    		this.req=req;
    	}
    }
    
    

    在这里插入图片描述

    案列1(OgnlContext)

    OgnlContext(ongl上下文)其实就是Map (教室、老师、学生)
    根对象和非根对象的理解

    
    public class Demo1 {
    
    	/**
    	 * @param args
    	 * @throws OgnlException
    	 */
    	public static void main(String[] args)  {
    		Employee e = new Employee();
    		e.setName("小李");
    
    		Manager m = new Manager();
    		m.setName("张经理");
    
    		// 创建OGNL下文,而OGNL上下文实际上就是一个Map对象
    		OgnlContext ctx = new OgnlContext();
    
    		// 将员工和经理放到OGNL上下文当中去
    		ctx.put("employee", e);
    		ctx.put("manager", m);
    		ctx.setRoot(e);// 设置OGNL上下文的根对象
    
    		/** ********************** 取值操作 *************************** */
    		// 表达式name将执行e.getName(),因为e对象是根对象(请注意根对象和非根对象表达式的区别)
    		String employeeName = (String) OnglExpression.getValue("name", ctx, e);
    		System.out.println(employeeName);
    
    		// 表达式#manager.name将执行m.getName(),注意:如果访问的不是根对象那么必须在前面加上一个名称空间,例如:#manager.name
    		String managerName = (String) OnglExpression.getValue("#manager.name",
    				ctx, e);
    		System.out.println(managerName);
    
    		// 当然根对象也可以使用#employee.name表达式进行访问
    		employeeName = (String) OnglExpression.getValue("#employee.name", ctx,
    				e);
    		System.out.println(employeeName);
    
    		/** ********************** 赋值操作 *************************** */
    		OnglExpression.setValue("name", ctx, e, "小明");
    		employeeName = (String) OnglExpression.getValue("name", ctx, e);
    		System.out.println(employeeName);
    
    		OnglExpression.setValue("#manager.name", ctx, e, "孙经理");
    		managerName = (String) OnglExpression.getValue("#manager.name", ctx, e);
    		System.out.println(managerName);
    
    		OnglExpression.setValue("#employee.name", ctx, e, "小芳");
    		employeeName = (String) OnglExpression.getValue("name", ctx, e);
    		System.out.println(employeeName);
    	}
    
    }
    
    

    效果如下图:
    在这里插入图片描述

    案列2(ValueStack)

    public class DemoAction {
    	/**
    	 * 
    	 * 值栈的使用
    	 * 
    	 */
    	public String  test1() {
    		// 栈:表示一个先进后出的数据结构
    		ValueStack vs = ActionContext.getContext().getValueStack();
    		// push方法把项压入栈顶
    		vs.push(new Employee("zs", 22));
    		vs.push(new Employee("ls", 22));
    		vs.push(new Employee("ww", 22));
    
    		// pop方法移除栈顶对象并作为此函数的值返回该对象
    		Employee e = (Employee) vs.pop();
    		System.out.println(e.getName());
    		e = (Employee) vs.pop();
    		System.out.println(e.getName());
    		e = (Employee) vs.pop();
    		System.out.println(e.getName());
    		return "rs";
    	}
    	
    	/**
    	 * 此例用于模拟struts2的值栈计算过程
    	 * 
    	 * @param args
    	 */
    	public String test2() {
    		ValueStack vs = ActionContext.getContext().getValueStack();
    		vs.push(new Employee("张雇员", 2000));// 往ValueStack裡面放入實體類
    		vs.push(new Student("小明同学", "s001"));// 0
    		System.out.println(vs.findValue("name"));
    		System.out.println(vs.findValue("salary2"));
    
    		ActionContext ac = ActionContext.getContext();
    		return "rs";
    	}
    	
    
    }
    
    

    效果如下图:
    在这里插入图片描述

    展开全文
  • ognl

    2019-08-23 11:05:47
    1.OGNL 1.1.OGNL的全称是object Graph Navigation Language(对象图导航语言) 1.2.OgnlContext(ongl上下文)其实就是Map(教室,老师,学生) map 教室 OgnlContext=根对象(1)+非根对象(n) 老师:跟对象 ...

    1.OGNL
    1.1.OGNL的全称是object Graph Navigation Language(对象图导航语言)
    1.2.OgnlContext(ongl上下文)其实就是Map(教室,老师,学生)
    map 教室
    OgnlContext=根对象(1)+非根对象(n)
    老师:跟对象
    学生:非根对象
    非根对象要通过“#key”反问,根对象可以省略“#key”
    注意:context:英文原意上下文,环境/容器
    重点:
    1、一个上下文中只有一个根对象
    2、取跟对象的值,只需要直接通过根对象属性即可
    3、非根对象取值必须通过指定的上下文容器中的#key.属性去取。
    1、ActionContext一次请求创建一次
    2、值栈取值从上往下,取到为止,如果已经拿到,不再往下找。
    在这里插入图片描述
    2.ValueStack
    2.1 值栈
    先进后出的数据结构,弹夹 push/pop
    2.2 为什么要使用ValueStack作为根对象
    放到值栈中的对象都可视为根对象
    从小到大
    page -> request -> session -> application
    从上至下
    A
    B
    C
    D
    3. ActionContext
    3.1 ActionContext ac = ActionContext.getContext();//保证同一请求中只创建一个上下文

           request
           session
           application
           parameters
           ValueStack(root)
    

    3.2 向ValueStack压栈
    push(XxxAction)//helloAction *action
    push(ModelDirver.getModel())//model不为null user

    3.3 Map<String,String[]> map = request.getParamterMap(); 压action代码详解
    //参数名==OGNL表达式
    {“userName”:“aaa”,“uname”:“bbb”,“upwd”:“ccc”,“age”:“22”}

      setValue("userName", ac, vs, "aaa");
      setValue("uname", ac, vs, "bbb");
      setValue("upwd", ac, vs, "ccc");
      setValue("age", ac, vs, "22");
    

    4. struts2中传递数据
    可以使用作用域,但更多的是利用ValueStack或ActionContext

    下面就是一些具体的案例
    实体类
    Student

    package com.yq.test;
    
    public class Student {
    	private String name;
    
    	private String number;
    
    	public Student() {
    		super();
    	}
    
    	public Student(String name, String number) {
    		super();
    		this.name = name;
    		this.number = number;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public String getNumber() {
    		return number;
    	}
    
    	public void setNumber(String number) {
    		this.number = number;
    	}
    
    	@Override
    	public String toString() {
    		return "Student [name=" + name + ", number=" + number + "]";
    	}
    
    }
    
    在这里插入代码片
    

    Manager

    package com.yq.test;
    
    public class Manager {
    	private String name;
    
    	public Manager() {
    		super();
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public String toString() {
    		return "Manager [name=" + name + "]";
    	}
    
    }
    
    在这里插入代码片
    

    Employee

    package com.yq.test;
    
    public class Employee {
    	private String name;
    
    	private Address address;
    
    	private Integer salary;
    
    	public Employee() {
    		super();
    	}
    
    	public Employee(String name, Integer salary) {
    		super();
    		this.name = name;
    		this.salary = salary;
    	}
    
    	public Integer getSalary() {
    		return salary;
    	}
    
    	public void setSalary(Integer salary) {
    		this.salary = salary;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Address getAddress() {
    		return address;
    	}
    
    	public void setAddress(Address address) {
    		this.address = address;
    	}
    
    	@Override
    	public String toString() {
    		return "Employee [name=" + name + ", address=" + address + ", salary=" + salary + "]";
    	}
    
    }
    
    在这里插入代码片
    

    Address

    package com.yq.test;
    
    public class Address {
    	private String city;
    
    	private String country;
    
    	public Address() {
    		super();
    	}
    
    	public Address(String city, String country) {
    		super();
    		this.city = city;
    		this.country = country;
    	}
    
    	public String getCity() {
    		return city;
    	}
    
    	public void setCity(String city) {
    		this.city = city;
    	}
    
    	public String getCountry() {
    		return country;
    	}
    
    	public void setCountry(String country) {
    		this.country = country;
    	}
    
    	@Override
    	public String toString() {
    		return "Address [city=" + city + ", country=" + country + "]";
    	}
    
    }
    
    在这里插入代码片
    

    OnglExpression

    package com.yq.test;
    
    import ognl.Ognl;
    import ognl.OgnlContext;
    import ognl.OgnlException;
    
    /**
     * 用于OGNL表达计算的一个工具类
     * 
     */
    public class OnglExpression {
    	private OnglExpression() {
    	}
    
    	/**
    	 * 根据OGNL表达式进行取值操作
    	 * 
    	 * @param expression
    	 *            ognl表达式
    	 * @param ctx
    	 *            ognl上下文
    	 * @param rootObject
    	 *            ognl根对象
    	 * @return
    	 */
    	public static Object getValue(String expression, OgnlContext ctx,
    			Object rootObject) {
    		try {
    			return Ognl.getValue(expression, ctx, rootObject);
    		} catch (OgnlException e) {
    			throw new RuntimeException(e);
    		}
    	}
    
    	/**
    	 * 根据OGNL表达式进行赋值操作
    	 * 
    	 * @param expression
    	 *            ognl表达式
    	 * @param ctx
    	 *            ognl上下文
    	 * @param rootObject
    	 *            ognl根对象
    	 * @param value
    	 *            值对象
    	 */
    	public static void setValue(String expression, OgnlContext ctx,
    			Object rootObject, Object value) {
    		try {
    			Ognl.setValue(expression, ctx, rootObject, value);
    		} catch (OgnlException e) {
    			throw new RuntimeException(e);
    		}
    	}
    }
    
    在这里插入代码片
    

    测试类

    package com.yq.test;
    
    import ognl.OgnlContext;
    import ognl.OgnlException;
    
    public class Demo1 {
    
    	/**
    	 * @param args
    	 * @throws OgnlException
    	 */
    	public static void main(String[] args)  {
    		Employee e = new Employee();
    		e.setName("小李");
    
    		Manager m = new Manager();
    		m.setName("张经理");
    
    		// 创建OGNL下文,而OGNL上下文实际上就是一个Map对象
    		OgnlContext ctx = new OgnlContext();
    
    		// 将员工和经理放到OGNL上下文当中去
    		ctx.put("employee", e);
    		ctx.put("manager", m);
    		ctx.setRoot(e);// 设置OGNL上下文的根对象
    
    		/** ********************** 取值操作 *************************** */
    		// 表达式name将执行e.getName(),因为e对象是根对象(请注意根对象和非根对象表达式的区别)
    		String employeeName = (String) OnglExpression.getValue("name", ctx, e);
    		System.out.println(employeeName);
    
    		// 表达式#manager.name将执行m.getName(),注意:如果访问的不是根对象那么必须在前面加上一个名称空间,例如:#manager.name
    		String managerName = (String) OnglExpression.getValue("#manager.name",
    				ctx, e);
    		System.out.println(managerName);
    
    		// 当然根对象也可以使用#employee.name表达式进行访问
    		employeeName = (String) OnglExpression.getValue("#employee.name", ctx,
    				e);
    		System.out.println(employeeName);
    
    		/** ********************** 赋值操作 *************************** */
    		OnglExpression.setValue("name", ctx, e, "小花");
    		employeeName = (String) OnglExpression.getValue("name", ctx, e);
    		System.out.println(employeeName);
    
    		OnglExpression.setValue("#manager.name", ctx, e, "赵经理");
    		managerName = (String) OnglExpression.getValue("#manager.name", ctx, e);
    		System.out.println(managerName);
    
    		OnglExpression.setValue("#employee.name", ctx, e, "小虾");
    		employeeName = (String) OnglExpression.getValue("name", ctx, e);
    		System.out.println(employeeName);
    	}
    
    }
    
    在这里插入代码片
    

    在这里插入图片描述
    Demo7

    package com.yq.test;
    
    import com.opensymphony.xwork2.ActionContext;
    import com.opensymphony.xwork2.ognl.OgnlValueStack;
    import com.opensymphony.xwork2.util.ValueStack;
    
    public class Demo7 {
    	/**
    	 * 
    	 * 值栈的使用
    	 * 
    	 */
    	public String test1() {
    		// 栈:表示一个先进后出的数据结构
    		ValueStack vs = ActionContext.getContext().getValueStack();
    		// push方法把项压入栈顶
    		vs.push(new Employee("zs", 22));
    		vs.push(new Employee("ls", 22));
    		vs.push(new Employee("ww", 22));
    
    		// pop方法移除栈顶对象并作为此函数的值返回该对象
    		Employee e = (Employee) vs.pop();
    		System.out.println(e.getName());
    		e = (Employee) vs.pop();
    		System.out.println(e.getName());
    		e = (Employee) vs.pop();
    		System.out.println(e.getName());
    		return "rs";
    	}
    
    	/**
    	 * 此例用于模拟struts2的值栈计算过程
    	 * 
    	 * @param args
    	 */
    	public String test2() {
    		ValueStack vs = ActionContext.getContext().getValueStack();
    		vs.push(new Employee("张雇员", 2000));// 1
    		vs.push(new Student("小明同学", "s001"));// 0
    		System.out.println(vs.findValue("name"));//小明同学
    		System.out.println(vs.findValue("salary"));//2000
    		System.out.println(vs.findValue("salary2"));//
    
    		ActionContext ac = ActionContext.getContext();
    		return "rs";
    	}
    }
     
    在这里插入代码片
    

    在struts_sy.xml配置

    <action name="ognl_*" class="com.yq.test.Demo7" method="{1}">
    	<result name="rs">/rs.jsp</result>
    	</action>
    在这里插入代码片
    

    jsp页面

    <h3>讲解ognl值栈</h3>
    <a href="${pageContext.request.contextPath}/sy/ognl_test1.action">测试7</a>
    <a href="${pageContext.request.contextPath}/sy/ognl_test2.action">测试8</a>
    在这里插入代码片
    

    在这里插入图片描述
    测试7
    在这里插入图片描述
    测试8

    在这里插入图片描述

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,605
精华内容 5,042
热门标签
关键字:

OGNL