if

New Help > core >
if

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 : <c:if>动作仅当所指定的表达式计算为true时才计算其体。计算结果也可以保存为一个作用域Boolean变量。

语法 :

语法1：没有体

<c:if test=" booleanExpression "

var=" var " [scope=" page |request|session|application"]/>

语法2：有体

<c:if test=" booleanExpression ">

JSP elements

</c:if>

属性 :

属性名 | 描述 | 类型 | 是否接受动态值 | 是否支持 EL | 是否 必须 | 默认值 | 说明
test | 测试表达式 | boolean | Y | Y | 是 | 无 | 如果表达式的结果为true则执行body,false则相反
var | 变量名 | String | N | N | 否 | 无 | 用来存储test运算后的结果，即true或false
scope | 变量作用域 | String | N | N | 否 | page | var变量的JSP范围

实例 :

<c:if test="${empty param.empDate}">

<jsp:forward page="input.jsp">

<jsp:param name="msg" value="Missing the Employment Date" />

</jsp:forward>

</c:if>

Copyright 2003-2012 Your company name(Edit the text to change this template.)


out

New Help > core >
out

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 :<c:out> 标签是一个最常用的标签，用于在 JSP 中显示数据。 它的作用是用来替代通过 JSP 内 置对象 out 或者 <%=%> 标签来输出对象的值。

语法 :

没有Body时的语法

<c:out value=”value” [escapeXml=”{true|false}”] [default=”defaultValue”]/>

有Body时的语法

<c:out value=”value” [escapeXml=”{true|false}”]>

这里是Body部分

</c:out>

属性 :

属性名 | 描述 | 类型 | 是否接受动态值 | 是否支持 EL | 是否 必须 | 默认值 | 说明
value | 需要显示的值 | Object | Y | Y | Y | 无 | 用来定义需要求解的表达式。
escapeXml | 是否转换特殊字符 | boolean | Y | Y | N | true | 用于指定在使用 <c:out> 标记输出诸如“ < ”、“ > ”、“ ’ ”、“ ” ”和“ & ”之类的字符（在 HTML 和 XML 中具有特殊意义）时是否应该进行转义。如果将 escapeXml 设置为 true ，则会自动的进行编码处理。
default | 缺省值 | Object | Y | Y | N | 无 | 当求解后的表达式为 null 或者String 为空时将打印这个缺省值。

Null和错误说明

假若value为null,会显示default的值；假若没有设定default的值，则会显示一个空的字符串。

实例 :

------------------------------------------------------------------------------------------------------------------------------------------

Example1

<c:out value="${sessionScope.anyValue}" default="no value" escapeXml="false"/>

该示例将从Session查找名为“anyValue”的参数，并显示在页面，若没有找到则显示“no value”。

------------------------------------------------------------------------------------------------------------------------------------------

Example2

您的用户名是: <c:out value=”${user.username}” default=”guest”/>

显示用户的用户名，如为空则显示guest

<c:out value="${sessionScope.username}"/>

指定从session中获取username的值显示；

<c:out value="${username}" />

显示username的值，默认是从request(page)中取，如果request中没有名为username的对象则从session中取，session中没有则从application(servletContext)中取，如果没有取到任何值则不显示


forEach

New Help > core >
forEach

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 : <c:forEach>动作将其体反复计算固定次数，或者针对一个集合中的每个元素分别计算一次体。当前元素（如果未指定集合则为当前索引）和迭代状态可以通过嵌套变量提供给体中的动作元素。

此动作接受属性表中所列的类型集合。当前元素的类型即为底层集合的类型，仅有两个例外。对于一个基本类型的数组，当前元素将作为相应包装类（Integer、Float等等）的一个实例提供。对于一个java.util.Map，当前元素则作为一个java.util.Map.Entry提供。

语法 :

语法1：基于集合元素进行迭代

<c:forEach items="collection" [var="var"] [varStatus="varStatus"]

[begin="startIndex"] [end="stopIndex"] [step="increment"]>

JSP elements

</c:forEach>

语法2：迭代固定次数

<c:forEach [var="var"] [varStatus="varStatus"]

begin="startIndex" end="stopIndex" [step="increment"]>

JSP elements

</c:forEach>

属性 :

属性名 | 描述 | 类型 | 是否接受动态值 | 是否支持 EL | 是否 必须 | 默认值 | 说明
begin | 开始位置 | int | Y | Y | 否 | 0 | 结合集合使用时的开始索引，从0计起。对于集合来说默认为0
end | 结束位置 | int | Y | Y | 否 | 最后一个成员 | 结合集合使用时的结束索引（元素引要小于等于此结束索引），从0计起。默认为集合的最后一个元素。如果end小于begin，则根本不计算体集合，迭代即要针对此集合进行。
items | 被迭代的集合对象 | Collection, Iterator, Enumeration, Map, 数组 | Y | Y | 否 | 无 | 集合，迭代即要针对此集合进行。
step | 步长 | int | Y | Y |  | 1 | 每次迭代时索引的递增值。默认为1。
var | 当前项目 | String | N | N | 否 | 无 | 保存当前元素的嵌套变量的名字。
varStatus | 循环状态 | String | N | N | 否 | 无 | 保存LoopTagStatus对象的嵌套变量的名字。

Null 和 错误处理

.假若items为null时，则表示为一空的集合对象

.假若begin大于或等于items时，则迭代不运算

注意:

varName的范围只存在<c:forEach>的本体中，如果超出了本题，则不能取得varName的值。如:

<c:forEach items="${atts}" var="item">

</c:forEach>

${item}</br>

${item}则不会显示item的内容。<c:forEach>除了支持数组之外，还有标准的J2SE的结合类型，例如:

ArrayList,List,LinkedList,Vector,Stack和Set等等；另外包括java.util.Map类的对象，例如:

HashMap,Hashtable,Properties,Provider和Attributes。

另外<c:forEach>还提供了varStatus属性，主要用来存放现在指到成员的相关信息。例如：我们写成

varStatus="s",那么就会把信息存放到名称为s的属性当中。varStatus属性还提供另外四个属性:index,

count,fist和last，它们个自的意义如下:

属性 类型 意义

index number 现在指到成员的索引

count number 总共指到成员的总和

first boolean 现在指到成员是否为第一个

last boolean 现在指到成员是否为最后一个

实例 :

----------------------------------------------------------------------------------------------------------------------------------------

Example1

<%

String atts[] = new String[5];

atts[0]="hello";

atts[1]="this";

atts[2]="is";

atts[3]="a";

atts[4]="girl";

request.setAttritue("atts",atts);

%>

<c:forEach items="${atts}" var="item" varStatus="s">

<h2><c:out value="${item}"/>的四种属性></h2>

index: ${s.index}</br>

count: ${s.count}</br>

first: ${s.first}</br>

last: ${s.last}</br>

</c:forEach>

----------------------------------------------------------------------------------------------------------------------------------------

Example2

综合实例

< select >

< c:forEach  items = " ${model.options} "   var = "forum" >

  < c:choose >

     < c:when  test = " ${forum.id == model.forumId} " >

     < option  value = " ${forum.id} "   elected > ${forum.name} </option >

     </ c:when >

       < c:otherwise >

       < option  value = " ${forum.id} " > ${forum.name} </ option >

       </ c:otherwise >

     </ c:choose >

   </ c:forEach >

</ select >

Example3

奇偶行样式

<c:forEach items="${model.page.list}" var="observer" varStatus="loop">

< tr class="row$(loop.count%2)">

<td>迭代observer</td>

<td>迭代observer</td>

...

</tr>

</c:forEach>

Example4

分页条1

< c:set  var = "page"  value = " ${model.page} " ></ c:set >

< table  width = "800"  align = "center"  cellpadding = "0"  cellspacing = "0" >

   < tr  class = "even" >

     < td  height = "20"  align = "center"  colspan = "3"  valign = "top" >

       < a  href = "javascript:page(1)"  class = "gr_pages" > 首页 </ a >

    < c:if  test = " ${page.currentPage > 1} " >

      < a  href = " javascript:page( < c:out   value = " ${page.currentPage -1 } "   /> ) "  class = "gr_pages" > 上页 </ a >

    </ c:if >

    < c:if  test = " ${page.currentPage < page.totalPage} " >

    < a    href = " javascript:page( < c:out   value = " ${page.currentPage +1 } "   /> ) "  class = "gr_pages" > 下页 </ a >

    </ c:if >

    < a  href = " javascript:page( < c:out   value = " ${page.totalPage} "   default = "1"  /> ) "   class = "gr_pages" > 末页 </ a >

    当前第 < c:out  value = " ${page.currentPage} "   /> / < c:out  value = "${page.totalPage} "   /> 页

     </ td >

   </ tr >

</ table >

Example5

分页条2

< div  align = "center" >< span  class = "all_font12" >   < a

      href = " jsp/vote/voteAreaService.do?method=listVote¤tPage=1&subareaCode=${param.subareaCode} "   class = "gr_pages" >  首页  </ a >     < c:if

      test = " ${page.currentPage > 1 } " >

      < a

        href = " jsp/vote/voteAreaService.do?method=listVote¤tPage=${page.currentPage - 1} &subareaCode= ${param.subareaCode} "

        class = "gr_pages" >  前页  </ a >

         </ c:if >   < a

      href = " jsp/vote/voteAreaService.do?method=listVote¤tPage= ${page.currentPage}&subareaCode= ${param.subareaCode} " >

      < c:out  value = " ${page.currentPage} "   /></ a >

      < c:if

      test = " ${page.currentPage + 1 <= page.totalPage} " >

      < a

        href = " jsp/vote/voteAreaService.do?method=listVote¤tPage=${page.currentPage + 1} &subareaCode= ${param.subareaCode} " >< c:out

        value = " ${page.currentPage + 1} "   /></ a >

         </ c:if >   < c:if  test = " ${page.currentPage + 2 <= page.totalPage} " >

      < a

        href = " jsp/vote/voteAreaService.do?method=listVote¤tPage=${page.currentPage + 2} &subareaCode= ${param.subareaCode} " >< c:out

        value = " ${page.currentPage + 2} "   /></ a >

         </ c:if >   < c:if  test = " ${page.currentPage + 3 <= page.totalPage} " >

      < a

        href = " jsp/vote/voteAreaService.do?method=listVote¤tPage=${page.currentPage + 3} &subareaCode= ${param.subareaCode} " >< c:out

        value = " ${page.currentPage + 3} "   /></ a >

         </ c:if >   < c:if  test = " ${page.currentPage <page.totalPage} " >

      < a

        href = " jsp/vote/voteAreaService.do?method=listVote¤tPage=${page.currentPage + 1} &subareaCode= ${param.subareaCode} "

        class = "gr_pages" > 后页 </ a >

         </ c:if >   < a

      href = " jsp/vote/voteAreaService.do?method=listVote¤tPage= ${page.totalPage}&subareaCode= ${param.subareaCode} "

      class = "gr_pages" > 末页 </ a >   < a > 当前第 < c:out

      value = " ${page.currentPage} "   /> / < c:out

      value = " ${page.totalPage} "   /> 页 </ a ></ span ></ div >

Example6

综合实例

<%

Map map = new HashMap();

map.put("a", "12345");

map.put("b", "abcde");

out.println(map.get("a"));

request.setAttribute("map",map);

%>

<!-- 完全迭代 -->

<c:forEach items="${map}" var="mymap" >

<c:out value="${mymap.key}" />

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

</c:forEach>

<!-- 根据map的key来找到特定的值 -->

<c:forEach items="${map}" var="mymap">

<c:if test="${mymap.key=='a'}">

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

</c:if>

</c:forEach>


choose

New Help > core >
choose

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 : <c:choose>动作用于控制嵌套<c:when>和<c:otherwise>动作的处理，它只允许第一个测试表达式计算为true的<c:when>动作得到处理；如果所有<c:when>动作的测试表达式都计算为false，则会处理一个<c:otherwise>动作。<c:choose>标签没有属性，可以被认为是父标签，<c:when>、<c:otherwise>将作为其子标签来使用。

语法 :

<c:choose>

body(<when>和<otherwise>)

</c:choose>

限制:

<c:choose>的本地内容只能有:

.空白

.1或多个<c:when>

.0或多个<c:otherwise>

属性 :

无

实例 :

----------------------------------------------------------------------------------------------------------------------------------------

Example1

<c:choose>

<c:when test="${product.onSale}">

${product.salesPrice} On sale!

</c:when>

<c:otherwise>

${product.price}

</c:otherwise>

</c:choose>

---------------------------------------------------------------------------------------------------------------------------------------

Example2

<c:choose>

<c:when test="${condition1}">

condition1 为 true

</c:when>

<c:when test="${condition2}">

condition2 为 true

</c:when>

<c:otherwise>

condition1和conditon2都为false

</<c:otherwise >

说明:

在同一个<c:choose>中，假如所有的<c:when>的test都不为true时，则执行<c:otherwise>的本体内容。

在同一个<c:choose>中，假若有好几个<c:when>都会true时，只能有一个<c:when>成立。

</c:choose>


when

New Help > core >
when

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 :<c:when>标签等价于“if”语句，它包含一个test属性，该属性表示需要判断的条件。

语法 :

<c:when test="testCondition">

Body content

</c:when>

属性 :

属性名 | 描述 | 类型 | 是否接受动态值 | 是否支持 EL | 是否 必须 | 默认值 | 说明
test | 测试表达式 | boolean | Y | Y | 是 | 无 | 如果表达式的结果为true则执行body,false则相反


otherwise

New Help > core >
otherwise

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 :<c:otherwise>标签没有属性，它等价于“else”语句。

语法 :

<c:otherwise>

conditional block

</c:otherwise>

属性 :

无

实例 :

<c:choose>、<c:when>、<c:otherwise>标签 综合实例

<c:choose>

<c:when test="${paramValues.sampleValue[2] == 11}">

not 12 not 13,it is 11

</c:when>

<c:when test="${paramValues.sampleValue[2] == 12}">

not 11 not 13,it is 12

</c:when>

<c:when test="${paramValues.sampleValue[2] == 13}">

not 11 not 12,it is 13

</c:when>

<c:otherwise>

not 11 、12、13

</c:otherwise>

</c:choose>


redirect

New Help > core >
redirect

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 : 可以将客户端的请求从一个 JSP 网页导向到其他文件。

语法 :

语法1：没有本体内容

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

语法2：本体内容代表查询字符串(Query String)参数

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

<c:param>

</c:redirect >

属性 :

属性名 | 描述 | 类型 | 是否接受动态值 | 是否支持 EL | 是否 必须 | 默认值 | 说明
url | 统一资源定位器 | String | true | Y | 是 | 无 | 导向的目标地址,它可以是相对或绝对地址。
context | 上下文 | String | true | Y | 否 | 无 | 相同Container下，其他web站台必须以“/”开头

实例 :

<c:redirect> 的功能不止可以导向网页，同样它还可以传递参数给目标文件。如：

<c:redirect url="http://java.sun.com">

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

</c:redirect>


param

New Help > core >
param

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 :用于传递参数,用来为包含或重定向的页面传递参数。

语法 :

属性 :

属性名 | 描述 | 类型 | 是否接受动态值 | 是否支持 EL | 是否 必须 | 默认值 | 说明
name | 参数名 | String | true | Y | 是 | 无 | 传递的参数名
value | 参数值 | String | true | Y | 否 | 无 | 传递的参数值（可选）

实例 :

<c:redirect url="/MyHtml.jsp">

<c:param name="userName" value=”RW” />

</c:redirect>

该示例将为重定向的“MyHtml.jsp”传递指定参数“userName=’RW’”。


url

New Help > core >
url

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 : 主要用来产生一个URL。

语法 :

语法1：没有本体内容

<c:url value="value" [context="context"] [var="varName"]

[scope="{page|request|session|application}"] />

语法2：本体内容代表查询字符串(Query String)参数

<c:url value="value" [context="context"] [var="varName"]

[scope="{page|request|session|application}"] >

<c:param> 标签

</c:url>

属性 :

属性名 | 描述 | 类型 | 是否接受动态值 | 是否支持 EL | 是否 必须 | 默认值 | 说明
value |  | String | true | Y | 是 | 无 | 执行的URL
context |  | String | true | Y | 否 | 无 | 相同Container下，其他web站台必须以“/”开头
var |  | String | false | N | 否 | 无 | 储存被包含文件的内容(以String 类型存入)
scope |  | String | false | N | 否 | page | var变量的JSP范围

实例 :

<c:url value="http://www.javafan.net " >

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

</c:url>

上面执行结果将会产生一个网址为http://www.javafan.net?param=value，我们更可以搭配 HTML 的<a>使用，如下：

<a href="

<c:url value="http://www.javafan.net " >

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

</c:url>">Java爱好者</a>

如果<c:url>有 var属性时，则网址会被存到 varName中，而不会直接输出网址。


set

New Help > core >
set

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 : <c:set>标签用于为变量或JavaBean中的变量属性赋值的工作。这个标签用于在某个范围(page、request、session、application等)中使用某个名字设定特定的值，或者设定某个已经存在的javabean对象的属性。他类似于<%request.setAttrbute("name","value");%>

语法 :

语法1: 没有body

将value的值存储至范围为scope的varName变量之中

<c:set value="value" var="varName" [scope="{page|request|session|application}"]/>

语法2: 有body

将body内容存储至范围为scope的varName变量之中

<c:set value="value" [scope="{page|request|session|application}"]>

body.....

</c:set>

语法3: 将value的值存储至target对象属性中

<c:set value="value" target="target" property="propertyNmae"/>

语法4: 将body内容的数据存储至target对象属性中

<c:set target="target" property="propertyNmae">

body....

</c:set>

? Null 和 错误处理:

语法3和语法4会产生异常错误,有以下两种情况:

.target 为null

.target 不是java.util.Map或JavaBean对象

假若value为null时:将由存储变量改为移除变量

.语法1: 由var和scope所定义的变量，将被移除

.若scope已指定时，则PageContext.removeAttribute(varName,scope);

.若scope未指定时，则PageContext.removeAttribute(varName);

.语法3:

.假若target为Map时，则Map.remove(property);

.假若target为JavaBean时，propertye指定的属性为null

注意: var和scope这两个属性不能使用表达式来表示，我们不能写成 scope="${ourScope}"或var="${a}"

属性 :

属性名 | 描述 | 类型 | 是否接受动态值 | 是否支持 EL | 是否 必须 | 默认值 | 说明
value | 要被存储的值 | Object | true | Y | 否 | 无 | 被计算的表达式
var | 变量名 | String | false | N | 否 | 无 | 被导出的保存了value属性计算结果的范围变量的名称
scope | 范围 | String | true | N | 否 | page | var的JSP范围
target | 目标 对象 | String | true | Y | 否 | 无 | 要设置属性的对象。必须是JavaBean对象或java.util.Map对象
property | 指定target对象属性 | Object | true | Y | 否 | 无 | 要设置的target对象的属性的名称

实例 :

------------------------------------------------------------------------------------------------------------------------------------------

Example1

<c:set value="this is andy" var="oneString"/>

该示例将为名为“oneString”的变量赋值为“this is andy”，其作用范围为page。

------------------------------------------------------------------------------------------------------------------------------------------

Example2

<c:set target="${cust.address}" property="city" value="$"/>

将对象cust.address的city属性值保存到变量city中。

------------------------------------------------------------------------------------------------------------------------------------------

Example3

设置不同的属性，并且指定它们的范围：

<c:set value="10000" var="maxUser" scope="application"/>

<c:set value="20" var="maxIdelTime" scope="session"/>

<c:set value="next.jsp" var="nextPage" scope="page"/>

------------------------------------------------------------------------------------------------------------------------------------------

Example4

<c:set var="bid" value="${param.bookId}"/>

<jsp:setProperty name="bookDB" property="bookId" value="${bid}" />

------------------------------------------------------------------------------------------------------------------------------------------

Example5

<% Foo foo = new Foo(); pageContext.setAttribute("foo", foo); %>

<c:out value="${foo.date}"/><br> <c:set target="${foo}" property="day" value="1"/>

<c:out value="${foo.date}"/>


remove

New Help > core >
remove

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 : <c:remove>标签用于删除存在于scope中的变量。 类似于 <%session.removeAttribute(“name”)%> 、

<%request.removeAttribute(“name”)%>...

语法 :

<c:remove var="varName" [scope="{page|request|session|application}"]/>

属性 :

属性名 | 描述 | 类型 | 是否接受动态值 | 是否支持 EL | 是否 必须 | 默认值 | 说明
var | 变量名 | String | N | N | 是 | 无 | 欲移除变量的名称
scope | 范围 | String | N | N | 否 | page | var变量的JSP范围; 若没有指定，默认为全部查找

------------------------------------------------------------------------------------------------------------------------------------------

实例 :

Example1

<c:remove var="sampleValue" scope="session"/>

${sessionScope.sampleValue}

------------------------------------------------------------------------------------------------------------------------------------------

Example2

<c:remove var="username" scope="session"/>

将username变量从session范围移除。若我们不设定scope，则<c:remove>会移除所有范围名称为username

的数据。


catch

New Help > core >
catch

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 : <c:catch>动作用于捕获JSP元素在其体中抛出的异常，从而提供细粒度的错误控制， 此异常也可以保存为一个页面作用域变量。当错误发生<c:catch>和</c:catch>之间时，只有<c:catch>和</c:catch>之间的程序会被中止忽略，但整个网页不会被中止。 它包含一个var属性，是一个描述异常的变量，该变量可选。若没有var属性的定义，那么仅仅捕捉异常而不做任何事情，若定义了var属性，则可以利用var所定义的异常变量进行判断转发到其他页面或提示报错信息。

语法 :

<c:catch [var="var"]>

//可能发生错误的部分

JSP elements

</c:catch>

属性 :

属性名 | 描述 | 类型 | 是否接受动态值 | 是否支持 EL | 是否 必须 | 默认值 | 说明
var | 变量名 | String | N | N | N | 无 | 用来存储错误信息的变量

实例 :

------------------------------------------------------------------------------------------------------------------------------------------

Example1

<c:catch var="importException">

<fmt:parseDate value="${param.empDate}" dateStyle="short" />

</c:catch>

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

<jsp:forward page="input.jsp">

<jsp:param name="msg" value="Invalid date format" />

</jsp:forward>

</c:if>

------------------------------------------------------------------------------------------------------------------------------------------

Example2

<c:catch var="err">

${param.sampleSingleValue[9] == 3}

</c:catch>

${err}

当“${param.sampleSingleValue[9] == 3}”表达式有异常时，可以从var属性“err”得到异常的内容，通常判断“err”是否为null来决定错误信息的提示。


import

New Help > core >
import

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 : 标签允许包含另一个 JSP 页面到本页面来。jsp有两种内置机制可以将来自不同 URL 的内容合并到一个 JSP 页面:include 伪指令和 <jsp:include> 操作。不过，不管是哪种机制，要包含的内容都必须属于与页面本身相同的 Web 应用程序（或 servlet 上下文）。两个标记之间的主要区别在于： include 伪指令在页面编译期间合并被包含的内容，而 <jsp:include> 操作却在请求处理 JSP 页面时进行。

core 库的 <c:import>和 <jsp:include> 一样， <c:import> 也是一种请求时操作，它的基本任务就是将其它一些 Web 资源的内容插入 JSP 页面中。 通过 url 属性指定将要导入内容的 URL，这个属性是 <c:import> 的唯一一个必选属性。这里允许使用相对 URL，并且根据当前页面的 URL 来解析这个相对 URL。但是，如果 url 属性的值以斜杠开始，那么它就被解释成本地 JSP 容器内的绝对 URL。如果没有为 context 属性指定值，那么就认为这样的绝对 URL 引用当前 servlet 上下文内的资源。如果通过 context 属性显式地指定了上下文，那么就根据指定的 servlet 上下文解析绝对（本地）URL。 但 <c:import> 操作并不仅仅限于访问本地内容。也可以将包含协议和主机名的完整 URI 指定为 url 属性的值。实际上，协议甚至不仅局限于 HTTP。 <c:import> 的 url 属性值可以使用 java.net.URL 类所支持的任何协议。

语法 :

语法1：资源的内容使用String对象向外暴露

<c:import url="url" [context="context"]

[var="varName"] [scope="{page|request|session|application}"] [charEncoding="charEncoding"]>

内容

</c:import>

语法2：资源的内容使用Reader对象向外暴露。

<c:import url="url" [context="context"]

varReader="varReaderName" [charEncoding="charEncoding"]>

内容

</c:import>

属性 :

属性名 | 描述 | 类型 | 是否接受动态值 | 是否支持 EL | 是否 必须 | 默认值 | 说明
url | 统一资源定位器 | String | true | Y | 是 | 无 | 待导入资源的URL，可以是相对路径和绝对路径，并且可以导入其他主机资源
context | 上下文 | String | true | Y | 否 | 无 | 当使用相对路径访问外部context资源时，context指定了这个资源的名字。
var | 变量 | String | false | N | 否 | 无 | 参数的名字。
scope | 范围 | String | false | N | 否 | page | var参数的作用范围。
cahrEncoding | 字符编码 | String | true | Y | 否 | 无 | 输入资源的字符编码。
varReader | 资源 阅读器 | String | false | N | 否 | 无 | 这个参数的类型是Reader,用于读取资源。

说明

<c:import>中必须要有 url 属性，它是用来设定被包含网页的地址。它可以为绝对地址或是相对地址.

<c:import>也支持FTP协议，假设现在有一个 FTP站台，地址为 ftp.javaworld.com.tw，它里面有一个文件data.txt，那么可以写成如下方式将其内容显示出来：

<c:import url="ftp://ftp.cse.yzu.edu.tw/data.txt" />

另外，可以在<c:import>的本体内容中使用<c:param>，它的功用主要是：可以将参数传递给被包含的文件，它有两个属性name和value.如：

<c:import url="http://java.sun.com" >

<c:param name="test" value="1234" />

</c:import>

这样的做法等于是包含一个文件，并且所指定的网址会变成如下：

http://java.sun.com?test=1234

实例 :

----------------------------------------------------------------------------------------------------------------------------------------

Example1

<c:catch var="exception">

<c:import url="ftp://ftp.example.com/package/README"/>

</c:catch>

<c:if test="${not empty exception}">

Sorry, the remote content is not currently available.

</c:if>

<c:import> 操作用来包含通过 FTP 协议访问的文档内容。此外，还使用了 <c:catch> 操作，以便在本地处理 FTP 文件传送期间可能发生的任何错误。错误处理是这样实现的：使用 <c:catch> 的 var 属性为异常指定一个限定了作用域的变量，然后使用 <c:if> 检查其值。如果产生了异常，那么就会对那个限定了作用域的变量进行赋值：如清单 18 中的 EL 表达式所显示的那样，该变量的值将 不会为空。由于 FTP 文档的检索将会失败，因此会显示有关这种情况的错误消息。<c:import> 操作的最后两个（可选的）属性是 var 和 scope 。 var 属性会导致从指定 URL 获取的内容（作为 String 值）被存储在一个限定了作用域的变量中，而不是包含在当前 JSP 页面中。 scope 属性控制该变量的作用域，缺省情况下是页面作用域。如同我们在今后的文章中将要看到的那样，JSTL xml 库中的标记利用了 <c:import> 这种能力，即将整个文档存储在一个限定了作用域的变量中。

还要注意的是，可以使用（可选的）嵌套的 <c:param> 标记来为正在导入的 URL 指定请求参数。与在 <c:url> 中嵌套 <c:param> 标记一样，必要时也要对参数名称和参数值进行 URL 编码。

----------------------------------------------------------------------------------------------------------------------------------------

Example2

<c:import url="/MyHtml.html" var="thisPage" />

<c:import url="/MyHtml.html" context=”/sample2” var="thisPage"/>

<c:import url="www.sample.com/MyHtml.html" var="thisPage"/>

该示例演示了三种不同的导入方法，第一种是在同一 Context 下的导入，第二种是在不同的 Context 下导入，第三种是导入任意一个 URL 。


forTokens

New Help > core >
forTokens

库 :Core(核心库)

URI : http://java.sun.com/jsp/jstl/core

前缀 : c

描述 : 标签可以根据某个分隔符分隔指定字符串，相当于 java.util.StringTokenizer 类。

语法 :

<c:forTokens items="stringFoTokens" delims="delimmmmiters" [var="varName"]

[varStatus="varStatusName"] [begin="begin"] [end="end"] [step="step"]>

...body内容....

</c:forTokens>

属性 :

属性名 | 描述 | 类型 | 是否接受动态值 | 是否支持 EL | 是否 必须 | 默认值 | 说明
var | 变量名 | String | false | Y | 否 | 无 | 用来存放现在指到的成员
items | 被迭代的字符串 | String | true | Y | 是 | 无 | 被迭代的字符串
delims | 分隔符 | String | true | N | 是 | 无 | 定义用来分割字符串的字符
varStatus | 循环状态变量 | String | false | N | 否 | 无 | 用来存放现在指到的相关成员信息
begin | 开始条件 | int | true | Y | 否 | 0 | 开始的位置
end | 结束条件 | int | true | Y | 否 | 最后一个成员 | 结束的位置
step | 步长 | int | true | Y | 否 | 1 | 每次迭代步长

限制:

.假若有begin属性时，begin必须大于等于0

.假若有end属性时，必须大于begin

.假若有step属性时，step必须大于等于1

Null 和 错误处理

.假如itmes为null时,则表示为有空的集合对象

.假若begin大于等于items的大小时，则迭代不运算

实例 :

<c:forToken items="A,B,C,D,E,F,G" delims="," var="item>

${item}

</c:forToken>

items属性也可以用EL，例如:

<%

String phonenumber="123-456-7899";

request.setAttribute("userPhone",phonenumber);

%>

<c:forTokens items="${userPhone}" delims="-" var="item">

${item}

</c:forTokens>


length

New Help > fn >
length

返回参数item中包含元素的数量。参数Item类型是数组、collection或者String。如果是String类型,返回值是String中的字符数。

长度函数fn:length的出现有重要的意义。在JSTL1.0中，有一个功能被忽略了，那就是对集合的长度取值。虽然java.util.Collection接口定义了size方法，但是该方法不是一个标准的JavaBean属性方法（没有get,set方法），因此，无法通过EL表达式“${collection.size}”来轻松取得。

fn:length函数正是为了解决这个问题而被设计出来的。它的参数为input，将计算通过该属性传入的对象长度。该对象应该为集合类型或String类型。其返回结果是一个int类型的值。下面看一个示例。

<%ArrayList arrayList1 = new ArrayList();

arrayList1.add("aa");

arrayList1.add("bb");

arrayList1.add("cc");

%>

<%request.getSession().setAttribute("arrayList1", arrayList1);%>

${fn:length(sessionScope.arrayList1)}

假设一个ArrayList类型的实例“arrayList1”，并为其添加三个字符串对象，使用fn:length函数后就可以取得返回结果为“3”。


contains

New Help > fn >
contains

如果参数string中包含参数substring，返回true

fn:contains函数用来判断源字符串是否包含子字符串。它包括string和substring两个参数，它们都是String类型，分布表示源字符串和子字符串。其返回结果为一个boolean类型的值。下面看一个示例。

${fn:contains("ABC", "a")}<br>

${fn:contains("ABC", "A")}<br>

前者返回“false”，后者返回“true”。


containsIgnoreCase

New Help > fn >
containsIgnoreCase

如果参数string中包含参数substring（忽略大小写），返回true

fn:containsIgnoreCase函数与fn:contains函数的功能差不多，唯一的区别是fn:containsIgnoreCase函数对于子字符串的包含比较将忽略大小写。它与fn:contains函数相同，包括string和substring两个参数，并返回一个boolean类型的值。下面看一个示例。

${fn:containsIgnoreCase("ABC", "a")}<br>

${fn:containsIgnoreCase("ABC", "A")}<br>

前者和后者都会返回“true”。


startsWith

New Help > fn >
startsWith

如果参数string以参数prefix开头，返回true

fn:startsWith函数用来判断源字符串是否符合一连串的特定词头。它除了包含一个string参数外，还包含一个subffx参数，表示词头字符串，同样是String类型。该函数返回一个boolean类型的值。下面看一个示例。

${fn:startsWith ("ABC", "ab")}<br>

${fn:startsWith ("ABC", "AB")}<br>

前者返回“false”，后者返回“true”。


endsWith

New Help > fn >
endsWith

如果参数 string 以参数suffix结尾，返回true

fn:endsWith函数用来判断源字符串是否符合一连串的特定词尾。它与fn:startsWith函数相同，包括string和subffx两个参数，并返回一个boolean类型的值。下面看一个示例。

${fn:endsWith("ABC", "bc")}<br> ${fn:endsWith("ABC", "BC")}<br>

前者返回“false”，后者返回“true”。


escapeXml

New Help > fn >
escapeXml

将有特殊意义的XML (和HTML)转换为对应的XML character entity code，并返回

fn:escapeXml函数用于将所有特殊字符转化为字符实体码。它只包含一个string参数，返回一个String类型的值。


indexOf

New Help > fn >
indexOf

返回参数substring在参数string中第一次出现的位置

fn:indexOf函数用于取得子字符串与源字符串匹配的开始位置，若子字符串与源字符串中的内容没有匹配成功将返回“-1”。它包括string和substring两个参数，返回结果为int类型。下面看一个示例。

${fn:indexOf("ABCD","aBC")}<br> ${fn:indexOf("ABCD","BC")}<br>

前者由于没有匹配成功，所以返回-1，后者匹配成功将返回位置的下标，为1。


join

New Help > fn >
join

将一个给定的数组array用给定的间隔符separator串在一起，组成一个新的字符串并返回。

fn:join函数允许为一个字符串数组中的每一个字符串加上分隔符，并连接起来。它的参数、返回结果和描述如表9.25所示：

表9.25　fn:join函数

参数 | 描述
array | 字符串数组。其类型必须为String[]类型
separator | 分隔符。其类型必须为String类型
返回结果 | 返回一个String类型的值

下面看一个示例。

<% String[] stringArray = {"a","b","c"}; %>

<%request.getSession().setAttribute("stringArray", stringArray);%>

${fn:join(sessionScope.stringArray,";")}<br>

定义数组并放置到Session中，然后通过Session得到该字符串数组，使用fn:join函数并传入分隔符“;”，得到的结果为“a;b;c”。


replace

New Help > fn >
replace

返回一个String对象。用参数after字符串替换参数string中所有出现参数before字符串的地方，并返回替换后的结果

fn:replace函数允许为源字符串做替换的工作。它的参数、返回结果和描述如表9.26所示：

表9.26　 fn:replace函数

参数 | 描述
inputString | 源字符串。其类型必须为String类型
beforeSubstring | 指定被替换字符串。其类型必须为String类型
afterSubstring | 指定替换字符串。其类型必须为String类型
返回结果 | 返回一个String类型的值

下面看一个示例。

${fn:replace("ABC","A","B")}<br>

将“ABC”字符串替换为“BBC”，在“ABC”字符串中用“B”替换了“A”。


split

New Help > fn >
split

返回一个数组，以参数separator 为分割符分割参数string，分割后的每一部分就是数组的一个元素

fn:split函数用于将一组由分隔符分隔的字符串转换成字符串数组。它的参数、返回结果和描述如表9.27所示：

表9.27　 fn:split函数

参数 | 描述
string | 源字符串。其类型必须为String类型
delimiters | 指定分隔符。其类型必须为String类型
返回结果 | 返回一个String[]类型的值

下面看一个示例。

${fn:split("A,B,C",",")}<br>

将“A,B,C”字符串转换为数组{A,B,C}。


substring

New Help > fn >
substring

返回参数string部分字符串, 从参数begin开始到参数end位置，包括end位置的字符

fn:substring函数用于截取字符串。它的参数、返回结果和描述如表9.28所示：

表9.28　 fn:substring函数

参数 | 描述
string | 源字符串。其类型必须为String类型
beginIndex | 指定起始下标（值从0开始）。其类型必须为int类型
endIndex | 指定结束下标（值从0开始）。其类型必须为int类型
返回结果 | 返回一个String类型的值

下面看一个示例。

${fn:substring("ABC","1","2")}<br>

截取结果为“B”。


substringAfter

New Help > fn >
substringAfter

返回参数substring在参数string中后面的那一部分字符串


substringBefore

New Help > fn >
substringBefore

返回参数substring在参数string中前面的那一部分字符串


toLowerCase

New Help > fn >
toLowerCase

将参数string所有的字符变为小写，并将其返回


toUpperCase

New Help > fn >
toUpperCase

将参数string所有的字符变为大写，并将其返回


trim

New Help > fn >
trim

去除参数string 首尾的空格，并将其返回


bundle

New Help > fmt >
bundle

<fmt:bundle> 标签:用于资源配置文件的数据来源，标签将资源配置文件绑定于它标签体中的显示
属性描述
basename:资源配置文件的指定，只需要指定文件名而无须扩展名
prefix:前置关键字
如:
资源文件中配置的数据为:
label.backcolor=#FFF
label.fontcolor=#000
则,可以用如下方法取得label的backcolor和fontcolor值:
<fmt:bundle basename="MyResourse" prefix="label.">
<fmt:message key="backcolor" />
<fmt:message key="fontcolor" />
</fmt:bundle>


formatDate

New Help > fmt >
formatDate

<fmt:formatDate>标签:用于格式化日期
属性描述
value:格式化的日期，该属性的内容应该是 java.util.Date 类型的实例
type:格式化的类型
pattern:格式化模式
var:结果保存变量
scope:变量的作用范围
timeZone:指定格式化日期的时区


formatNumber

New Help > fmt >
formatNumber

<fmt:formatNumber>标签:用于格式化数字
属性描述
value:格式化的数字,该数值可以是 String 类型或 java.lang.Number 类型的实例
type:格式化的类型,可能值包括:currency（货币）、number（数字）和percent（百分比）
pattern:格式化模式
var:结果保存变量
scope:变量的作用范围
maxIntegerDigits:指定格式化结果的最大值
minIntegerDigits:指定格式化结果的最小值
maxFractionDigits:指定格式化结果的最大值，带小数
minFractionDigits:指定格式化结果的最小值，带小数

如:
结果将被保存在“ money ”变量中，将根据 Locale 环境显示当地的货币格式
<fmt:formatNumber value="1000.888" type="currency" var="money"/>


message

New Help > fmt >
message

<fmt:message> 标签:用于显示资源配置文件信息(该资源文件必须遵循如下格式:1.扩展名必须为properties,2.文件的内容必须依照key = value的格式;3.文件要放到WEB-INF/classes目录下)
属性描述
key:资源配置文件的“键”指定
bundle:若使用 <fmt:setBundle> 保存了资源配置文件，该属性就可以从保存的资源配置文件中进行查找
var:将显示信息保存为一个变量
scope:变量的作用范围
如:
1)用<fmt:setBundle>标签将"applicationMessage"资源配置文件被赋于了变量"applicationBundle"
用<fmt:message>标签显示由<fmt:setBundle>标签保存的资源配置文件中"键"为"passWord"的信息

<fmt:setBundle basename="applicationMessage" var="applicationBundle"/>
<fmt:message key="passWord" bundle="${applicationBundle}" />

2)用<fmt:bundle>标签定义的"applicationAllMessage"资源配置文件作用于其标签体内的显示
用<fmt:message>标签显示"applicationAllMessage"资源配置文件中"键"为"userName"的信息

<fmt:bundle basename="applicationAllMessage">
<fmt:message key="userName" />
</fmt:bundle>


param

New Help > fmt >
param

<fmt:param> 标签:用于参数传递
<fmt:param>标签应该位于 <fmt:message> 标签内，将为该消息标签提供参数值。它只有一个属性value
如：在MyResourse.properties文件中,有一个索引值如下(其中,{0}代表占位符):
Str2=Hi,{0}
则,使用<fmt:param>标签传入值如下:
<fmt:bundle basename="MyResourse">
<fmt:message key="Str2">
<fmt:param value="张三" />
</fmt:message>
</fmt:bundle>
也可以在资源文件中指定参数的类型:
如:在MyResourse.properties文件中,有一个索引值如下:
Str3={0,date}
则,使用<fmt:param>标签传入值如下:
<% request.setAttribute("now",new Date()); %>
<fmt:bundle basename="MyResourse">
<fmt:message key="Str3">
<fmt:param value="${now}" />
</fmt:message>
</fmt:bundle>


parseDate

New Help > fmt >
parseDate

<fmt:parseDate>标签:用于解析日期
属性描述
value:将被解析的字符串
type:解析格式化的类型
pattern:解析格式化模式
var:结果保存变量，类型为 java.lang.Date
scope:变量的作用范围
parseLocale:以本地化的形式来解析字符串，该属性的内容为 String 或 java.util.Locale 类型的实例
timeZone:指定解析格式化日期的时区


parseNumber

New Help > fmt >
parseNumber

<fmt:parseNumber> 标签:用于解析数字
属性描述
value:将被解析的字符串
type:解析格式化的类型
pattern:解析格式化模式
var:结果保存变量，类型为 java.lang.Number
scope:变量的作用范围
parseLocale:以本地化的形式来解析字符串，该属性的内容应为 String 或 java.util.Locale 类型的实例

如:
将"15%"转换为数字
<fmt:parseNumber value="15%" type="percent" var="num"/>


requestEncoding

New Help > fmt >
requestEncoding

<fmt:requestEncoding>标签:用于为请求设置字符编码
它只有一个属性 value ，在该属性中可以定义字符编码。
如：
<fmt:requestEncoding value="GB2312"/>


setBundle

New Help > fmt >
setBundle

<fmt:bundle> 、 <fmt:setBundle> 标签:用于资源配置文件的数据来源，标签则允许将资源配置文件保存为一个变量，在之后的工作可以根据该变量来进行
属性描述 ，二组标签共有的属性
var:<fmt:setBundle> 独有的属性，用于保存资源配置文件为一个变量
scope:变量的作用范围
如:
查找一个名为 applicationMessage_zh_CN.properties 的资源配置文件，来作为显示的 Resource 绑定
<fmt:setBundle basename="applicationMessage" var="applicationBundle"/>


setLocale

New Help > fmt >
setLocale

<fmt:setLocale>标签:用于设置本地化环境
属性描述
value:Locale 环境的指定，可以是 java.util.Locale 或 String 类型的实例
scope:Locale 环境变量的作用范围（可选）
如:
设置本地环境为繁体中文
<fmt:setLocale value="zh_TW"/>
设置本地环境为简体中文
<fmt:setLocale value="zh_CN"/>


setTimeZone

New Help > fmt >
setTimeZone

<fmt:setTimeZone> 标签则允许将时区设置保存为一个变量，在之后的工作可以根据该变量来进行
属性描述
value:时区的设置
var:<fmt:setTimeZone> 独有的属性，用于保存时区为一个变量
scope:变量的作用范围


timeZone

New Help > fmt >
timeZone

<fmt:timeZone> 标签将使得在其标签体内的工作可以使用该时区设置
属性描述
value:时区的设置
var:<fmt:setTimeZone> 独有的属性，用于保存时区为一个变量
scope:变量的作用范围


form

New Help > SpringMVC >
form

使用Spring的form标签主要有两个作用，第一是它会自动的绑定来自Model中的一个属性值到当前form对应的实体对象，默认是command属性，这样我们就可以在form表单体里面方便的使用该对象的属性了；第二是它支持我们在提交表单的时候使用除GET和POST之外的其他方法进行提交，包括DELETE和PUT等。

1.1.1 支持绑定表单对象

我们先来看如下使用form标签的一个示例：

Jsp代码
    <form:form action="formTag/form.do" method="post">
        <table>
            <tr>
                <td>Name:</td><td><form:input path="name"/></td>
            </tr>
            <tr>
                <td>Age:</td><td><form:input path="age"/></td>
            </tr>
            <tr>
                <td colspan="2"><input type="submit" value="提交"/></td>
            </tr>
        </table>
    </form:form>
    <form:form action="formTag/form.do" method="post">
    <table>
        <tr>
            <td>Name:</td><td><form:input path="name"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><form:input path="age"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

这个时候如果Model中存在一个属性名称为command的javaBean，而且该javaBean拥有属性name和age的时候，在渲染上面的代码时就会取command的对应属性值赋给对应标签的值。如在上面的代码中，假设Model中存在一个属性名称为command的javaBean，且它的name和age属性分别为“Zhangsan”和“36”时，那么它在渲染时就会生成如下一段代码：

Html代码
<form id="command" action="formTag/form.do" method="post">
    <table>
        <tr>
            <td>Name:</td><td><input id="name" name="name" type="text" value="ZhangSan"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><input id="age" name="age" type="text" value="36"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form>
<form id="command" action="formTag/form.do" method="post">
    <table>
        <tr>
            <td>Name:</td><td><input id="name" name="name" type="text" value="ZhangSan"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><input id="age" name="age" type="text" value="36"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form>

从上面生成的代码中，我们可以看出，当没有指定form标签的id时它会自动获取该form标签绑定的Model中对应属性名称作为id，而对于input标签在没有指定id的情况下它会自动获取path指定的属性作为id和name。

我们指定form默认自动绑定的是Model的command属性值，那么当我的form对象对应的属性名称不是command的时候，应该怎么办呢？对于这种情况，Spring给我们提供了一个commandName属性，我们可以通过该属性来指定我们将使用Model中的哪个属性作为form需要绑定的command对象。除了commandName属性外，指定modelAttribute属性也可以达到相同的效果。这里假设上面代码中我们存放在Model中的是user对象而不是默认的command对象，那么我们的代码就可以如下定义了：

Jsp代码
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>Name:</td><td><form:input path="name"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><form:input path="age"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>Name:</td><td><form:input path="name"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><form:input path="age"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

1.1.2 支持全部的Http请求方法

Jsp代码
<form:form action="formTag/form.do" method="delete" modelAttribute="user">
    <table>
        <tr>
            <td>Name:</td><td><form:input path="name"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><form:input path="age"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>
<form:form action="formTag/form.do" method="delete" modelAttribute="user">
    <table>
        <tr>
            <td>Name:</td><td><form:input path="name"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><form:input path="age"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

在上面代码中我们设定了该form的提交方法是delete，这样在后台我们就可以给对应的请求方法的RequestMapping加上method为RequestMethod.DELETE的限制。我们来看一下上面的代码在进行渲染的时候会生成怎样的Html代码，其生成的代码如下所示：

Html代码
<form id="user" action="formTag/form.do" method="post">
    <input type="hidden" name="_method" value="delete"/>
    <table>
        <tr>
            <td>Name:</td><td><input id="name" name="name" type="text" value="ZhangSan"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><input id="age" name="age" type="text" value="36"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form>
<form id="user" action="formTag/form.do" method="post">
    <input type="hidden" name="_method" value="delete"/>
    <table>
        <tr>
            <td>Name:</td><td><input id="name" name="name" type="text" value="ZhangSan"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><input id="age" name="age" type="text" value="36"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form>

从它生成的代码我们可以看出，Spring在实现除GET和POST之外的请求方法时，还是使用的POST方法进行请求，然后给表单加上了一个隐藏域，用以表示真正的请求方法，这个隐藏域的名称默认是“_method”。上面这样定义之后是不是就意味着我们可以以delete方式访问到“formTag/form.do”了呢？答案是不行的。这样定义我们只是多加了一个用以表示请求方法的隐藏域而已，实际的请求方式还是POST。Spring为我们提供了一个Filter——HiddenHttpMethodFilter，通过这个Filter我们可以把以POST方式传递过来的表示实际请求方式的参数转换为对应的真正的Http请求方法。所以这个时候我们还需要在web.xml中加上如下代码：

Xml代码
<filter>
   <filter-name>hiddenHttpMethodFilter</filter-name>
   <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
   <filter-name>hiddenHttpMethodFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>
    <filter>
       <filter-name>hiddenHttpMethodFilter</filter-name>
       <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>
    <filter-mapping>
       <filter-name>hiddenHttpMethodFilter</filter-name>
       <url-pattern>/*</url-pattern>
    </filter-mapping>

注意：HiddenHttpMethodFilter只能对以POST方式进行传递的表示请求方式的隐藏域转换为真正的Http请求方式。当我们直接在form：form标签的method中使用除GET和POST方法以外的其他方法时，Spring会自动生成以POST方式进行传递的表单以及对应的隐藏域。所以当我们需要手动的设置表示请求方法的隐藏域时，我们就需要指定表单的请求方式为POST，为GET将不会生效。

Jsp代码
<form:form action="formTag/form.do" method="post" modelAttribute="user">
    <input type="hidden" name="_method" value="head"/>
    <table>
        <tr>
            <td>Name:</td><td><form:input path="name"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><form:input path="age"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>
<form:form action="formTag/form.do" method="post" modelAttribute="user">
    <input type="hidden" name="_method" value="head"/>
    <table>
        <tr>
            <td>Name:</td><td><form:input path="name"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><form:input path="age"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

上面代码就是一个手动定义请求方式的隐藏域的示例。这里表示请求方式的隐藏域的名称默认是“_method”，如果不想使用这个默认值的话，我们也可以通过form:form标签的methodParam属性来指定。如下面这个示例：

Jsp代码
<form:form action="formTag/form.do" method="post" methodParam="requestMethod" modelAttribute="user">
    <input type="hidden" name="requestMethod" value="head"/>
    <table>
        <tr>
            <td>Name:</td><td><form:input path="name"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><form:input path="age"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>
<form:form action="formTag/form.do" method="post" methodParam="requestMethod" modelAttribute="user">
    <input type="hidden" name="requestMethod" value="head"/>
    <table>
        <tr>
            <td>Name:</td><td><form:input path="name"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><form:input path="age"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

同时我们也要告诉HiddenHttpMethodFilter我们是使用哪个表单参数作为methodParam，所以我们需要在配置HiddenHttpMethodFilter的时候指明methodParam对应的值。

Xml代码
<filter>
   <filter-name>hiddenHttpMethodFilter</filter-name>
   <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
   <init-param>
       <param-name>methodParam</param-name>
       <param-value>requestMethod</param-value>
   </init-param>
</filter>
<filter-mapping>
   <filter-name>hiddenHttpMethodFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>
    <filter>
       <filter-name>hiddenHttpMethodFilter</filter-name>
       <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
       <init-param>
           <param-name>methodParam</param-name>
           <param-value>requestMethod</param-value>
       </init-param>
    </filter>
    <filter-mapping>
       <filter-name>hiddenHttpMethodFilter</filter-name>
       <url-pattern>/*</url-pattern>
    </filter-mapping>

另外需要注意的是在有Multipart请求处理的时候HiddenHttpMethodFilter需要在Multipart处理之后执行，因为在处理Multipart时需要从POST请求体中获取参数。所以我们通常会在HiddenHttpMethodFilter之前设立一个MultipartFilter。MultipartFilter默认会去寻找一个名称为filterMultipartResolver的MultipartResolver bean对象来对当前的请求进行封装。所以当你定义的MultipartResolver的名称不为filterMultipartResolver的时候就需要在定义MultipartFilter的时候通过参数multipartResolverBeanName来指定。

Xml代码
<filter>
   <filter-name>multipartFilter</filter-name>
   <filter-class>org.springframework.web.multipart.support.MultipartFilter</filter-class>
   <init-param>
       <param-name>multipartResolverBeanName</param-name>
       <param-value>multipartResolver</param-value>
   </init-param>
</filter>
<filter-mapping>
   <filter-name>multipartFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

<filter>
   <filter-name>hiddenHttpMethodFilter</filter-name>
   <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
   <init-param>
       <param-name>methodParam</param-name>
       <param-value>requestMethod</param-value>
   </init-param>
</filter>
<filter-mapping>
   <filter-name>hiddenHttpMethodFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>
    <filter>
       <filter-name>multipartFilter</filter-name>
       <filter-class>org.springframework.web.multipart.support.MultipartFilter</filter-class>
       <init-param>
           <param-name>multipartResolverBeanName</param-name>
           <param-value>multipartResolver</param-value>
       </init-param>
    </filter>
    <filter-mapping>
       <filter-name>multipartFilter</filter-name>
       <url-pattern>/*</url-pattern>
    </filter-mapping>

    <filter>
       <filter-name>hiddenHttpMethodFilter</filter-name>
       <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
       <init-param>
           <param-name>methodParam</param-name>
           <param-value>requestMethod</param-value>
       </init-param>
    </filter>
    <filter-mapping>
       <filter-name>hiddenHttpMethodFilter</filter-name>
       <url-pattern>/*</url-pattern>
    </filter-mapping>


input

New Help > SpringMVC >
input

SpringMVC的input标签会被渲染为一个type为text的普通Html input标签。使用SpringMVC的input标签的唯一作用就是它能绑定表单数据。SpringMVC表单标签最大的好处就是它支持数据绑定，当我们的表单标签不需要绑定的数据的时候，我们应该使用普通的Html标签。关于input标签绑定表单数据的方法已经在介绍form标签的时候顺带介绍过了，这里就不再过多的赘述了。

Jsp代码
<form:form action="formTag/form.do" method="head" modelAttribute="user" methodParam="requestMethod">
    <table>
        <tr>
            <td>Name:</td><td><form:input path="name"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><form:input path="age"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>
<form:form action="formTag/form.do" method="head" modelAttribute="user" methodParam="requestMethod">
    <table>
        <tr>
            <td>Name:</td><td><form:input path="name"/></td>
        </tr>
        <tr>
            <td>Age:</td><td><form:input path="age"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>


hidden

New Help > SpringMVC >
hidden

hidden标签会被渲染为一个type为hidden的普通Html input标签。用法跟input标签一样，也能绑定表单数据，只是它生成的是一个隐藏域。


checkbox

New Help > SpringMVC >
checkbox

checkbox标签会被渲染为一个type为checkbox的普通HTML input标签。checkbox标签也是支持绑定数据的。我们知道checkbox就是一个复选框，有选中和不选中两种状态，那么我们在使用checkbox标签的时候是如何来设定它的状态的呢？checkbox标签的选中与否状态是根据它绑定的值来判断的。

1.4.1 绑定boolean数据

当checkbox绑定的是一个boolean数据的时候，那么checkbox的状态跟该boolean数据的状态是一样的，即true对应选中，false对应不选中。

Jsp代码
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>Male:</td><td><form:checkbox path="male"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>Male:</td><td><form:checkbox path="male"/></td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

看上面这段代码，这个时候假设我们在渲染该视图之前往ModelMap中添加了一个user属性，并且该user对象有一个类型为boolean的属性male，那么这个时候如果male属性为true则Male那一栏的复选框将会被选中。

1.4.2 绑定列表数据

这里的列表数据包括数组、List和Set。下面将以List为例讲一下checkbox是如何根据绑定的列表数据来设定选中状态的。现在假设有一个类User，其有一个类型为List的属性roles，如下所示：

Java代码
    public class User {

        private List<String> roles;

        public List<String> getRoles() {
           return roles;
        }

        public void setRoles(List<String> roles) {
           this.roles = roles;
        }
    }
    public class User {

    private List<String> roles;

    public List<String> getRoles() {
       return roles;
    }

    public void setRoles(List<String> roles) {
       this.roles = roles;
    }
}

那么当我们需要展现该User是否拥有某一个Role的时候，我们可以使用checkbox标签来绑定roles数据进行展现。当checkbox标签的value在我们绑定的列表数据中存在的时候该checkbox将为选中状态。来看下面一段代码：

Jsp代码
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>Roles:</td>
            <td>
               <form:checkbox path="roles" value="role1"/>Role1<br/>
               <form:checkbox path="roles" value="role2"/>Role2<br/>
               <form:checkbox path="roles" value="role3"/>Role3
            </td>
        </tr>
    </table>
</form:form>
<form:form action="formTag/form.do" method="post" commandName="user">

    <table>
        <tr>
            <td>Roles:</td>
            <td>
               <form:checkbox path="roles" value="role1"/>Role1<br/>
               <form:checkbox path="roles" value="role2"/>Role2<br/>
               <form:checkbox path="roles" value="role3"/>Role3
            </td>
        </tr>
    </table>
</form:form>

就上面代码而言就是当User拥有role1的时候对应的<form:checkbox path="roles" value="role1"/>就会为选中状态，也就是说roles列表中包含role1的时候该checkbox就会为选中状态。

1.4.3 绑定一个Object数据

checkbox还支持绑定数据类型为Object的数据，这种情况下Spring会拿所绑定对象数据的toString结果跟当前checkbox的value进行比较，如果能够进行匹配则该checkbox将为选中状态。看这样一个例子，有一个User类代码如下：

Java代码
    public class User {

        private Blog blog;

        public Blog getBlog() {
           return blog;
        }

        public void setBlog(Blog blog) {
           this.blog = blog;
        }
    }
    public class User {

    private Blog blog;

    public Blog getBlog() {
       return blog;
    }

    public void setBlog(Blog blog) {
       this.blog = blog;
    }
}

Blog类的代码如下：

Java代码
    public class Blog {

        public String toString() {
           return "HelloWorld";
        }

    }
    public class Blog {

    public String toString() {
       return "HelloWorld";
    }

}

我们可以看到Blog类的toString方法已经被写死为“HelloWorld”了。这个时候假设我们往ModelMap中放了一个user对象，而且给该user对象设定了一个blog属性，那么当我们使用该ModelMap对象渲染如下视图代码时，checkbox标签的选中状态是怎样的呢？根据前面描述的当checkbox标签绑定的是一个Object对象的时候我们会拿该Object对象的toString和checkbox的value值进行比较，如果匹配则当前checkbox为选中状态，我们知道这里的checkbox将为选中状态。

Jsp代码
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>HelloWorld:</td>
            <td>
               <form:checkbox path="blog" value="HelloWorld"/>
            </td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>
<form:form action="formTag/form.do" method="post" commandName="user">

    <table>
        <tr>
            <td>HelloWorld:</td>
            <td>
               <form:checkbox path="blog" value="HelloWorld"/>
            </td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>


Checkboxes

New Help > SpringMVC >
Checkboxes

相对于一个checkbox标签只能生成一个对应的复选框而言，一个checkboxes标签将根据其绑定的数据生成N个复选框。checkboxes绑定的数据可以是数组、集合和Map。在使用checkboxes时我们有两个属性是必须指定的，一个是path，另一个是items。Items表示当前要用来展现的项有哪些，而path所绑定的表单对象的属性表示当前表单对象拥有的项，即在items所展现的所有项中表单对象拥有的项会被设定为选中状态。先来看以下一段代码：

Jsp代码 复制代码 收藏代码
  1. <form:form action="formTag/form.do" method="post" commandName="user">
  2. <table>
  3. <tr>
  4. <td>Roles:</td>
  5. <td>
  6. <form:checkboxes path="roles" items="${roleList}"/>
  7. </td>
  8. </tr>
  9. <tr>
  10. <td colspan="2"><input type="submit" value="提交"/></td>
  11. </tr>
  12. </table>
  13. </form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
           <td>Roles:</td>
            <td>
               <form:checkboxes path="roles" items="${roleList}"/>
            </td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

上面的JSP视图对应着如下的处理器方法：

Java代码 复制代码 收藏代码
  1. @RequestMapping(value="form", method=RequestMethod.GET)
  2. public String formTag(Map<String, Object> map) {
  3. User user = new User();
  4. List<String> roles = new ArrayList<String>();
  5. roles.add("role1");
  6. roles.add("role3");
  7. user.setRoles(roles);
  8. List<String> roleList = new ArrayList<String>();
  9. roleList.add("role1");
  10. roleList.add("role2");
  11. roleList.add("role3");
  12. map.put("user", user);
  13. map.put("roleList", roleList);
  14. return "formTag/form";
  15. }
    @RequestMapping(value="form", method=RequestMethod.GET)
    public String formTag(Map<String, Object> map) {
       User user = new User();
       List<String> roles = new ArrayList<String>();
       roles.add("role1");
       roles.add("role3");
       user.setRoles(roles);
       List<String> roleList = new ArrayList<String>();
       roleList.add("role1");
       roleList.add("role2");
       roleList.add("role3");
       map.put("user", user);
       map.put("roleList", roleList);
       return "formTag/form";
    }

从以上代码中我们可以看到我们放在ModelMap中的roleList对象有三个元素，分别是role1、role2和role3，而我们的表单对象User的roles属性只拥有两个元素，分别是role1和role3,，所以当我们访问该处理器方法返回如上所示的视图页面时，我们要展现的复选框项是roleList，也就是role1、role2和role3，而我们表单对象只拥有role1和role3，所以在页面进行渲染的时候会展示3个复选框项，但只有role1和role3会被设定为选中状态。

上面介绍的这种情况是使用List作为展现复选框项的数据源，这种情况我们已经看到了它所呈现出来的标签Label和它的值是一样的。使用Array和Set作为数据源也是这种情况。那么如果要让checkboxes呈现出来的Label和实际上送的value不同的话应该怎么做呢？这个时候我们就可以使用Map作为数据源了。使用Map作为checkboxes的items属性的数据源时Key将作为真正的复选框的value，而Map的value将作为Label进行展示。当使用Map作为checkboxes的items属性的数据源时我们绑定的表单对象属性的类型可以是Array、集合和Map，这种情况就是判断items Map中是否含有对应的key来决定当前的复选框是否处于选中状态。我们来看以下一个处理器方法以及其对应的视图代码。

处理器方法：

Java代码 复制代码 收藏代码
  1. @RequestMapping(value="form", method=RequestMethod.GET)
  2. public String formTag(Map<String, Object> map) {
  3. User user = new User();
  4. List<String> roles = new ArrayList<String>();
  5. roles.add("role1");
  6. roles.add("role3");
  7. user.setRoles(roles);
  8. Map<String, String> roleMap = new HashMap<String, String>();
  9. roleMap.put("role1", "角色1");
  10. roleMap.put("role2", "角色2");
  11. roleMap.put("role3", "角色3");
  12. map.put("user", user);
  13. map.put("roleMap", roleMap);
  14. return "formTag/form";
  15. }
    @RequestMapping(value="form", method=RequestMethod.GET)
    public String formTag(Map<String, Object> map) {
       User user = new User();
       List<String> roles = new ArrayList<String>();
       roles.add("role1");
       roles.add("role3");
       user.setRoles(roles);
       Map<String, String> roleMap = new HashMap<String, String>();
       roleMap.put("role1", "角色1");
       roleMap.put("role2", "角色2");
       roleMap.put("role3", "角色3");
       map.put("user", user);
       map.put("roleMap", roleMap);
       return "formTag/form";
    }

对应的视图代码：

Jsp代码 复制代码 收藏代码
  1. <form:form action="formTag/form.do" method="post" commandName="user">
  2. <table>
  3. <tr>
  4. <td>Roles:</td>
  5. <td>
  6. <form:checkboxes path="roles" items="${roleMap}"/>
  7. </td>
  8. </tr>
  9. <tr>
  10. <td colspan="2"><input type="submit" value="提交"/></td>
  11. </tr>
  12. </table>
  13. </form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>Roles:</td>
            <td>
               <form:checkboxes path="roles" items="${roleMap}"/>
            </td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

这个时候我们知道会呈现出3个复选框，而checkboxes绑定的表单对象user的roles属性是一个集合对象，其包含的两个元素都能在checkboxes的items数据源中找到对应的Key，所以以这两个元素为value的checkbox将处于选中状态。效果如下：

当我们使用Array或者集合作为数据源，且里面的元素都是一个一个POJO时，我们还可以使用checkboxes标签的itemLabel和itemValue属性来表示使用数组或者集合中元素对象的哪一个属性作为需要呈现的单选框的label和value。


radiobutton

New Help > SpringMVC >
radiobutton

radiobutton标签会被渲染为一个type为radio的普通HTML input标签。radiobutton标签也是可以绑定数据的。以下是一个radiobutton的简单应用示例：

Jsp代码 复制代码 收藏代码
  1. <form:form action="formTag/form.do" method="post" commandName="user">
  2. <table>
  3. <tr>
  4. <td>性别:</td>
  5. <td>
  6. <form:radiobutton path="sex" value="1"/>男
  7. <form:radiobutton path="sex" value="0"/>女
  8. </td>
  9. </tr>
  10. <tr>
  11. <td colspan="2"><input type="submit" value="提交"/></td>
  12. </tr>
  13. </table>
  14. </form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>性别:</td>
            <td>
               <form:radiobutton path="sex" value="1"/>男
               <form:radiobutton path="sex" value="0"/>女
            </td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

在上面代码中我们的radiobutton标签都是绑定了表单对象user的sex属性，当sex为1的时候就代表性别为男，上面性别为男的那一行就会被选中，当sex为0的时候就代表性别为女，上面性别为女的那一行就会被选中。


radiobuttons

New Help > SpringMVC >
radiobuttons

radiobuttons标签跟radiobutton标签的区别如同checkbox标签对checkboxes标签的区别。使用radiobuttons标签的时候将生成多个单选按钮。使用radiobuttons有两个属性也是我们必须指定的，一个是path属性，表示绑定的表单对象对应的属性，另一个是items属性，表示用于生成单选按钮的数据源。跟checkboxes一样，radiobuttons的items属性和path属性都可以是Array、集合或者是Map。现在我们假设user在篮球、足球、乒乓球、羽毛球和排球这5种运动中选择一种作为自己最喜欢的球类运动。处理器方法和返回的对应的视图代码如下：

Java代码 复制代码 收藏代码
  1. @RequestMapping(value="form", method=RequestMethod.GET)
  2. public String formTag(Map<String, Object> map) {
  3. User user = new User();
  4. user.setFavoriteBall(4);//设置我最喜爱的球类运动是4羽毛球
  5. Map<Integer, String> ballMap = new HashMap<Integer, String>();
  6. ballMap.put(1, "篮球");
  7. ballMap.put(2, "足球");
  8. ballMap.put(3, "乒乓球");
  9. ballMap.put(4, "羽毛球");
  10. ballMap.put(5, "排球");
  11. map.put("user", user);
  12. map.put("ballMap", ballMap);
  13. return "formTag/form";
  14. }
    @RequestMapping(value="form", method=RequestMethod.GET)
    public String formTag(Map<String, Object> map) {
       User user = new User();
       user.setFavoriteBall(4);//设置我最喜爱的球类运动是4羽毛球
       Map<Integer, String> ballMap = new HashMap<Integer, String>();
       ballMap.put(1, "篮球");
       ballMap.put(2, "足球");
       ballMap.put(3, "乒乓球");
       ballMap.put(4, "羽毛球");
       ballMap.put(5, "排球");
       map.put("user", user);
       map.put("ballMap", ballMap);
       return "formTag/form";
    }

Jsp代码 复制代码 收藏代码
  1. <form:form action="formTag/form.do" method="post" commandName="user">
  2. <table>
  3. <tr>
  4. <td>最喜欢的球类:</td>
  5. <td>
  6. <form:radiobuttons path="favoriteBall" items="${ballMap}" delimiter="&nbsp;"/>
  7. </td>
  8. </tr>
  9. <tr>
  10. <td colspan="2"><input type="submit" value="提交"/></td>
  11. </tr>
  12. </table>
  13. </form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>最喜欢的球类:</td>
            <td>
               <form:radiobuttons path="favoriteBall" items="${ballMap}" delimiter="&nbsp;"/>
            </td>
        </tr>
        <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

在上述代码中我们可以看到我们使用了radiobuttons的delimiter属性，该属性表示进行展示的radiobutton之间的分隔符。这里用的是一个空格。结果页面如下所示：


password

New Help > SpringMVC >
password

password标签将会被渲染为一个type为password的普通HTML input标签。


select

New Help > SpringMVC >
select

select标签将会被渲染为一个普通的HTML select标签。这里还拿前面的user最喜欢的球类运动来做示例，有如下这样一个处理器方法和对应的视图页面：

Java代码 复制代码 收藏代码
  1. @RequestMapping(value="form", method=RequestMethod.GET)
  2. public String formTag(Map<String, Object> map) {
  3. User user = new User();
  4. user.setFavoriteBall(4);//设置我最喜爱的球类运动是4羽毛球
  5. Map<Integer, String> ballMap = new HashMap<Integer, String>();
  6. ballMap.put(1, "篮球");
  7. ballMap.put(2, "足球");
  8. ballMap.put(3, "乒乓球");
  9. ballMap.put(4, "羽毛球");
  10. ballMap.put(5, "排球");
  11. map.put("user", user);
  12. map.put("ballMap", ballMap);
  13. return "formTag/form";
  14. }
    @RequestMapping(value="form", method=RequestMethod.GET)
    public String formTag(Map<String, Object> map) {
       User user = new User();
       user.setFavoriteBall(4);//设置我最喜爱的球类运动是4羽毛球
       Map<Integer, String> ballMap = new HashMap<Integer, String>();
       ballMap.put(1, "篮球");
       ballMap.put(2, "足球");
       ballMap.put(3, "乒乓球");
       ballMap.put(4, "羽毛球");
       ballMap.put(5, "排球");
       map.put("user", user);
       map.put("ballMap", ballMap);
       return "formTag/form";
    }

Jsp代码 复制代码 收藏代码
  1. <form:form action="formTag/form.do" method="post" commandName="user">
  2. <table>
  3. <tr>
  4. <td>最喜欢的运动:</td>
  5. <td>
  6. <form:select path="favoriteBall" items="${ballMap}"/>
  7. </td>
  8. </tr>
  9. <tr>
  10. <td colspan="2"><input type="submit" value="提交"/></td>
  11. </tr>
  12. </table>
  13. </form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>最喜欢的运动:</td>
            <td>
               <form:select path="favoriteBall" items="${ballMap}"/>
            </td>
        </tr>
       <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

这个时候会渲染出如下结果：

从上面示例我们可以看出，我们通过items属性给select标签指定了一个数据源，并且绑定了表单对象user的favoriteBall属性。Items属性是用于指定当前select的所有可选项的，但是它对于select标签而言不是必须的，因为我们还可以手动的在select标签中间加上option标签来指定select可选的option。Select标签支持的items属性的数据类型可以是Array、Collection和Map，当数据类型为Array或Collection时且其中的元素为一个POJO时，我们可以通过属性itemLabel和itemValue来指定将用于呈现的option Label和Value，其他情况下Array和Collection数据源中的元素将既作为可选项option的value又作为它的Label。当items的数据类型为Map时，Map的key将作为可选项option的value，而Map的value将作为option的Label标签。


option

New Help > SpringMVC >
option

option标签会被渲染为一个普通的HTML option标签。当一个SpringMVC select标签没有通过items属性指定自己的数据源的时候，我们就可以在select标签中通过普通HTML option标签或者SpringMVC option标签来指定可以选择的项。

Jsp代码 复制代码 收藏代码
  1. <form:form action="formTag/form.do" method="post" commandName="user">
  2. <table>
  3. <tr>
  4. <td>最喜欢的运动:</td>
  5. <td>
  6. <form:select path="favoriteBall">
  7. <option>请选择</option>
  8. <form:option value="1">篮球</form:option>
  9. <option value="4">羽毛球</option>
  10. </form:select>
  11. </td>
  12. </tr>
  13. <tr>
  14. <td colspan="2"><input type="submit" value="提交"/></td>
  15. </tr>
  16. </table>
  17. </form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>最喜欢的运动:</td>
            <td>
               <form:select path="favoriteBall">
                   <option>请选择</option>
                   <form:option value="1">篮球</form:option>
                   <option value="4">羽毛球</option>
               </form:select>
            </td>
        </tr>
       <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

我们可以看到在上面代码中我们是没有指定select标签的数据源的，而是通过在select标签体里面指定普通HTML option标签和SpringMVC option标签来指定可选项。其渲染的效果如下：

这个时候你可能会有两个疑问：

l 如果我在使用select标签的时候通过items属性指定了其数据源，同时又在其标签体里面使用了option标签，那么这个时候会渲染出什么样的效果呢？是两种形式有一个优先级呢，还是会两种共存呢？

l 从上面代码产生的效果来看SpringMVC option标签跟普通的HTML option标签的效果无异，那为什么还要引进一个SpringMVC option标签呢？

先来解释第一个问题，我们把上面的视图代码改为如下形式：

Jsp代码 复制代码 收藏代码
  1. <form:form action="formTag/form.do" method="post" commandName="user">
  2. <table>
  3. <tr>
  4. <td>最喜欢的运动:</td>
  5. <td>
  6. <form:select path="favoriteBall" items="${ballMap}">
  7. <option>请选择</option>
  8. <form:option value="1">篮球</form:option>
  9. <option value="4">羽毛球</option>
  10. </form:select>
  11. </td>
  12. </tr>
  13. <tr>
  14. <td colspan="2"><input type="submit" value="提交"/></td>
  15. </tr>
  16. </table>
  17. </form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>最喜欢的运动:</td>
            <td>
               <form:select path="favoriteBall" items="${ballMap}">
                   <option>请选择</option>
                   <form:option value="1">篮球</form:option>
                   <option value="4">羽毛球</option>
               </form:select>
            </td>
        </tr>
       <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

从上述代码中我们可以看出来我们就是给select标签加了一个items属性，然后指定其数据源为当前pageContext的ballMap属性。此时，将渲染出如下效果：

答案很明显，当select标签指定了items属性的时候，它会忽略其标签体的内容，而使用items指定的内容来渲染出可选项。

对于第二个问题，我们把视图代码改为如下形式：

Jsp代码 复制代码 收藏代码
  1. <form:form action="formTag/form.do" method="post" commandName="user">
  2. <table>
  3. <tr>
  4. <td>最喜欢的运动:</td>
  5. <td>
  6. <form:select path="favoriteBall">
  7. <option>请选择</option>
  8. <form:option value="1">篮球</form:option>
  9. <option value="4">羽毛球-A</option>
  10. <form:option value="4">羽毛球-B</form:option>
  11. </form:select>
  12. </td>
  13. </tr>
  14. <tr>
  15. <td colspan="2"><input type="submit" value="提交"/></td>
  16. </tr>
  17. </table>
  18. </form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>最喜欢的运动:</td>
            <td>
               <form:select path="favoriteBall">
                   <option>请选择</option>
                   <form:option value="1">篮球</form:option>
                   <option value="4">羽毛球-A</option>
                   <form:option value="4">羽毛球-B</form:option>
               </form:select>
            </td>
        </tr>
       <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

我们可以看到，在上面代码中，我们定义了一个select标签，其绑定了当前表单对象user的favoriteBall属性，而且我们没有给该select指定items数据源。值得注意的是在该select标签体中我们通过普通HTML option和SpringMVC option标签定义了两个value均为4的option元素，而且我们也知道当前表单对象user的favoriteBall属性的值是4。接着我们来看一下上面代码渲染出的效果：

接着我们把上述代码中以SpringMVC option标签定义的option给删除，再看一下其渲染出的效果如下：

由此我们可以看出SpringMVC option标签和普通HTML option标签的区别就在于普通HTML option标签不具备数据绑定功能，而SpringMVC option标签具有数据绑定功能，它能把当前绑定的表单对象的属性对应的值对应的option置为选中状态。


options

New Help > SpringMVC >
options

使用options标签的时候需要我们指定其items属性，它会根据其items属性生成一系列的普通HTML option标签。这里的items属性的可取数据类型及其对应的渲染规则跟select的items属性是一样的。

Jsp代码 复制代码 收藏代码
  1. <form:form action="formTag/form.do" method="post" commandName="user">
  2. <table>
  3. <tr>
  4. <td>最喜欢的运动:</td>
  5. <td>
  6. <form:select path="favoriteBall">
  7. <option>请选择</option>
  8. <form:options items="${ballMap}"/>
  9. </form:select>
  10. </td>
  11. </tr>
  12. <tr>
  13. <td colspan="2"><input type="submit" value="提交"/></td>
  14. </tr>
  15. </table>
  16. </form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>最喜欢的运动:</td>
            <td>
               <form:select path="favoriteBall">
                   <option>请选择</option>
                   <form:options items="${ballMap}"/>
               </form:select>
            </td>
        </tr>
       <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

上面代码将渲染出如下效果：


textarea

New Help > SpringMVC >
textarea

SpringMVC textarea标签将被渲染为普通HTML textarea标签。简单示例如下：

Jsp代码 复制代码 收藏代码
  1. <form:form action="formTag/form.do" method="post" commandName="user">
  2. <table>
  3. <tr>
  4. <td>自我介绍:</td>
  5. <td>
  6. <form:textarea path="introduction" cols="20" rows="10"/>
  7. </td>
  8. </tr>
  9. <tr>
  10. <td colspan="2"><input type="submit" value="提交"/></td>
  11. </tr>
  12. </table>
  13. </form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table>
        <tr>
            <td>自我介绍:</td>
            <td>
               <form:textarea path="introduction" cols="20" rows="10"/>
            </td>
        </tr>
       <tr>
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>


errors

New Help > SpringMVC >
errors

SpringMVC errors标签是对应于SpringMVC的Errors对象的。它的作用就是用于展现Errors对象中包含的错误信息的。我们利用errors标签来展现Errors的时候是通过errors标签的path属性来绑定一个错误信息的。我们可以通过path属性来展现两种类型的错误信息。

l 所有的错误信息，这个时候path的值应该置为“*”

l 当前对象的某一个域的错误信息，这个时候path的值应为所需展现的域的名称

看下面这样一个例子：

定义了一个UserValidator对象，专门用来对User对象进行验证，其代码如下：

Java代码 复制代码 收藏代码
  1. import org.springframework.validation.Errors;
  2. import org.springframework.validation.ValidationUtils;
  3. import org.springframework.validation.Validator;
  5. public class UserValidator implements Validator {
  7. @Override
  8. public boolean supports(Class<?> clazz) {
  9. // TODO Auto-generated method stub
  10. return User.class.equals(clazz);
  11. }
  13. @Override
  14. public void validate(Object target, Errors errors) {
  15. // TODO Auto-generated method stub
  16. ValidationUtils.rejectIfEmpty(errors, "name", null, "Name Is Empty");
  17. ValidationUtils.rejectIfEmpty(errors, "username", null, "Username Is Empty.");
  18. }
  20. }
import org.springframework.validation.Errors;
import org.springframework.validation.ValidationUtils;
import org.springframework.validation.Validator;

public class UserValidator implements Validator {

    @Override
    public boolean supports(Class<?> clazz) {
       // TODO Auto-generated method stub
       return User.class.equals(clazz);
    }

    @Override
    public void validate(Object target, Errors errors) {
       // TODO Auto-generated method stub
       ValidationUtils.rejectIfEmpty(errors, "name", null, "Name Is Empty");
       ValidationUtils.rejectIfEmpty(errors, "username", null, "Username Is Empty.");
    }

}

然后我们有这样一个控制器类：

Java代码 复制代码 收藏代码
  1. @Controller
  2. @RequestMapping("formTag")
  3. public class FormTagController {
  5. @RequestMapping(value="form", method=RequestMethod.GET)
  6. public String formTag(Map<String, Object> map) {
  7. User user = new User();
  8. map.put("user", user);
  9. return "formTag/form";
  10. }
  12. @InitBinder
  13. public void initBinder(DataBinder binder) {
  14. binder.setValidator(new UserValidator());
  15. }
  17. @RequestMapping(value="form", method=RequestMethod.POST)
  18. public String form(@Valid User user, Errors errors) {
  19. if (errors.hasFieldErrors())
  20. return "formTag/form";
  21. return "formTag/submit";
  22. }
  23. }
@Controller
@RequestMapping("formTag")
public class FormTagController {

    @RequestMapping(value="form", method=RequestMethod.GET)
    public String formTag(Map<String, Object> map) {
       User user = new User();
       map.put("user", user);
       return "formTag/form";
    }

    @InitBinder
    public void initBinder(DataBinder binder) {
       binder.setValidator(new UserValidator());
    }

    @RequestMapping(value="form", method=RequestMethod.POST)
    public String form(@Valid User user, Errors errors) {
       if (errors.hasFieldErrors())
           return "formTag/form";
       return "formTag/submit";
    }
}

我们可以看到我们在上述控制器类中通过DataBinder对象给该类设定了一个用于验证的UserValidator，这样当我们请求该控制器的时候UserValidator将生效。

我们有如下这样一段表单代码：

Jsp代码 复制代码 收藏代码
  1. <form:form action="formTag/form.do" method="post" commandName="user">
  2. <table border="1px" bordercolor="blue">
  3. <tr align="center">
  4. <td width="100">姓名:</td>
  5. <td width="150"><form:input path="name"/></td>
  6. </tr>
  7. <tr align="center">
  8. <td>用户名:</td>
  9. <td><form:input path="username"/></td>
  10. </tr>
  11. <tr>
  12. <td>所有错误信息:</td>
  13. <td><form:errors path="*"/></td>
  14. </tr>
  15. <tr>
  16. <td>Name的错误信息:</td>
  17. <td><form:errors path="name"/></td>
  18. </tr>
  19. <tr align="center">
  20. <td colspan="2"><input type="submit" value="提交"/></td>
  21. </tr>
  22. </table>
  23. </form:form>
<form:form action="formTag/form.do" method="post" commandName="user">
    <table border="1px" bordercolor="blue">
        <tr align="center">
            <td width="100">姓名:</td>
            <td width="150"><form:input path="name"/></td>
        </tr>
        <tr align="center">
            <td>用户名:</td>
            <td><form:input path="username"/></td>
        </tr>
        <tr>
            <td>所有错误信息:</td>
            <td><form:errors path="*"/></td>
        </tr>
        <tr>
            <td>Name的错误信息:</td>
            <td><form:errors path="name"/></td>
        </tr>
        <tr align="center">
            <td colspan="2"><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form:form>

当我们提交上面的表单的时候会往Errors中注入两个错误信息，展示的页面信息将如下所示：


guest

New Help > shiro >
guest

用户没有身份验证时显示相应信息，即游客访问信息。

<shiro:guest>

欢迎游客访问，<a href="${pageContext.request.contextPath}/login.jsp">登录</a>

</shiro:guest>


user

New Help > shiro >
user

用户已经身份验证/记住我登录后显示相应的信息

<shiro:user>

欢迎[<shiro:principal/>]登录，<a href="${pageContext.request.contextPath}/logout">退出</a>

</shiro:user>


authenticated

New Help > shiro >
authenticated

用户已经身份验证通过，即Subject.login登录成功，不是记住我登录的。

<shiro:authenticated>
用户[<shiro:principal/>]已身份验证通过
</shiro:authenticated>


notAuthenticated

New Help > shiro >
notAuthenticated

用户已经身份未验证通过，即没有调用Subject.login进行登录，包括记住我自动登录的也属于未进行身份验证

<shiro:notAuthenticated> 未身份验证（包括记住我）</shiro:notAuthenticated>


principal

New Help > shiro >
principal

显示用户身份信息，默认调用Subject.getPrincipal()获取，即Primary Principal。

<shiro: principal/>

Java代码
  1. <shiro:principal type="java.lang.String"/>

相当于Subject.getPrincipals().oneByType(String.class)。

Java代码
  1. <shiro:principal type="java.lang.String"/>

相当于Subject.getPrincipals().oneByType(String.class)。

Java代码
  1. <shiro:principal property="username"/>

相当于((User)Subject.getPrincipals()).getUsername()。


hasRole

New Help > shiro >
hasRole

如果当前Subject有角色将显示body体内容。

<shiro:hasRole name="admin">

用户[<shiro:principal/>]拥有角色admin<br/>

</shiro:hasRole>


lacksRole

New Help > shiro >
lacksRole

如果当前Subject没有角色将显示body体内容。

<shiro:lacksRole name="abc">

用户[<shiro:principal/>]没有角色abc<br/>

</shiro:lacksRole>


hasAnyRoles

New Help > shiro >
hasAnyRoles

如果当前Subject有任意一个角色（或的关系）将显示body体内容。

<shiro:hasAnyRoles name="admin,user">

用户[<shiro:principal/>]拥有角色admin或user<br/>

</shiro:hasAnyRoles>


hasAllRoles

New Help > shiro >
hasAllRoles

如果当前Subject有所有角色将显示body体内容。

<shiro:hasAllRoles name="admin,user">
用户[<shiro:principal/>]拥有角色admin和user<br/>
</shiro:hasAllRoles>


hasPermission

New Help > shiro >
hasPermission

如果当前Subject有权限将显示body体内容。

<shiro:hasPermission name="user:create">

用户[<shiro:principal/>]拥有权限user:create<br/>

</shiro:hasPermission>


lacksPermission

New Help > shiro >
lacksPermission

如果当前Subject没有权限将显示body体内容。

<shiro:lacksPermission name="org:create">

用户[<shiro:principal/>]没有权限org:create<br/>

</shiro:lacksPermission>


hasAnyPermissions

New Help > shiro >
hasAnyPermissions

如果当前Subject有任意一个权限将显示body体内容。

<shiro:hasAnyPermissions name="user:create,abc:update">
用户[<shiro:principal/>]拥有权限user:create或abc:update<br/>
</shiro:hasAnyPermissions>


hasAllPermissions

New Help > shiro >
hasAllPermissions

如果当前Subject有所有权限将显示body体内容。

<shiro:hasAllPermissions name="user:create,user:update">
用户[<shiro:principal/>]拥有权限user:create和user:update<br/>
</shiro:hasAllPermissions>


getAdminPath

New Help > 自定义 > fns >
getAdminPath

获取管理路径

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


getFrontPath

New Help > 自定义 > fns >
getFrontPath

获取网站路径

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getFrontPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getFrontPath()}"/>


getUrlSuffix

New Help > 自定义 > fns >
getUrlSuffix

获取网站URL后缀

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getUrlSuffix()}

实例

<c:set var="urlSuffix" value="${fns:getUrlSuffix()}"/>


getConfig

New Help > 自定义 > fns >
getConfig

获取配置

参数信息

参数类型 | 参数描述
java.lang.String | 配置的键值

返回信息

java.lang.String

使用方法

${fns:getConfig(key)}

实例

< P><title>${fns:getConfig('productName')}</title>


getUser

New Help > 自定义 > fns >
getUser

获取当前用户对象

参数信息

参数类型 | 参数描述

返回信息

com.thinkgem.jeesite.modules.sys.entity.User

使用方法

${fns:getUser()}

实例

< P>当前用户：${fns:getUser().name}<br/>


getMenuList

New Help > 自定义 > fns >
getMenuList

获取当前用户的菜单对象列表

参数信息

参数类型 | 参数描述

返回信息

java.util.List

使用方法

${fns:getMenuList()}

实例

<c:forEach items="${fns:getMenuList()}" var="menu">
<c:if test="${menu.isShow eq '1'}">

< P> id：<label>${menu.id}</label>

< P> name:<label>${menu.name}</label>

</c:if>
</c:forEach>


getAreaList

New Help > 自定义 > fns >
getAreaList

获取当前用户的区域对象列表

参数信息

参数类型 | 参数描述

返回信息

java.util.List

使用方法

${fns:getAreaList()}

实例

<select id="area" name="area">
<c:forEach items="${fns:getAreaList()}" var="area">
<option value="${area.code}">${area.name}</option>
</c:forEach>
</select>


getOfficeList

New Help > 自定义 > fns >
getOfficeList

获取当前用户的部门对象列表

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

getOfficeList

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


getCache

New Help > 自定义 > fns >
getCache

获取当前用户缓存

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


getDictLabel

New Help > 自定义 > fns >
getDictLabel

获取字典标签

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


getDictLabels

New Help > 自定义 > fns >
getDictLabels

获取字典标签(多个)[标签之间使用逗号(,)分割]

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


getDictValue

New Help > 自定义 > fns >
getDictValue

获取字典值

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


getDictList

New Help > 自定义 > fns >
getDictList

获取字典对象列表

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


urlEncode

New Help > 自定义 > fns >
urlEncode

URL编码

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


urlDecode

New Help > 自定义 > fns >
urlDecode

URL解码

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


escapeHtml

New Help > 自定义 > fns >
escapeHtml

HTML编码，如将<转换为&lt;

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


unescapeHtml

New Help > 自定义 > fns >
unescapeHtml

HTML解码

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


substringAfterLast

New Help > 自定义 > fns >
substringAfterLast

从后边开始截取字符串

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


startsWith

New Help > 自定义 > fns >
startsWith

判断字符串是否以某某开头

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


endsWith

New Help > 自定义 > fns >
endsWith

判断字符串是否以某某结尾

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


abbr

New Help > 自定义 > fns >
abbr

缩写字符串，超过最大宽度用“...”表示

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


replaceHtml

New Help > 自定义 > fns >
replaceHtml

替换掉HTML标签

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


jsGetVal

New Help > 自定义 > fns >
jsGetVal

转换为JS获取对象值，生成三目运算返回结果。

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


getDate

New Help > 自定义 > fns >
getDate

获取当前日期

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


pastDays

New Help > 自定义 > fns >
pastDays

获取过去的天数

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>


toJsonString

New Help > 自定义 > fns >
toJsonString

对象转换JSON字符串

参数信息

参数类型 | 参数描述

返回信息

java.lang.String

使用方法

${fns:getAdminPath()}

实例

<c:set var="ctx" value="${pageContext.request.contextPath}${fns:getAdminPath()}"/>