JSTL自定义标签

  1. 云栖社区>
  2. 博客>
  3. 正文

JSTL自定义标签

ghost丶桃子 2016-05-26 15:27:25 浏览1428
展开阅读全文

目录(?)[+]

        这节我们总结一下JSTL自定义标签相关内容。

1. 自定义标签简介

        自定义标签主要用于移除JSP页面中的Java代码。Jsp页面主要是用来显示给前台的,如果里面有过多的java代码的话,会显得很乱,但是没有java代码也无法获取相关数据或完成相关操作。那么这时候我们就可以自己定义一个标签,来完成需要用java代码完成的事情,这样Jsp页面就会清洁很多,可读性也更强。JSP中使用自定义标签移除只需要完成以下两个步骤:

        1)编写一个实现Tag接口的java类(标签处理类)
        2)编写标签库描述符(tld)文件,在tld文件中对标签处理类进行描述。

2. 一个简单实例

        我们写一个简单的实例来快速理解自定义标签:输出客户机的IP。按照上面描述的两个步骤,我们首先编写一个实现Tag接口的java类:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class ViewIPTag implements Tag {  
  2.   
  3.     private PageContext pageContext;      
  4.     @Override  
  5.     public int doStartTag() throws JspException {  
  6.         HttpServletRequest request = (HttpServletRequest)pageContext.getRequest(); //获取request  
  7.         JspWriter out = pageContext.getOut(); //获取out</span>  
  8.           
  9.         String ip = request.getRemoteAddr(); //通过request获取客户机的ip  
  10.         try {  
  11.             out.write(ip); //写到浏览器  
  12.         } catch (IOException e) {  
  13.             throw new RuntimeException(e);  
  14.         }         
  15.         return 0;  
  16.     }     
  17.     @Override  
  18.     public int doEndTag() throws JspException {  
  19.         return 0;  
  20.     }  
  21.     @Override  
  22.     public Tag getParent() {  
  23.         return null;  
  24.     }  
  25.     @Override  
  26.     public void release() {  
  27.     }  
  28.     @Override  
  29.     public void setPageContext(PageContext arg0) {        
  30.         this.pageContext = arg0;  
  31.     }  
  32.     @Override  
  33.     public void setParent(Tag arg0) {  
  34.     }  
  35. }  
        写好了java类,我们来编写标签库描述符(tld)文件,在WEB-INF目录下新建一个tld文件,在tld文件中对标签处理器类进行描述:
[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2.   
  3. <taglib xmlns="http://java.sun.com/xml/ns/j2ee"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"  
  6.     version="2.0">  
  7.     <description>A tag library exercising SimpleTag handlers.</description>  
  8.     <tlib-version>1.0</tlib-version>  
  9.     <short-name>SimpleTagLibrary</short-name>  
  10.     <uri>/test</uri>  <!--为该标签配一个uri-->  
  11.       
  12.     <tag>  
  13.     <name>viewIP</name> <!-- 为标签处理器类配一个标签名 -->  
  14.     <tag-class>web.tag.ViewIPTag</tag-class>  
  15.     <body-content>empty</body-content>  
  16.     </tag>  
  17.       
  18. </taglib>  
        这样我们在JSP页面中就可以导入并使用自定义标签了:
[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
  2. <%@ taglib uri="/test" prefix="test"%>  <!--uri与tld文件中配的uri相同-->  
  3.   
  4. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
  5. <html>  
  6.   <head>    
  7.     <title>输出客户机的IP</title>  
  8.   </head>  
  9.     
  10.   <body>  
  11.     您的IP是:<test:viewIP/>  
  12.       
  13.     <!--该标签相当于执行下面脚本代码-->  
  14.     <%   
  15.         String ip = request.getRemoteAddr();  
  16.         out.write(ip);  
  17.     %>         
  18.   </body>  
  19. </html>  
        到这里,应该就能清楚了自定义标签的定义和配置了。我们来分析一下执行顺序:JSP引擎首先通过uri和viewIP标签名去找tld文件,在tld中通过viewIP找到ViewIPTag类,该类中,首先调用setPageContext方法把页面的pageContext传递进来,再调用setParent把父标签传递进来(没有则不传),至此完成了标签的初始化工作。然后调用doStartTag和doEndTag方法,开始和结束标签,最后调用release方法释放标签,运行时所占的资源。

3. 自定义标签功能扩展

        开发人员在编写JSP页面时,经常还需要在页面中引入一些逻辑,如:

        控制JSP页面某一部分内容是否执行;
        控制整个JSP页面是否执行;
        控制JSP页面内容重复执行;
        修改JSP页面内容输出。

        即:自定义标签除了可以移除JSP页面的java代码外,还可以实现以上功能。下面我们一个个来分析:

1)控制JSP页面某一部分内容是否执行

        新建一个标签处理类TagDemo1继承TagSupport类(TagSupport类已经实现了Tag接口,不用直接去实现了),doStartTag方法中可以通过不同的返回值类控制标签体是否执行。返回Tag.EVAL_BODY_INCLUDE表示执行标签体内容,返回Tag.SKIP_BODY表示不执行

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //控制标签体是否执行  
  2. public class TagDemo1 extends TagSupport {  
  3.   
  4.     @Override  
  5.     public int doStartTag() throws JspException {  
  6.               
  7. //      return Tag.SKIP_BODY;//不执行标签体内容  
  8.         return Tag.EVAL_BODY_INCLUDE; //执行标签体内容  
  9.     }  
  10. }  

         然后在文件中配置好:

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <tag>  
  2.     <name>demo1</name>  
  3.     <tag-class>web.tag.TagDemo1</tag-class>  
  4.     <body-content>JSP</body-content> <!--JSP表示标签体内容为JSP-->  
  5. </tag>  
        这样即可在JSP页面中可以根据标签处理类doStartTag方法的返回值控制标签体内容是否执行。
 2)控制整个JSP页面是否执行

        同样地,doEndTag方法中可以通过不同的返回值类控制下面的JSP页面是否执行。返回Tag.EVAL_PAGE表示执行下面的JSP页面内容,返回Tag.SKIP_PAGE表示不执行。如下:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //控制JSP页面是否执行  
  2. public class TagDemo2 extends TagSupport {  
  3.   
  4.     @Override  
  5.     public int doEndTag() throws JspException {  
  6.           
  7. //      return Tag.SKIP_PAGE;//不执行JSP页面  
  8.         return Tag.EVAL_PAGE;//执行JSP页面  
  9.     }         
  10. }  
3)控制JSP页面内容重复执行

        控制页面内容重复执行的话Tag接口就无法满足了,需要实现它的子接口IterationTag接口,该接口中有个doAfterBody方法来决定是否重复执行标签体内容。如果该方法返回IterationTag.EVAL_BODY_AGAIN则继续执行,如果返回IterationTag.SKIP_BODY则结束重复并跳转到doEndTag()方法执行了。不过不用直接去实现IterationTag接口,TagSupport类也实现了该接口,所以只要让标签处理类继承TagSupport类即可。需要注意的是除了覆盖doAfterBody方法外,还得覆盖doStartTag方法并返回Tag.EVAL_BODY_INCLUDE。因为只有允许标签体执行才能重复执行。如下:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //控制页面内容重复执行  
  2. public class TagDemo3 extends TagSupport {  
  3.   
  4.     int i = 5;  
  5.     @Override  
  6.     public int doAfterBody() throws JspException {  
  7.           
  8.         i--;  
  9.         if(i >= 0)   
  10.             return IterationTag.EVAL_BODY_AGAIN;  
  11.         else  
  12.             return IterationTag.SKIP_BODY;  
  13.     }  
  14.   
  15.     @Override  
  16.     public int doStartTag() throws JspException {  
  17.           
  18.         return Tag.EVAL_BODY_INCLUDE;  
  19.     }  
  20. }  
4)修改JSP页面内容输出

        修改JSP页面内容输出的话IterationTag接口就无法满足了,需要实现它的子接口BodyTag接口,该接口增加了两个方法:doInitBody()和setBodyContent(BodyContent b)方法。如果doStartTag方法返回BodyTag.EVAL_BODY_BUFFERED,则BodyContent对象就会被JSP翻译过后的Servlet创建,即得到标签体对象。在doEndTag方法里对标签内容进行修改,可以通过this.getBodyContent().getString()拿到转成String的标签体内容,然后对该内容进行修改,再将结果result通过this.pageContext().getOut().write(result)进行输出,在doEndTag方法里返回Tag.EVAL_PAGE。然后JSP翻译过的servlet再把该BodyContent对象传递给setBodyContent方法完成修改。所以我们只需要覆盖doStartTag和doEndTag方法即可。该接口已经有个默认实现类BodyTagSupport,编写标签处理类直接继承这个类即可。如下:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //修改标签内容  
  2. public class TagDemo4 extends BodyTagSupport {  
  3.   
  4.     @Override  
  5.     public int doStartTag() throws JspException {  
  6.   
  7.         return BodyTag.EVAL_BODY_BUFFERED;  
  8.           
  9.     }  
  10.       
  11.     @Override  
  12.     public int doEndTag() throws JspException {  
  13.   
  14.         //拿到标签体  
  15.         String content = this.getBodyContent().getString();  
  16.         String result = content.toUpperCase();  
  17.           
  18.         try {  
  19.             this.pageContext.getOut().write(result);  
  20.         } catch (IOException e) {  
  21.             throw new RuntimeException(e);  
  22.         }  
  23.           
  24.         return Tag.EVAL_PAGE;  
  25.     }             
  26. }  

        注:以上扩展功能的知识点在JSP2.0后已经被淘汰掉了,会有一个新的简单标签(SimpleTag)接口可以更方便的实现。但是以上的知识点在Struts框架中还在使用。在学Struts框架的标签库会遇到。下面我们来看一看简单标签的相关内容。

4. 简单标签

        简单标签接口SimpleTag与上面提到的标签接口不同,SimpleTag标签提供了一个简单的doTag()方法代替了doStartTag和doEndTag方法。所有标签的逻辑、迭代、计算等等都在这个方法中运行。因此SimpleTag接口也可以替代BodyTag接口。该接口中有以下方法:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. void doTag()  
  2. JspTag getParent()  
  3. void setJspBody(JspFragment jspBody):把标签体通过该方法传递进来,我们可以在doTag方法中拿到jspBody对象即拿到了标签体,然后可以对标签体做想做的事。包括上面所有功能  
  4. void setJspContext(JspContext pc)  
  5. void setParent(JspTag parent)  

        JspContext是pageContext的父类,执行顺序:JSP引擎首先通过uri和viewIP标签名去找tld文件,在tld中通过viewIP找到ViewIPTag类,该类中,首先调用setJspContext方法把页面的pageContext传递进来,再调用setParent把父标签传递进来(没有则不传),然后再调用setJspBody方法,把代表标签体的jspFragment对象传递进去,至此完成了标签的初始化工作。然后开始执行标签,即调用doTag方法。下面我们使用简单标签扩展上面的功能。

 1)控制JSP页面某一部分内容是否执行      

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //控制标签体是否执行  
  2. public class SimpleTagDemo1 extends SimpleTagSupport {  
  3.   
  4.     //用简单标签使用这个方法完成所有业务逻辑  
  5.     @Override  
  6.     public void doTag() throws JspException, IOException {  
  7.           
  8.         //得到代表标签体的JspFragment  
  9.         JspFragment jf = this.getJspBody();  
  10.           
  11. //      PageContext pageContext = (PageContext)this.getJspContext();    //获得pageContext      
  12. //      jf.invoke(pageContext.getOut());//将输出流放到invoke方法中,写给浏览器  
  13.           
  14.         jf.invoke(null);//null默认写给浏览器。不调用该方法即不运行标签体  
  15.           
  16.     }         
  17. }<span style="font-family:Microsoft YaHei;">  
  18. </span>  
          在simple.tld文件中配置如下(与上面的基本一样的):

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2.   
  3. <taglib xmlns="http://java.sun.com/xml/ns/j2ee"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"  
  6.     version="2.0">  
  7.     <description>A tag library exercising SimpleTag handlers.</description>  
  8.     <tlib-version>1.0</tlib-version>  
  9.     <short-name>SimpleTagLibrary</short-name>  
  10.     <uri>/simpleitcast</uri>  
  11.       
  12.     <tag>  
  13.         <name>demo1</name>   
  14.         <tag-class>web.simpletag.SimpleTagDemo1</tag-class>  
  15.         <body-content>scriptless</body-content>  
  16.     </tag>  
  17. </taglib>  
 2)控制整个JSP页面是否执行
[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class SimpleTagDemo4 extends SimpleTagSupport {  
  2.   
  3.     @Override  
  4.     public void doTag() throws JspException, IOException {  
  5.   
  6.         throw new SkipPageException();//抛出个SkipPageException异常即不会执行下面的JSP页面,否则会执行  
  7.           
  8.     }         
  9. }  
        tld文件中的配置略,跟上面一样的……不再赘述。

3)控制JSP页面内容重复执行

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //控制标签体执行10次  
  2. public class SimpleTagDemo<span style="font-family:Microsoft YaHei;">3</span> extends SimpleTagSupport {  
  3.   
  4.     @Override  
  5.     public void doTag() throws JspException, IOException {  
  6.   
  7.         JspFragment jf = this.getJspBody();  
  8.           
  9.         for(int i = 0; i < 10; i++) {  
  10.             jf.invoke(null);  
  11.         }  
  12.           
  13.     }         
  14. }  

4)修改JSP页面内容输出

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //将标签体内容改成大写  
  2. public class SimpleTagDemo3 extends SimpleTagSupport {  
  3.   
  4.     @Override  
  5.     public void doTag() throws JspException, IOException {  
  6.           
  7.         JspFragment jf = this.getJspBody();  
  8.         StringWriter sw = new StringWriter();  
  9.         jf.invoke(sw);//不要invoke到浏览器,先invoke到自己的流里,然后修改修改再输出  
  10.           
  11.         String content = sw.getBuffer().toString();//获得标签体的String内容  
  12.         content = content.toUpperCase();  
  13.           
  14.         PageContext pageContext = (PageContext)this.getJspContext();  
  15.         pageContext.getOut().write(content);//再将流输出给浏览器  
  16.           
  17.     }  
  18. }  

5. 带属性的标签

        自定义标签可以定义一个或多个属性,这样在JSP页面中应用自定义标签时就可以设置这些属性的值,通过这些属性为标签处理器传递参数信息,从而提供标签的灵活性和复用性。想要让一个自定义标签具有属性,通常需要完成两个任务即可:

        1)在标签处理器中编写每个属性对应的setter方法

        2)在tld文件中描述标签的属性

        为自定义标签定义属性时,每个属性都必须按照javaBean的属性命名方式,在标签处理器中定义属性名对应的setter方法,用来接收JSP页面调用自定义标签时传递进来的属性值。例如属性url,在标签处理器类中就要定义相应的setUrl(String url)方法。在标签处理器中定义相应的set方法后,JSP引擎在解析执行开始标签前,也就是调用doStartTag方法前,会调用set属性方法,为标签设置属性。我们看下面的例子:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //通过属性控制标签体的执行次数  
  2. public class SimpleTagDemo5 extends SimpleTagSupport {  
  3.       
  4.     public int count; //<itcast:demo5 count="6"  
  5.   
  6.     public void setCount(int count) {//自动将属性传进来  
  7.         this.count = count;  
  8.     }  
  9.   
  10.     @Override  
  11.     public void doTag() throws JspException, IOException {  
  12.           
  13.         for(int i = 0; i < count; i++){  
  14.             this.getJspBody().invoke(null);  
  15.         }  
  16.     }     
  17. }  
         tld文件中配置如下:
[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <tag>  
  2.     <name>demo5</name>   
  3.     <tag-class>web.simpletag.SimpleTagDemo5</tag-class>  
  4.     <body-content>scriptless</body-content>         
  5.     <attribute>  
  6.         <name>count</name>  
  7.         <required>true</required>  
  8.         <rtexprvalue>true</rtexprvalue>  <!-- true的话jsp中该属性只可以为表达式,false只能为静态值 -->  
  9.         <type>java.lang.Integer</type>  <!-- 指明参数的类型 -->  
  10.     </attribute>  
  11. </tag>  
        在JSP页面中就可以使用标签
[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <itcast:demo5 count="4">  
  2.     xxxx  
  3. </itcast>  
        xxxx被输出4次

6. JSTL案例

        我们来用自定义JSTL标签开发一个防盗链的标签:如果客户端直接访问http://localhost:8080/example/test.jsp,会被阻止,先跳转到主页index.jsp,再访问1.jsp

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class RefererTag extends SimpleTagSupport {  
  2.       
  3.     private String site;  
  4.     private String page;  
  5.       
  6.     public void setSite(String site) {  
  7.         this.site = site;  
  8.     }  
  9.     public void setPage(String page) {  
  10.         this.page = page;  
  11.     }  
  12.       
  13.     @Override  
  14.     public void doTag() throws JspException, IOException {  
  15.   
  16.         //看来访者是从哪个页面来的  
  17.         PageContext pageContext = (PageContext)this.getJspContext();  
  18.         HttpServletRequest request = (HttpServletRequest)pageContext.getRequest();  
  19.                   
  20.         String referer = request.getHeader("referer");//得到是从哪个页面来的  
  21.           
  22.         //判断是否从自己的主页过来的  
  23.         if(referer == null || !referer.startsWith(site)) {  
  24.               
  25.             HttpServletResponse response = (HttpServletResponse)pageContext.getResponse();  
  26.             String webroot = request.getContextPath(); //example  
  27.             if(page.startsWith(webroot))  
  28.                 response.sendRedirect(page);  
  29.             else  
  30.                 response.sendRedirect(webroot + page);  
  31.               
  32.             //重定向后,控制保护的页面不要执行  
  33.             throw new SkipPageException();  
  34.         }  
  35.     }  
  36. }  
        看一下index.jsp页面:

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
  2. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
  3. <html>  
  4.   <head>  
  5.     <title>My JSP 'index.jsp' starting page</title>   
  6.   </head>    
  7.   <body>  
  8.     This is my JSP page. <br>  
  9.     <a href="${pageContext.request.contextPath }/test.jsp">内容</a> <!--掉转到1.jsp-->  
  10.   </body>  
  11. </html>  
       再看一下test.jsp:

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
  2. <%@ taglib uri="/simpleitcast" prefix="it"%>  
  3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
  4. <it:referer site="http://localhost:8080/" page="/index.jsp"/>  
  5. <html>  
  6.   <head>     
  7.     <title>防盗链</title>        
  8.   </head>    
  9.   <body>  
  10.     这是内容  
  11.   </body>  
  12. </html>  

7.  打包标签库

        既然我们可以自定义标签,那我们定义好的标签如何打包供其他工程使用呢?这在开发中是很重要的。我们按照下列步骤来打包自定义标签库:

        a. 新建一个普通java project,将原来开发标签库工程的src目录下的标签处理类全部拷贝过来;
        b. 在工程下新建一个lib目录,把jsp和servlet两个JAR包(jsp-api.jar和servlet-api.jar)拷贝进来(在tomcat目录\lib下);
        c. 选中这两个JAR包,右击->build path->Add to path,变成两个"奶瓶状"即可;
        d. 在工程下新建一个META-INF目录,将标签的配置文件(tld文件)考进来;
        e. 将整个工程导出:export->选择java->JAR File->next->右边的classpath和project不用打钩,然后选择导出目录即可导出。
        这样标签库的JAR包就打包好了。
        再新建一个web project,将刚刚打包好的JAR包拷贝到WEB-INF\lib下,这样在WEB-INF下新建一个JSP文件,在该文件里就可以通过taglib导入刚刚的JAR包了,然后使用自己开发的标签了。

8.  JSTL常用标签库

1)<c:out>

        <c:out>标签用于输出一段文本内容到pageContext对象当前保存的"out"对象中,即:将内容输出给浏览器。该标签有三个属性可选,value属性指定要输出的内容;escapeXml指定是否将<、>、&、`等特殊字符进行html编码转换后再进行输出,默认为true;default属性指定如果value属性的值为null时所输出的默认值。该标签主要用于escapeXml属性和default属性

2)<c:set>

        <c:set>标签用于把某一个对象存在指定的域范围内,或者设置web域中的java.util.Map类型的属性对象或javaBean类型的属性对象的属性。有如下属性:
        value:用于指定属性的值;
        scope:用于指定属性所在的web域;
        var:用于指定要设置的web域属性的名称;
        target:用于指定要设置属性的对象,这个对象必须是javaBean对象或者java.util.Map对象;
        property:用于指定当前为对象设置的属性名称。

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <!-- c:set标签 :向web域中存数据,向map或Bean中存数据-->  
  2. <c:set var="data" value="xxx" scope="page"/>  
  3. ${pageScope.data }  
  4.   
  5. <%   
  6.     Map map = new HashMap();  
  7.     request.setAttribute("map", map);  
  8. %>  
  9. <c:set property="data" value="yyy" target="${map }" />  
  10. ${map.data }  
  11.   
  12. <c:set property="name" value="eson_15" target="${person }"/>  
  13. ${person.name }  

3) <c:remove>

        <c:remove>标签用于删除各种web域中的属性:

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <c:remove var="varName" [scope="{page|request|session|application}"]/>  

4)<c:if>

        <c:if>标签可以判断是否执行标签体

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <c:if test="${user==null}" var="result" scope="page">  
  2.     xxx  
  3. </c:if>  
        如果test中的表达式为真则执行标签体,另外将test的值保存在page域中,保存参数为result,可以通过${result}获取保存的值

5)<c:choose>

        标签用于构造条件判断语句

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <c:choose>  
  2.     <c:when test="${count == 0}">  
  3.         对不起,没有符合您要求的记录  
  4.     </c:when>  
  5.     <c:otherwise>  
  6.         符合您要求的记录共有${count}条  
  7.     </c:otherwise>  
  8. </c:choose>  

6)<c:forEach>

        <c:forEach>标签用于对一个集合对象中的元素进行循环迭代操作,或者按指定的次数重复迭代执行标签体中的内容。它有如下属性:

        var属性:指定当前迭代到的元素保存到page域中的属性名称;
        items属性:将要迭代的集合对象;
        begin属性:如果指定items属性,就从集合中的第begin个元素开始迭代,begin的索引值从0开始编号;如果没有指定items属性,就从begin指定的值开始迭代,直到end值结束。
        step属性:指定迭代的步长

[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <!-- c:forEach标签 -->  
  2. <c:forEach var="num" begin="1" end="10" step="1">   
  3. ${num }  <!-- 输出1-10 -->  
  4. </c:forEach> <br>  
  5.   
  6. <%   
  7.     List list = Arrays.asList("1","2");  
  8.     request.setAttribute("list", list);  
  9. %>  
  10. <c:forEach var="index" begin="0" end="${fn.length(list) }">  
  11. ${list[index] }  
  12. </c:forEach>  
  13.   
  14. <c:forEach var="index" items="${list}">  
  15. ${index}  
  16. </c:forEach>  

7)<c:param>标签

        在JSP页面进行url的相关操作时,经常用在url地址后面附加一些参数。<c:param>标签可以嵌套在<c:import>、<c:url>或<c:redirect>标签内,为这些标签所使用的url地址附加参数。<c:param>标签在为一个url地址附加参数时,将自动对参数值进行url编码,例如,如果传递的参数为“中国”,则将其转换为"%d6%d0%b9%fa"后再附加到url地址后面,这也就是使用<c:param>标签的最大好处。如:<c:param name="name" value="value"/>
        <c:url>标签用于在JSP页面中构造一个url地址,其主要目的是实现url重写。url重写就是将会话标识号以参数形式附加在url地址后面(关于url重写,在总结session技术的时候有写到)。它有如下属性:
        value属性:指定要构造的url;
        var属性:指定将构造出的url结果保存到web域中的属性名称
        scope属性:指定将构造出的url结果保存到那个web域中
[html] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. <!-- c:url标签(重点) -->  
  2. <a href="<c:url value="/servlet/servletDemo1"/>">点点</a>  
  3.   
  4. <c:url value="/servlet/servletDemo2" var="servletdemo2"><!-- 如果没有var,则会把地址直接打给浏览器 -->  
  5.     <c:param name="name" value="中国"/> <!-- 中国两个字已经被url编码了 -->  
  6.     <c:param name="password" value="我是一个"></c:param>  
  7. </c:url>  
  8. <a href="${servletdemo2}">点点</a>  
        <c:redirect>标签用于实现请求重定向。
        url属性:指定要转发或重定向到的目标资源的url地址;

       context:当要使用相对路径重定向到同一个服务器下的其他web应用程序中的资源时,context属性指定其他web应用程序的名称。

       关于JSTL部分的内容暂时就总结到这吧,如有错误之处,欢迎留言指正~

       相关阅读:http://blog.csdn.net/column/details/servletandjsp.html

_____________________________________________________________________________________________________________________________________________________

-----乐于分享,共同进步!

-----更多文章请看:http://blog.csdn.net/eson_15


网友评论

登录后评论
0/500
评论
ghost丶桃子
+ 关注