精华内容
下载资源
问答
  • struts2标签库struts2标签库struts2标签库struts2标签库
  • struts2标签库

    2019-06-20 16:16:37
    struts2标签库介绍: struts2标签库不依赖任何表现层技术,其提供的大部分标签,可以在各种表现层技术中使用,分为两大类:UI标签和非UI标签,UI标签由于生成html元素标签,非UI标签用于数据访问、逻辑控制等。 UI...

    struts2标签库介绍:
    struts2标签库不依赖任何表现层技术,其提供的大部分标签,可以在各种表现层技术中使用,分为两大类:UI标签和非UI标签,UI标签由于生成html元素标签,非UI标签用于数据访问、逻辑控制等。
    UI标签分为两类:表单标签(用于生成form元素,普通表单元素的标签)和非表单标签(生成页面树,Tab页等标签),非UI标签也分为两类:流程控制标签(实现分支、循环登录流程控制标签)和数据访问标签(输出ValueStack中的值,完成国家化等功能的标签)。

    struts2的标签库定义文件位于struts2-core-XXX.jar的META_INF文件下,文件名为:struts-tag.tld。可查看该文件定义的标签库。在jsp中使用struts2标签库:

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

    使用具体标签:

    <s:xxx .../>
    

    OGNL表达式语言介绍:
    OGNL是一种数据访问语言,用于访问对象,数组,集合,OGNL会假设只有一个"根"对象。
    eg1,访问方法:

    #foo.blah//返回foo.getBlah()方法的返回值
    #bar.blah//返回bar.getBlah()方法的返回值
    #blah//返回foo.getBlah()方法的返回值
    #bar.foo.blah//返回bar.getFoo().getBalh()方法的返回值
    

    eg2:访问实例属性:

    #person.name
    

    eg3:索引访问:

    [0].name
    [1].name
    

    eg4:命名对象属性访问:

    #parameters.xxx//用于访问HTTP请求参数
    #request.xxx//用于访问HTTPServletRequest属性
    #session.xxx//用于访问HttpSession属性
    #attr.xxx//依次搜索PageContext、HTTPServletRequest、HttpSession、ServletContext中的属性
    

    OGNL中集合操作:
    创建List类型集合语法:
    #{e1,e2,e3…}
    创建Map类型集合语法:
    #{key1:value1,key2,value2…}

    访问静态成员:
    OGNL默认不能访问静态方法,若要访问静态,应开启:

    <constant name="struts.ognl.allowStaticMethodAccess" value="true">
    

    开启后则可以通过语法访问:
    @类名@静态方法(参数…)
    jsp访问示例:

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

    控制标签:
    if:用于控制选择输出标签
    elseIf/elseif:与if标签结合使用
    else:与if标签结合使用
    append:用于将多个集合拼接成一个新的集合
    generator:字符串解析器,将一个字符串解析成一个集合
    iterator:迭代器,用于将集合迭代输出
    merge:用于将多个集合拼接成一个新集合
    sort:用于对集合进行排序
    subset:截取集合部分元素,形成新的子集合

    数据标签:
    aciton:用于在jsp页面直接调用一个Action,通过指定executeResult参数,可以将Action处理结果包含到本页面中
    bean:用于创建JavaBean实例,如果指定了var属性,可以将创建的JavaBean实例放入Stack Context中
    date:用于格式化输出一个日期
    debug:用于在页面生成一个调试链接,单击该链接,可以看到当前ValueStack和Stack Context中的内容
    i18n:指定国际化资源文件的baseName
    include:用于在jsp页面中包含其他的jsp或Servlet资源
    param:用于设置一个参数,通常用于bean标签、url标签的子标签
    push:将某个值放入ValueStack的栈顶
    set:设置新变量
    text:输出国际化消息
    url:生成一个URL地址
    property:用于输出某个值,包括输出ValueStack、Stack Context和Action Context中的值

    主题和模板:
    所有的Struts2标签都是基于主题和模板的,对于一个jsp页面包含的UI标签,既可以直接设置该UI标签需要使用的模板,也可以设置该UI标签使用的主题,建议界面开发选择特定主题,而不是强制使用特定模板表现UI标签。主题是模板的组织形式,模板被包装在主题里面,设置主题方法有如下几种:
    1.通过特定UI标签上的theme属性指定主题
    2.通过设定特定UI标签外围的<s:form…/>标签的theme属性来指定主题
    3.通过page会话范围内的theme属性来确定主题
    4.通过request会话范围内的theme属性来确定主题
    5.通过session会话范围内的theme属性来确定主题
    6.通过application会话范围内的theme属性来确定主题
    7.通过设置名为Struts.ui.theme常量确定,该常量可以通过struts.properties文件或者struts.xml文件确定
    优先级从1-7是从大到小,比如如果设置了page和struts.xml,则主题是page设置的主题
    关于模板的加载:
    struts2的模板目录是通过struts.ui.templateDir常量指定,默认值为template,即会从Web应用的template目录、CLAASSPATH(包括WEB-INF/classes和WEB-INF/lib路径)的template目录一次加载特定模板文件,如果要选择自己的模板技术,可通过修改struts.ui.templateSuffix常量的值为:
    1.ftl:基于FreeMarker的模板技术
    2.vm:基于Velocity的模板技术
    3.jsp:基于JSP的模板技术

    表单标签:
    所有的表单标签处理类都继承了UIBean,UIBean包含了一些通用属性,这些通用属性分配三类:模板相关属性,JavaScript相关,通用属性,特殊属性form

    非表单标签:
    作用:在页面中显示Action里封装的信息
    具体:
    1.actionerror:如果Action实例的getActionErrors()方法返回不为null,则该标签负责输出该方法的系列错误
    2.actionmessage:如果Action实例的getActionMessages()方法返回不为null,则该标签负责输出该方法返回的系列消息
    3.component:使用此标签可以生成一个自定义组件
    4.fielderror:如果Action实例存在表单域的类型转换错误、校验错误。该标签负责输出这些错误提示

    展开全文
  • struts2 标签库

    千次阅读 2011-12-20 16:45:49
    第五章:Struts2标签库 — Presentation Transcript 原文地址:http://www.slideshare.net/shmily7788/struts2-8161454 第五章: Struts 2 标签库 主讲:刘雷 学习目标 Struts2 标签库概述 Struts2 ...
    
    

    第五章:Struts2标签库 — Presentation Transcript

    1. 第五章: Struts 2 标签库 主讲:刘雷
    2. 学习目标
      • Struts2 标签库概述
      • Struts2 数据标签
      • Struts2 控制标签
      • Struts2 表单标签
      • Struts2 非表单标签
    3. Struts2 标签库概述
      • Struts2 标签库的组成
      • Struts2 框架的标签库可以分为以下三类:
        • 用户界面标签 (UI 标签 ) :主要用来生成 HTML 元素的标签。
          • 表单标签:主要用于生成 HTML 页面的 FORM 元素,以及普通表单元素的标签。
          • 非表单标签:主要用于生成页面上的 tree , Tab 页等。
        • 非用户界面标签 ( 非 UI 标签 ) :主要用于数据访问,逻辑控制。
          • 数据访问标签:主要包含用于输出值栈 (ValueStack) 中的值,完成国际化等功能的标签。
          • 流程控制标签:主要包含用于实现分支,循环等流程控制的标签。
        • AJAX 标签 : 用于支持 Ajax 效果
    4. Struts2 标签库
      • 在早期的 WEB 开发中, JSP 视图控制和显示技术主要依靠 Java 脚本来实现,这样一来, JSP 页面重新嵌入了大量的 Java 脚本代码,给开发带来了极大的不方便。
      • 从 JSP1.1 规范后, JSP 增加了自定义标签库的支持。标签库是一种组件技术,通过标签库,可以将复杂的 Java 脚本代码封装在组件中,开发者只需要使用简单的代码就可以实现复杂的 Java 脚本功能。提供了 Java 脚本的复用性,提高了开发者的开发效率。
      • Struts2 标签库相对 struts1.x 进行了巨大的改进,支持 OGNL 表达式,不再依赖任何表现层技术。
    5. Struts2 标签的使用
      • 我们可以在 struts2-core-2.0.11.jar 压缩文件的 META-INF 目录下找到 struts-tags.tld 文件,这个文件里定义了 Struts2 的标签。
      • 要在 jsp 中使用 Struts2 的标志,先要指明标志的引入。通过 jsp 的代码的顶部加入以下的代码:
      • <%@taglib prefix=&quot;s&quot; uri=&quot;/struts-tags&quot; %>
    6. Struts2 标签语法 ( 一 )
      • Struts2 的标签都支持动态数据的访问,标签的属性都可以使用 OGNL 表达式, struts2 标签的属性具有类型,这些类型可以简单地分为字符串类型和非字符串类型,对于字符串类型的属性,如果要访问动态数据,需要使用 %{… } 这样的语法,
        • 例如: <s:include value=“%{ url }” />
      • Include 标签的 value 属性是字符串类型, Struts2 将对这个属性进行解析,查找符合 %{…} 样式的字符串,然后将花括号之间的内容作为 OGNL 表达式进行求值。如果属性中没有 %{…} 样式的字符串,那么属性的值将被直接看成是字符串数据。
        • 例如: <s:include value=“urlTag.action” />
      • 对于非字符串类型的属性值,将直接作为 OGNL 表达式进行求值。
        • 例如: <s:property value=“username”/>
      • property 标签的 value 属性是 Object 类型,它的值 username 将作为 OGNL 表达式进行求值,结果是值栈中位于栈顶的对象的 username 属性的值。如果要为非字符串类型的属性直接指定字符串数据,那么需要使用 OGNL 中的字符串常量,即用单引号(‘)或双引号(“)将字符串括起来。
        • 例如: <s:property value=“’zhangsan‘”/>
        • value 属性的值‘ zhangsan’ 作为字符串常量,计算结果就是 zhangsan ,因此输出 zhangsan 。
    7. Struts2 标签语法 ( 二 )
      • 除上述用法之外,也可以使用 %{…} 这样的语法来指定字符串常量。
      • 例如: <s:property value=“%{ ‘zhangsan’ }”/>
      • 在这种情况下, %{ } 将被忽略,花括号中的内容将作为表达式被计算。
      • 总结一下, struts2 标签的属性按照下列的三个规则进行计算。
        • (1) 所有的字符串属性类型都会解析“ %{…}” 这样的语法。
        • (2) 所有的非字符属性类型都不会被解析,而是直接被看作一个 OGNL 表达式进行求值
        • (3) 对于第二个规则的例外情况是,如果非字符串属性使用了“ %{…}” 语法,那么 %{…} 将被忽略,花括号中的内容将作为表达式计算。
      • 如果大家在使用标签时, 忘记了某个属性是字符串类型,还是非字符串类型,那么有一个简单的方法,那就是不考虑它是什么类型,统一使用“ %{…}” 语法。
    8. Struts2 通用标签
      • Struts2 中通用标签可以分为二类:控制标签和数据标签 。控制标签用于呈现页面时控制执行流程,数据标签用于访问值栈中的数据。
      • 数据标签: 用于访问 ActionContext 和值栈中的数据。数据标签包括:
        • property set push param bean action include
        • url a i18n text date debug
      • 控制标签: 用于在呈现结果页面时控制程序的执行流程,根据程序执行的状态输出不同的结果,控制标签包括下列标签:
        • if/elseif/else iterator append merge
        • generator subset sort
    9. 数据标签 -----property 标签
      • property 标签用于输出值栈中的对象的属性 (property) 值,使用 value 属性来指定要输出的对象属性,如果没有指定 value 属性,那么默认输出栈顶对象。
              • property 标签属性
      • 在前面的章节中,我们已经使用过了 property 标签,我们再看一个例子:
      • <s:property value=“username” default=“ 游客” />
      • 取出栈顶对象 ( 通常是 action) 的 username 属性并输出,如果没有找到 username 属性,那么输出”游客”。
    10. 数据标签 -----set 标签
      • Set 标签将一个值赋给指定范围内变量。 Set 标签在某些情况下是比较有用的,例如在页面中多次引用一个复杂的表达式,我们可以将这个表达式赋给一个变量,然后直接引用变量。带来的好处就是:
        • 提升了性能 ( 表达式的计算只有一次 )
        • 提高了代码的可读性。
              • set 标签属性
      • Set 标签以 name 属性的值作为键 (key) ,将 value 属性的值保存到指定的范围对象中。属性 scope 取值中的 page,request,session,application 同 JSP 的 4 种范围,如果指定了 action 范围 ( 默认值 ) , value 属性的值将被同时保存到 request 范围和 OgnlContext 中。
    11. 示例:访问地址: http://localhost:8080/.../setTag.action
    12. 数据标签 -----push 标签
      • push 标签用于把一个值压入值栈 ( 位于栈顶 ) ,注意和 set 标签的区别, set 标签是将值放到 action 上下文中。当 push 标签结束后, push 标签放入值栈中的对象将被删除,换句话说,要访问 push 标签压入栈中的对象,需要在标签内部去访问。
              • push 标签的属性
      public class User { private String username; private String email; private String sex; 省略 set/get 方法 }
    13. Push 标签示例 访问: http://localhost:8080/...../pushTag.action
    14. 数据标签 -----param 标签
      • param 标签被用作其他标签的子标签,用于为其他标签提供参数,例如:为 bean 标签和 include 标签提供参数。
              • param 标签的属性
      • 当使用 param 标签时, 参数的值可以通过 value 属性给出,也可以在标签体中给出 ( 开始标签和结束标签之间的文本 ) 。这二种用法有一些区别。我们看下面的例子:
      • <param name=“color”>blue</param> <!-- (1) -->
      • <param name=“color” value=“blue” /> <!-- (2) -->
      • 在第 (1) 种情形中,参数值将作为 java.lang.String 对象 ( 即字符串 ) 被放入栈中;
      • 在第 (2) 种情形中,参数值将作为表达式进行计算,如果 blue 不存在,则 color 参数的值为 null 。
      • 在第 (1) 种情形中,要为 color 指定字符串值,可以写为:
      • <param name=“color” value=“ ‘ blue ‘ ”/> 或者 <param name=“color” value=“%{‘ blue ‘ }“/>
      • 使用单引号包围字符串,表明这是一个字符串常量
    15. 数据标签 -----bean 标签
      • bean 标签用于实例化一个 JavaBean 对象 ( 必须遵照 JavaBean 规范 ) , bean 标签的标签体内可以包含多个 param 标签,用于设置 Bean 的属性 ( 必须有相应的 setter 方法 ) 。如果指定了 id 属性,则创建的 Bean 实例将被放入到 OgnlContext 中。
              • bean 标签的属性
      • 注意:
        • id 属性是可选的,无论是否指定 id 属性, bean 标签创建的 JavaBean 实例都会被压入到值栈的顶部,在 bean 标签内部可以直接访问创建的对象,无须使用” #” 标记,当 bean 标签结束的时候, bean 标签创建的实例将从值栈中删除。
        • 如果指定了 id 属性,那么 bean 标签创建的 JavaBean 实例还将被放到 OgnlContext 中,这样在 bean 标签的外部,也可以访问创建的对象了,不过此时就要使用” #” 标记了。
    16. bean 标签示例
    17. bean 标签示例说明
      • 在没有指定 id 属性的情况下,创建的 User 对象只被压入值栈,在 bean 标签的内部使用 property 标签可以直接访问 User 对象的属性。在 bean 标签外部,由于值栈中的 User 对象已被删除,所以无法访问到 User 对象的属性了。
      • 在指定了 id 属性的情况下,创建的 User 对象除了被放到值栈中外,还被放到 action 上下文中,因此在标签的内部和外部都可以访问 User 对象属性,只不过在标签外部访问时需要添加 #user 前缀 ,
      • 访问路径: http://localhost:8080/..../beanTag.action
      • 通过指定 action 的名字和可选的名称空间, action 标签允许你在 JSP 中直接调用 action 。如果将标签的 excuteResult 属性设为 true, 那么 action 对应的结果输出也将被包含到本页面中。
      • 在 action 标签的标签体中可以嵌套 param 标签,向 action 传递参数。
              • action 标签的属性
      数据标签 -----action 标签
      • 如果指定了 id 属性,则 action 将被放到 OgnlContext 中,在 action 标签结束后,可以通过 #id 来引用 action.
    18. ActionTagAction.java actionTagSuccess.jsp
    19. actionTag.jsp
    20. 示例说明
      • 在第一个 action 标签调用中,执行了结果,但没有设置 ActiontagAction 的 username 和 email 属性,所以结果页面中的这两项输出为空。
      • 在第二个 action 标签调用中,不执行结果,调用 ActionTagAction 的 doDefault() 方法,在这个方法中,我们在请求对象中设置了 greeting 属性,在页面中使用 property 标签,通过表达式 #attr.greeting 来获取 greeting 属性。
      • 在第三个 action 标签调用中,执行了结果,并通过 param 标签设置了 ActionTagAction 的 username 和 email 属性,在结果页面中通过 property 标签输出这两个属性的值。
      • 访问路径: http://localhost:8080/....actionTag.jsp
    21. 数据标签 -----include 标签
      • include 标签类似于 JSP 的 <jsp:include> 标签,用于包含一个 Servlet 或 JSP 页面。 include 标签的标签体内可以包含多个 param 标签,用于向被包含的页面传递请求参数
      • include 标签的属性
    22. include 标签示例说明
      • 在 jsp2.jsp 中,我们使用 JSP 的 EL 表达式来获取传的请求参数。注意:在 include 标签内部使用 param 标签向被包含的页面传递的请求参数, 不能使用如下的 property 标签来访问: <s:property value=“#parameters.username” />
      • #parameters 引用的实质是一个 Map 对象,并不等同于 HttpServletRequest 对象。
      • 在包含页面时,如果页面中有中文,将会出现乱码,要解决这个问题,可以在 struts.xml 文件中配置 struts.i18n.encoding 属性,如下:
        • <constant name=“struts.i18n.encoding” value=“gbk” />
      • 访问路径: http://localhost:8080/.../includeTag.jsp
    23. 数据标签 -----i18n 和 text 标签
      • i18n 和 text 标签用于对国际化提供支持 .i18n 标签用于将一个资源包放入值栈, text 标签用于从资源包中获取消息。例如
        • <s:i18n name=“ApplicationResources”>
        • <s:text name=“title”/>
        • </s:i18n>
      • i18n 标签将基名为 ApplicationResources 的资源包放入到值栈中, text 标签从资源包中获取键为 title 的文本消息。
      • 注意: i18n 标签放入值栈的资源包只能在 i18n 标签的标签体内访问,一旦 i18n 标签结束,值栈中的资源包将被删除。
      • text 标签也可以单独使用,在这种情况下,它将首先查找资源包的基名与调用的 Action 类名相同的资源包。这意味着你可以在 Action 类所在的包中创建与 Action 类名相同的资源文件,例如:在 com.ibm.action 包中有一个名为 LoginAction 的类, 你可以在 com.ibm.action 包括中创建名为 LoginAction.properties 、 LoginAction_zh.properties 、 LoginAction_en.properties 等资源文件 ( 名字中的 LoginAction 部分称为基名 ) ,当执行完 LoginAction 后,在转向的结果页面中使用单独的 text 标签获取本地化的文本消息,那么 text 标签将从 com.ibm.action.LoginAction_xx.properties( 根据当前的语言环境选择某个资源文件 ) 中读取 name 属性值对应的文本消息。
    24. 数据标签 -----i18n 和 text 标签
      • 如果找不到与 Action 类名相同的资源包,那么就从默认资源包中获取消息;如果默认资源包不存在,或者默认资源包中也没有找到对应的消息,那么 text 标签的标签体内容将作为默认消息被输出;如果没有标签体,那么 name 属性的值将直接被输出。
      • text 标签内部还可以使用嵌套的 param 标签,来指定消息文本中的参数, param 标签的顺序对应了消息文本中参数的索引顺序。
              • i18n 标签的属性
              • text 标签的属性
    25. i18n 和 text 标签示例
      • 第一步
      • 在项目的 src 下新建包: com.ibm.action, 在这个包中新建 TextTagAction 类,继承自 ActionSupport 类,注意:你的 Action 类一定要继承 ActionSupport 类,因为 ActionSupport 类对国际化提供了支持,这样 text 标签才能访问到资源包的基名与你的 Action 类名相同的资源包。
      • TextAction 类没有任何代码,这主要是因为 ActionSupport 基类已经实现了 execute() 方法,该方法返回 Action.SUCCESS, 这就足够了,我们编写 TextAction 类的目的是为了通过这个 Action 来访问使用了 text 标签的结果页面。
    26. i18n 和 text 标签示例
      • 第二步
      • 在 com.ibm.action 包中新建 TextTagAction.properties, 内容如下:
        • username= lisi
        • email= lisi @163. com
        • now=Now is {0} . {1} , welcome you.
        • 键为 now 的消息有两个参数,分别用 {0} 和 {1} 来表示。
      • 第三步
      • 新建 ApplicationResources.properties, 内容如下:
        • username=zhangsan
        • email=zhangsan@sina.com
    27. i18n 和 text 标签示例
      • 第四步
    28. 数据标签 -----date 标签
      • date 标签用于格式化输出日期值,也可用于输出当前日期值与指定日期值之间的时差
      • date 标签的属性
      • 注意:
      • 1 、 format 属性用于指定日期的格式化样式,具体的样式规则可以参看 java.text.SimpleDateFormat 类的 API 文档。
      • 2 、将 nice 属性设为 true ,可以输出指定日期值和当前日期值之间的时差,此时 format 属性失效,也就是说,当 nice 属性为 true 时,即使你指定了 format 属性,它也不会起作用
      • 3 、如果没有使用 nice 属性,也没有指定 format 属性,那么 date 标签将会在国际化资源包中查找 struts.date.format 键,并以这个键的值作为日期的格式化样式;如果这个键不存在,那么默认将会使用 DateFormat.MEDIUM 格式化样式。
      • 4 、如果找不到 name 属性指定的 Date 对象,那么将返回空。
    29. date 标签示例
      • 第一步
      • 在 ApplicationResources.properties 文件中添加 struts.date.format 键
      • struts.date.format=yyyy/MM/dd hh:mm:ss
      • 第二步、
      • 可以使用 struts2 的 struts.custom.i18n.resources 属性来设置默认的资源包,编辑 struts.xml 文件,使用 constant 元素来配置 struts.custom.i18n.resources 属性,内容如下
      • <constant name=“struts.custom.i18n.resources” value=“ApplicationResources”/>
    30. 测试: http://localhost:8080/...../dateTag.jsp
      • 第三步
    31. 控制标签
      • 控制标签用于完成流程控制,例如分支,循环等操作。控制标签包含下面几个:
        • if: 用于控制选择输出。
        • elseif: 同 if 标签结合使用,用来控制选择输出。
        • else: 同 if 标签结合使用,用来控制选择输出。
        • append: 用来将多个集合拼接为一个新的集合。
        • generator: 为一个字符串解析器,用来将一个字符串解析为一个集合。
        • iterator: 迭代器,用来迭代输出集合数据。
        • merge: 用来将多个集合拼接为一个新的集合 , 同 append 有所区别。
        • sort: 用来对集合排序。
        • subset :用来截取集合的部分集合,开成新的集合子集合。
    32. 控制标签 -----if/elseif/else 标签
      • if/elseif 标签属性 test: 为必填属性,是一个 Boolean 类型值,决定是否显示 if 标签内容。该标签标准格式如下:
          • <s:if test=“ 表达式” >
          • …… ..
          • </s:if>
          • <s:elseif test=“ 表达式” >
          • …… ..
          • </s:elseif>
          • <s:else>
          • ……… ..
          • </s:else>
    33. 控制标签 ----- if/elseif/else 标签举例
      • <%@ taglib prefix=&quot;s&quot; uri=&quot;/struts-tags&quot;%>
      • <!-- 定义一个 testname 属性 -->
      • <s:set name=&quot;testname&quot; value=&quot;%{'Java'}&quot; />
      • <!-- 使用 if 标签判断 -->
      • <s:if test=&quot;%{#testname=='Java'}&quot;>
      • <div>
      • <s:property value=&quot;%{# testname}&quot; />
      • </div>
      • </s:if>
      • <s:elseif test=&quot;%{#testname=='Jav'}&quot;>
      • <div>
      • <s:property value=&quot;%{# testname}&quot; />
      • </div>
      • </s:elseif>
      • <s:else>
      • <div>
      • testname 不是“ Java”
      • </div>
      • </s:else>
    34. 控制标签 ----- if/elseif/else 标签举例
        • <%@ taglib prefix=&quot;s&quot; uri=&quot;/struts-tags&quot;%>
        • <s:set name=&quot;age&quot; value=&quot;61&quot;/>
        • <s:if test=&quot;${age > 60}&quot;>
        •     老年人
        • </s:if>
        • <s:elseif test=&quot;${age > 35}&quot;>
        •     中年人
        • </s:elseif>
        • <s:elseif test=&quot;${age > 15}&quot; id=&quot;wawa&quot;>
        •     青年人
        • </s:elseif>
        • <s:else>
        •     少年
        • </s:else>
    35. 控制标签 ----- if/elseif/else 标签举例
        • <%@ taglib prefix=&quot;s&quot; uri=&quot;/struts-tags&quot;%>
        • <s:set name=&quot;name&quot; value=&quot;<%=&quot;'&quot;+ request.getParameter(&quot;name&quot;)+&quot;'&quot; %>&quot;/>
        • <%
        •   System.out.println(request.getParameter(&quot;name&quot;));
        •   %>
        • <s:if test=&quot;#name=='zhaosoft'&quot;>
        •   zhaosoft here
        • </s:if>
        • <s:elseif test=&quot;#name=='zxl'&quot;>
        •   zxl here
        • </s:elseif>
        • <s:else>
        •   other is here
        • </s:else>
    36. 控制标签 ----- iterator (迭代标签)
      • Iterator (迭代)
      • 描述:用于遍历集合( java.util.Collection ) List,Map, 数组或枚举值 (java.util.iterator) 。该标签的属性如下表:
    37. IteratorStauts 实例包含方法
      • int getCount(): 返回当前迭代过元素的总数。
      • int getIndex(): 返回当前迭代元素的索引。
      • boolean isEven(): 判断当前迭元素是否为偶数。
      • boolean isOdd(): 判断当前迭元素是否为奇数。
      • boolean isFirst(): 判断当前迭元素是否为第一个元素。
      • boolean isLast(): 判断当前迭元素是否为最后一个元素
      • IteratorStauts 的这些方法分别对应了 count,index,even,odd,first,last 属性
    38. 控制标签 ----- iterator 标签示例
    39. 控制标签 ----- iterator (迭代标签)举例
        • <s:iterator value =&quot;{' 第一个元素 ',' 第二个元素 '}&quot; >
        • <p>day is: <s:property/></p>
        • </s:iterator>
        • private List myList;
        • private Map myMap;
        • public String execute() throws Exception {
        • myList = new ArrayList();
        • myList.add(&quot; 第一个元素 &quot;);
        • myList.add(&quot; 第二个元素 &quot;);
        • myList.add(&quot; 第三个元素 &quot;);
        • myMap = new HashMap();
        • myMap.put(&quot;key1&quot;, &quot; 第一个元素 &quot;);
        • myMap.put(&quot;key2&quot;, &quot; 第二个元素 &quot;);
        • myMap.put(&quot;key3&quot;, &quot; 第三个元素 &quot;);
        • return SUCCESS ;
        • }
        • 省略生成 setter/getter 方法
        • <table>
        • <s:iterator value=&quot;{' 第一个元素 ',' 第二个元素 '}&quot; status=&quot;st&quot;>
        • <tr>
        • <td><s:property value=&quot;#st.getIndex()&quot; /></td>
        • <td><s:property /></td>
        • </tr>
        • </s:iterator>
        • </table>
        • <h2> 显示 List 属性 </h2>
        • <table>
        • <s:iterator value=&quot;myList&quot; status=&quot;st&quot;>
        • <tr>
        • <td><s:property value=&quot;#st.getIndex()&quot; /></td>
        • <td><s:property /></td>
        • </tr>
        • </s:iterator>
        • </table>
        • <h2> 显示 Map</h2>
        • <table>
        • <s:iterator value=&quot;#{'key1':' 第一个元素 ','key2':' 第二个元素 '}&quot; status=&quot;st&quot;>
        • <tr>
        • <td><s:property value=&quot;#st.getIndex()&quot; /></td>
        • <td><s:property /></td>
        • </tr>
        • </s:iterator>
        • </table>
        • <h2> 显示 Map 属性 </h2>
        • <table>
        • <s:iterator value=&quot;myMap&quot; status=&quot;st&quot;>
        • <tr>
        • <td><s:property value=&quot;#st.getIndex()&quot; /></td>
        • <td><s:property /></td>
        • </tr>
        • </s:iterator>
        • </table>
    40. 控制标签 ----- append 标签
      • append: 用来将多个集合拼接为一个新的集合。这样拼接的目的就是可以将多个集合使用一个 <iterator /> 标签完成迭代。标签属性 id: 指定了集合元素的 ID 。
      • private List myList1, myList2;
      • private Map myMap1, myMap2;
      • public String execute() throws Exception {
      • myList1 = new ArrayList();
      • myList2 = new ArrayList();
      • myList1.add(&quot; 第一个集合 # 第一个元素 &quot;);
      • myList1.add(&quot; 第一个集合 # 第二个元素 &quot;);
      • myList1.add(&quot; 第一个集合 # 第三个元素 &quot;);
      • myList2.add(&quot; 第二个集合 # 第一个元素 &quot;);
      • myList2.add(&quot; 第二个集合 # 第二个元素 &quot;);
      • myList2.add(&quot; 第二个集合 # 第三个元素 &quot;);
      • myMap1 = new HashMap(); myMap2 = new HashMap();
      • myMap1.put(&quot;key1&quot;, &quot; 第一个集合 # 第一个元素 &quot;);
      • myMap1.put(&quot;key2&quot;, &quot; 第一个集合 # 第二个元素 &quot;);
      • myMap1.put(&quot;key3&quot;, &quot; 第一个集合 # 第三个元素 &quot;);
      • myMap2.put(&quot;key1&quot;, &quot; 第二个集合 # 第一个元素 &quot;);
      • myMap2.put(&quot;key2&quot;, &quot; 第二个集合 # 第二个元素 &quot;);
      • myMap2.put(&quot;key3&quot;, &quot; 第二个集合 # 第三个元素 &quot;);
      • return SUCCESS;
      • } // 省略 setter/getter 方法
      • <h1><span style=&quot;background-color: #FFFFcc&quot;>Append 标签示例 </span></h1>
      • <h2> 拼接 List 属性 </h2>
      • <table>
      • <s:append id=&quot;newList&quot;>
      • <s:param value=&quot;myList1&quot; />
      • <s:param value=&quot;myList2&quot; />
      • </s:append>
      • <s:iterator value=&quot;#newList&quot; id=&quot;name&quot; status=&quot;st&quot;>
      • <tr>
      • <td><s:property value=&quot;#st.getIndex()&quot; /></td>
      • <td><s:property /></td>
      • </tr>
      • </s:iterator>
      • </table>
      • <h2> 拼接 Map 属性 </h2>
      • <table>
      • <s:append id=&quot;newMap&quot;>
      • <s:param value=&quot;myMap1&quot; />
      • <s:param value=&quot;myMap2&quot; />
      • </s:append>
      • <s:iterator value=&quot;#newMap&quot; status=&quot;st&quot;>
      • <tr>
      • <td><s:property value=&quot;#st.getIndex()&quot; /></td>
      • <td><s:property /></td>
      • </tr>
      • </s:iterator>
      • </table>
    41. 控制标签 ----- generator 标签
      • generator 标签用来将指定的字符串按规定的分隔符分解为多个子字符串,生成的多个子字符串可以使用 iterator 标签输出。
      • 该标签的属性如下:
        • id: 指定了集合元素的 ID 。
        • count :可选属性,为一个 Integer 类型值,指定生成集合中元素的总数。
        • separator: 必填属性,为一个 String 类型值,指定用来分解字符串的分隔符。
        • val :必填属性,为一个 String 类型值,指定被分解的字符串。
        • converter :可选属性,为一个 Converter 类型实例,指定一个转换器,该转换器负责将集合中的每个字符串转换为对象。
    42. 控制标签 ----- generator 标签举例
      • private String msg;
      • public String getMsg() {
      • return msg;
      • }
      • public void setMsg(String msg) {
      • this.msg = msg;
      • }
      • public String execute() throws Exception {
      • setMsg(&quot; 第一个元素 ; 第二个元素 ; 第三个元素 &quot;);
      • return SUCCESS;
      • }
    43. 控制标签 ----- generator 标签举例
      • <h1>
      • <span style=&quot;background-color: #FFFFCC&quot;>Generator 标签示例 </span>
      • </h1>
      • <table>
      • <s:generator separator=&quot;;&quot; val=&quot;msg&quot; id=&quot;temp&quot; count=&quot;2&quot;></s:generator>
      • <s:iterator status=&quot;st&quot; value=&quot;#attr.temp&quot;>
      • <tr>
      • <td><s:property value=&quot;#st.getIndex()&quot; /></td>
      • <td><s:property /></td>
      • </tr>
      • </s:iterator>
      • </table>
      • 注意:如果在 generator 标签中指定了 count 属性,则该集合中最多只能有 count 个元素,多余的元素将会被忽略。
    44. 控制标签 ----- append 标签
      • append: 用来将多个集合拼接为一个新的集合。
    45. 控制标签 ----- merge 标签
      • Merge 标签用于合并迭代器,其用法与 append 相似,区别就是对合并后的迭代器中的元素迭代的顺序不一样。
    46. 控制标签 ----- subset 标签
      • Subset 标签用于截取一个迭代器的子集,其内部实现是通过 org.apache.struts2.util.SubsetIteratorFilter 类来完成的。
    47. Subset 标签示例
    48. subset 标签示例
      • 除了上面的用法之外,还可以使用 subset 属性指定一个 Decider ,用于过滤某些元素。要编写一个 Decider 类,需要实现 org.apache.struts2.util.SubsetIteratorFilter.Decider 接口,该接口只有一个方法, public boolean decide(Object element) throw Exception, 如果该方法返回 true ,表明参数 element 表示的元素应该被包含到子集中。
      • 我们编写一个 Decider 类,选取集合中含有“ java” 子串的元素,代码如下:
      首先使用 bean 标签实例化 MyDecider 对象,并将这个对象放入到 OgnlContext 中。在 subset 标签的 decider 属性中,通过 OGNL 表达式 #myDecider 来引用 MyDecider 对象。
    49. 控制标签 ----- sort 标签
      • Sort 标签根据 comparator 属性指定的比较器对集合进行排序,并将排序后的迭代器压入值栈的栈顶。在 sort 标签的内部,你可以使用 iterator 标签取出栈顶的迭代器对排序后的元素进行迭代。当 sort 标签结束时,栈顶的迭代器将被删除。
    50. sort 标签示例
    51. 表单标签
      • Struts2 的表单标签可以分为两类, form 标签本身和包装 HTML 表单元素的其他标签。 form 标签本身的行为不同于它内部的元素。
      • Struts2 表单标签包括下列标签:
        • form textfield password radio checkbox checkboxlist select
        • doubleselect combobox optiontransferselect optgroup updownselect
        • textarea hidden file label reset submit token head
    52. 表单标签
    53. 表单标签的 name 和 value 属性
      • 很多表单标签( form 标签除外)的 name 属性和 value 属性之间存在一个独特的关系。 name 属性除了为 HTML 表单元素指定名字,在表单提交时作为请求参数的名字外,同时它还映射到 Action 的属性。
      • 在大多数情况下, name 属性映射到一个简单的 JavaBean 属性,例如 name 属性的值为” postalCode”, 在表单提交后, struts2 框架将会调用 Action 的 setPostalCode() 方法来设置属性。
      • 有的时候你希望在表单元素中显示 Action 属性的数据,这时就轮到 value 属性登场了,为 value 属性指定表达式” %{postalCode}”, 这将会调用 Action 的 getPostalCode() 方法,并在表单中显示返回的数据,之后, 用户可以编辑这个值,然后重新提交它。
    54. form 标签
      • form 标签输出一个 HTML 输入表单,此外, xhtml 主题的 form 标签还输出表单元素外围的表格。
      • 1) 通常情况下,当前输出表单的请求和提交表单的请求属于同一个命名空间。例如:请求 /admin/updateCategory!default.action 输出的表单,命名空间会被假设为 /admin ,因此在使用 form 标签时,可以不使用 namespace 属性。如下:
        • <s:form action=“updateCategory” >
        • 如果输出表单的请求和提交表单的请求分属于不同的名称空间,那么可以通过
        • namespace 属性指定处理表单提交的 action 所属的名称空间。
      • 2) 若通过 action 的一个非 execute 方法输出表单,然后将表单提交给 action 默认的 execute 方法执行,那么 form 标签的 action 属性可以忽略。例如:对于下面的表单:
        • <s:form >
        • <s:textfield name=“username” label=“ 用户名” />
        • <s:submit />
        • </s:form>
        • 当访问 /register!default.action 时, 输出上表单, form 标签会自动将 action 属性设为
        • register ,这样在表单提交后就会执行 action 的 execute 方法。
      • 3)method 和 enctype 是 HTML form 标签的属性。
      • 4) 当使用验证框架时,将 form 标签的 validate 属性设为 true ,将自动生成客户端的 JavaScript 验证代码。
      • <s:form action=“register” method=“post” />
      • struts2 默认的主题是 xhtml, 上述代码在客户端浏览器中的输出如下:
      • <s:form id=“register” οnsubmit=“return true” action=“register” method=“post”>
      • <table class=“wwFormTable”></table>
      • </s:form>
      • 可以看到 form 标签内部输出了一个 table 元素。
    55. textfield 标签
      • textfield 标签输出一个 HTML 单行文本输入控件,等价于 HTML 代码: <input type=“text” …/>
      • 看下面的代码:
        • <s:form action=“register” method=“post”>
        • <s:textfield name=“username” label=“ 用户名” />
        • </s:form>
    56. password 标签
      • password 标签输出一个 HTML 口令输入控件,等价于 HTML 代码: <input type=“password” ../>
      • 例子: <s:password name=“password” label=“ 密码” />
    57. textarea 标签
      • textarea 标签输出一个 HTML 多行文本输入控件,等价于 HTML 代码: <textarea …./>.
      • 例子:
      • <s:textarea name=“personal” cols=“30” rows=“5” label=“ 个人简历” />
    58. select 标签
      • select 标签输出一个 HTML 列表框,等价于 HTML 代码:
      • <select …><option..></option></select>
    59. select 标签示例
      • 示例一:
        • <s:form>
        • <s:select label=“ 最高学历” name=“education” list=“{‘ 高中’,‘大学’,‘硕士’ }” />
        • </s:form>
        • 在 select 标签的 list 属性中直接使用 OGNL 表达式创建了一个列表,列表中的每一项都将作为 HTML 列表框的一个选项。
      • 示例二:
        • <s:form>
        • <s:select label=“ 最高学历” name=“education” list=“#{1:‘ 高中’, 2:‘ 大学’, 3:‘ 硕士’ }” />
        • </s:form>
        • 在 select 标签的 list 属性中直接使用 OGNL 表达式创建了一个 Map 。在这里要注意的是, Map 的 key 是作为列表框选项的值,而 Map 中的 value 是作为列表框选项的内容。
    60. select 标签示例
      • 示例三:
        • <s:form>
        • <s:select label=“ 最高学历” name=“education” list=“{‘ 高中’,‘大学’,‘硕士’ }” headerKey=“-1” headerValue=“ 请选择你的学历” />
        • Header 选项主要用来越提示作用,因此应该将 header 选项的值 ( 通过 headerKey 属性设置 ) 设为无意义的值,例如此处的 -1.
      • 示例四:
        • <s:form>
        • <s:select label=“ 最高学历” name=“education” list=“{‘ 高中’,‘大学’,‘硕士’ }” headerKey=“-1” headerValue=“ 请选择你的学历” emptyOption=“true” multiple=“true” / >
      • 使用 emptyOption 属性在 header 选项后添加一个空的选项。
      • multiple 属性设为 false ,则只能从下拉列表中选择一个选项,如果设为 true ,则可以多选。
    61. optgroup 标签
      • optgroup 标签作为 select 标签的子标签使用,用于创建选项组。你可以在 select 标签的标签体中使用一个或者多个 optgroup 标签,对选项进行逻辑分组。注意, optgroup 标签本身不能嵌套。
      • 例子:
      • <%@ taglib prefix=“s” uri=“/struts-tags” %>
      • <s:form>
      • <s:select label= &quot; 选择图书 &quot; name= &quot;book&quot; list=&quot;#{1:'JAVA 核心编程 ',2:' 深入 struts2 学习 '}&quot; >
      • <s:optgroup label= &quot;C/C++ 图书 &quot; list=&quot;#{3:'VC++ 编程详解 ',4:'Spring 详解 '}&quot;/>
      • <s:optgroup label= &quot;Oracle 图书 &quot; list=&quot;#{5:'Oracle 基础 ',6:'DBA 入门 '}&quot;/>
      • </s:select>
      • </s:form>
    62. optgroup 标签注意
      • optgroup 标签的 label 属性指定选项组的组名。 optgroup 标签对应的模板需要使用 listKey 和 listValue 属性的值,因此你要么为 list 属性指定一个 Map 类型的值 ( 此时, listKey 默认为 Map.Entry 的 key , listValue 默认为 Map.Entry 的 value) ,要么为 list 属性指定一个对象列表,然后使用 listKey 和 listValue 属性指定对象的属性作为选项的值和内容。
    63. radio 标签
      • radio 标签输出一组 HTML 单选按钮,等价于一组 HTML 代码: <input type=“radio” …/>
      • 例子:
        • <%@ taglib prefix= &quot;s&quot; uri= &quot;/struts-tags&quot; %>
        • <s:form>
        • <s:radio name= &quot;user.sex&quot; value= &quot;1&quot; list=&quot;#{1 : ' 男 ', 0 : ' 女 '}&quot; label= &quot; 性别 &quot; />
        • </s:form>
    64. checkbox 标签
      • checkbox 标签输出一个 HTML 复选框,等价于代码: <input type=“checkbox”…/>
      • checkbox 标签创建一个 value 属性为 true 或者为 false 的复选框。你可以通过 checkbox 标签的 fieldValue 属性来指定创建的 HTML 复选框 value 属性的值。我们看下面的代码:
      • <s:checkbox name=“user.username” label=“ 是否显示 Email” fieldValue=“true” />
      • 复选框的值是 true 还是 false ,是由 fieldValue 属性来控制的,而不是由通常的 value 属性来设置的。
      • 注意,除非你知道你要做什么,否则不要将 fieldValue 属性设置为 false 。将 fieldValue 属性设置为 false 可能会导致一些问题。 HTML 规范规定,复选框只有在选中时才会被提交,在通常的 Servlet/JSP 处理过程中,我们可以通过判断复选框的 name 属性所指定的请求参数是否存在来获知用户是否选中了复选框,如果选中,则取出它的值。然而,在使用 struts2 框架时,这一切发生了一些微妙的变化。如果将 fieldValue 属性设置为 false ,那么复选框的值将是 false 。当没有选中复选框时,提交的请求参数中不会有复选框对应的请求参数。不过,虽然 struts2 框架没有接收到这个请求参数,但它仍然会将复选框对应的 action 属性的值设为 false 。于是你就会看到一个奇怪的现象,那就是不管你是否选中复选框,对应的 action 属性的值都是 false.
    65. checkboxlist 标签
      • checkboxlist 标签使用一个列表创建一系列复选框,属性设置与 <s:select/> 和 <s:radio/> 类似,只是创建的是 HTML 复选框。不同的是, checkboxlist 标签是多选标签。
      • 示例:
        • <s:form>
        • <s:checkboxlist name= &quot;interest&quot; list= &quot;{' 足球 ',' 篮球 ',' 排球 ',' 游泳 '}&quot; label= &quot; 兴趣爱好 &quot; />
        • </s:form>
    66. hidden 标签
      • hidden 标签输出一个 HTML 隐藏表单元素,等价于 HTML 代码: <input type=“hidden”…/>. 在 xhtml 主题下, hidden 标签与其它的标签不太一样, hidden 标签并不输出表行。 xhtml 主题直接从 simple 主题继承了 hidden.ftl 模板。除了公共属性外, hidden 标签没有特有的属性。
      • 示例:
        • <s:hidden name=“id” value=“5” />
    67. submit 标签
      • submit 标签输出一个提交按钮。 submit 标签和 form 标签一起使用可以提供异步表单提交功能。 submit 标签可以输出以下三种类型的提交按钮。
        • input: 等价于 HTML 代码 <input type=“submit”…>
        • image: 等价于 HTML 代码 <input type=“image”…>
        • button: 等价于 HTML 代码 <input type=“submit”…>
      • HTML 的 button 标签已经演进为可以分别指定提交的值 ( 通过 value 属性指定 ) 和按钮上显示的文本 ( 通过标签的内容来指定 ) ,但只能用于 IE6.0 以上版本的浏览器。
    68. submit 标签示例
      • 例 1 :指定 image 类型的提交按钮,使用 method 属性。
        • <s:submit type=“image” method=“login” src=“images/login.gif” />
        • 上述代码在客户端浏览器中的输出如下:
        • <input type=“image” src=“images/login.gif” name=“method:login” value=“Submit”…./>
        • 注意生成的 input 元素的 name 属性。
      • 例 2 :指定 button 类型的提交按钮,使用 action 和 method 属性。
        • <s:submit type=“button” action=“userManager” method=“login” label=“ 登录” />
        • 上述代码在客户端浏览器中的输出如下 :
        • <button type=“submit” name=“action:userManager!login” value=“submit” …/> 登录 </button>
        • 注意 button 标签的 name 属性。
        • 通过上面的例子可以看到 name 属性有二个前缀: method 和 action ,这是 struts2 提供的一种特性,即使用一些预定义的前缀来命名一个按钮,通过按钮的名字来改变执行的行为。 Struts2 定义了 4 个前缀,如下:
        • method-------method:login
        • action--------action:userManager
        • redirect------redirect:cancel.jsp
        • redirection-action------redirect-action:register
    69. method 前缀
      • 使用 method 前缀,来取代 action 默认的 execute() 方法的执行。例如一个表单同时用于用户注册和登录,那么可以编写代码如下:
      • <s:form action=“userManager”>
        • <s:textfield label=“ 用户名” name=“user.username” />
        • <s:password label=“ 密码” name=“user.password” />
        • <s:submit value=“ 登录” name=“method:login” />
        • <s:submit value=“ 注册” name=“method:reg” />
        • </s:form>
        • 注意: 1) 对于 input 类型的提交按钮,不能通过 submit 标签的 label 属性来设置提交按钮上的文本,只能使用 value 属性。
        • 2) 可以在 submit 标签的 name 属性中直接使用 method 前缀,也可以像前面给出的例子中使用 submit 标签的 method 属性来指定处理请求的 action 方法。
    70. action 前缀
      • 使用 action 前缀,取代 form 标签指定的 action ,将请求导向到另外的 action 进行处理。
      • 示例:
      • <s:form action=“login”>
        • <s:textfield label=“ 用户名” name=“user.username” />
        • <s:password label=“ 密码” name=“user.password” />
        • <s:submit value=“ 登录” />
        • <s:submit value=“ 注册” name=“action:register” />
        • </form>
      • 如果用户已经注册,可以直接登录,否则单击注册按钮,转到注册页面。 action 前缀也可以和 struts2 的动态方法调用结合使用,例如: name=“action:userManager!register”.
    71. redirect 前缀
      • 使用 redirect 前缀将请求重定向到其他的 URL ,甚至可以是 Web 应用程序外部的 URL 。
      • 示例:
      • <s:form action=“login”>
        • <s:textfield label=“ 用户名” name=“user.username” />
        • <s:password label=“ 密码” name=“user.password” />
        • <s:submit value=“ 登录” />
        • <s:submit value=“ 注册” name=“redirect:www.163.com” />
        • </form>
    72. redirect-action 前缀
      • 使用 redirect-action 前缀将请求重定向到其他的 action 。在内部, struts2 使用 ServletRedirectResult 来执行这个任务。
      • 示例:
      • <s:form action=“login”>
        • <s:textfield label=“ 用户名” name=“user.username” />
        • <s:password label=“ 密码” name=“user.password” />
        • <s:submit value=“ 登录” />
        • <s:submit value=“ 注册” name=“redirect-action : register” />
        • </form>
    73. reset 标签
      • reset 标签输出一个重置按钮。 reset 标签与 form 标签一起使用,用来提供表单的重置。 reset 标签可以输出以下两种类型的重置按钮:
        • input: 等价于 HTML 代码 <input type=“reset”…>
        • button: 等价于 HTML 代码 <button type=“reset”…>
      • 示例
      • <s:reset value=“ 重置” />
      • <s:reset type=“button” label=“ 重置” />
      • 如果是类型为 input 的重置按钮,则只能通过 value 属性来设置重置按钮上的文本。
    74. label 标签
      • Xhtml 主题下的 label 标签输出两个 HTML 的 label 标签 (simple 主题下的 label 标签只输出一人 HTML label 标签 ) ,分别位于一行的两列,左边的 label 标签起提示作用,右列的 label 标签用于显示只读的 action 属性数据。
      • 示例
        • <s:label label=“ 用户名” name=“user.username” />
        • 如果 Action 实例已经创建,并且 user.username 有值,那么在表行的右列中将显示 user.username 的值。
    75. token 标签与 file 标签
      • token 标签输出两个隐藏的表单字段,用于防止表单的重复提交。要让 token 标签正常工作,需要启用 TokenInterceptor 或者 TokenSessionInterceptor 拦截器。
      • 示例: <s:token /> 具体使用后面章节讲解。
      • file 标签输出一个 HTML 文件选择框,等价于 HTML 代码: <input type=“file” …/>.
      • 示例:
        • <s:file name=“uploadFile” accept=“text / *” />
        • <s:file name=“anotherUploadFile” accept=“text/html,text/plain” />
        • 文件上传后面章节详解。
    76. 非表单标签
      • Struts2 的非表单标签包括下列标签:
        • component 、 a 、 actionerror 、 actionmessage 、 fielderror
      • component 标签使用特定的模板输出一个自定义的 UI 小部件 (widget) 。
      • a 标签创建一个 HTML 超链接,等价于 HTML 代码: <a href=“….” />.
      • a 标签虽然可以在 simple 、 xhtml 和其它主题中使用,但它实际上是为了更好地和 ajax 主题一起工作布置而设计的 .
      • a 标签有一个 String 类型的 href 属性,用于指定链接的 URL 。看下面的例子:
        • <s:a href=“register!default.action”> 重新注册 </s:a>
    77. actionerror 、 actionmessage 、 fielderror 标签
      • actionerror 、 actionmessage 、 fielderror 标签都是用于输出消息的 .
      • 不同的是 :
        • actionerror 标签输出 action 的错误消息,
        • actionmessage 标签输出 action 的一般消息,
        • fielderror 标签输出 action 字段的错误消息 .
      • actionerror 标签输出 action 的 actionErrors 属性 (property) 保存的错误消息, actionErrors 是一个 Collection 类型的属性;
      • actionmessage 标签输出 action 的 actionMessages 属性保存的消息, actionMessages 是一个 Collection 类型的属性;
      • fielderror 标签输出 action 的 fieldErrors 属性保存的字段错误消息, actionMessages 是一个 Map 类型的属性;
      • 对于 fielderror 标签,可以通过嵌套的 param 标签来指定输出特定字段的错误消息。
      • actionerror 、 actionmessage 、 fielderror 标签输出消息的布局依赖于使用的主题。
    78. 示例 : MessageAction .java
      • public class MessageAction extends ActionSupport
      • {
      • @Override
      • public String execute() throws Exception
      • {
      • // 添加 action 错误消息
      • addActionError(&quot;Action Error Message1&quot;);
      • addActionError(&quot;Action Error Message2&quot;);
      • // 添加 action 一般性消息
      • addActionMessage(&quot;Action Message1&quot;);
      • addActionMessage(&quot;Action Message2&quot;);
      • // 添加字段消息
      • addFieldError(&quot;field1&quot;,&quot;field1 error&quot;);
      • addFieldError(&quot;field2&quot;,&quot;field2 error&quot;);
      • return SUCCESS ;
      • }
      • }
    79. 示例 : message.jsp
      • <%@ page contentType= &quot;text/html;charset=GBK&quot; %>
      • <%@ taglib prefix= &quot;s&quot; uri= &quot;/struts-tags&quot; %>
      • <h3> 输出 action 的错误消息 </h3>
      • <s:actionerror/>
      • <h3> 输出 action 的一般性消息 </h3>
      • <s:actionmessage/>
      • <h3> 输出所有字段的错误消息 </h3>
      • <s:fielderror/>
      • <h3> 输出特定字段的错误消息 </h3>
      • <s:fielderror>
      • <s:param value= &quot;'field2'&quot; />
      • </s:fielderror>
    展开全文
  • Struts2标签库

    千次阅读 2014-06-01 14:30:23
    Struts2标签概述

    Struts2标签主要学习目标

     一、 Struts2标签库概述 
     二、 Struts2数据标签 
     三、 Struts2控制标签 
     四、 Struts2表单标签 
     五、 Struts2非表单标签 

     Struts2标签库概述 
     Struts2标签库的组成 
     Struts2框架的标签库可以分为以下三类: 
            用户界面标签(UI标签):主要用来生成HTML元素的标签。 
                    表单标签:主要用于生成HTML页面的FORM元素,以及普通表单元素的标签。 
                    非表单标签:主要用于生成页面上的tree,Tab页等。 
            非用户界面标签(非UI标签):主要用于数据访问,逻辑控制。 
                    数据访问标签:主要包含用于输出值栈(ValueStack)中的值,完成国际化等功能的标签。 
                    流程控制标签:主要包含用于实现分支,循环等流程控制的标签。 
             AJAX标签:用于支持Ajax效果 

     Struts2标签库

           在早期的WEB开发中,JSP视图控制和显示技术主要依靠Java脚本来实现,这样一来,JSP页面重新嵌入了大量的Java脚本代码,给开发带来了极大的不方便。 
          从JSP1.1规范后,JSP增加了自定义标签库的支持。标签库是一种组件技术,通过标签库,可以将复杂的Java脚本代码封装在组件中,开发者只需要使用简单的代码就可以实现复杂的Java脚本功能。提供了Java脚本的复用性,提高了开发者的开发效率。 
          Struts2标签库相对struts1.x进行了巨大的改进,支持OGNL表达式,不再依赖任何表现层技术。



    Struts2标签的使用 
     我们可以在struts2-core-2.0.11.jar压缩文件的META-INF目录下找到struts-tags.tld文件,这个文件里定义了Struts2的标签。 
     
     要在jsp中使用Struts2的标志,先要指明标志的引入。通过jsp的代码的顶部加入以下的代码: 
     
      <%@taglib prefix="s" uri="/struts-tags" %> 

    Struts2标签语法(一) 
          Struts2的标签都支持动态数据的访问,标签的属性都可以使用OGNL表达式,struts2标签的
    属性具有类型,这些类型可以简单地分为字符串类型和非字符串类型,对于字符串类型的属
    性,如果要访问动态数据,需要使用%{… }这样的语法, 
        例如:<s:include value=“%{ url }” /> 
     
         Include标签的value属性是字符串类型,Struts2将对这个属性进行解析,查找符合%{…}样式
    的字符串,然后将花括号之间的内容作为OGNL表达式进行求值。如果属性中没有%{…}样式
    的字符串,那么属性的值将被直接看成是字符串数据。 
        例如:<s:include value=“urlTag.action” /> 
     
         对于非字符串类型的属性值,将直接作为OGNL表达式进行求值。 
         例如:<s:property value=“username”/> 
     
         property标签的value属性是Object类型,它的值username将作为OGNL表达式进行求值,结
    果是值栈中位于栈顶的对象的username属性的值。如果要为非字符串类型的属性直接指定字
    符串数据,那么需要使用OGNL中的字符串常量,即用单引号(‘)或双引号(“)将字符
    串括起来。 
         例如:<s:property value=“’zhangsan‘”/> 
    value属性的值‘zhangsan’作为字符串常量,计算结果就是zhangsan,因此输出zhangsan


    Struts2标签语法(二) 
    除上述用法之外,也可以使用%{…}这样的语法来指定字符串常量。 
    例如: <s:property value=“%{ ‘zhangsan’ }”/> 
    在这种情况下,%{ }将被忽略,花括号中的内容将作为表达式被计算。 
     
    总结一下,struts2标签的属性按照下列的三个规则进行计算。 
                   (1)所有的字符串属性类型都会解析“%{…}”这样的语法。 
                   (2)所有的非字符属性类型都不会被解析,而是直接被看作一个OGNL表达式进行求值 
                   (3)对于第二个规则的例外情况是,如果非字符串属性使用了“%{…}”语法,那么 %{…}将被忽略,花括号中的内容将作为表达式计算。 

    如果大家在使用标签时, 忘记了某个属性是字符串类型,还是非字符串类型,那么有一个简单的方法,那就是不考虑它是什么类型,统一使用“%{…}”语法。


    Struts2通用标签 
    Struts2中通用标签可以分为二类:

    控制标签和数据标签。控制标签用于呈现页面时控制执行流程,数据标签用于访问值栈中的数据。 
     
    数据标签:用于访问ActionContext和值栈中的数据。数据标签包括: 
        property  set  push  param  bean  action  include   
        url  a  i18n  text  date  debug 
     
    控制标签:用于在呈现结果页面时控制程序的执行流程,根据程序执行的状态输出不同的结果,控制标签包括下列标签: 
        if/elseif/else        iterator  append      merge 
         generator        subset  sort     

    数据标签-----property标签 

    property标签用于输出值栈中的对象的属性(property)值,使用value属性来指定要输出的对象属性,如果没有指定value属性,那么默认输出栈顶对象。

          例如:<s:property value=“username” default=“游客” /> 
       取出栈顶对象(通常是action)的username属性并输出,如果没有找到username属性,那么输出”游客”。 

    数据标签-----set标签 
    Set标签将一个值赋给指定范围内变量。Set标签在某些情况下是比较有用的,例如在页面中多次引用一个复杂的表达式,我们可以将这个表达式赋给一个变量,然后直接引用变量。带来的好处就是: 
         提升了性能(表达式的计算只有一次) 
         提高了代码的可读性。
     

    Set标签以name属性的值作为键(key),将value属性的值保存到指定的范围对象中。属性scope取值中的page,request,session,application同JSP的4种范围,如果指定了action范围(默认值),value属性的值将被同时保存到request范围和OgnlContext中。 

    数据标签-----push标签 
         push标签用于把一个值压入值栈(位于栈顶),注意和set标签的区别,set标签是将值放到action上下文中。当push标签结束后,push标签放入值栈中的对象将被删除,换句话说,要访问push标签压入栈中的对象,需要在标签内部去访问。 
    数据标签-----param标签 
    param标签被用作其他标签的子标签,用于为其他标签提供参数,例如:为bean标签和include标签提供参数。 

    当使用param标签时, 参数的值可以通过value属性给出,也可以在标签体中给出(开始标签和结束标签之间的文本)。这二种用法有一些区别。我们看下面的例子: 
           <param name=“color”>blue</param>    <!--  (1) --> 
           <param name=“color” value=“blue” />   <!--  (2) --> 
    在第(1)种情形中,参数值将作为java.lang.String对象(即字符串)被放入栈中; 
    在第(2)种情形中,参数值将作为表达式进行计算,如果blue不存在,则color参数的值为null。 
    在第(1)种情形中,要为color指定字符串值,可以写为: 
             <param name=“color” value=“ ‘ blue ‘ ”/>或者<param name=“color” value=“%{‘ blue ‘ }“/> 
    使用单引号包围字符串,表明这是一个字符串常量 


    数据标签-----bean标签 
    bean标签用于实例化一个JavaBean对象(必须遵照JavaBean规范),bean标签的标签体内可以包含多个param标签,用于设置Bean的属性(必须有相应的setter方法)。如果指定了id属性,则创建的Bean实例将被放入到OgnlContext中。 

    注意: 
            id属性是可选的,无论是否指定id属性,bean标签创建的JavaBean实例都会被压入到值栈的顶部,在bean标签内部可以直接访问创建的对象,无须使用”#”标记,当bean标签结束的时候,bean标签创建的实例将从值栈中删除。 
            如果指定了id属性,那么bean标签创建的JavaBean实例还将被放到OgnlContext中,这样在bean标签的外部,也可以访问创建的对象了,不过此时就要使用”#”标记了

    数据标签-----action标签 
    通过指定action的名字和可选的名称空间,action标签允许你在JSP中直接调用action。如果将标签的excuteResult属性设为true,那么action对应的结果输出也将被包含到本页面中。 在action标签的标签体中可以嵌套param标签,向action传递参数。

    如果指定了id属性,则action将被放到OgnlContext中,在action标签结束后,可以通过#id来引用action. 


    数据标签-----include标签 
    include标签类似于JSP的<jsp:include>标签,用于包含一个Servlet或JSP页面。
    include标签的标签体内可以包含多个param标签,用于向被包含的页面传递请求参数 


    数据标签-----i18n和text标签 
    i18n和text标签用于对国际化提供支持.i18n标签用于将一个资源包放入值栈,text标签用于从资源包中获取消息。例如 
    <s:i18n name=“ApplicationResources”> 
        <s:text name=“title”/> 
    </s:i18n> 
    i18n标签将基名为ApplicationResources的资源包放入到值栈中,text标签从资源包中获取键为title的文本消息。 
    注意:i18n标签放入值栈的资源包只能在i18n标签的标签体内访问,一旦i18n标签结束,值栈中的资源包将被删除。 
     
    text标签也可以单独使用,在这种情况下,它将首先查找资源包的基名与调用的Action类名相同的资源包。这意味着你可以在Action类所在的包中创建与Action类名相同的资源文件,例如:在com.ibm.action包中有一个名为LoginAction的类, 你可以在com.ibm.action包括中创建名为LoginAction.propertiesLoginAction_zh.properties、LoginAction_en.properties等资源文件(名字中的LoginAction部分称为基名),当执行完LoginAction后,在转向的果页面中使用单独的text标签获取本地化的文本消息,那么text标签将从com.ibm.action.LoginAction_xx.properties(根据当前的语言环境选择某个资源文件)中读取name属性值对应的文本消息。 

    数据标签-----date标签 
    date标签用于格式化输出日期值,也可用于输出当前日期值与指定日期值之间的时差

    注意: 
    1、format属性用于指定日期的格式化样式,具体的样式规则可java.text.SimpleDateFormat类的API文档。 
    2、将nice属性设为true,可以输出指定日期值和当前日期值之效,也就是说,当nice属性为true时,即使你指定了format属性
    3、如果没有使用nice属性,也没有指定format属性,那么date查找struts.date.format键,并以这个键的值作为日期的格式化么默认将会使用DateFormat.MEDIUM格式化样式。 
    4、如果找不到name属性指定的Date对象,那么将返回空。 


    控制标签 
    控制标签用于完成流程控制,例如分支,循环等操作。控制标签包含下面几个: 
         if:用于控制选择输出。 
         elseif:同if标签结合使用,用来控制选择输出。 
         else:同if标签结合使用,用来控制选择输出。 
         append:用来将多个集合拼接为一个新的集合。 
         generator:为一个字符串解析器,用来将一个字符串解析为一个集合。 
         iterator:迭代器,用来迭代输出集合数据。 
         merge:用来将多个集合拼接为一个新的集合,同append有所区别。 
         sort:用来对集合排序。 

           subset:用来截取集合的部分集合,开成新的集合子集合

    控制标签-----if/elseif/else标签 
         if/elseif标签属性test:为必填属性,是一个Boolean类型值,决定是否显示if标签内容。
    该标签标准格式如下: 
    <s:if test=“表达式”> 
      …….. 
    </s:if> 
    <s:elseif test=“表达式”> 
      …….. 
    </s:elseif> 
    <s:else> 
      ……….. 
    </s:else> 

    控制标签----- if/elseif/else标签举例 
    <%@ taglib prefix="s" uri="/struts-tags"%> 
     
    <!-- 定义一个testname属性 --> 
        <s:set name="testname" value="%{'Java'}" /> 
        <!-- 使用if标签判断-->  
        <s:if test="%{#testname=='Java'}"> 
          <div> 
            <s:property value="%{# testname}" /> 
          </div> 
        </s:if> 
        <s:elseif test="%{#testname=='Jav'}"> 
          <div> 
            <s:property value="%{# testname}" /> 
          </div> 
        </s:elseif> 
        <s:else> 
          <div> 
            testname不是“Java” 
          </div> 
        </s:else> 

    控制标签----- if/elseif/else标签举例 
    <%@ taglib prefix="s" uri="/struts-tags"%> 
     
    <s:set name="age" value="61"/> 
    <s:if test="${age > 60}">  
        老年人  
    </s:if> 
    <s:elseif test="${age > 35}"> 
        中年人 
    </s:elseif> 
    <s:elseif test="${age > 15}" id="wawa"> 
        青年人 
    </s:elseif> 
    <s:else> 
        少年 
    </s:else> 

    控制标签----- if/elseif/else标签举例 
    <%@ taglib prefix="s" uri="/struts-tags"%>  
    <s:set name="name" value="<%="'"+ request.getParameter("name")+"'" %>"/> 
    <% 
      System.out.println(request.getParameter("name")); 
     %> 
    <s:if test="#name=='zhaosoft'"> 
      zhaosoft here 
    </s:if> 
    <s:elseif test="#name=='zxl'"> 
      zxl here 
    </s:elseif> 
    <s:else> 
      other is here  
    </s:else> 

    控制标签----- iterator(迭代标签) 
    Iterator(迭代) 
    描述:用于遍历集合(java.util.Collection)List,Map,数组或枚举值(java.util.iterator)。

    IteratorStauts实例包含方法 
    int getCount():返回当前迭代过元素的总数。 
    int getIndex():返回当前迭代元素的索引。 
    boolean isEven():判断当前迭元素是否为偶数。 
    boolean isOdd():判断当前迭元素是否为奇数。 
    boolean isFirst():判断当前迭元素是否为第一个元素。 
    boolean isLast():判断当前迭元素是否为最后一个元素 
     
    IteratorStauts的这些方法分别对应了count,index,even,odd,first,last属性 

    控制标签----- iterator(迭代标签)举例 
    <s:iterator value ="{'第一个元素','第二个元素'}" > 
      <p>day is: <s:property/></p> 
    </s:iterator> 
     
    private List myList; 
    private Map myMap; 
    public String execute() throws Exception { 
    myList = new ArrayList(); 
    myList.add("第一个元素"); 
    myList.add("第二个元素"); 
    myList.add("第三个元素"); 
    myMap = new HashMap(); 
    myMap.put("key1", "第一个元素"); 
    myMap.put("key2", "第二个元素"); 
    myMap.put("key3", "第三个元素"); 
    return SUCCESS; 

     省略生成setter/getter方法

    <table> 
        <s:iterator value="{'第一个元素','第二个元素'}" status="st"> 
        <tr> 
        <td><s:property value="#st.getIndex()" /></td> 
          <td><s:property /></td> 
        </tr> 
          </s:iterator> 
      </table> 
     
        <h2>显示List属性</h2> 
        <table> 
              <s:iterator value="myList" status="st"> 
          <tr> 
            <td><s:property value="#st.getIndex()" /></td> 
            <td><s:property /></td> 
          </tr> 
             </s:iterator> 
        </table> 

    <h2>显示Map</h2> 
      <table> 
        <s:iterator value="#{'key1':'第一个元素','key2':'第二个元素'}" status="st"> 
               <tr> 
          <td><s:property value="#st.getIndex()" /></td> 
          <td><s:property /></td> 
               </tr> 
        </s:iterator> 
      </table> 
     
        <h2>显示Map属性</h2> 
      <table> 
        <s:iterator value="myMap" status="st"> 
              <tr> 
          <td><s:property value="#st.getIndex()" /></td> 
          <td><s:property /></td> 
             </tr> 
        </s:iterator> 
      </table> 


    控制标签----- append标签 
    append:用来将多个集合拼接为一个新的集合。这样拼接的目的就是可以将多个集合使用一个<iterator />标签完成迭代。标签属性id:指定了集合元素的ID。 
    private List myList1, myList2; 
    private Map myMap1, myMap2; 
    public String execute() throws Exception { 
      myList1 = new ArrayList();   
      myList2 = new ArrayList(); 
      myList1.add("第一个集合#第一个元素"); 
      myList1.add("第一个集合#第二个元素"); 
      myList1.add("第一个集合#第三个元素"); 
      myList2.add("第二个集合#第一个元素"); 
      myList2.add("第二个集合#第二个元素"); 
      myList2.add("第二个集合#第三个元素"); 
      myMap1 = new HashMap();  myMap2 = new HashMap(); 
      myMap1.put("key1", "第一个集合#第一个元素"); 
      myMap1.put("key2", "第一个集合#第二个元素"); 

      myMap1.put("key3", "第一个集合#第三个元素"); 
      myMap2.put("key1", "第二个集合#第一个元素"); 
      myMap2.put("key2", "第二个集合#第二个元素"); 
      myMap2.put("key3", "第二个集合#第三个元素"); 
      return SUCCESS; 
    }  //省略setter/getter方法 


    <h1><span style="background-color: #FFFFcc">Append标签示例</span></h1>
        <h2>拼接List属性</h2> 
        <table> 
          <s:append id="newList"> 
            <s:param value="myList1" /> 
            <s:param value="myList2" /> 
          </s:append> 
          <s:iterator value="#newList" id="name" status="st"> 
              <tr> 
                   <td><s:property value="#st.getIndex()" /></td> 
                   <td><s:property /></td> 
              </tr> 
          </s:iterator> 
        </table> 
        <h2>拼接Map属性</h2> 
        <table> 

      <s:append id="newMap"> 
              <s:param value="myMap1" /> 
              <s:param value="myMap2" /> 
      </s:append> 
      <s:iterator value="#newMap" status="st"> 
               <tr> 
                    <td><s:property value="#st.getIndex()" /></td> 
                    <td><s:property /></td> 
               </tr> 
      </s:iterator> 
    </table> 


    控制标签----- generator标签 
    generator标签用来将指定的字符串按规定的分隔符分解为多个子字符串,生成的多个子字符串可以使用iterator标签输出。 
    该标签的属性如下: 
         id:指定了集合元素的ID。 
         count:可选属性,为一个Integer类型值,指定生成集合中元素的总数。 
         separator:必填属性,为一个String类型值,指定用来分解字符串的分隔符。 
         val:必填属性,为一个String类型值,指定被分解的字符串。 
         converter:可选属性,为一个Converter类型实例,指定一个转换器,该转换器负
    责将集合中的每个字符串转换为对象。 

    控制标签----- generator标签举例 

    private String msg; 
    public String getMsg() { 
      return msg; 

    public void setMsg(String msg) { 
      this.msg = msg; 

    public String execute() throws Exception { 
      setMsg("第一个元素;第二个元素;第三个元素"); 
      return SUCCESS; 

    控制标签----- generator标签举例 
    <h1> 
      <span style="background-color: #FFFFCC">Generator标签示例</span> 
    </h1> 
    <table> 
      <s:generator separator=";" val="msg" id="temp" count="2"></s:generator> 
      <s:iterator  status="st"  value="#attr.temp"> 
        <tr> 
          <td><s:property value="#st.getIndex()" /></td> 
          <td><s:property /></td> 
        </tr> 
      </s:iterator> 
    </table> 

    注意:如果在generator标签中指定了count属性,则该集合中最多只能有count个元素,多余的元素将会被忽略。 

    控制标签----- append标签 

    append:用来将多个集合拼接为一个新的集合。

    控制标签----- merge标签 
    Merge标签用于合并迭代器,其用法与append相似,区别就是对合并后的迭代器中的元素迭代的顺序不一样。 


    控制标签----- subset标签 
    Subset标签用于截取一个迭代器的子集,其内部实现是通过org.apache.struts2.util.SubsetIteratorFilter类来完成的。 


    控制标签----- sort标签 
    Sort标签根据comparator属性指定的比较器对集合进行排序,并将排序后的迭代器压入值栈的栈顶。在sort标签的内部,你可以使用iterator标签取出栈顶的迭代器对排序后的元素进行迭代。当sort标签结束时,栈顶的迭代器将被删除。


    表单标签 
    Struts2的表单标签可以分为两类,form标签本身和包装HTML表单元素的其他标签。
    form标签本身的行为不同于它内部的元素。 
    Struts2表单标签包括下列标签: 
    form     textfield      password        radio  checkbox      checkboxlist     select 
    doubleselect      combobox       optiontransferselect       optgroup       updownselect 
    textarea       hidden       file      label    reset     submit     token      head 


      



    表单标签的name和value属性 
    很多表单标签(form标签除外)的name属性和value属性之间存在一个独特的关系。name属性除了为HTML表单元素指定名字,在表单提交时作为请求参数的名字外,同时它还映射到Action的属性。 在大多数情况下,name属性映射到一个简单的JavaBean属性,例如name属性的值为”postalCode”,在表单提交后,struts2框架将会调用Action的setPostalCode()方法来设置属性。 有的时候你希望在表单元素中显示Action属性的数据,这时就轮到value属性登场了,为value属性指定表达式”%{postalCode}”,这将会调用Action的getPostalCode()方法,并在表单中显示返回的数据,之后, 用户可以编辑这个值,然后重新提交它。 


    form标签 
    form标签输出一个HTML输入表单,此外,xhtml主题的form标签还输出表单元素外围的表格。 

    1)通常情况下,当前输出表单的请求和提交表单的请求属于同一个命名空间。

    例如:请求/admin/updateCategory!default.action输出的表单,命名空间会被假设为/admin,因此在
    使用form标签时,可以不使用namespace属性。如下: 
    <s:form action=“updateCategory”  > 
    如果输出表单的请求和提交表单的请求分属于不同的名称空间,那么可以通过 
    namespace属性指定处理表单提交的action所属的名称空间。 
    2)若通过action的一个非execute方法输出表单,然后将表单提交给action默认的execute方
    法执行,那么form标签的action属性可以忽略。例如:对于下面的表单:      
    <s:form  > 
        <s:textfield name=“username” label=“用户名”/> 
        <s:submit  /> 
    </s:form> 
    当访问/register!default.action时, 输出上表单,form标签会自动将action属性设为 register,这样在表单提交后就会执行action的execute方法。 
    3)method和enctype是HTML form标签的属性。 
    4)当使用验证框架时,将form标签的validate属性设为true,将自动生成客户端的JavaScript验证代码。 
    <s:form  action=“register” method=“post” /> struts2默认的主题是xhtml,上述代码在客户端浏览器中的输出如下: 
    <s:form id=“register” οnsubmit=“return true” action=“register”  method=“post”> 
    <table class=“wwFormTable”></table> 
    </s:form> 
    可以看到form标签内部输出了一个table元素。 


    textfield标签 
    textfield标签输出一个HTML单行文本输入控件,等价于HTML代码:<input  type=“text” …/> 
    看下面的代码: 
    <s:form action=“register” method=“post”> 
      <s:textfield name=“username” label=“用户名” /> 
    </s:form> 

     

    password标签 
    password标签输出一个HTML口令输入控件,等价于HTML代码:<input type=“password” ../> 
    例子:<s:password name=“password”  label=“密码” /> 


    textarea标签 
    textarea标签输出一个HTML多行文本输入控件,等价于HTML代码:<textarea …./>. 
    例子: 
      <s:textarea  name=“personal” cols=“30”  rows=“5” label=“个人简历” /> 


    select标签 
    select标签输出一个HTML列表框,等价于HTML代码: 
      <select …><option..></option></select> 


    select标签示例 
    示例一: 
    <s:form> 
        <s:select label=“最高学历” name=“education”  list=“{‘高中’,‘大学’,‘硕士’}”  
    /> 
    </s:form> 
    在select标签的list属性中直接使用OGNL表达式创建了一个列表,列表中的每一项都将作为
    HTML列表框的一个选项。 
     
    示例二: 
    <s:form> 
        <s:select label=“最高学历” name=“education”  list=“#{1:‘高中’,2:‘大学’,3:‘硕士
    ’}”  /> 
    </s:form> 

    在select标签的list属性中直接使用OGNL表达式创建了一个Map。在这里要注意的是,Map的key是作为列表框选项的值,而Map中的value是作为列表框选项的内容。
    示例三: 
    <s:form> 
        <s:select label=“最高学历” name=“education” list=“{‘高中’,‘大学’,‘硕士
    ’}”  headerKey=“-1”   headerValue=“请选择你的学历”  /> 
    Header选项主要用来越提示作用,因此应该将header选项的值(通过headerKey属性设置)
    设为无意义的值,例如此处的-1. 
     
    示例四: 
    <s:form> 
        <s:select label=“最高学历” name=“education” list=“{‘高中’,‘大学’,‘硕士
    ’}”  headerKey=“-1”   headerValue=“请选择你的学历”   emptyOption=“true”  
    multiple=“true” / > 

     使用emptyOption属性在header选项后添加一个空的选项。 
      multiple属性设为false,则只能从下拉列表中选择一个选项,如果设为true,则可以多选。

    optgroup标签 
        optgroup标签作为select标签的子标签使用,用于创建选项组。你可以在select标签的标签体中
    使用一个或者多个optgroup标签,对选项进行逻辑分组。注意, optgroup标签本身不能嵌套。 
     
         例子: 
      <%@ taglib prefix=“s” uri=“/struts-tags” %> 
      <s:form> 
     <s:select label="选择图书" name="book" list="#{1:'JAVA核心编程',2:'深入struts2学习'}" > 
         <s:optgroup label="C/C++图书" list="#{3:'VC++编程详解',4:'Spring详解'}"/> 
     <s:optgroup label="Oracle图书" list="#{5:'Oracle基础',6:'DBA入门'}"/> 
    </s:select>   
    </s:form> 

    optgroup标签注意 
    optgroup标签的label属性指定选项组的组名。 optgroup标签对应的模板需要使用listKey和listValue属性的值,因此你要么为list属性指定一个Map类型的值(此时,listKey默认为Map.Entry的key,listValue默认为Map.Entry的value),要么为list属性指定一个对象列表,然后使用listKey和listValue属性指定对象的属性作为选项的值和内容


    radio标签 
    radio标签输出一组HTML单选按钮,等价于一组HTML代码:<input type=“radio” …/> 
     
    例子: 
    <%@ taglib prefix="s" uri="/struts-tags" %> 
    <s:form> 
      <s:radio name="user.sex" value="1" list="#{1 : '男', 0 : '女'}" label="性别" /> 
    </s:form> 


    checkbox标签 
    checkbox标签输出一个HTML复选框,等价于代码:<input type=“checkbox”…/> 
    checkbox标签创建一个value属性为true或者为false的复选框。你可以通过checkbox标签的fieldValue属性来指定创建的HTML复选框value属性的值。我们看下面的代码: <s:checkbox name=“user.username” label=“是否显示Email” fieldValue=“true” /> 复选框的值是true还是false,是由fieldValue属性来控制的,而不是由通常的value属性来设置的。 
     
    注意,除非你知道你要做什么,否则不要将fieldValue属性设置为false。将fieldValue属性设置为false可能会导致一些问题。HTML规范规定,复选框只有在选中时才会被提交,在通常的Servlet/JSP处理过程中,我们可以通过判断复选框的name属性所指定的请求参数是否存在来获知用户是否选中了复选框,如果选中,则取出它的值。然而,在使用struts2框架时,这一切发生了一些微妙的变化。如果将fieldValue属性设置为false,那么复选框的值将是false。当没有选中复选框时,提交的请求参数中不会有复选框对应的请求参数。不过,虽然struts2框架没有接收到这个请求参数,但它仍然会将复选框对应的action属性的值设为false。于是你就会看到一个奇怪的现象,那就是不管你是否选中复选框,对应的action属性的值都是false. 

    checkboxlist标签 
    checkboxlist标签使用一个列表创建一系列复选框,属性设置与<s:select/>和<s:radio/>类
    似,只是创建的是HTML复选框。不同的是, checkboxlist标签是多选标签。 
    示例: 
    <s:form> 
      <s:checkboxlist name="interest" list="{'足球','篮球','排球','游泳'}" label="兴趣爱好"/> 
    </s:form> 

    hidden标签 
    hidden标签输出一个HTML隐藏表单元素,等价于HTML代码:<input type=“hidden”…/>.在xhtml主题下,hidden标签与其它的标签不太一样,hidden标签并不输出表行。xhtml主题直接从simple主题继承了hidden.ftl模板。除了公共属性外,hidden标签没有特有的属性。 
     
    示例: <s:hidden name=“id”  value=“5” /> 

    submit标签 
    submit标签输出一个提交按钮。 submit标签和form标签一起使用可以提供异步表单提交功能。 submit标签可以输出以下三种类型的提交按钮。 
         input:等价于HTML代码<input type=“submit”…> 
         image:等价于HTML代码<input type=“image”…> 
         button:等价于HTML代码<input type=“submit”…> 
    HTML的button标签已经演进为可以分别指定提交的值(通过value属性指定)和按钮上显示的文本(通过标签的内容来指定),但只能用于IE6.0以上版本的浏览器。 
     
    submit标签示例 
    例1:指定image类型的提交按钮,使用method属性。 
    <s:submit type=“image”  method=“login”  src=“images/login.gif” /> 
    上述代码在客户端浏览器中的输出如下: 
    <input type=“image” src=“images/login.gif”  name=“method:login”  value=“Submit”…./> 
    注意生成的input元素的name属性。 
     
    例2:指定button类型的提交按钮,使用action和method属性。 
    <s:submit type=“button”  action=“userManager” method=“login” label=“登录” /> 
    上述代码在客户端浏览器中的输出如下: 
    <button type=“submit” name=“action:userManager!login” value=“submit” …/> 登录</button> 
    注意button标签的name属性。 
     
    通过上面的例子可以看到name属性有二个前缀:method和action,这是struts2提供的一种特性,即使用一些预定义的前缀来命名一个按钮,通过按钮的名字来改变执行的行为。Struts2定义了4个前缀,如下: 
    method-------method:login 
    action--------action:userManager 
    redirect------redirect:cancel.jsp 
    redirection-action------redirect-action:register 

    method  
    使用method前缀,来取代action默认的execute()方法的执行。例如一个表单同时用于
    用户注册和登录,那么可以编写代码如下: 
    <s:form  action=“userManager”> 
      <s:textfield  label=“用户名”  name=“user.username” /> 
      <s:password label=“密码”  name=“user.password” /> 
      <s:submit value=“登录”  name=“method:login” /> 
      <s:submit value=“注册”  name=“method:reg” /> 
    </s:form> 
     
    注意:1)对于input类型的提交按钮,不能通过submit标签的label属性来设置提交按钮上的文本,只能使用value属性。 
              2)可以在submit标签的name属性中直接使用method前缀,也可以像前面给出的例子中使用submit标签的method属性来指定处理请求的action方法。 

    action前缀 
    使用action前缀,取代form标签指定的action,将请求导向到另外的action进行处理。 
     
    示例: 
    <s:form  action=“login”> 
      <s:textfield  label=“用户名”  name=“user.username” /> 
      <s:password label=“密码”  name=“user.password” /> 
      <s:submit value=“登录” /> 
      <s:submit value=“注册”  name=“action:register” /> 
    </form> 
     
    如果用户已经注册,可以直接登录,否则单击注册按钮,转到注册页面。action前缀也可以和struts2的动态方法调用结合使用,
    例如:name=“action:userManager!register”. 

    展开全文
  • struts2标签库

    千次阅读 2009-12-29 10:53:00
    struts2标签库 文本框输入文字 struts2标签是struts2的重点,和action配合使用,就是struts2的重点。第一次使用struts2,就觉得比 jsp/servlet这样的方案,容易多了。 在jsp放个input之类的文本框,在servlet中用...

    struts2标签库

    文本框输入文字
    struts2标签是struts2的重点,和action配合使用,就是struts2的重点。第一次使用struts2,就觉得比 jsp/servlet这样的方案,容易多了。
    在jsp放个input之类的文本框,在servlet中用request.getParameter() 来获取值insert数据库,然后再用request.setAttribute()来给页面返回值。
    代码量非常可观。但struts2中就方便多了。一般的写法是这样的。写一个JAVA类继承ActionSupport,然后在JSP页面就可以直接使用了。
    例:<s:textfield name="" label="" />

       言归正传,struts2的标签分为UI标签和非UI标签。下面就struts2与html作个对比.在此推荐一个eclipse html插件
    http://sourceforge.net/project/showfiles.php?group_id=68009

    文本框:
       Struts2:
       <s:textfield name="" label="" />
              如果是日期型,可使用<s:date name="Date" format="yyyy-MM-dd" />
              由于struts2支持使用el表达式,所以textfield也可写
              <s:textfield name="Date" label="Date" value={Date} />
       HTML:
              <input type="text" name="textfield1">

    列表框:
    Struts2:
             固定值:
              <s:select
                tooltip="Choose Your Favourite Color"
                label="Favorite Color"
                list="{'Red', 'Blue', 'Green'}"
                name="favoriteColor"
                emptyOption="true"
                headerKey="None"
                headerValue="None"/>

             动态列表:
               <s:select
                tooltip="Choose Your Favourite Language"
                label="Favourite Language"
                list="favouriteLanguages"
                name="favouriteLanguage"
                listKey="key"
                listValue="description"
                emptyOption="true"
                headerKey="None"
                headerValue="None"/>

           注:如果采用动态列表,必须用action访问,如果用JSP访问会报错.

              list指action中的list、map等集合类,

              listKey相当于html中的value

              listValue相当于html中select显示的值

              emptyOption是否为空

              headerKey、headerValue 初始的键、值
             
    对应的Action里你的Map类型的值 声明时应该如下写法:
    private Map <String, String> Return_TR=new java.util.HashMap <String, String>();

    struts2的select标签中,常用的有以下几个属性:
    (1)struts2中的select 标签中,必须设置的属性只有一个,即是list。
    (2)select标签的list中必须有值,不然会报错。如果没有值,可以加上headerKey, headerValue,这样就可以通过了。如:
    代码
    <s:select name="geElement.childType" list="childTypeList" listKey="key"
    listValue="value" headerKey="0" headerValue="--请选择子类型--"/>

    其中,即使list中有值,我们也通常会加上headerKey, headerValue,即列表中显示的第一个选项。注意,headerKey不可以为空,不可以为-1。

    (3)list属性:通常是在action中定义的,必须是一个可以迭代的源,如为一个List, Map, Set等。如果是一个Map,
    那么map的key就对应于select标签中的value,map中的value就对应于select标签中的 option。而如果是一个List或者是一个Set,
    那么可以通过listKey和listValue指定。

    (4)listKey和listValue:listKey即对应于select标签中的value, listValue即对应于select标签中的option。

    (5)name属性:即是表单中select的名称
          

           HTML:
             <select name="lst_QproProduce" id="lst_QproProduce">
                 <option value="1" selected>英语</option>
                 <option value="2" selected>汉语</option>
             </select>

    URL参数传递:
       Struts2:                   
              <s:praram name="test" value="testValue" />
              例:<a href='<s:url="test.action">
                 <s:param name="test" value="testValue"/></s:url> '> urlTest </a>
       HTML:
              url?name = testValue
              例:192.168.1.1/test.action?name=testValue
               
    日期下拉框:
       Struts2:                   
         <s:datetimepicker
            label="toggleType='wipe'"
            value="${orderMain.orderDate}"
            toggleType="wipe"
            toggleDuration="300"
            displayFormat="yyyy-MM-dd"
            name="orderMain.orderDate"/>
         说明:${orderMain.orderDate}取类的值,这个参数也可不写,用name就可以。
         使用该tag时要在</head>前要加入<s:head/>。

       HTML:
          只能用js写了.事实上struts2 的datetimepicker也是js的封装.
      

    隐藏域:
       strut2:
            <s:hidden name="Value"/>
       HTML:
             <input type="hidden" name="orderMain.orderId" value="1" />

       另外,struts2的tag是默认在enter时自动提交表单,要屏蔽此功能。在onkeydown事件中加入键盘触发代码。
    例:if(event.keyCode==13) event.keyCode=9;就是将回车转成tab键.
    还有一种方法更为简便方法:
    //回车转Tab
    function EnterTabGlobal(){
    document.οnkeydοwn=function keyDown(){
            if(event.keyCode==13)
             event.keyCode=9
           }
    }
    //在onLoad执行


    一、 url标签
     简介
    url标签用于生成一个URL地址,可以通过url标签指定param子元素,从而向指定URL发送请求参数。
    1. jsp代码
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=GBK"/>
    <title>使用s:url来生成一个URL地址</title>
    </head>
    <body>
    <h2>s:url来生成一个URL地址</h2>
    只指定value属性的形式。<br>
    <s:url value="editGadget.action"/>
    <hr>
    指定action属性,且使用param传入参数的形式。<br>
    <s:url action="showBook">
    <s:param name="author" value="'yeeku'" />
    </s:url>
    <hr>
    既不指定action属性,也不指定value属性,且使用param传入参数的形式。<br>
    <s:url includeParams="get" >
    <s:param name="id" value="%{'22'}"/>
    </s:url>
    <hr>
    同时指定action属性和value属性,且使用param传入参数的形式。<br>
    <s:url action="showBook" value="xxxx">
    <s:param name="author" value="'yeeku'" />
    </s:url></body></html>
    备注:我们用的最多的是以下的方式:
    <s:url id="url" action="preModifyCategoryName" includeParams="none" namespace="/category">
    <s:param name="categoryId" value="%{categoryId}"/>
    </s:url>
    <s:a href="%{url}">
    <s:text name="modify_category_name"/>
    </s:a>
    2. 页面效果
    s:url来生成一个URL地址
    只指定value属性的形式。
    editGadget.action
    ________________________________________
    指定action属性,且使用param传入参数的形式。
    /portal/test/showBook.action?author=yeeku
    ________________________________________
    既不指定action属性,也不指定value属性,且使用param传入参数的形式。
    /portal/test/s-url.jsp?id=22
    ________________________________________
    同时指定action属性和value属性,且使用param传入参数的形式。
    xxxx?author=yeeku
    二、 s:checkboxlist标签
     简介
    Checkboxlist标签可以一次创建多个复选框,用于一次生成多个HTML标签中的<inputtype=”checkbox” …/>,它根据list属性指定的集合来生成多个复选框。
    1. jsp代码
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=GBK"/>
    <title>使用s:checkboxlist生成多个复选框</title>
    <s:head/>
    </head>
    <body>
    <h3>使用s:checkboxlist生成多个复选框</h3>
    <s:form>
    <!-- 使用简单集合来生成多个复选框 -->
    <s:checkboxlist name="a" label="请选择您喜欢的图书" labelposition="top"
    list="{'Spring2.0宝典' , '轻量级J2EE企业应用实战' , '基于J2EE的Ajax宝典'}"/>
    <!-- 使用简单Map对象来生成多个复选框 -->
    <s:checkboxlist name="b" label="请选择您想选择出版日期" labelposition="top"
    list="#{'Spring2.0宝典':'2006年10月' , '轻量级J2EE企业应用实战':'2007月4月' , '基于J2EE的Ajax宝典':'2007年6月'}"
    listKey="key"
    listValue="value"/>
    <s:bean name="lee.BookService" id="bs"/>
    </s:form>
    </body>
    </html>
    备注
     <!-- 使用集合里放多个JavaBean实例来生成多个复选框 -->
    <s:checkboxlist name="b" label="请选择您喜欢的图书" labelposition="top"
    list="#bs.books"
    listKey="name"
    listValue="author"/>
     listKey:该属性指定集合元素中某个属性作为复选框的value.
     listValue: 该属性指定集合元素中某个属性作为复选框的标签。
    2. 页面效果
    三、 使用s:combobox生成下拉输入框
     简介
    Combobox标签生成一个单行文本框和下拉列表框的组合,但两个表单元素只对应一个请求参数,只有单行文本框里的值才包含请求参数,而下拉列表框则只是用于辅助输入,并没有name,也不会产生请求参数。使用该标签,需要指定一个list属性,该list属性指定的集合将用于生成列表项。
    1. Jsp代码
    <body>
    <h3>使用s:combobox生成下拉输入框</h3>
    <s:form>
    <s:combobox label="请选择您喜欢的图书" theme="css_xhtml" labelposition="top"
    list="{'Spring2.0宝典' , '轻量级J2EE企业应用实战' , '基于J2EE的Ajax宝典'}"
    size="20" maxlength="20" name="book"/>
    </s:form>
    </body>
    1. 页面效果
    第一步
    第二步
    备注:
    与<s:select …/>标签不同的是,对于下面的下拉列表,无需指定listKey和listValue属性,因为此处的下拉列表,不再用于发送请求参数,而仅仅是用于辅助输入,因此该下拉列表的value没有任何意义。(注:使用combobox标签时不能指定listKey和 listValue属性)
    四、 使用s:datetimepicker生成日期选择框
     简介
    Datetimepicker标签生成一个日期,时间下拉选择框,当我们使用该日期,时间选择框选择某个日期,时间,系统会自动将选中的日期,时间输入指定文本框。
    1. Jsp代码
    <body>
    <h3>使用使用s:datetimepicker生成日期选择框</h3>
    <s:form theme="simple">
    日期选择部件,指定toggleType属性,且指定value="today"<br>
    <s:datetimepicker name="order.date" label="购买日期" toggleType="explode" value="today"/><hr>
    日期选择部件,指定了format属性<br>
    <s:datetimepicker name="order.date" label="购买日期" displayFormat="dddd年MM月dd日"/><hr>
    日期选择部件,指定了weekStartsOn属性<br>
    <s:datetimepicker name="order.date" label="购买日期" displayFormat="dddd年MM月dd日" weekStartsOn="2"/><hr>
    时间选择部件<br>
    <s:datetimepicker label="选择出发时间'" name="start" type="time" value="13:00"/><hr>
    </s:form>
    </body>
    2. 页面效果
    第一步
    第二步
    第三步 :
    第四步:
    备注
     toggleType:指定日期选择框出现、隐藏的方式,可以选择plain,wipe,explode和fade4个值。
     value:指定当前的日期,时间。可使用today来代表今天。
    五、 使用s:select生成下拉选择框
     简介
    Select 标签用于生成一个下拉列表框,通过为该元素指定list属性,系统会使用list属性指定的集合来生成下拉列表框的选项。
    1. Jsp代码
    <body>
    <h3>使用s:select生成下拉选择框</h3>
    <s:form>
    <!-- 使用简单集合来生成下拉选择框 -->
    <s:select name="a" label="请选择您喜欢的图书" labelposition="top" multiple="true"
    list="{'Spring2.0宝典' , '轻量级J2EE企业应用实战' , 'JavaScript: The Definitive Guide'}"/>
    <!-- 使用简单Map对象来生成下拉选择框 -->
    <s:select name="b" label="请选择您想选择出版日期" labelposition="top"
    list="#{'Spring2.0宝典':'2006年10月' , '轻量级J2EE企业应用实战':'2007月4月' , '基于J2EE的Ajax宝典':'2007年6月'}"
    listKey="key"
    listValue="value"/>
    <s:bean name="lee.BookService" id="bs"/>
    <!-- 使用集合里放多个JavaBean实例来生成下拉选择框 -->
    <s:select name="b" label="请选择您喜欢的图书" labelposition="top" multiple="true"
    list="#bs.books"
    listKey="author"
    listValue="name"/>
    </s:form>
    </body>
    2. 页面效果
    第二步
    六、使用s:radio生成多个单选框
     简介
    s:radio生成多个单选框。
    1. Jsp代码
    <body>
    <h3>使用s:radio生成多个单选框</h3>
    <s:form>
    <!-- 使用简单集合来生成多个单选框 -->
    <s:radio name="a" label="请选择您喜欢的图书" labelposition="top"
    list="{'Spring2.0宝典' , 'Spring In Action' , 'JavaScript: The Definitive Guide'}"/>
    <!-- 使用简单Map对象来生成多个单选框 -->
    <s:radio name="b" label="请选择您想选择出版日期" labelposition="top"
    list="#{'Spring2.0宝典':'2006年10月' , '轻量级J2EE企业应用实战':'2007月4月' , '基于J2EE的Ajax宝典':'2007年6月'}"
    listKey="key"
    listValue="value"/>
    <s:bean name="lee.BookService" id="bs"/>
    <!-- 使用集合里放多个JavaBean实例来生成多个单选框 -->
    <s:radio name="c" label="请选择您喜欢的图书" labelposition="top"
    list="#bs.books"
    listKey="author"
    listValue="name"/>
    </s:form>
    </body>
    2、 页面效果
    七、使用s:optgroup生成下拉选择框的选项组
     简介
    Optgroup标签用于生成一个下拉列表框的选项组。
    1. Jsp代码
    <body>
    <h3>使用s:optgroup生成下拉选择框的选项组</h3>
    <s:form>
    <!-- 使用Map对象来生成下拉选择框的选项组 -->
    <s:select label="选择您喜欢的图书"
    name="book"
    list="#{'Spring2.0宝典':'李刚','轻量级J2EE企业应用实战':'李刚','基于J2EE的Ajax宝典':'李刚'}"
    listKey="value"
    listValue="key">
    <s:optgroup label="Rod Johnson"
    list="#{'Expert One-on-One J2EE Design and Development':'Johnson'}"
    listKey="value"
    listValue="key"/>
    <s:optgroup label="David Flanagan"
    list="#{'JavaScript: The Definitive Guide':'David'}"
    listKey="value"
    listValue="key"/>
    </s:select>
    </s:form>
    </body>
    2、 页面效果
    第二步
    八、使用s:optiontransferselect来生成可移动列表项的下拉列表框
     简介
    使用s:optiontransferselect来生成可移动列表项的下拉列表框。
    1. Jsp代码
    <body>
    <h3>使用s:optiontransferselect来生成可移动列表项的下拉列表框</h3>
    <s:form>
    <!-- 使用简单集合对象来生成可移动的下拉列表框 -->
    <s:optiontransferselect
    label="请选择你喜欢的图书"
    name="cnbook"
    leftTitle="中文图书:"
    rightTitle="外文图书"
    list="{'Spring2.0宝典','轻量级J2EE企业应用实战','基于J2EE的Ajax宝典'}"
    multiple="true"
    addToLeftLabel="向左移动"
    selectAllLabel="全部选择"
    addAllToRightLabel="全部右移"
    headerKey="cnKey"
    headerValue="--- 选择中文图书 ---"
    emptyOption="true"
    doubleList="{' J2EE Design and Development', 'The Definitive Guide'}"
    doubleName="enBook"
    doubleHeaderKey="enKey"
    doubleHeaderValue="--- 选择外文图书 ---"
    doubleEmptyOption="true"
    doubleMultiple="true"
    />
    </s:form>
    </body>
    2、 页面效果
    备注:
    如果我们不想用它默认的图标,我们可以添加标签,将它默认的覆盖掉:例如我们添加如下代码:
    addToRightLabel="向右移动"
    leftDownLabel="下移按钮 "
    页面效果
    九、使用s:updownselect生成可上下移动选项的下拉选择框
     简介
    Updownselect标签的用法非常类似于select标签的用法,区别是该标签声称的列表框可以支持选项的上下移动。
    1. Jsp代码
    <body>
    <h3>使用s:updownselect生成可上下移动选项的下拉选择框</h3>
    <s:form>
    <!-- 使用简单集合来生成可上下移动选项的下拉选择框 -->
    <s:updownselect name="a" label="请选择您喜欢的图书" labelposition="top"
    moveUpLabel="向上移动"
    list="{'Spring2.0宝典' , '轻量级J2EE企业应用实战' , 'JavaScript: The Definitive Guide'}"/>
    <!-- 使用简单Map对象来生成可上下移动选项的下拉选择框
    且使用emptyOption="true"增加一个空选项-->
    <s:updownselect name="b" label="请选择您想选择出版日期" labelposition="top"
    moveDownLabel="向下移动"
    list="#{'Spring2.0宝典':'2006年10月' , '轻量级J2EE企业应用实战':'2007月4月' , '基于J2EE的Ajax宝典':'2007年6月'}"
    listKey="key"
    emptyOption="true"
    listValue="value"/>
    <s:bean name="lee.BookService" id="bs"/>
    <!-- 使用集合里放多个JavaBean实例来可上下移动选项的生成下拉选择框 -->
    <s:updownselect name="c" label="请选择您喜欢的图书的作者" labelposition="top"
    selectAllLabel="全部选择" multiple="true"
    list="#bs.books"
    listKey="author"
    listValue="name"/>
    </s:form>
    </body>
    2.页面效果
    十、使用s:doubleselect生成级联下拉列表框
     简介
    1.Jsp代码
    <body>
    <h3>使用s:doubleselect生成级联下拉列表框</h3>
    <s:form action="x" method="post" theme="simple">
    <s:doubleselect
    label="请选择您喜欢的图书"
    name="author" list="{'李刚', 'David'}"
    doubleList="top == '李刚' ? {'Spring2.0宝典', '轻量级J2EE企业应用实战' , '基于J2EE的Ajax宝典'} : {'JavaScript: The Definitive Guide'}"
    doubleName="book"/>
    </s:form>
    </body>
    2。页面效果
    备注:
    错误原因可能是我们的模板有bug.
    十一、使用s:tree和s:treenode标签生成静态树
     简介
    1。Jsp代码
    <body>
    <s:tree label="计算机图书" id="book" theme="ajax"
    showRootGrid="true" showGrid="true" treeSelectedTopic="treeSelected">
    <s:treenode theme="ajax" label="李刚" id="yeeku">
    <s:treenode theme="ajax" label="Spring2.0宝典" id="spring"/>
    <s:treenode theme="ajax" label="轻量级J2EE企业应用实战" id="lightweight"/>
    <s:treenode theme="ajax" label="基于J2EE的Ajax宝典" id="ajax"/>
    </s:treenode>
    <s:treenode theme="ajax" label="David" id="David">
    <s:treenode theme="ajax" label="JavaScript: The Definitive Guide" id="javascript"/>
    </s:treenode>
    <s:treenode theme="ajax" label="Johnson" id="Johnson">
    <s:treenode theme="ajax" label="Expert One-on-One J2EE Design and Development" id="j2ee"/>
    </s:treenode>
    </s:tree>
    </body>
    2。页面效果
    十二、使用s:append标签拼接两个集合
     简介
    使用s:append标签拼接 多个集合,组成一个新的集合。
    1.Jsp代码
    <body>
    <s:append id="newList">
    <s:param value="{'Spring2.0宝典','轻量级J2EE企业应用实战','基于J2EE的Ajax宝典'}" />
    <s:param value="{'新东方IT培训', '东方标准职业教育'}" />
    </s:append>
    <table border="1" width="240">
    <s:iterator value="#newList" status="st">
    <tr <s:if test="#st.odd">style="background-color:#bbbbbb"</s:if>>
    <td><s:property/></td>
    </tr>
    </s:iterator>
    </table>
    </body>
    2。页面效果
    十三、使用s:append标签拼接集合和Map
     简介
    Append标签用于将多个集合对象拼接起来,组成一个新的集合。通过这种拼接,从而允许通过一个<s:iterator …/>标签就完成对多个集合的迭代。
    1.Jsp代码
    <body>
    <s:append id="newList">
    <s:param value="#{'Spring2.0宝典':'李刚','轻量级J2EE企业应用实战':'李刚','基于J2EE的Ajax宝典':'李刚'}" />
    <s:param value="#{'新东方IT培训', '东方标准职业教育'}" />
    </s:append>
    <table border="1" width="240">
    <s:iterator value="#newList" status="st">
    <tr <s:if test="#st.odd">style="background-color:#bbbbbb"</s:if>>
    <td><s:property value="key"/></td>
    <td><s:property value="value"/></td>
    </tr>
    </s:iterator>
    </table>
    </body>
    2.页面效果
    十五、使用s:generator生成集合
     简介
    使用generator标签可以将指定字符串按指定分隔符分隔成多个子串,临时生成的多个子串可以使用iterator标签迭代输出。可以这样理解:generator将一个字符串转化成一个集合。在该标签的标签体内,整个临时生成的集合将位于ValueStack的顶端,但一旦该标签结束,该集合将被移出ValueStack。
    1.Jsp代码
    <body>
    <s:generator val="'Spring2.0宝典,轻量级J2EE企业应用实战,基于J2EE的Ajax宝典'"
    separator="," id="books" count="2"/>
    <table border="1" width="240">
    <%
    java.util.Iterator i = (java.util.Iterator) pageContext.getAttribute("books");
    while(i.hasNext())
    {
    String s = (String) i.next(); %>
    <tr>
    <td><%=s%></td>
    </tr>
    <%
    }
    %>
    </table>
    </body>
    备注:如果指定了count属性,则以为这集合中最多只能包含count个元素(就是前coun个元素);如果指定了id属性,就可以将临时生成的集合放置到pageContext属性中。
    2.页面效果
    3.jsp代码
    <body>
    <table border="1" width="240">
    <s:generator val="'Spring2.0宝典,轻量级J2EE企业应用实战,基于J2EE的Ajax宝典'" separator=",">
    <s:iterator status="st">
    <tr <s:if test="#st.odd">style="background-color:#bbbbbb"</s:if>>
    <td><s:property/></td>
    </tr>
    </s:iterator>
    </s:generator>
    </table>
    </body>

    展开全文
  • Struts 2 标签库

    千次阅读 2015-02-06 10:53:39
    标签 拥有一个test属性,其表达式的值用来决定标签里内容是否显示 欢迎clf 欢迎yqy 请登录 标签 用于遍历集合(java.util.Collection)或者枚举值(java.util.Iterator)类型的对象,value属性表示集合或枚举对象,...
  • Struts2标签库详解

    2010-05-17 16:43:44
    Struts2标签库详解,Struts2标签库详解,Struts2标签库详解,Struts2标签库详解,Struts2标签库详解,Struts2标签库详解,Struts2标签库详解,Struts2标签库详解,Struts2标签库详解,
  • struts 2标签库介绍

    2009-06-24 00:15:24
    struts 2标签库介绍struts 2标签库介绍struts 2标签库介绍struts 2标签库介绍struts 2标签库介绍
  • struts2标签库详解

    2009-04-11 23:51:37
    struts2标签库详解struts2标签库详解struts2标签库详解
  • Struts2标签库常用标签

    万次阅读 多人点赞 2016-11-24 21:01:18
    Struts2标签库常用标签 基本概述  对于一个MVC框架而言,重点是实现两部分:业务逻辑控制器部分和视图页面部分。Struts2作为一个优秀的MVC框架,也把重点放在了这两部分上。控制器主要由Action来提供支持,而视图...
  • Struts2-10.Struts2标签库

    万次阅读 2018-01-05 13:52:19
    10.1什么是Struts2标签库 对于一个 MVC 框架来说,重点是实现两个部分,一个是控制器部分,一个是视图部分。 Struts 2 框架也把重点放在了这两部分上:控制器主要由 Action 来提供支持,而视图则是由大量的标签来...
  • Struts2标签库和OGNL

    千次阅读 2017-05-26 21:29:03
    学习内容 Struts 2标签库 OGNL能力目标 熟练使用Struts 2常用标签 熟练使用OGNL 本章简介前面我们编写的案例使用的都是HTML标签,这些标签并不能很好的与Struts 2框架结合,Struts 2Struts 1一样都自带了功能...
  • struts2标签库常用标签详解 struts2标签主要分两种: 注意:标签的属性可以被赋值为一个静态的值或一个 OGNL 表达式. 如果在赋值时使用了一个 OGNL 表达式并把它用 %{} 括起来, 这个表达式将会被求值. 1.通用...
  • struts2 API 和struts2 标签库。 中文。 标签库中每个标签都带有解释和例子,非常使用起来非常方便,非常实用。 现将两个一齐打包,方便广大朋友下载。
  • Struts2标签库提供了主题、模板支持,简化了视图页面的编写。今天简单介绍一下struts2标签的大体分类,作为一个了解。 Struts的标签分为五大类: 一、逻辑控制标签 1. 条件标签 2. 迭代标签 二、数据输出标签 ...
  • Struts2 标签库讲解

    千次阅读 2013-07-13 23:35:41
    Struts2 标签库讲解 转自:http://blog.163.com/hzd_love/blog/static/131999881201082111852520/ 要使用Struts2的标签,只需要在JSP页面添加如下一行定义即可: struts2的标签共分为五大类: 一、逻辑控制...
  • Struts2提供了大量标签来帮助开发表现层页面,struts2标签库的标签不依赖于任何表现层技术,也就是说,Struts2提供的大部分标签,可以在各种表现层技术中使用,包括最常用的JSP页面,也可以在Velocity和FreeMarker等...
  • struts2标签库(1)

    千次阅读 2016-05-27 17:39:01
    struts2标签库是一个比较完善而且功能强大的标签库,该标签库大大的简化了试图页的代码,从而能够提高视图页面的维护效率,struts2标签库功能强大,而且简单易用。 优点  struts2标签库的标签不依赖于任何表现层...
  • struts2标签库2

    2016-05-30 16:27:48
    struts2标签库 主题模板  struts2中的所有UI标签都是基于主题和模板的,其中模板是一个UI标签的外在表现形式,如果为所有的UI标签提供样式和视觉效果的模板,那么这一系列的模板就形成了一个主题。  struts2...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,241
精华内容 12,896
关键字:

struts2标签库