JSP页面中常用四种标签

最新推荐文章于 2023-06-25 17:54:33 发布

发呆程序员

最新推荐文章于 2023-06-25 17:54:33 发布

阅读量2.5w

点赞数 1

分类专栏： javaweb 文章标签： jsp标签

javaweb 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

JSP页面常用四种标签：

1. EL表达式: ${}

2. jstl表达式（sun apache）:

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

3. struts-tags标签表达式:

<%@ taglib prefix="s" uri="/struts-tags"%> <s:form><s:property>……

4. Ognl表达式(Struts)

systemSettingModel.settingValue的值可以这样取得
${systemSettingModel.settingValue}
<s:property value="systemSettingModel.settingValue"/>
<s:property value="#request.systemSettingModel.settingValue"/>

＃表示不在struts堆栈里，没有＃表示从struts堆栈里取

/***********************************
Struts2堆栈
struts2中的标签
s:a 中的href

s:select 中的list

s:if 中的test

s:iterator中的value

s:checkboxlist 中的list

他们什么时候使用“# ” 什么时候该用“%{ }” 什么时候该用“%{# }” 什么时候用“”

Struts2中有值堆栈和堆栈上下文的概念,你用 <s:debug />可以看出.

S标签中用#可以取出堆栈上下文中的存放的对象.
用%{}可以取出存在值堆栈中的Action对象,直接调用它的方法.例如你的Action如果继承了ActionSupport .那么在页面标签中，用%{getText('key')}的方式可以拿出国际化信息. %{#}，这是JSP2.1最新规范中的语法，是Struts2为其解决兼容性问题而写成%{#}的

在域对象中使用%{#}
比如%{#session.user.userName}
将获得user对象的 userName属性值
%{}强调的是从你设定的root点取

%{}用于计算表达式
      如%{10+20}结果将输出30
      如%{"a"+"b"}结果将输出"ab"
#通常强调从上下文取
      如#parameters.name[0]等价于request.getParameter("name")
      如#session.name等价于session.getAttribute("name")（EL表达式取值）
      如#request.name等价于request.getAttribute("name")
%{#}仍然用于计算表达式，只不过操作元可以是变量
      如先定义一个变量
      <s:set name="age" value="%{25}"/>
      则%{#age}将输出25，也可以省略"#",写为%{age}
      若将age加10，可这么写：
      %{#age+10}，将输出30.不能省略"#"。也就说变量用于计算时不能省略"#"

Map集合包含list如何在页面取值：（此处使用的是user对象，换成list也一样，另外使用s:property的value=”list.size()”可以取到list的长度）

public String execute() throws Exception ...{

if(this.getUserName().equals("chen") && this.getPwd().equals("chen")) ...{

ActionContext.getContext().getSession().put("userName", this.getUserName());

User user = new User();

user.setName("a");

user.setCode("A");

map.put(1, user);

user = new User();

user.setName("b");

user.setCode("B");

map.put(2, user);

return SUCCESS;

}

return ERROR;

<s:iterator value="map.keySet()" id="id">

<s:property value="#id"/></td>

<s:iterator value="map.get(#id)">

</s:iterator>

</tr>

</s:iterator>

一、JSP EL语言定义

E L（Expression Language）目的：为了使JSP写起来更加简单。

表达式语言的灵感来自于 ECMAScript和 XPath表达式语言，它提供了在 JSP中简化表达式的方法。它是一种简单的语言，基于可用的命名空间（PageContext属性）、嵌套属性和对集合、操作符（算术型、关系型和逻辑型）的访问符、映射到 Java类中静态方法的可扩展函数以及一组隐式对象。

EL 提供了在 JSP脚本编制元素范围外使用运行时表达式的功能。脚本编制元素是指页面中能够用于在 JSP文件中嵌入 Java代码的元素。它们通常用于对象操作以及执行那些影响所生成内容的计算。JSP 2.0将 EL表达式添加为一种脚本编制元素。

二、JSP EL简介

1、语法结构

${expression}

2、[ ]与.运算符

EL 提供“.“和“[ ]“两种运算符来存取数据。

当要存取的属性名称中包含一些特殊字符，如.或?等并非字母或数字的符号，就一定要使用“[ ]“。例如：

${user.My-Name}应当改为${user["My-Name"] }

如果要动态取值时，就可以用“[ ]“来做，而“.“无法做到动态取值。例如：

${sessionScope.user[data]}中data是一个变量

3、变量

EL存取变量数据的方法很简单，例如：${username}。它的意思是取出某一范围中名称为username的变量。

因为我们并没有指定哪一个范围的username，所以它会依序从Page、Request、Session、Application范围查找。

假如途中找到username，就直接回传，不再继续找下去，但是假如全部的范围都没有找到时，就回传null。

属性范围在EL中的名称

Page PageScope

Request RequestScope

Session SessionScope

Application ApplicationScope

request的生命周期是request请求域，一个请求结束，则request结束
session的生命周期是session会话域，打开一个浏览器请求一个网站的页面后，Session开始，当session超过时间限制（一般是20分种）后，session注销而失效
或是人为使用session.invalidate();使用session失效；
或是关闭浏览器后，session还存在，但是这里已经无法获取session了，过一会它还是失效

二、JSP EL 中的有效表达式

有效表达式可以包含文字、操作符、变量（对象引用）和函数调用。我们将分别了解这些有效表达式中的每一种：

1、文字

JSP 表达式语言定义可在表达式中使用的以下文字：

文字文字的值

Boolean

true 和 false

Integer

与 Java类似。可以包含任何正数或负数，例如 24、-45、567

Floating Point

与 Java类似。可以包含任何正的或负的浮点数，例如 -1.8E-45、4.567

String

任何由单引号或双引号限定的字符串。对于单引号、双引号和反斜杠，使用反斜杠字符作为转义序列。必须注意，如果在字符串两端使用双引号，则单引号不需要转义。

Null null

2、操作符

JSP 表达式语言提供以下操作符，其中大部分是 Java中常用的操作符：

术语定义

算术型

+、-（二元）、*、/、div、%、mod、-（一元）

逻辑型

and、&&、or、||、!、not

关系型

==、eq、!=、ne、、gt、<=、le、>=、ge。可以与其他值进行比较，或与布尔型、字符串型、整型或浮点型文字进行比较。

空

空操作符是前缀操作，可用于确定值是否为空。

条件型 A ?B :C。根据 A赋值的结果来赋值 B或 C。

3、隐式对象

JSP 表达式语言定义了一组隐式对象，其中许多对象在 JSP scriplet和表达式中可用：

pageContext

JSP 页的上下文。它可以用于访问 JSP隐式对象，如请求、响应、会话、输出、servletContext等。例如，${pageContext.response}为页面的响应对象赋值。

此外，还提供几个隐式对象，允许对以下对象进行简易访问：

术语定义

param

将请求参数名称映射到单个字符串参数值（通过调用 ServletRequest.getParameter (String name)获得）。getParameter (String)方法返回带有特定名称的参数。表达式 $(param.name)相当于 request.getParameter (name)。

paramValues

将请求参数名称映射到一个数值数组（通过调用 ServletRequest.getParameter (String name)获得）。它与 param隐式对象非常类似，但它检索一个字符串数组而不是单个值。表达式 ${paramvalues.name)相当于 request.getParamterValues(name)。

header

将请求头名称映射到单个字符串头值（通过调用 ServletRequest.getHeader(String name)获得）。表达式 ${header.name}相当于 request.getHeader(name)。

headerValues

将请求头名称映射到一个数值数组（通过调用 ServletRequest.getHeaders(String)获得）。它与头隐式对象非常类似。表达式 ${headerValues.name}相当于 request.getHeaderValues(name)。

cookie 将 cookie名称映射到单个 cookie对象。向服务器发出的客户端请求可以获得一个或多个 cookie。表达式 ${cookie.name.value}返回带有特定名称的第一个 cookie值。如果请求包含多个同名的 cookie，则应该使用 ${headerValues.name}表达式。

initParam 将上下文初始化参数名称映射到单个值（通过调用 ServletContext.getInitparameter(String name)获得）。

除了上述两种类型的隐式对象之外，还有些对象允许访问多种范围的变量，如 Web上下文、会话、请求、页面：

术语定义

pageScope

将页面范围的变量名称映射到其值。例如，EL表达式可以使用 ${pageScope.objectName}访问一个 JSP中页面范围的对象，还可以使用 ${pageScope.objectName.attributeName}访问对象的属性。

requestScope

将请求范围的变量名称映射到其值。该对象允许访问请求对象的属性。例如，EL表达式可以使用 ${requestScope.objectName}访问一个 JSP 请求范围的对象，还可以使用 ${requestScope.objectName.attributeName}访问对象的属性。

sessionScope

将会话范围的变量名称映射到其值。该对象允许访问会话对象的属性。例如：

$sessionScope.name}

applicationScope

将应用程序范围的变量名称映射到其值。该隐式对象允许访问应用程序范围的对象。

三、特别强调：

1、注意当表达式根据名称引用这些对象之一时，返回的是相应的对象而不是相应的属性。例如：即使现有的 pageContext属性包含某些其他值，${pageContext}也返回 PageContext对象。

2、注意 <%@ page isELIgnored="true" %>表示是否禁用EL语言,TRUE表示禁止.FALSE表示不禁止.JSP2.0中默认的启用EL语言。

四、举例说明

1、例如，

< %=request.getParameter(“username”)% >等价于 ${ param.username }

2、例如，但是下面的那句EL语言可以完成如果得到一个username为空，则不显示null,而是不显示值。

<%=user.getAddr( ) %>等价于 ${user.addr}。

3、例如：

<% =request.getAttribute(“userlist”) %>等价于$ { requestScope.userlist }

4、例如，原理如上例3。

${ sessionScope.userlist } 1

${ sessionScope.userlist } 2

${ applicationScope.userlist } 3

${ pageScope.userlist } 4

${uselist} 含义：执行顺序为4 1 2 3。

“.”后面的只是一个字符串，并不是真正的内置对象，不能调用对象。

4、例如，

<%=user.getAddr( ) %>等价于 ${user.addr}

第一句前面的user,为一个变量。

第二句后面user，必须为在某一个范围里的属性。

二，Struts标签

一、
写jsp页面的时候，在struts2中，用的是s标记，先引入标记：
<%@ taglib prefix="s" uri="/struts-tags"%>
二、
struts2的标签和1是完全不同的。
struts2的标签分为两大类：非UI标志和UI标志 struts1将标志库按功能分成HTML、Tiles、Logic和Bean等几部分
下面就介绍strut2的具体标签：
1、UI
UI 标志又可以分为表单UI和非表单UI两部分。表单UI部分基本与Struts 1.x相同，都是对HTML表单元素的包装。不过，Struts 2.0加了几个我们经常在项目中用到的控件如：datepicker、doubleselect、timepicker、 optiontransferselect等。因为这些标志很多都经常用到，而且参数也很多，要在一篇文章详细说明并非易事。
下面主要是ui标签的一些用法
form:
<s:form action="exampleSubmit" method="post" enctype="multipart/form-data">
<s:submit />
<s:reset />

</s:form>可以上传文件的form。
textfield：
<s:textfield
             label="姓名："
             name="name"
             tooltip="Enter your Name here" />
datepicker：
<s:datepicker
             tooltip="Select Your Birthday"
             label="生日"
             name="birthday" />
textarea：
<s:textarea
             tooltip="Enter your remart"
             label="备注"
             name="remart"
             cols="20"
             rows="3"/>
select:
<s:select
             tooltip="Choose user_type"
             label=""
             list="#{'free':'免费','vip':'收费'}" value="#{'free':'免费'}"
           name="bean.user_type"
             emptyOption="true"
             headerKey="None"
             headerValue="None"/>
<s:select
             tooltip="Choose user_type"
             label=""
             list="#{'free':'免费','vip':'收费'}" value="#{'free':'免费'}"
           name="bean.user_type"
             emptyOption="true"
             headerKey="None"
             headerValue="None"/>
<s:select
list="venderList"
listKey="id"
listValue="name"
value="%{profile.companyName}"
name="companyName" cssClass="sel_style_w_180"/>
挺好用的
checkboxlist：
<s:checkboxlist
             tooltip="Choose your Friends"
             label="朋友"
             list="{'Patrick', 'Jason', 'Jay', 'Toby', 'Rene'}"
             name="friends"/>
checkbox：
   <s:checkbox
             tooltip="Confirmed that your are Over 18"
             label="n年龄"
             name="legalAge"
            value="18"/>
file:
   <s:file
             tooltip="Upload Your Picture"
             label="Picture"
             name="picture" />
a:
<s:a href="getP.jsp">超链接提交</s:a>
date :
<s:date name="ad_end_time" format="yyyy-MM-dd"/>
2、非UI
if、elseif和else描述：
执行基本的条件流转。
参数：
名称必需默认类型描述备注test是Boolean决定标志里内容是否显示的表达式else标志没有这个参数id否Object/String用来标识元素的id。在UI和表单中为HTML的id属性例子：
<%@ page c %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
         <title>ConditionFlow</title>
     </head>
     <body>
         <h3>Condition Flow</h3>
         
     <s:iterator value="linkList" status="bean">
   <tr>
     <td class="data_tab_tdcl">
     <s:property value="#bean.Index+1" />     </td>
     <td class="data_tab_tdcl"><s:property value="link_title" /></td>
     <td class="data_tab_tdcl"><s:property value="link_url" /></td>
     <td class="data_tab_tdcl">
     <s:if test="link_type == 1">
                   文字
                 </s:if>
                 <s:elseif test="link_type == 2">
                   图片
                 </s:elseif>
                 <s:else>
                 -----
               </s:else>
     </td>
     </body>
</html>
例1 condition.jsp
iterator 描述：
用于遍历集合（java.util.Collection）或枚举值（java.util.Iterator）。
参数：
名称必需默认类型描述status否String如果设置此参数，一个IteratorStatus的实例将会压入每个遍历的堆栈value否 Object/String要遍历的可枚举的（iteratable）数据源，或者将放入新列表（List）的对象id否Object/String用来标识元素的id。在UI和表单中为HTML的id属性例子：
<%@ page c %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ taglib prefix="s" uri="/struts-tags" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%
     List list = new ArrayList();
     list.add("Max");
     list.add("Scott");
     list.add("Jeffry");
     list.add("Joe");
     list.add("Kelvin");
     request.setAttribute("names", list);
%>
<html>
     <head>
         <title>Iterator</title>
     </head>
     <body>
         <h3>Names: </h3>
         
         <ol>
             <s:iterator value="#request.names" status="stuts">
                 <s:if test="#stuts.odd == true">
                     <li>White <s:property /></li>
                 </s:if>
                 <s:else>
                     <li style="background-color:gray"><s:property /></li>
                 </s:else>
             </s:iterator>
         </ol>
     </body>
</html>

例2 iterator.jsp
i18n 描述：
加载资源包到值堆栈。它可以允许text标志访问任何资源包的信息，而不只当前action相关联的资源包。
参数：
名称必需默认类型描述value是Object/String资源包的类路径（如com.xxxx.resources.AppMsg）id否Object/String用来标识元素的id。在UI和表单中为HTML的id属性例子：
HelloWorld=Hello Wrold!
例3 classes\ ApplicationMessages.properties

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

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
     <head>
         <title>Internationization</title>
     </head>
     <body>
         <h3>
             <s:i18n name="ApplicationMessages">
                 <s:text name="HelloWorld" />
             </s:i18n>
         </h3>
     </body>
</html>
例3 i18n.jsp
include 描述：
包含一个servlet的输出（servlet或jsp的页面）。
参数：
名称必需默认类型描述value是String要包含的jsp或servletid否Object/String用来标识元素的id。在UI和表单中为HTML的id属性例子：
<%@ page c %>
<%@ taglib prefix="s" uri="/struts-tags" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
     <head>
         <title>Iterator</title>
     </head>
     <body>
         <h3>Interator Page</h3>
         <s:include value="/condition.jsp">
             <s:param name="name">Max</s:param>
         </s:include>
         <h3>i18n</h3>
         <s:include value="/i18n.jsp" />
     </body>
</html>
例4 include.jsp
param 描述：
为其他标签提供参数,比如include标签和bean标签.参数的name属性是可选的,如果提供，会调用Component的方法addParameter(String, Object),如果不提供，则外层嵌套标签必须实现UnnamedParametric接口(如TextTag)。

value的提供有两种方式,通过value属性或者标签中间的text,不同之处我们看一下例子:
<param name="color">blue</param>
<param name="color" value="blue"/>
(A)参数值会以String的格式放入statck.
(B)该值会以java.lang.Object的格式放入statck.
参数：
名称必需默认类型描述name否String参数名value否Stringvalue表达式id否Object/String用来标识元素的id。在UI和表单中为HTML的id属性例子：
请参考例4。
set 描述：
set标签赋予变量一个特定范围内的值。当希望给一个变量赋一个复杂的表达式,每次访问该变量而不是复杂的表达式时用到。其在两种情况下非常有用:复杂的表达式很耗时 (性能提升)或者很难理解 (代码可读性提高)。
参数：
名称必需默认类型描述name是String变量名字scope否String变量作用域,可以为application, session, request, page, 或action.value否Object/String将会赋给变量的值id否Object/String用来标识元素的id。在UI和表单中为 HTML的id属性例子：
请参考例1。
text 描述：
支持国际化信息的标签。国际化信息必须放在一个和当前 action同名的resource bundle中,如果没有找到相应message,tag body将被当作默认message,如果没有tag body,message的name会被作为默认message。
参数：
名称必需默认类型描述name是String资源属性的名字id否Object/String用来标识元素的id。在UI和表单中为HTML的id属性例子：
请参考例3。
url 描述：
该标签用于创建url,可以通过"param"标签提供request参数。

当includeParams的值时'all'或者'get', param标签中定义的参数将有优先权,也就是说其会覆盖其他同名参数的值。参数：略
例子：
<%@ page c %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
     <head>
         <title>URL</title>
     </head>
     <body>
         <h3>URL</h3>
         <a href='<s:url value="/i18n.jsp" />'>i18n</a>

         <s:url id="url" value="/condition.jsp">
             <s:param name="name">Max</s:param>
         </s:url>
         <s:a href="%{url}">if\elseif\else</s:a>
     </body>
</html>
例5 url.jsp
property 描述：
得到'value'的属性,如果value没提供,默认为堆栈顶端的元素。
参数：
名称必需默认类型描述default否String如果属性是null则显示的default值escape否trueBooelean是否escape HTMLvalue否栈顶Object要显示的值id否Object/String用来标识元素的id。在UI和表单中为HTML的id属性例子：
请参考例2

三、OGNL(struts)

Struts2的OGNL标签详解

一、Struts2可以将所有标签分成3类：

UI标签：主要用于生成HTML元素的标签。

非UI标签：主要用于数据库访问，逻辑控制等标签。

Ajax标签：用于Ajax支持的标签。

对于UI标签，则有可以分为两类：

表当标签：表单标签主要用与生成HTML页面的from元素，以及普通表单元素的标签。

非表单标签：非表单标签主要用于生成页面的树、Tab页等。

流程控制标签：主要包含用于实现分页、循环等流程的标签。

数据访问标签：主要包含用于输出ValueStack中的值，完成国际化等功能的标签。

Struts2标签库分类图：

二、使用Struts2标签库的准备：

1、在Web.Xml文件中增加标签库d定义。(如果应用使用的是Servlet2.3以前)

2、现在jsp中使用taglib编辑指令导入标签库，然后才可以使用标签。

三、Struts2的OGNL标签：

OGNL是Object Graphic Navigation Language的缩写，它是一个开源项目。Struts2框架使用OGNL作为默认的表达式语言。

在传统的OGNL表达式求值中，系统会假设系统只要一个根对象，但Struts2的Stack Context需要多个“根”对象，其中ValueStacke只是多个“根”对象的其中之一。

假设：使用标签OGNL表达式求值，不是用Struts2的OGNL表达式是求之。如果系统的Context中包含两个对象：foo对象，它在Context中的名字为foo;bar对象,并且它在Context中的名为bar。将foo对象设置成Context的根对象。

返回foo.getBlah()方法的返回值#foo.blah

返回bar.getBlah()方法的返回值#bar.blah

可以看出ONGL表达式的语法非正常简洁。

Struts2不知根据表达式从ValueStack中取的对象，还可以直接从对象中获取属性。Struts2提供了一个特殊的OGNL ProperAccessories(属性访问器)，它可以自动搜寻栈内的所有实体(从上到下)，直接找到求值表达式匹配的属性。

Struts2使用标准的Context来进行OGNL表达式求值，OGNl处理的顶级对象是一个Context，这个Context对象就是一个Map类型实例，在该OGNL的Context中，有一个对象，这个根对象就是OGNL ValueStack，如果需要访问ValueStack里的属性,例如：#取出Valuestack中的bar属性：${bar}；

除此之外：Struts2还提供了一些命名对象，这些命名对象与根对象无关，它们只是存在于Stack Context中。所以，访问这些对象实现需要使用#前缀来指明。

1、paramenters对象：用于访问HTTP请求参数，

2、request对象：用于访问HttpServletRequset的属性(Attribute)的Map。例如#request.userName

3、Session对象：用于访问HttpSession的属性。例如#session.userName

4、Application对象：用于访问ServletContext的属性。例如#application.userName

5、Attr对象：如果可以访问到，则访问PageContext，否则将依次搜索HttpServletRequset，HttpSession，ServletContext中的属性。

值得注意的是：当系统创建Action实例后，该Action实例已经被保存到ValueStack中，故无需书写#即可访问Action属性。

OGNL中的集合(List/Map)：

直接生成一个List类型的集合，该List对象中包含三个元素，都个元素之间以英文逗号隔开；

例：

<s:set name="list" value="{'song','li','xing'}" />

直接生成一个Map类型的集合，该Map对象中每个Key-value对象之间以英文冒号隔开：多项之间以英文逗号隔开。

例：

<s:set name="foobar" value="#{'1':'song', '2':'li', '3':'xing'}" />

Set标签用于蒋某个值放入指定范围：

Scope：指定变量被放置的范围，该属性可以接受aplication、session、requset、page、action。如果该属性，则默认在OGNL Context中。

Value：赋给变量的值，如果没有设置该属性，则将ValueStack栈顶的值付给变量。

对于集合，OGNL提供了两个与元素：in和not in，其中in判断某个元素是否在指定集合中；not in则用于判断某个元素是否不在指定集合中。 in表达式： <s:if test="'foo' in {'foo','bar'}"> 在 </s:if> <s:else> 不在 </s:else> not in表达式： <s:if test="'foo' not in {'foo','bar'}"> 不在 </s:if> <s:else> 在 </s:else>

OGNL还允许通过某个规则取得集合的自己，取得集合子集有三个操作符：

1、?:取出所有符合选择逻辑的元素

2、^:取出符合集合逻辑的第一个元素

3、$:取出符合选择逻辑的最后一个元素

例：<s:iterator value="books. {?#this.price > 35}"> <s:property value="title" /> - $<s:property value="price" /><br></s:iterator>

在上面代码中，直接在集合后紧跟.{}运算符表明用于取出该集合的子集，{}内的表达式用于获取符合集合的元素，this指的是为了从大集books刷选数据到小集合，需要对大集合books进行迭代，this代表当前迭代的元素。表达式用于获取集合中价格大于35的书的集合。

（一）、控制标签：

Struts2的非UI标签包括控制标签和数据标签，主要用于完成流程控制，以及对ValueStack的控制，数据标签主要用于访问ValueStack中的数据；控制标签可以完成输出流程控制，例如分支，循环等操作，也可以对集合的合并，排列。

控制标签有：

1、if：用于控制选择器输出的标签；

2、else if: 与if标签结合使用，用于控制选择输出的标签；

3、else:与if标签结合使用，用于控制选择输出的标签；

4、append:将多个集合拼接成一个新的集合；

5、generator：字符解析器，用于将一个字符串解析成一个集合；

6、Iterator：这是一个迭代器，用于将集合迭代输出；

7、merge：用于多个集合拼接陈一个新的集合。但与appernd的拼接方式有所不同。

8、sort：用于对集合进行排序；

9、Subset：截取集合的部分元素，形成新的子集；

If/elseif/else这三个标签都是用于进行分支控制的，他们都是用于根据一个Boolean表达式的值，来确定是否计算、输出标签体的内容。

例：<s:set name="age" value="21" />

<s:if test="#age==23"> 23</s:if><s:elseif test="#age==21"> 21</s:elseif><s:else>都不等</s:else>

iterator标签：

用于对集合进行迭代，这里集合包含List、Set和数组，也可对Map类型的对象进行迭代输出。Value、id、Status三个属性都是可选属性，如果没有指定value属性，则使用ValueStack栈顶的集合。

例：

<s:iterator var="u" value="users" status="sts">

<s:property value="#sts"/>

<s:property value="#u"/><br/>

</s:iterator>

如果为<s:iterator/>标签指定status属性，即每次迭代时都会有一个IteratorStatus实例，该实例的方法包含如下几个：

Int getCount():返回当前迭代了几个元素；

Int getIndex():返回当前元素的索引；

Boolean isEven(): 当前元素的索引是否是偶数；

Boolean isFirst()：当前元素是否是第一个元素；

Boolean isLast()：当前元素是否是最后一个元素；

Boolean isOdd()：当前元素的索引是否是奇数；

append标签：

用于将多个集合拼接起来，组成一个新的集合，通过阵中的拼接，从而允许通过一个<s:iterator …./>标签就完成对多个集合的迭代。

merge标签的用法看起来很像append标签，也是用于将多个集合拼接成一个集合但是采用的拼接方式与append不同，append是以集合位顺序的拼接，merge是以元素位顺序拼接；

generator标签：指定字符串按指定分隔符分隔成多个子串，临时生成多个子串可以使用iterator标签来迭代输出。可以理解我generator将一个字符串转化成一个集合，在该标签的标签体内，整个临时生成的集合将位于Valuestack的顶端，但一旦该标签结束，该集合将被移除Valuestack。

属性有count：指定生成集合中元素的总数，separator：指定用于解析字符串的分隔符；val：指定被解析的字符串；converter：制定一个转化器，该转化器负责将集合中的每个字符串转化成对象；id：可选属性，制定了该属性，则将生成的集合放在pageContext属性中；

Subset标签：用于取得集合的子集，该标签的底层通过org.apache.Struts2.util.Subset.IteratorFilter类提供实现。属性有：

count：指定生成集合中元素的总数，如果不指定该属性，默认取得源集合的全部元素。还有source，start，decider属性；

subset标签生成的子集放在ValueStack的栈顶，如果该标签结束后，该标签生成的子集将被移除出ValueStack栈。

Sort标签指定集合元素进行排序，进行排序是=时，必须提供自己的排序规则，即使实现自己的Comparator，自己的Comparator需要实现java.util.Comparator接口。属性有：

Comparator：该属性指定进行排序的Comparator实例。source：该属性指定排序的集合。如果不指定该属性，则对ValueStack栈顶的集合进行排序。

(二)、数据标签：

数据标签主要用于提供各种数据范文相关的功能，包含显示一个Action里的属性，以及生成国际化输出等功能，

数据标签主要包含：action，bean，date，debug，i18n，include，param，push，set，text，url，property；

1、 action:用于直接在JSP页面直接调用一个Action，通过指定executeResult参数，还可以将该Action的处理结果包含到本页面中来。如果指定了executeResult参数的属性值为true，该标签还会把Action的处理结果包含到本页面中来。属性有：

i. id：该属性会作为该Action的应用ID

ii. name：指定该标签调用哪个Action

iii. nameSpace：指定该标签调用的Action所在的namespace

iv. executeResult：该是属性指定是否要将action 的处理结果页面包含到本页面。默认值为false，即不包含。

v. ignoreContextParams：指定该页面中的参数是否需要转入调用Action，该参数的默认值是false，即将本页面的请求参数传入被调用的Action。

2、bean：用于创建一个JavaBEan实例，如果指定id属性，则可以将创建的JavaBean实例放入Stack Context中。属性有name：指定要实例化的JavaBean的实现类；id：该属性是个可选属性，指定该属性后该实例JavaBean实例会被放入到Stack Context中(并不是ValueStack) ，从而允许直接通过该id属性来访问该JavaBean实例；

3、date：用于格式化输出一个日期。属性有：format：根据该属性指定的格式来个事化日期；nice：该属性只能为true或false，它用于指定是否输出指定日期和当前时刻之间的时差；name指定要格式化的日期值；id：制定引用该元素的id值。

4、debug：主要用于辅助调试，在页面上生成一个调试链接，通过该链接到ValueStack和Stack Context中的所有的值信息；

例：<s:debug />

5、i18n：用于制定国际化资源的文件的baseName

6、include：用于JSP页面中包含其他的JSP或Servlet资源，属性有value：指定需要被包含的JSP页面或者Servlet；id指定该标签的ID引用

例：<s:include value=”include-file.jsp”>

<s:param name=”author” value=”yeeku”/>

</s:inlcude>

7、param：通常用作bean标签，url标签的子标签，属性有name:指定需要设置参数的参数名；value：指定需要设置参数的参数值；id:指定引用该元素的ID

例：<s:param name=”color”>blue</param>

或<s:param name=”color” value=”blue”/>

8、push：用于将某个值放到ValueStack的栈顶。属性有：value：该属性指定需要放到ValueStack栈顶的值；id：指定引用该元素的ID

例：<s:push value=”#p”>

<s:property value=”name”/><br>

</s:push>

9、set：用于设置一个新变量，并可以将新变量放入到指定的范围内，属性有name：重新生成的新变量的名字；scope：可选属性，指定新变量被放置的范围，属性值有application、session、requset、page、action，没有指定属性，则默认为放置到Stack Context中；value：指定将赋值给变量的值，如果没有制定该属性，则将ValueStack栈顶的支付给行变量；id：指定该元素的引用ID；

例：<s:set value=”#p” name=”xxx”/>

10、text：用于输出国际化消息

11、url：用于生一个URL地址,属性有：includeParams该属性指定包含的参数，属性值只能为none，get，all;scheme用于设置scheme属性；value指定生成URL的地址值，如果value不提供就有action属性指定的Action作为URL地址；action指定生成URL的地址为那个Action，如果不提供，就用valuezuoweiURL的地址值；namespace；

method；encode指定是否需要encode指定是否需要encode请求属性；includeContext指定是否需要将上下文包含在URL地址中；anchor指定URL的锚点；id;

12、property：用于生成输出某个值，包括输出ValueStack，Stack，Context和Action Context中得值。属性有default如果需要输出的属性值为null，则显示的default属性指定的值；espcape指定是否escape HTML代码；value 到指定需要输出的属性值，如果没有指定该属性，则默认输出ValueStack栈顶的值；id指定该元素的标识；

（三）、表单标签

Struts2的表单标签，可分为两种：form表单本身和单个表单元素的标签。Form标签本身的行为不同于表单元素的标签。Struts2的表单元素标签都包含了非常多的属性，但有很多属性完全是通用的。

1）、表单标签的通用属性

所有表单标签处理类都继承了UIBean类，UIBean包含了一些通用属性，分为3种：

1、模板相关属性

2、 JavaScript相关属性

3、通用属性

除此之外，所有表单元素标签都存在一个特殊属性：form,通过该属性可以实现表单元素和表单之间的交互。例如，我们可以通过${parameters.form.id}来取得表单元素所在表单的ID。下面是表单标签的通用属性。

模板相关的通用属性如下：

1、 templateDir：指定该表单所用的模板文件目录。

2、 theme：指定该表单所用的主题

3、 template：指定该表单所用的模板

JavaScript相关的通用属性如下：

1、 onclick：指定鼠标在该标签生成的表单元素上单击时触发的JavaScript函数。

2、 ondbclick：指定鼠标在该标签生成的表单元素上双击时触发的JavaScript函数。

3、 onmousedown：指定鼠标在该标签生成的表单元素上按下时触发的JavaScript函数。

4、 onmouseup：指定鼠标在该标签生成的表单元素上松开时触发的JavaScript函数。

5、 onmouseover：指定鼠标在该标签生成的表单元素上悬停时触发的JavaScript函数。

6、 onmouseout：指定鼠标移除该标签生成的表单元素时触发的函数。

7、 onfocus：指定该标签生成的表单元素得到焦点时触发的函数。

8、 onblur：指定该标签生成的表单元素失去焦点时触发的函数。

9、 onkeypress：指定单击键盘上某个键时触发的函数。

10、onkeyup：指定松开键盘上某个键时触发的函数。

11、onkeydown：指定按下键盘上某个键时触发的函数。

12、onselect：对下拉列表项等可以选择表单的元素，指定选中该元素时触发的JavaScript函数。

13、 onchange：对于文本框等可以接受输入的表单元素，指定当值改变时触发的javaScript函数。

因为Html本身的限制，并不是每个Html元素都可以触发以上的所有函数。因此，上面的属性并不是对Struts2 的每个标签都有效。

Struts2还允许为表单元素设置提示，单鼠标在这些元素上停悬时，系统将出现提示。Struts2将这种特性称为Tooltip。相关的通用属性如下：

1、 tooltip：设置此组件的Tooltip。

2、 tooltipIcon：设置Tooltip图标的URL路径。

3、 tooltipAboveMousePointer：是否在光标位置上显示Toopltip。也可以通过设置tooltipOffseY属性，设置Tooltip与光标位置的垂直位移。

4、 tooltipBgColor：设置Tooltip的背景色。

5、 tooltipBgImg：设置Tooltip的背景图片。

6、 tooltipBorderWidth：设置Tooltip边框的宽度

2）、表单标签的name和value属性

Name和value属性之间存在一个独特的关系：因为表单元素的name属性会映射到Action的属性当对应的Action已经被实例化，且对应属性有值时，表单元素会显示出该属性的值，该值就是表单元素的value值。

3）、 checkboxlist标签

checkboxlist标签可以一次创建多个复选框，要根据list属性指定的集合。还有两个常用的属性。

1、 listKey：该属性指定集合元素中的某个属性作为复选框的value值

2、 listValue：该属性指定集合元素中的某个属性作为复选框的标签。

4）、 doubleselect标签

doubleselect标签会生成一个级联列表框（会生成两个下拉列表框），当选第一个列表框时，第二个的内容也会随之改变。常用属性如下：

1、 list：指定用于输出第一个下拉列表框中选项的集合

2、 listKey：该属性指定集合元素中的某个属性作为复选框的value值

3、 listValue：该属性指定集合元素中的某个属性作为复选框的标签。

4、 doubleList：指定用于输出的第一个下拉列表框中选项的集合

5、 doubleList key：该属性指定集合元素中的某个属性作为复选框的value值

6、 doubleList Value：该属性指定集合元素中的某个属性作为复选框的标签。

7、 doubleName：指定第二个下拉列表框的name属性。

一、 head标签

二、 optiontransferseselect标签

三、 select标签

四、 radio标签

五、 optgroup标签

六、 token标签

七、 updownselect标签

非表单标签

一、 actionerror和actionmessage标签

二、 component标签

三、 tree和treenode初步

四JSTL

JSP 标准标记库（ Standard Tag Library， JSTL)是一组以标准化格式实现许多通用的 Web站点功能的定制标记。

JSP 技术的优势之一在于其定制标记库工具。除了核心 JSP标记，如 jsp:include之外，定制标记库工具使您能够创建唯一的标记来描述以站点或应用程序为导向的操作。一旦您创建了定制标记库 (简称 taglib)，当您扩展项目或转向另一个项目时您可以重复使用这些标记。您还可以将 taglib传递给其它开发人员，从而他们可以在自己的网站上使用，或者在您 Web应用程序的其它部分使用。

JSTL 的目标是为了简化 JSP页面的设计。对于页面设计人员来说，使用脚本语言（默认值是 JAVA语言）操作动态数据是比较困难的，而采用标签和表达式语言相对容易一些， JSTL的使用为页面设计人员和程序开发人员的分工协作提供了便利。

一．配置 JSTL

包括两个 JAR 文件， jstl.jar 和 standard.jar。是什么没有必要管，重在应用（ 1+1？ =2，我们没有必要深究，只需要知道这么用就行。）。

原文引入：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

二． Core 标签库

Core 标签库主要包括了一般用途的标签、条件标签、迭代标签和 URL相关的标签。在 JSP页面使用 Core标签，要使用 taglig指令，指定引用的标签库，如下：

<%@ taglib rui=”http://java.sun.com/jsp/jstl/core” prefix=”c” %>

一般用途的标签有<c:out>、<c:set>、<c:remove>、<c:cath>

1.<c:out>

用于计算一个表达式并将结果输出。类似于 JSP中 <%=%>表达式，或者是 EL中 $ ${el-expression}。

2.<c:set>

用于设置范围变量的值或者 javabean对象的属性。

看个实际例子：

<c:set var=”username” value=”lisi” scope=”session”/>

这样就相当于设置了 session。

3.<c:remove>

相对 <c:set> 其作用是移除范围变量。比如： <c:remove var=”nusername” scope=”session”/>

4.<c:catch>

用于捕获在其中嵌套的操作所抛出的异常对象，并将异常信息保存到变量中。

我们将有可能抛出异常的代码放置到开始标签 :<c:catch>和结束标签 :</c:catch>之间。如果其中代码出现异常，异常对象将被捕获，保存在 var声明的变量中，该变量总是有 page范围。如果没有发生异常，而 var所标识的范围变量将被移除。

如果没有指定 var 属性，异常只是简单的被捕获，异常信息并不会被保存。

Eg ：

<c:catch var=”exception”>

int i = 5;

int j = 0;

int k=i/j;

</c:catch>

<c:out value=”${exception}” /><br>

<c:out value=”${exception.massage}”/>

后一句相当于： exception.getMessage()

条件标签包括<c:if><c:choose><c:when><c:otherwise>

1.<c:if>

用于实现 java 中的 if 语句功能。

<c:if test=”${user.visitCount==1}”>

This is your first visit .

</c:if>

若为 true ，会打印中间部分。也可以声明 var ，方便下一步判断。

<c:if test=”${param.name==’admin’}” value=”result”/>

<c:out value=”${result}” />

2.<c:choose>

<c:choose> 和 <c:when>、 <c:otherwise>一起实现互斥条件执行，类似于 java中的 if else.

<c:choose> 一般作为 <c:when>、 <c:otherwise>的父标签。

eg ：

<c:choose>

<c:when test="${row.v_money<10000}">

初学下海

</c:when>

<c:when test="${row.v_money>=10000&&row.v_money<20000}">

身手小试

</c:when>

<c:otherwise>

商业能手

</c:otherwise>

</c:choose>

迭代标签迭代标签有<c:forEach>和</c:forEach>

// 遍历记录集

<c:forEach items="${finalResult.rows}" var="row">

</tr>

<%rank++;%>

</c:forEach>

也可以设定固定次数。

<c:forEach var =”i” begin=”100 “ end= “110”>

${i}

</c:forEach>

如果再加个 step= “ 2 ”那么每次增长为 2。

三． sql 标签

设置数据源：

<sql:setDataSource dataSource="proxool.breadTycoon" />

// 将数据库某查询的结果声明为一个变量

<sql:query var="finalResult" >

select player_name,money from tb_player order by money DESC LIMIT 10

</sql:query>

然后可以：

<c:forEach items="${ finalResult.rows}" var="row" varStatus="s">

advCosts[${s.index}]=${row.adv_cost};

</c:forEach>

数据更新标签：

<sql:update>

call proc_set_role_salespro(?,?,?,?,?);

<sql:param value="30"/>

<sql:param value="39"/>

<sql:param value="<%=spID%>"/>

<sql:param value="<%=productID%>"/>

<sql:param value="1"/>

</sql:update>

<sql:query var="queryAllChannelCount">

SELECT COUNT(*) as total FROM tb_channel WHERE game_id=? AND begin_round<func_cur_round(?) AND player_id=? AND channel_flag=0

<sql:param value="${gameID}"/>

<sql:param value="${playerID}"/>

</sql:query>

<c:forEach items="${queryAllChannelCount.rowsByIndex}" var="channelCN">

<c:set value="${channelCN[0]}" var="channelTotal"/>

</c:forEach>

调用存储过程更新数据库：

<c:if test="${param.changsubmit!=null}" >

<c:forEach items="${paramValues.pro_id}" var="getpro_id" varStatus="getparamsta">

<sql:update>

call proc_set_role_product(?,?,?,?,?,?,?,?);

<sql:param value="${gameID}"/>

<sql:param value="${playerID}"/>

<sql:param value="${getpro_id}"/>

<sql:param value="${paramValues.pro_sort[getparamsta.index]}"/>

<sql:param value="${paramValues.price[getparamsta.index]}"/>

<sql:param value="${paramValues.output[getparamsta.index]}"/>

<sql:param value="0"/>

</sql:update>

</c:forEach>

</c:if>

四．格式化标签

<fmt: formatNumber value =”12.3” pattern=”.000”/>

将输出 12.300. 应用样式 ”.000”, 将使格式化后的小数部分有 3位。不足 3位将以 0补齐。

<fmt:formatDate value=”<%=new java.util.Date() %>” type=”date” />

格式化的结果是： 2007-5-27 .

<fmt:formatDate value=”<%=new java.util.Date() %>” type=”time” />

格式化的结果是： 9:25:11

<fmt:formatDate value=”<%=new java.util.Date() %>” type=”both” />

格式化的结果是： 2007-5-27 9:25:11

补充知识点：

1. 替换 request.getParameter("test"):

<c:if test="${param.test!=null}" >

<c:out value="${param.test}" />

</c:if>

2. <c:redirect url="a.jsp">

3.<c:redirect url="/max.jsp" context="/ch16">

<c:param name="name1" value="665"/>

<c:param name="name3" value="斯蒂芬 "/>

</c:redirect>

4.<c:forTokens items="zhangsan:lisi:as" delims=":" var="name">

${name}

</c:forTokens>

JSTL核心标签库使用

JSTL 核心标签库标签共有13个，功能上分为4类：

1.表达式控制标签：out、set、remove、catch

2.流程控制标签：if、choose、when、otherwise

3.循环标签：forEach、forTokens

4.URL操作标签：import、url、redirect

使用标签时，一定要在jsp文件头加入以下代码：

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

下面分别对这些标签进行说明：

1. <c:out>用来显示数据对象（字符串、表达式）的内容或结果

使用Java脚本的方式为：<% out.println("hello") %> <% =表达式 %>

使用JSTL标签：<c:out value="字符串">，例如：

<body>
<c:outvalue="&lt要显示的数据对象（未使用转义字符）&gt" escapeXml="true" default="默认值"></c:out><br/>
<c:outvalue="&lt要显示的数据对象（使用转义字符）&gt" escapeXml="false" default="默认值"></c:out><br/>
<c:outvalue="${null}" escapeXml="false">使用的表达式结果为null，则输出该默认值</c:out><br/>
</body>

那么网页显示效果为：

2. <c:set>用于将变量存取于 JSP范围中或 JavaBean属性中。下面的例子中假设已经有 Person.java这个类文件。

<%@ page language="java" import="java.util.*" pageEncoding="gb2312"%>
<%@page contentType="text/html; charset=utf-8"%>

<jsp:useBeanid="person" class="lihui.Person"></jsp:useBean>

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>JSTL测试</title>
</head>

<body>
<c:setvalue="张三" var="name1" scope="session"></c:set>
<c:setvar="name2" scope="session">李四</c:set>
<c:setvalue="赵五" target="${person}" property="name"></c:set>
<c:settarget="${person}" property="age">19</c:set>
<li>从session中得到的值：${sessionScope.name1}</li>
<li>从session中得到的值：${sessionScope.name2}</li>
<li>从Bean中获取对象person的name值：<c:outvalue="${person.name}"></c:out></li>
<li>从Bean中获取对象person的age值：<c:outvalue="${person.age}"></c:out></li>
</body>
</html>

一共有四种语法格式，前两种是给jsp的范围变量赋值，后两个是给 javabean变量赋值

效果如下：

3.<c:remove>主要用来从指定的 jsp范围内移除指定的变量。使用类似，下面只给出语法：

<c:remove var="变量名" [scope="page|request|session|application"]></c:remove>

4.<c:catch> 用来处理 JSP页面中产生的异常，并存储异常信息

<c:catch var="name1">

容易产生异常的代码

</c:catch>

如果抛异常，则异常信息保存在变量 name1中。

5.<c:if>

<c:if test="条件1" var="name" [scope="page|request|session|application"]></c:remove>

例：

效果：

6. <c:choose> <c:when> <c:otherwise>三个标签通常嵌套使用，第一个标签在最外层，最后一个标签在嵌套中只能使用一次

例：

   <c:setvar="score">85</c:set>
    <c:choose>
    <c:whentest="${score>=90}">
    你的成绩为优秀！
    </c:when>
    <c:whentest="${score>=70&&score<90}">
    您的成绩为良好!
    </c:when>
    <c:whentest="${score>60&&score<70}">
    您的成绩为及格
    </c:when>
    <c:otherwise>
    对不起，您没有通过考试！
    </c:otherwise>
    </c:choose>

7.<c:forEach>

语法：<c:forEach var="name" items="Collection" varStatus="statusName" begin="begin" end="end" step="step"></c:forEach>

该标签根据循环条件遍历集合 Collection中的元素。 var用于存储从集合中取出的元素；items指定要遍历的集合；varStatus用于存放集合中元素的信息。varStatus一共有4种状态属性，下面例子中说明：

View Code

1<%@ page contentType="text/html;charset=GBK"%>
2<%@page import="java.util.List"%>
3<%@page import="java.util.ArrayList"%>
4<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
5<html>
6<head>
7    <title>JSTL: -- forEach标签实例</title>
8</head>
9<body>
10<h4><c:outvalue="forEach实例"/></h4>
11<hr>
12    <%
13        List a=new ArrayList();
14        a.add("贝贝");
15        a.add("晶晶");
16        a.add("欢欢");
17        a.add("莹莹");
18        a.add("妮妮");
19    request.setAttribute("a",a);
20%>
21    <B><c:outvalue="不指定begin和end的迭代："/></B><br>
22    <c:forEachvar="fuwa" items="${a}">
23     <c:outvalue="${fuwa}"/><br>
24    </c:forEach>
25    <B><c:outvalue="指定begin和end的迭代："/></B><br>
26    <c:forEachvar="fuwa" items="${a}" begin="1" end="3" step="2">
27     <c:outvalue="${fuwa}"/><br>
28    </c:forEach>
29    <B><c:outvalue="输出整个迭代的信息："/></B><br>
30    <c:forEachvar="fuwa" items="${a}" begin="3" end="4" step="1" varStatus="s">
31     <c:outvalue="${fuwa}"/>的四种属性：<br>
32      所在位置，即索引：<c:outvalue="${s.index}"/><br>
33      总共已迭代的次数：<c:outvalue="${s.count}"/><br>
34      是否为第一个位置：<c:outvalue="${s.first}"/><br>
35      是否为最后一个位置：<c:outvalue="${s.last}"/><br>
36    </c:forEach>
37</body>
38</html>

显示效果：

8.<c:forTokens>用于浏览字符串，并根据指定的字符串截取字符串
语法：<c:forTokens items="stringOfTokens" delims="delimiters" [var="name" begin="begin" end="end" step="len" varStatus="statusName"]></c:forTokens>

还是看个例子吧：

View Code

1<%@ page contentType="text/html;charset=GBK"%>
2<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
3<html>
4    <head>
5        <title>JSTL: -- forTokens标签实例</title>
6    </head>
7    <body>
8        <h4>
9            <c:outvalue="forToken实例"/>
10        </h4>
11        <hr>
12        <c:forTokensitems="北、京、欢、迎、您" delims="、" var="c1">
13            <c:outvalue="${c1}"></c:out>
14        </c:forTokens>
15        <br>
16        <c:forTokensitems="123-4567-8854" delims="-" var="t">
17            <c:outvalue="${t}"></c:out>
18        </c:forTokens>
19        <br>
20        <c:forTokensitems="1*2*3*4*5*6*7" delims="*" begin="1" end="3"
21            var="n" varStatus="s">
22     <c:outvalue="${n}"/>的四种属性：<br>
23          所在位置，即索引：<c:outvalue="${s.index}"/>
24            <br>
25          总共已迭代的次数：<c:outvalue="${s.count}"/>
26            <br>
27          是否为第一个位置：<c:outvalue="${s.first}"/>
28            <br>
29          是否为最后一个位置：<c:outvalue="${s.last}"/>
30            <br>
31        </c:forTokens>
32    </body>
33</html>

显示结果：

9.URL操作标签

（1）<c:import>把其他静态或动态文件包含到 JSP 页面。与<jsp:include>的区别是后者只能包含同一个web应用中的文件，前者可以包含其他web应用中的文件，甚至是网络上的资源。

语法：<c:import url="url" [context="context"] [value="value"] [scope="..."] [charEncoding="encoding"]></c:import>

<c:import url="url" varReader="name" [context="context"][charEncoding="encoding"]></c:import>

看个例子：

View Code

1<%@ page contentType="text/html;charset=GBK"%>
2<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
3<html>
4    <head>
5         <title>JSTL: -- import标签实例</title>
6    </head>
7    <body>
8        <h4>
9            <c:outvalue="import实例"/>
10        </h4>
11        <hr>
12        <h4>
13            <c:outvalue="绝对路径引用的实例"/>
14        </h4>
15        <c:catchvar="error1">
16            <c:importurl="http://www.baidu.com"/>
17        </c:catch>
18        <c:outvalue="${error1}"></c:out>
19        <hr>
20        <h4>
21            <c:outvalue="相对路径引用的实例，引用本应用中的文件"/>
22        </h4>
23        <c:catch>
24            <c:importurl="a1.txt" charEncoding="gbk"/>
25        </c:catch>
26        <hr>
27        <h4>
28            <c:outvalue="使用字符串输出、相对路径引用的实例，并保存在session范围内"/>
29        </h4>
30        <c:catchvar="error3">
31            <c:importvar="myurl" url="a1.txt" scope="session" charEncoding="gbk"></c:import>
32            <c:outvalue="${myurl}"></c:out>
33            <c:outvalue="${myurl}"/>
34        </c:catch>
35        <c:outvalue="${error3}"></c:out>
36    </body>
37</html>

显示结果：

URL路径有个绝对路径和相对路径。相对路径：<c:import url="a.txt"/>那么，a.txt必须与当前文件放在同一个文件目录下。如果以"/"开头，表示存放在应用程序的根目录下，如Tomcat应用程序的根目录文件夹为 webapps。导入该文件夹下的 b.txt的编写方式： <c:import url="/b.txt">。如果要访问webapps管理文件夹中的其他Web应用，就要用context属性。例如访问demoProj下的index.jsp，则：<c:import url="/index.jsp" context="/demoProj"/>.

（2）<c:redirect>该标签用来实现请求的重定向。例如，对用户输入的用户名和密码进行验证，不成功则重定向到登录页面。或者实现Web应用不同模块之间的衔接

语法：<c:redirect url="url" [context="context"]/>

或：<c:redirect url="url" [context="context"]>

<c:param name="name1" value="value1">

</c:redirect>

看个例子：

1<%@ page contentType="text/html;charset=GBK"%>
2<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
3<c:redirecturl="http://127.0.0.1:8080">
4 <c:paramname="uname">lihui</c:param>
5 <c:paramname="password">11111</c:param>
6</c:redirect>

则运行后，页面跳转为：http://127.0.0.1:8080/?uname=lihui&password=11111

（3）<c:url>用于动态生成一个 String 类型的URL，可以同上个标签共同使用，也可以使用HTML的<a>标签实验超链接。

语法：<c:url value="value" [var="name"] [scope="..."] [context="context"]>

<c:param name="name1" value="value1">

</c:url>

或：<c:url value="value" [var="name"] [scope="..."] [context="context"]/>

看个例子：

View Code

1<%@ page contentType="text/html;charset=GBK"%>
2<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
3<c:outvalue="url标签使用"></c:out>
4<h4>
5 使用url标签生成一个动态的url，并把值存入session中.
6</h4>
7<hr>
8<c:urlvalue="http://127.0.0.1:8080" var="url" scope="session">
9</c:url>
10<ahref="${url}">Tomcat首页</a>

显示：

1）访问bean的属性（就是普通的Java类，有属性和get/set方法）

第一种方式：例如：${user.name}，容器会依次从4个隐含对象中pageContext、request、session、application中查找（getAttribute）绑定名为"user"的对象。接下来，会调用该对象的"getName"方法（自动将n变大写然后加get），最后输出执行结果。

优点：①会自动将null转换成""输出。

②如果绑定名称对应的值不存在，会不报null指针异常，会输出""。

u 注意事项：依次是指先从pageContext中查找，如果找不到，再查找request，如果找到了，则不再向下查找。如果要指定查找范围，可以使用pageScope、requestScope、sessionScope、applicationScope来指定查找的范围。

eg：jsp页面测试

<% User user=new User(); user.setName("chang"); user.setAge(22);

request.setAttribute("user",user); User user2=new User(); user2.setName("bo"); user2.setAge(22); session.setAttribute("user",user2); %>

name：<% User user=(User)request.getAttribute("user"); out.println(user.getName()); %>

name：${user.name}<br />

name：${sessionScope.user.name}

第二种方式：比如${user["name"]}，与第一种方式是等价的！容器会依次从4个隐含对象中pageContext、request、session、application中查找（getAttribute）绑定名为"user"的对象。接下来，会调用该对象的"getName"方法（自动将n变大写然后加get），最后输出执行结果。

优点：①中括号[]里面可以出现变量。②中括号[]里面可以出现下标从0开始的数组。

u 注意事项：

v 中括号[]里的字符串用双引号、单引号都可以！

v EL表达式中没引号的为变量，有引号的为字符串。

eg：jsp页面测试

step1：User类

private String name; private int age; private String[] interest;

private IdCard card; ……get/set方法

step2：IdCard类

private String cardNo; ……get/set方法

step3：jsp页面

<% User user=new User(); user.setName("chang"); user.setAge(22);

user.setInterest(new String[]{"台球","乒乓球"});

user.setCard(new IdCard("1008611")); request.setAttribute("user",user); %>

name：${user["name"]}<br />

<% request.setAttribute("propname","age"); %>

name：${user[propname]}<br />

interest：${user.interest}<br />

interest：${user.interest[1]}<br />

IdCard：${user.card.cardNo }

2）进行一些简单的计算，计算的结果可以用来给JSP标签的属性赋值，也可以直接输出。

①算术运算：“+”、“-”、“*”、“/”、“%”

u 注意事项："+"号操作不能连接字符串。如"abc"+"bcd"会报错！"100"+"200"=${"100"+"200"}可以！

②关系运算：“>”、“>=”、“<”、“<=”、“!=”、"=="

u 注意事项：“eq”也可判断是否相等

eg：相关测试

1>0?${1>0 }<br />

<% request.setAttribute("str1","abc"); request.setAttribute("str2","bcd"); %>

${str1==str2}<br /> ${str1=="abc"}<br />

eq：${str1 eq "abc" }<br /> ${sessionScope.str1=="abc"}<br />

③逻辑运算："&&"、"||"、"!"，与Java中的一样

④empty运算：判断是否是一个空字符串，或者是一个空的集合，如果是，返回true。

以下四种情况都是true：A.空字符串。B.空集合。C.null。

D.根据绑定名找不到值。

eg：相关测试

<% request.setAttribute("str3",""); %>

空字符串：${empty str3 }<br />

<% List<String> list1=new ArrayList<String>(); //list1.add("abc");//false

request.setAttribute("list1",list1); %>

空集合：${empty list1 }<br />

<% request.setAttribute("obj",null); %>

null：${empty obj }<br />

找不到值：${empty abc }<br />

发呆程序员

关注

1
点赞
踩
27

收藏

觉得还不错? 一键收藏
0
评论
JSP页面中常用四种标签

JSP页面常用四种标签：1. EL表达式: ${}2. jstl表达式（sun apache）: uri="http://java.sun.com/jsp/jstl/core" %> uri="http://java.sun.com/jsp/jstl/functions" %> uri="http://java.sun.com/jsp/jstl/fmt" %>3.
复制链接

扫一扫