struts2学习笔记(五)—— OGNL

一、OGNL概述

1.1 什么是OGNL

  OGNL的全称是对象图导航语言( object-graph Navigation Language),它是一种功能强大的开源表达式语言,使用这种表达式语言,可以通过某种表达式语法,存取Java对象的任意属性,调用Java对象的方法,同时能够自动实现必要的类型转换。如果把表达式看作是一个带有语义的字符串,那么OGNL无疑成为了这个语义字符串与Java对象之间沟通的桥梁。

1.2 OGNL的作用

  Struts2默认的表达式语言就是OGNL,它具有以下特点:

    ● 支持对象方法调用。例如: objName. methodName( )。

    ● 支持类静态方法调用和值访问,表达式的格式为@[类全名(包括包路径)]@[ 方法名|值名 ]。例如:@java.lang.String@format( "foo%s","bar")。

    ● 支持赋值操作和表达式串联,例如: price=100, discount=0.8, calculatePrice( ),在方法中进行乘法计算会返回80。

    ● 访问OGNL上下文( OGNL context)和 ActionContext。

    ● 操作集合对象。

1.3 OGNL的要素

  了解什么是OGNL及其特点后,接下来,分析一下OGNL的结构。OGNL的操作实际上就是围绕着OGNL结构的三个要素而进行的,分别是表达式(Expression)、根对象(Root Object)、上下文环境(Context),下面分别讲解这三个要素,具体如下:

  1、表达式
  表达式是整个OGNL的核心,OGNL会根据表达式去对象中取值。所有OGNL操作都是针对表达式解析后进行的。它表明了此次OGNL操作要”做什么”。表达式就是一个带有语法含义的字符串,这个字符串规定了操作的类型和操作的内容。OGNL支持大量的表达式语法,不仅支持这种”链式”对象访问路径,还支持在表达式中进行简单的计算。
  2、根对象(Root)
Root对象可以理解为OGNL的操作对象,表达式规定了”做什么”,而Root对象则规定了”对谁操作”。OGNL称为对象导航语言,所谓对象图,即以任意一个对象为根,通过OGNL可以访问与这个对象关联的其他对象。
  3、Context对象
实际上OGNL的取值还需要一个上下文环境。设置了Root对象,OGNL可以对Root对象进行取值或写值等操作,Root对象所在环境就是OGNL的上下文环境(Context)。上下文环境规定了OGNL的操作”在哪里进行”。上下文环境Context是一个Map类型的对象,在表达式中访问Context中的对象,需要使用”#”号加上对象名称,即”#对象名称”的形式。

  总结来说:OGNL是一种表达式语言,之前我们学过el表达式,el表达式用于在JSP页面中获取域对象里面的值,但OGNL表达式比el表达式功能更加强大,我们使用OGNL表达式主要做的事情是在Struts2里面获取值栈中的数据(OGNL在Struts2里面经常和Struts2标签一起使用)。这就是我们接下来要重点讲解的内容,即在Struts2里面如何获取值栈中数据。

  我们还需要注意一点:OGNL本身不是Struts2框架的一部分,而是一个单独的项目,只不过它经常和Struts2框架一起使用而已。要使用OGNL表达式,首先要导入Jar包,Struts2的包中已经包含了OGNL表达式的Jar包:,所以不需要导入额外的jar包。

二、OGNL的入门

2.1 取值环境

  OGNL表达式作为一种与EL表达式性质相同的语言,主要都是用于取值的语言。我们首先要给这个语言的取值准备一个取值的环境。

  我们先回顾一下EL表达式的取值环境。EL表达式的取值范围是11大内置对象,分别为:requestScope,sessionScope,applicationScope,pageScopepageContext,param,paramValues,header,headerValues,cookie,initParam。 

  那么OGNL的取值环境在哪呢?我们需要给它准备一个对象OgnlContext,你写OGNL表达式的时候,就会从OgnlContext这个对象中取值。OgnlContext由两部分构成:一部分是Root,可以放置任何对象作为root,在整个OgnlContext中有且最多只能有一个根对象,可以通过调用OgnlContext.setRoot(obj)设置为根对象;一部分是Context,这里必须是Map,即键值对的形式存放。OGNL就在ROOT和Context这两部分中取值。

  

2.2 语法

  • 取值
    public void demo1() throws Exception {
            // 准备OGNLContext
            // 准备Root
            User rootUser = new User("tom", 18);
            // 准备Context
            Map<String, User> context = new HashMap<>();
            context.put("user1", new User("jack", 20));
            context.put("user2", new User("rose", 24));
            // OgnlContext实现了Map接口
            OgnlContext ognlContext = new OgnlContext();
            // 将rootUser作为Root部分
            ognlContext.setRoot(rootUser);
            // 将Context这个Map作为Context部分
            ognlContext.setValues(context);
            // -----------------------------------------------------
            /*
             *  public static Object getValue(String expression, Map context, Object root){...}
             * 书写OGNL Ognl.getValue(expression, context, root); 
             * expression:表明这次OGNL操作要"做什么" 
             * context:规定OGNL的操作"在哪里进行"
             * root:规定"对谁操作"
             */
            // 取出Root中user对象的name属性
            String name = (String) Ognl.getValue("name", ognlContext, ognlContext.getRoot());
            Integer age = (Integer) Ognl.getValue("age", ognlContext, ognlContext.getRoot());
            System.out.println(name);
            System.out.println(age);
    
            // -----------------------------------------------------------------
            // 取出Context中键为user1对象的name属性
            String name1 = (String) Ognl.getValue("#user1.name", ognlContext, ognlContext.getRoot());
            String name2 = (String) Ognl.getValue("#user2.name", ognlContext, ognlContext.getRoot());
            Integer age1 = (Integer) Ognl.getValue("#user1.age", ognlContext, ognlContext.getRoot());
            System.out.println(name1);// jack
            System.out.println(name2);// rose
            System.out.println(age1);// 20
        }

   Ognl在解析表达式的时候如果发现表达式开头带有"#",会去context对象中寻找;如果没有"#",则会默认去根对象中去寻找,由于根对象只有一个,所以只需要属性名字。

  • 赋值
    public void demo2() throws Exception {
            // 准备OGNLContext
            // 准备Root
            User rootUser = new User("tom", 18);
            // 准备Context
            Map<String, User> context = new HashMap<>();
            context.put("user1", new User("jack", 20));
            context.put("user2", new User("rose", 24));
            OgnlContext ognlContext = new OgnlContext();
            // 将rootUser作为Root部分
            ognlContext.setRoot(rootUser);
            // 将Context这个Map作为Context部分
            ognlContext.setValues(context);
            
            //----------------------------------------------
            // 为root中的user对象的name属性赋值
            Ognl.getValue("name='mike'", ognlContext, ognlContext.getRoot());
            String name = (String) Ognl.getValue("name", ognlContext, ognlContext.getRoot());
            System.out.println(name); //mike
            
            // 为context中的user1对象的name属性赋值
            /*Ognl.getValue("#user1.name='jerry'", ognlContext, ognlContext.getRoot());
            String name1 = (String) Ognl.getValue("#user1.name", ognlContext, ognlContext.getRoot());*/
            // 上述表达式可以合并为:
            String name1 = (String) Ognl.getValue("#user1.name='jerry',#user1.name", ognlContext, ognlContext.getRoot());
            System.out.println(name1);
        }
  • 调用方法
    public void demo3() throws Exception {
            // 准备OGNLContext
            // 准备Root
            User rootUser = new User("tom", 18);
            // 准备Context
            Map<String, User> context = new HashMap<>();
            context.put("user1", new User("jack", 20));
            context.put("user2", new User("rose", 24));
            OgnlContext ognlContext = new OgnlContext();
            // 将rootUser作为Root部分
            ognlContext.setRoot(rootUser);
            // 将Context这个Map作为Context部分
            ognlContext.setValues(context);
            
            //-------------------------------------------
            // 调用root中user对象的setName方法
            Ognl.getValue("setName('lucy')", ognlContext, ognlContext.getRoot());
            String name = (String) Ognl.getValue("getName()", ognlContext, ognlContext.getRoot());
            System.out.println(name); //lucy
            
            // 调用context中user1对象的setName方法
            String name1 = (String) Ognl.getValue("#user1.setName('kobe'),#user1.getName()", ognlContext, ognlContext.getRoot());
            System.out.println(name1);
        }
  • 调用静态方法
    public void demo4() throws Exception {
            OgnlContext context = new OgnlContext();
            // @类的全路径名@方法名称(参数列表)
            Object value = Ognl.getValue("@java.lang.Math@random()", context, context.getRoot());
            // @类的全路径名@属性名称
            Double pi = (Double) Ognl.getValue("@java.lang.Math@PI", context, context.getRoot());
            System.out.println(value);
            System.out.println(pi);
        }
  • 创建对象(list,map)
    public void demo5() throws Exception {
            // 准备OGNLContext
            // 准备Root
            User rootUser = new User("tom", 18);
            // 准备Context
            Map<String, User> context = new HashMap<>();
            context.put("user1", new User("jack", 20));
            context.put("user2", new User("rose", 24));
            OgnlContext ognlContext = new OgnlContext();
            // 将rootUser作为Root部分
            ognlContext.setRoot(rootUser);
            // 将Context这个Map作为Context部分
            ognlContext.setValues(context);
    
            // -------------------------------------------
            // 创建list对象
            Integer size = (Integer) Ognl.getValue("{'tom','jerry','jack'}.size()", ognlContext, ognlContext.getRoot());
            System.out.println(size);//3
            String name1 = (String) Ognl.getValue("{'tom','jerry','jack'}[0]", ognlContext, ognlContext.getRoot());
            System.out.println(name1);//tom
            String name2 = (String) Ognl.getValue("{'tom','jerry','jack'}.get(1)", ognlContext, ognlContext.getRoot());
            System.out.println(name2);//jerry
            //----------------------------------------------------
            // 创建map对象
            // 这里的#号表示创建的是map对象,不是从context中取值的#
            Integer size2 = (Integer) Ognl.getValue("#{'name':'tom','age':18}.size()", ognlContext, ognlContext.getRoot());
            System.out.println(size2);//2
            String name3 = (String) Ognl.getValue("#{'name':'tom','age':18}['name']", ognlContext, ognlContext.getRoot());
            System.out.println(name3);//tom
            Integer age = (Integer) Ognl.getValue("#{'name':'tom','age':18}.get('age')", ognlContext, ognlContext.getRoot());
            System.out.println(age);
        }

三、OGNL与Struts2的结合

3.1 结合原理

  OGNL表达式不管是自己单独拿来用,还是与struts2结合来用,一定要给它提供一个OgnlContext对象(root+context)。我们学习struts2与ognl结合,其实学的就是struts2分别给root部分和context部分准备了什么东西。struts2为OGNL准备的OgnlContext对象是一个ValueStack(值栈),可以简单的理解为OgnlContext在struts2中改名为ValueStack了。ValueStack由两部分组成,一部分叫做Root,放置的是一个栈;一部分是Context,放置的是ActionContext数据中心。

  

3.2 ValueStack

  

  ValueStack是Struts2的一个接口,字面意义为值栈,而OgnlValueStack是它的唯一实现类 

  

  在这个类中,有两个属性CompoundRoot root;和Map<String, Object> context;分别与上图对应

  

  CompoundRoot其实就是一个栈:

  

  context部分就是ActionContext数据中心(request、response、ServletContext、requestScope、sessionScope、applicationScope、params、attrs)

  客户端发起一个请求时,Struts2框架会创建一个Action实例,同时创建一个OgnlValueStack值栈实例,OgnlValueStack贯穿整个Action的生命周期,Struts2中使用OGNL将请求Action的参数封装为对象存储到值栈中,并通过OGNL表达式读取值栈中的对象属性值。 取栈的属性值时,会从栈顶开始寻找,如果栈顶对象不存在该属性,就会从第二个对象寻找,如果没有找到就从第三个对象寻找,依次往下访问,直到找到为止。

  值栈的作用:在我们访问一个action时,会将action加入到栈顶,也就是action会在CompoundRoot的栈顶,而我们提交的各种表单参数(充当了ognl表达式)会在valueStack从顶向下查找对应的属性进行赋值。

3.2.1 使用<debug>查看值栈中两部分内容

  (1)创建一个Action类——ValueStackAction

public class ValueStackAction extends ActionSupport{

    @Override
    public String execute() throws Exception {
        return SUCCESS;
    }
}

  (2)在struts.xml中配置该Action类

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">

<struts>
    <!-- 配置一个包:package -->
    <package name="demo" namespace="/" extends="struts-default">
        <action name="ValueStackDemo" class="cn.itcast.action.ValueStackAction">
            <result name="success">valueStack.jsp</result>
        </action>
    </package>
</struts>

  (3)创建valueStack.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="/struts-tags" prefix="s" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <!-- 使用这个标签可以看到值栈内部结构 -->
    <s:debug></s:debug>
</body>
</html>

  (4)访问http://localhost:8080/struts2-02/ValueStackDemo.action后,看到如下界面

    

  (5)点击这个[Debug]即可看到值栈的结构

  

 3.2.2 向值栈中存取数据

【方式一:获取值栈对象,调用值栈对象里面的set方法】

  • 使用set方法存数据
    public class ValueStackAction extends ActionSupport {
    
        @Override
        public String execute() throws Exception {
            // 获取ActionContext对象
            ActionContext context = ActionContext.getContext();
            // 获取ValueStack对象
            ValueStack stack = context.getValueStack();
            /*
             * 使用set方法存数据
             * set方法的第一个值:保存的数据的名字,在页面中取数据时使用该名字来取数据
             * set方法的第二个值:要在页面中展示的值
             */
            stack.set("name", "张三");
            return SUCCESS;
        }
    }

    

  • 在页面取set方法存的数据

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <%@ taglib uri="/struts-tags" prefix="s"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
        <!-- 使用这个标签可以看到值栈内部结构 -->
        <s:debug></s:debug>
    
        <!-- 
            1、ognl表达式必须要在struts2标签中使用 
            2、在ognl表达式中可以直接调用Java的方法
            3、value的值就是ognl表达式,就是在set方法中保存数据时的第一个参数的值 name: 
        -->
        <s:property value="name" />
    </body>
    </html>

【方式二:获取值栈对象,调用值栈对象里面的push方法】

  • 使用push方法存数据
    public class ValueStackAction extends ActionSupport {
    
        @Override
        public String execute() throws Exception {
            // 获取ActionContext对象
            ActionContext context = ActionContext.getContext();
            // 获取ValueStack对象
            ValueStack stack = context.getValueStack();
             
            /*
             * 使用push方法存数据
             * push方法的值:保存的数据.
             */
            stack.push("李四");
            return SUCCESS;
        }
    }

  

  • 在页面取push方法存的数据

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <%@ taglib uri="/struts-tags" prefix="s"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
        <!-- 使用这个标签可以看到值栈内部结构 -->
        <s:debug></s:debug>
    
        <!--
            1、ognl表达式必须要在struts2标签中使用
            2、在ognl表达式中可以直接调用Java的方法
            3、value的值就是ognl表达式.
            4、push存的数据在值栈中是以数组的方式来存放的
            5、数组的名字是固定的。就是top
            6、在Java中数组的第一个值是top[0],但是在ognl表达式中为[0].top
         -->
        name:<s:property value="[0].top"/>
    </body>
    </html>

【方式三:在action成员变量位置定义变量,生成这个变量的get方法(重点)

  • 存取字符串:

  (1)往值栈存字符串

public class ValueStackAction extends ActionSupport {

    // 存放字符串数据
    // 创建一个字符串对象
    private String name;

    // 创建该对象的getter方法
    public String getName() {
        return name;
    }

    public String execute() {
        // 对字符串对象赋值
        name = "王五";
        return SUCCESS;
    }
}

 

  (2)从值栈中读取字符串

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
    <!--要使用struts2标签,必须要引入struts2标签库 -->
<%@ taglib uri="/struts-tags" prefix="s"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <!--
        1、ognl表达式必须要在struts2标签中使用
        2、在ognl表达式中可以直接调用Java的方法
        3、value的值就是ognl表达式.是Action中字符串对象的名字
     -->
    name:<s:property value="name"/>
</body>
</html>  
  • 存取对象

  (1)往值栈中存入对象

public class ValueStackAction extends ActionSupport {

    // 保存对象到值栈中
    // 创建实体对象
    private User user = new User();
    
    public User getUser() {
        return user;
    }

    @Override
    public String execute() throws Exception {
        // 给对象的属性赋值
        user.setName("刘备");
        user.setAge(20);
        return SUCCESS;
    }
}

  (2)从值栈中读取对象

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ taglib uri="/struts-tags" prefix="s"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <!-- 使用这个标签可以看到值栈内部结构 -->
    <s:debug></s:debug>

    <!--
        1、ognl表达式必须要在struts2标签中使用
        2、在ognl表达式中可以直接调用Java的方法
        3、value的值就是ognl表达式.
        4、表达式的值为:对象实例名称.对象属性名称
     -->
    name:<s:property value="user.name"/>
    age:<s:property value="user.age"/>
</body>
</html>
  • 存取list集合

  (1)往值栈存list集合

public class ValueStackAction extends ActionSupport {

    // 往值栈中存放list集合数据
    // 声明一个list对象
    private List<User> list = new ArrayList<>();
    public List<User> getList() {
        return list;
    }

    @Override
    public String execute() throws Exception {
        // 创建对象,并设置属性值
        User user1 = new User("关羽", 18);
        User user2 = new User("张飞", 21);
        // 将对象放入list中
        list.add(user1);
        list.add(user2);
        return SUCCESS;
    }
}

  (2)从值栈中读取list集合(四种方式)

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%--要使用struts2标签,必须要引入struts2标签库 --%>
<%@ taglib uri="/struts-tags" prefix="s"%>
<%--要使用jstl标签,必须要引入jstl标签库 --%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    <!-- 使用这个标签可以看到值栈内部结构 -->
    <s:debug></s:debug>

    <!--
        第一种读取方式
        value的值:list[0]表示集合中的第一个对象
        表达式:Action中的集合名称[第几个对象].对象的属性名称
        缺点:要知道集合中对象的个数,如果个数太多,则代码太长
     -->
    name:<s:property value="list[0].name" />
    age:<s:property value="list[0].age" />

    name:<s:property value="list[1].name" />
    age:<s:property value="list[1].age" />
    <br>

    <!--
        第二种读取方式
        该方式使用struts2的<s:iterator>标签来读取
        <iterator>标签中value的值:Action中的集合名称
        <property>标签中value的值:对象的属性名称
      -->
    <s:iterator value="list">
        name:<s:property value="name" />
        age:<s:property value="age" />
    </s:iterator>
    <br>

    <!--
        第三种读取方式
        该方式使用struts2的<s:iterator>标签来读取
        <iterator>标签中value的值:Action中的集合名称
        <iterator>标签中var的值:相当于遍历时的每一个对象的名称
        <property>标签中value的值:#var属性的值.对象属性的值
        机制:遍历list集合。得到list集合中的每一个对象,将对象以map的方式保存到context中
        key就是var属性的值,值是每一个对象的引用。
        在ognl表达式中要访问context中的数据时,要在表达式前面加上#
    -->
    <s:iterator value="list" var="user"> 
        name:<s:property value="#user.name" />
        age:<s:property value="#user.age" />
    </s:iterator>
    <br>

    <!--
        第四种读取方式
        该方式使用jstl的<c:foreach>标签来读取
        <c:forEach>标签中value的值:Action中的集合名称
        <c:forEach>标签中var的值:相当于遍历时的每一个对象的名称
         
        el表达式能取到值栈数据的原因:struts2底层增强了request的setAttribute方法,
        在增强中,首先去域对象中取值,如果在域对象中没有取到值,就去值栈中取值,将从值栈
        中取到的值保存到域对象中返回。
             
        缺点:需要先去域对象中取值,没有才去值栈中取值,取到后又要保存到域对象中返回,所有效率不高
        一般不使用此方法
    -->
    <c:forEach items="${list }" var="user">
        name:${user.name }
        age:${user.age }
    </c:forEach>

</body>
</html>

四、struts2标签库

  Struts2中OGNL表达式必须配合Struts2标签使用,不然没什么效果

  对于一个MVC框架而言,重点是实现两部分:业务逻辑控制器部分和视图页面部分。Struts2作为一个优秀的MVC框架,也把重点放在了这两部分上。控制器主要由Action来提供支持,而视图则是由大量的标签来提供支持。

4.1 Struts2标签库概述

  在JavaWeb中,Struts2标签库是一个比较完善,而且功能强大的标签库,它将所有标签都统一到一个标签库中,从而简化了标签的使用,它还提供主题和模板的支持,极大地简化了视图页面代码的编写,同时它还提供对ajax的支持,大大的丰富了视图的表现效果。与JSTL(JSP Standard Library,JSP 标准标签库)相比,Struts2标签库更加易用和强大。

4.2 Struts2标签库的分类

  早期的JSP页面需要嵌入大量的Java脚本来进行输出,这样使得一个简单的JSP页面加入了大量的代码,不利于代码的可维护性和可读性。随着技术的发展,逐渐的采用标签库来进行JSP页面的开发,这使得JDP页面能够在很短的时间内开发完成,而且代码通俗易懂,大大的方便了开发者,Struts2的标签库就是这样发展起来的。

  Struts2框架对整个标签库进行了分类,按其功能大致可分为两类,如图所示。

  

  

  由图中可以看出, Struts2标签库主要分为两类:普通标签和UI标签。普通标签主要是在页面生成时,控制执行的流程。UI标签则是以丰富而可复用的HTML文件来显示数据。

  普通标签又分为控制标签( Control Tags)和数据标签( Data Tags)。控制标签用来完成条件逻辑、循环逻辑的控制,也可用来做集合的操作。数据标签用来输出后台的数据和完成其他数据访问功能。

  UI标签又分为表单标签( Form Tags)、非表单标签( non-form Tags)和Ajax标签。表单标签主要用来生成HTML页面中的表单元素,非表单标签主要用来生成HTML的<div>标签及输出 Action中封装的信息等。Ajax标签主要用来提供Ajax技术支持。

4.3 Struts2标签的使用

  Struts2标签库被定义在 struts-tags tld文件中,我们可以在 struts-core-2.3.24jar中的META-INF目录下找到它。要使用 struts2的标签库,一般只需在JsP文件使用 taglib指令导入 Struts2标签库,具体代码如下:

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

  在上述代码中, taglib指令的uri属性用于指定引入标签库描述符文件的URI, prefix属性用于指定引入标签库描述符文件的前缀。需要注意的是,在JSP文件中,所有的 Struts2标签库的使用“s”前缀。  

4.4 控制标签

<!-- 遍历标签 iterator -->
<!-- ------------------------------------- -->
<s:iterator value="#list" >
    <s:property /><br>
</s:iterator>
<!-- ------------------------------------- --><hr>
<s:iterator value="#list" var="name" >
    <s:property value="#name" /><br>
</s:iterator>
<!-- ------------------------------------- --><hr>
<s:iterator begin="1" end="100" step="1"  >
    <s:property />|
</s:iterator>
<!-- ------------------if else elseif------------------- --><hr>

<s:if test="#list.size()==4">
    list长度为4!
</s:if>
<s:elseif test="#list.size()==3">
    list长度为3!
</s:elseif>
<s:else>
    list不3不4!
</s:else>

4.5 数据标签

<!-- ------------------property 配合ognl表达式页面取值 ------------------- -->
<s:property value="#list.size()" />
<s:property value="#session.user.name" />

4.6 表单标签

  <!-- struts2表单标签 -->
    <!-- 好处1: 内置了一套样式.  -->
    <!-- 好处2: 自动回显,根据栈中的属性  -->
    <!-- theme:指定表单的主题
            xhtml:默认
            simple:没有主题
     -->
    <s:form action="Demo3Action" namespace="/" theme="xhtml" >
        <s:textfield name="name" label="用户名"  ></s:textfield>
        <s:password name="password" label="密码" ></s:password>
        <s:radio list="{'男','女'}" name="gender" label="性别" ></s:radio>
        <s:radio list="#{1:'男',0:'女'}" name="gender" label="性别" ></s:radio>
        <s:checkboxlist list="#{2:'抽烟',1:'喝酒',0:'烫头'}" name="habits" label="爱好" ></s:checkboxlist>
        <s:select list="#{2:'大专',1:'本科',0:'硕士'}" headerKey="" headerValue="---请选择---" name="edu" label="学历" >
        </s:select>
        <s:file name="photo" label="近照" ></s:file>
        <s:textarea name="desc" label="个人简介" ></s:textarea>
        <s:submit value="提交" ></s:submit>
    </s:form>

4.7 非表单标签

<s:actionerror/>
posted @ 2019-01-16 13:14  yi0123  阅读(465)  评论(0编辑  收藏  举报