JSTL学习

来源:互联网 发布:python读取jason文件 编辑:程序博客网 时间:2024/04/29 13:15

下载地址:http: /  /  archive.apache.org/dist/jakarta/taglibs/standard/binaries/      去掉空格。

   1.JSTL标签可与HTML元素相互嵌套

   2.JSTL可出现于HTML元素的内容区中
相同,HTML元素也可出现于JSTL标签的内容区中.
但是,两者都不会出现于对方的属性之中,仅仅出现在对方的内容区之中.

出现于两者属性区中的内容可以有两种可能:
    1.EL表达式(属性区+内容区)
    2.JSP元素
 示例1:
     <%
        List lst=new ArrayList();
        lst.add("abc");
        lst.add("123");
        pageContext.setAttrbute("list",lst);
     %>
     <1>JSP元素嵌入JSTL属性区
      <c:forEach items="<%= pageContext.getAttribute(\"list\")%>" var="l">
            <%= pageContext.getAttribute("L")%>
      </c:forEach>
     <2>EL嵌入JSTL属性区
      <c:forEach items="${list}" var="L">
             ${L}
      </c:forEach>
通常EL表达式与JSTL进行结合而不会与JSP元素结合使用,EL也可出现于HTML元素之中.类似于"<%= ... %>"的功能.
  示例2:EL出现于HTML元素的属性区中.
      <c:url value="/HelloServlet" var="nextURL">
          <c:param name="name"  value="username" />
      </c:url>
      <a href="${nextURL}">下一步</a>
EL是一个表达式,它是有返回值的.表达式是由操作数+操作符构成
  示例3:对比字符串与EL表达式的意义区别.
        即.如果中间的代码是要求进行运算的代码,而不是字面量,则必须使用EL表达式
     <c:set var="number" scope="page">
         ${1+1}
     </c:set>
     这样变量存储的值就是2.
     <c:set var="number" scope="page">
         1+1
     </c:set>
     这样number中存储的是1+1的字符串,而不是2
   示例4:
      <c:choose>
         <c:when test="${gender=='male'}">
              男
         </c:when>
         <c:when test="${gender='female'}">
              女
         </c:when>
         <c:otherwise>
              未知
         </c:otherwise>
      </c:choose> 
 




JSTL标签库的是由以下的五个标签库组成:


1.核心标签库(core)            URI:http://java.sun.com/jsp/jstl/core        prefix="c"

2.数据库相关标签库(SQL)         URI:http://java.sun.com/jsp/jstl/sql         prefix="sql"

3.XML相关标签库(XML)            URI:http://java.sun.com/jsp/jstl/xml         prefix="xml"

4.函数标签库(functions)         URI:http://java.sun.com/jsp/jstl/functions   prefix="fn"

5.国际化标签库(il8n)            URI:http://java.sun.com/jsp/jstl/fmt         prefix="fmt"

JSP标签库可以使用<%@ taglib ...%> JSP指令元素进行导入,这样就可以在JSP页面中使用相关的第三方标签了.
JSTL就是Apache组织开发的标准标签库.
例:
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

JSTL最大的有点就是把某种特定的功能进行封装,需要使用这种功能的地方可以直接调用,而不必重复写类似的代码,尤其是对Web开发常见的功能非常有帮助,这就相当于使用简介的语法来替代原先JSP页面中的脚本元素.
下面的例子可以看到使用JSP脚本元素和使用JSTL的形式上的差别.

JSP:
<%
    List list=new ArrayList();
    list.add("abc");
    list.add("123");
    pageContext.setAttribute("list",list);
%>
<%--下面的var参数是将items集合类中的元素一一取出来并作为属性放置于pageContext作用域中--%>
<c:forEach items="<%=pageContext.getAttribute(\"list\")%>" var="l">
    <%=pageContext.getAttribute("l")%>
</c:forEach>

EL具有获取数据更直接和简介的特点,所以EL出现以后,JSTL在传参和展示数据方面经常会使用El,这样使得JSP代码更简明.因此上面的JSTL代码可以这样使用EL进行改写:

<c:forEach item="${list}" var="l">
    <c:out value="${l}" escapeXML="true" />
</c:forEach>

重点:
    JSTL的主要用处也是为了简化JSP页面的代码量,使得整个页面的代码结构更加清晰,便于维护.主要方式就是利用JSTL标签替代原有的常JSP脚本元素的脚本段,换句话说就是利用JSTL对JSP的脚本元素的脚本段进行了封装.
    而EL则是替代了JSP脚本元素中的表达段.
=================================================================================================
下面介绍JSTL的各个标签库
一>JSTL核心标签库(Core):
一般用途的标签包括:<c:out> <c:set> 和 <c:remove>,他们在JSP里使用的相对频繁一些,操作的是页面上的各类变量.
-------------------------------------------------------------------------------------------------
1><c:out>
<c:out>用于想JSP的输出流打印一个表达式结果.
    1.语法:
        语法1: 没有标签体.
            <c:out value="表达式" [default="默认值" escapeXML="true|false"] />
        语法2: 有标签体.
            <c:out value="表达式" [escapeXML="true|false"]>
              默认值
            </c:out>
    2.实例:
         示例1:
              <c:out value="${book.name}" default="暂无" />
         示例2:
              <c:out value="&{book.name}">
                     暂无
              </c:out>
--------------------------------------------------------------------------------------------------
2> <c:set>
用于想特定的作用范围设置一个属性对象或者设置一个JavaBean的属性值.
    1.语法:
           语法1: 用value向特定作用范围设置属性值.
               <c:set value="对象" var="变量名称" [scope="作用范围"] />
           语法2: 用标签体向特定作用范围设置属性值.
               <c:set var="变量名称" [scope="作用范围"]>
                     内容
             </c:set>
           语法3: 用value 向target指定的JavaBean设置属性值
               <c:set value="值" target="目标JavaBean" property="属性名" />
           语法4: 用标签体向target指定的JavaBean设置属性值.
               <c:set target="目标JavaBean" property="属性名">
                     内容
             </c:set>
      2.示例:
           示例1:
               <c:set value="helloWorld" var="greeting" scope="page" />
           示例2:
                <c:set var="greeting" scope="page">
                      hello world
              </c:set>
           示例3:
                <c:set value="hello world" target="${greetBean}" property="text" />
           示例4:
                <c:set target="${greetBean}" property="text">
                       hello world
              </c:set>
       3.说明:
                <c:set>标签一般有两种作用.
                    (1)向四作用域范围对象(page,request,session,application)设置属性,相当于
                       setAttribute("var指定的名称",value或标签体内容);
                    (2)向某个JavaBean设置属性的值,类似于<jsp:setProperty>
                      (在本质上上JavaBean也是属于四作用域范围中的属性)
--------------------------------------------------------------------------------------------------
3><c:remove>
   用于删除特定作用域里变量.
         1.语法:
                 <c:remove var="变量名" scope="作用范围">
         2.示例:
                 <c:remove var="greet" />
         3.说明:
                 如果scope属性指定了作用范围,则相当于调用了
                 pageContext.removeAttribute("变量名","作用范围");
                 pageContext.removeAttribute("变量名");
--------------------------------------------------------------------------------------------------
4><c:forEach>循环显示数据
   该标记支持两种不同样式的迭代:
       1)整数范围上的迭代(类似于Java语言的for循环语句)
       2)集合类对象上的迭代(类似于Java语言的Iterator,Enumeration类)
      
       1.语法:
              语法1: 使用begin和end属性进行整数范围迭代.
                 <c:forEach begin="开始数子" end="结束数子" [var="循环过程中的变量"] step="每次迭代的增量">
                       每次循环体内容
               </c:forEach>
              语法2: 使用items和var属性进行集合迭代.
                <c:forEach items="集合类变量(EL)" var="循环过程中的变量" [varStatus="status"]>
                       每次循环体内容   
                 </c:forEach>
        2.示例1:打印20~50之间的偶数.
             <c:forEach begin="20" end="50" var="i" step="2">
                 <c:out value="${i}" />
              </c:forEach>
          示例2:用表格展示用户列表里所有用户的数据.
              <table>
                   <tr>
                       <th>编号</th>
                       <th>用户名</th>
                       <th>年龄</th>
                       <th>性别</th>
                   </tr>
                   <c:forEach items="${users} var="user"  var="stat">
                       <tr>
                           <td>${stat.count}</td>
                           <td>${user.name}</td> 
                           <td>${user.age}</td>
                           <td>${user.gender}</td>
                       </tr>
                   </c:forEach>
              </table>
              注意:<c:forEach>标签items属性需要用表达式语言赋值.例如以上示例,千万别写成了这样:
                    <c:forEach items="users">
                    其实这里的EL表达式就相当于.
                    <c:forEach items="<%=request.getAttribute(\"users\")%>">
                    因此EL就相当于JSP脚本元素的简化替代形式
           3.说明:
               对于整数范围的迭代,begin和end属性必须,他们或者是静态整数常量,或者是可以得出整数值的表达式(EL或JSP脚本元素的表达段),他们分别制定了迭代索引的初始值以及迭代索引的终止值.当出现step的时候,它也必须是整数值,它指定每次迭代的增量,迭代索引从begin属性开始(包括起始值),以step属性的值为增量进行递增,在迭代索引超过end属性的值(包括终止值)时候停止迭代.如果省略了step属性,那么步长缺省为1.
               在对集合的成员进行迭代的时候,会用到另一个属性,即items属性,当使用这种形式的
<c:forEach>标签时,items属性是唯一必须的属性.items属性的值应该是一个集合,对集合成员进行迭代,通常使用EL表达式指定其值.
               varStatus属性是可选的,但是有的时候他的作用比较大,例如,做一个分页程序需要在最后一行后面系那是当前页得记录数,可以通过${status.last}判断是否达到最后一行,然后使用${status.count}返回记录数即可.若没有该属性,还需要另外做大量的工作来满足这样的需求.
-------------------------------------------------------------------------------------------------
5><c:if>&<c:choose>
   <c:if>
       1.语法:
           <c:if>简单的对单个测试表达式进行求值,接下来,仅当对表达式求出的值为true时,它才处理标签体的内容.如果求出的值部位true就忽略该标记的主体内容.
          <c:if test="布尔表达式" [var="变量名" scope="作用范围"]>
                 内容
          </c:if>
    <c:choose>
        1.语法:
            对于需要进行互斥测试来确定应该显示什么内容的情况下,则使用<c:choose>进行操作
            <c:choose>
                <c:when test="布尔表达式">
                      内容
                </c:when>
                ...
                <c:otherwise>
                      内容
                </c:otherwise>
            </c:choose>
          2.示例:
             示例1:如果用户有相应的权限,则打印对应的超级链接按钮.
                <ul>
                      <c:if test="${user.permission1}">
                          <li><a href="ur1">链接</a></li>
                      </c:if>
                      <c:if test="${user.permission2}">
                          <li><a href="ur2">链接</a></li>
                      </c:if>
                      <c:if test="${user.permission3}">
                          <li><a href="ur3">链接</a></li>
                      </c:if>
                </ul>
              示例2:根据用户性别的标识符号来打印"男","女"或"未知性别"
                   <c:choose>
                          <c:when test="${param.gender='male'}">
                                男
                          </c:when>
                          <c:when test="${param.gender='female'}">
                                女
                          </c:when>
                          <c:otherwise>
                                未知性别
                          </c:when>
                   </c:choose>
         3.重要说明:
               <c:if>可以通过其var和scope属性(它们所起的作用和在<c:set>中所起的作用是一样的)选择将测试结果赋给特定作用范围的变量.当测试代价非常高昂时,这种能力尤为有用:可以将结果缓存在特定的作用范围的变量中,然后在随后对<c:if>或其他JSTL标签的调用中检索改结果.
               <c:choose>标签的每个要测试的条件都由相应的<c:when>标签来表示,至少要有一个<c:when>标签.只会处理第一个其test值为true的<c:when>标签体内的内容.如果没有一个<c:when>测试返回true
,那么会处理<c:otherwise> 标签的主体内容,尽管如此,<c:otherwise>标签确实可选的,而且<c:choose>标签之多可以有一个嵌套的<c:otherwise>标签,如果所有的<c:when>测试都为false,而且有没有给<c:otherwise> 操作,则色很猛也不处理.
--------------------------------------------------------------------------------------------------
6><c:url>和<c:param>生成URL
     1.语法:
           <c:url value="地址" [context="" var="" scope=""]>
                 <c:param name="" value="" />
                  ...
          </c:url>
     2.说明:
           <c:url>的value属性用来指定基本URL,然后在必要时对其进行转换.如果这个基本的URL以一个斜杠开始,那么会在它前面加上servlet上下文名称.可以使用context属性提供显式的上下文名称.如果省略context属性,那么就使用当前servlet上下文名称.这一点特别有用,因为servlet上下文名称是在部署期间而不是开发期间决定的.
            如果这个基本URL不是以斜杠开始的,那么就认为它是一个文档相对URL,此时就不必添加上下文名称了.
      3.示例:
            <c:url value="/HelloServlet" var="nextURL">
                 <c:param name="name" value="username"></c:param>
            </c:url>
            <a href="${nextURL}">下一步</a>
            <!-- 生成的URL为: /Servlet上下文名称/HelloServlet?name=username -->
==================================================================================================
二>JSTL数据库标签库(SQL):
      JSTL数据库标签库视为了减少操作数据库的JSP脚本代码而设计的,让开发者方便快捷的操作数据库,它本质上也是使用JDBC来进行数据库的相关操作的.JSP页面的引用格式为:
     <%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql" %>

1><sql:setDataSource>准备数据源
    使用JSTL数据库相关标签进行数据库数据的添加,删除,查询,修改操作大致可以分为3步:1准备数据源2执行SQL语句3根据执行结果进行相应的操作.数据源的准备是所有操作的前提,JSTL使用<SQL:setDataSource>标签为所有SQL标签准备数据源对象.一般来说,一个Web应用程序只需要一个数据源即可.
          1.语法:
                 <sql:setDataSource
                      driver="驱动类名"
                      url="连接字符串"
                      user="用户名"
                      password="密码"
                      var="数据源保存的变量名称"
                      scope="作用范围"

                  />  
           2示例:设置一个数据源
                 <sql:setDataSource
                      driver="com.mysql.jdbc.Driver"
                      url="jdbc:mysql://localhost:3306/test"
                      user="root"
                      password="123"

                 />
            注意:SQL标签库只是一种对JDBC的封装形式,数据源同样需要JDBC的驱动程序.
--------------------------------------------------------------------------------------------------
2><sql:query>标签查询数据
      该标签用于执行select的SQL语句,得到查询的记录集.

      1.语法:
          语法1:用sql属性指定SQL语句
                 <sql:query var="结果变量" sql="SQL语句"
                            [scope="作用范围"
                             dataSource="数据源"
                             maxRows="最大行数"
                             startRows="起始行数"]>
                  [<sql:param value="占位符参数值">]
                 </sql:query>
           语法2:用标签体指定SQL语句.
                 <sql:query var="结果变量"
                            [scope="作用范围"
                             dataSource="数据源"
                             maxRows="最大行数"
                             startRows="起始行数"]>
                  SELECT语句
                  [<sql:param value="占位符参数值">]
                 </sql:query>
      2.示例:
        示例1:打印所有用户数据
       
 <sql:query var="userData">
             select * from user_table;
          </sql:query>
          <table border="1">
             <tr>
                  <th>用户名</th>
                  <th>性别</th>
                  <th>年龄</th>
             </tr>
             <c:forEach var="row" items="${userData.rows}">
                  <tr>
                       <td><c:out value="${row.username}"></td>
                       <td><c:out value="${row.age}"></td>
                       <td><c:out value="${row.gender}"></td>

             </c:forEach>
           </table>

         示例2:打印年龄大于等于20岁用户的数据.
         
 <sql:query var="userData">
               select * from user_table where age>=?
               <sql;param value="20"></sql:param>
          </sql:query>
          <table border="1">
                <tr>
                     <th>用户名</th>
                     <th>年龄</th>
                     <th>性别</th>

                </tr>
                <c:forEach var="row" items="${userData.rows}">
                     <tr>
                          <td><c:out value="${row.username}" /></td>
                          <td><c:out value="${row.age}" /></td>
                          <td><c:out value="${row.gender}" /></td>

                     </tr>
                </c:forEach>
          </table>

--------------------------------------------------------------------------------------
4>使用<sql:update>标签更新数据库数据
 
   <sql:update>标签用于执行insert,update和delete的SQL语句,得到的结果为影响的记录条数.
    1.语法:
      
  语法1:用sql属性指定SQL语句.
       
 <sql:update var="结果变量" sql="SQL语句"
             [scope="作用范围"
              dataSource="数据源"]>
              [<sql:param>指定sql参数]
         </sql:update>
        语法2:用标签体指定SQL语句
        <sql:update var="结果变量"
             [scope="作用范围"
              dataSource="数据源"]>
            SQL语句
            [<sql:param>指定sql参数]
         </sql:update>

      2.示例:
           <sql:update var="updateRst" sql="update user_table set password=? where username=?">
                 <sql:param value="${param.password}"></sql:param>
                 <sql:param value="${param.username}"></sql:param>
           </sql:update>
           执行结果为
           <c:choose>
                <c:when test="${updateRst>0}">
                    成功
                </c:when>
                <c:otherwise>
                    失败
                </c:otherwise>
           </c:choose>
          注意:对于增删改查四种SQL操作,尽量不要使用字符串拼接的方式来构造,很可能会有SQL注入的危险.
--------------------------------------------------------------------------------------------------
5><sql:transaction>标签使用数据库事务
      事务处理用于保护作为一组必须成功或必须失败的一些列数据操作.当使用JSTL的数据库标签库的标签来进行数据库操作的时候同样可以使用事务,将对应的<sql:query>,<sql:update>的操作嵌套在<sql:transaction>元素的内容区中,就可以把一系列查询和更新操作打包到一个事务处理中.
      1.语法:
             <sql:transaction [dataSource="" isolation="隔离级别"]>
                  <sql:query .../>
                      or
                  <sql:update .../>
                      ...
              </sql:transaction>
      2.示例:
              <sql:transaction>
                  <sql:update sql="update user_table set password=? where username=?">
                      <sql:param value="${param.password}"/>
                      <sql:param value="${param.username}"/>
                  </sql:update>
                  <sql:update sql:="update user_table set age=? where username=?">
                       <sql:param value="${param.age}"/>
                       <sql:param value="${param.username}"/>
                  </sql:update>
              </sql:transaction>
      3.说明:
               <sql:transaction>操作没有必需的属性.如果忽略了dataSource属性,那么使用JSTL的默认数据源.isolation属性用于规定事务处理的隔离级别,他可以是:
               1.read_committed
               2.read_uncommitted
               3.repeatable_read
               4.serializable
               若未规定这一属性,事务处理将使用数据源的缺省隔离级别,通常是read_committed.
               事务的隔离级别的主动权在数据库,也就是说,即使程序里设置了某某隔离级别,同样需要数据库的支持才行.
==================================================================================================
三>JSTL函数标签库(Function):
函数标签库相对于其他标签库的使用方式来说有些特殊,它是JSTL定义的标准的EL函数集合,因此是要直接放置在EL中才能使用.使用方式为:
             fn:函数名(参数)
该标签库定义的函数基本上都是对字符串进行相关操作的函数.
在JSP页面中使用函数标签库的引用格式为:
       <%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
-------------------------------------------------------------------------------------------------
1>>布尔表达式函数:
   布尔表达式函数值的是返回值为布尔类型的函数,包括 contains,containsIgnoreCase,startsWith和
endsWith

1> fn:contains 和fn:containsIgnoreCase
   fn:contains 和fn:containsIgnoreCase函数用于判断字符串是否包含某一子串
       1.语法:
           fn:contains("源字符串","匹配字符串");
          fn:containsIgnoreCase("源字符串","匹配字符串")
       2.示例:
             示例1:
                 ${fn:contains("throne212","212")}
                  结果:true
             示例2:
                 ${fn:containsIgnoreCase("throne212","Rone")}
                  结果:true
2>fn:startsWith 和 fn:endsWith
   fn:startsWith 和 fn:endsWith函数用于判断字符串是否以某一字串开头和结尾
        1.语法:
           fn:startsWith("源字符串","匹配的开头字符串")
          fn:endsWith("源字符串","匹配的结尾字符串")
        2.示例:
               示例1:
                  ${fn:startsWith("throne212","thr")}
                  结果:true
               示例2:
                  ${fn:endsWith("throne212","212")}
                  结果:true
-------------------------------------------------------------------------------------------------
2>>整型表达式函数
   整型表达式函数包括两个,即indexOf和length,分别用于返回指定字符串的下标和整个字符串的长度,他们都返回一个int型数据.
1>fn:indexOf
    fn:indexOf函数用于计算某一子串的下标位置.
         1.语法:
            fn:indexOf("源字符串","匹配字符串")
         2.示例:
            示例1:
               ${fn:indexOf("throne212","ro")}
               结果:2(字符串的下标从0开始计算)
               ${fn:indexOf("throne212","abc")}
               结果:-1(找不到子串返回-1)
2>fn:length
    fn:length函数返回字符串的长度
         1.语法:
            fn:length("源字符串")
         2.示例:
            fn.length("throne212")
            结果:9
--------------------------------------------------------------------------------------------------
3>>字符修改函数:
字符修改函数用于对源字符串继续修改,产生一个新的字符串,但是源字符串本身均不会发生改变,包括replace,substring,toUpperCase,toLowerCase和trim
1>fn:replace和fnsubstring
    fn:replace和fnsubstring函数用于替换字符串的某些内容和街区字符串的一段,但是源字符串本身不会改变
           1.语法:
               fn:replace("源字符串","匹配字符串","替换后的字符串")
               fn:substring("源字符串",开始下标,结束下标)
           2.示例:
               示例1:
               ${fn:replace("throne212","212","456")}
               结果:throne456
               示例2:
               ${fn:substring("throne212",6,9)}
               结果:212
2>fn:toUpperCase和fn:toLowerCase
    fn:toUpperCase和fn:toLowerCase返回字符串的大写和小谢形式,源字符串本身并无改变.
          1.语法:
               fn:toUpperCase("源字符串")
               fn:toLowerCase("源字符串")
3>fn:trim
    fn:trim返回去掉字符串两头空格以后的字符串,源字符串本身并无改变.
         1.语法:
             fn:trim("源字符串")


0 0
原创粉丝点击