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

1. 自定义标签简介

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

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

2. 一个简单实例

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

 
    [java] 
    view plain
    copy

     
    
     
   
public class ViewIPTag implements Tag {  
  
    private PageContext pageContext;      
    @Override  
    public int doStartTag() throws JspException {  
        HttpServletRequest request = (HttpServletRequest)pageContext.getRequest(); //获取request  
        JspWriter out = pageContext.getOut(); //获取out</span>  
          
        String ip = request.getRemoteAddr(); //通过request获取客户机的ip  
        try {  
            out.write(ip); //写到浏览器  
        } catch (IOException e) {  
            throw new RuntimeException(e);  
        }         
        return 0;  
    }     
    @Override  
    public int doEndTag() throws JspException {  
        return 0;  
    }  
    @Override  
    public Tag getParent() {  
        return null;  
    }  
    @Override  
    public void release() {  
    }  
    @Override  
    public void setPageContext(PageContext arg0) {        
        this.pageContext = arg0;  
    }  
    @Override  
    public void setParent(Tag arg0) {  
    }  
}  

写好了java类，我们来编写标签库描述符（tld）文件，在WEB-INF目录下新建一个tld文件，在tld文件中对标签处理器类进行描述：

 
    [html] 
    view plain
    copy

     
    
     
   
<?xml version="1.0" encoding="UTF-8" ?>  
  
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"  
    version="2.0">  
    <description>A tag library exercising SimpleTag handlers.</description>  
    <tlib-version>1.0</tlib-version>  
    <short-name>SimpleTagLibrary</short-name>  
    <uri>/test</uri>  <!--为该标签配一个uri-->  
      
    <tag>  
    <name>viewIP</name> <!-- 为标签处理器类配一个标签名 -->  
    <tag-class>web.tag.ViewIPTag</tag-class>  
    <body-content>empty</body-content>  
    </tag>  
      
</taglib>  

这样我们在JSP页面中就可以导入并使用自定义标签了：

 
    [html] 
    view plain
    copy

     
    
     
   
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
<%@ taglib uri="/test" prefix="test"%>  <!--uri与tld文件中配的uri相同-->  
  
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
<html>  
  <head>    
    <title>输出客户机的IP</title>  
  </head>  
    
  <body>  
    您的IP是：<test:viewIP/>  
      
    <!--该标签相当于执行下面脚本代码-->  
    <%   
        String ip = request.getRemoteAddr();  
        out.write(ip);  
    %>         
  </body>  
</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

//控制标签体是否执行  
public class TagDemo1 extends TagSupport {  
  
    @Override  
    public int doStartTag() throws JspException {  
              
//      return Tag.SKIP_BODY;//不执行标签体内容  
        return Tag.EVAL_BODY_INCLUDE; //执行标签体内容  
    }  
}

然后在文件中配置好：

 
    [html] 
    view plain
    copy

<tag>  
    <name>demo1</name>  
    <tag-class>web.tag.TagDemo1</tag-class>  
    <body-content>JSP</body-content> <!--JSP表示标签体内容为JSP-->  
</tag>

这样即可在JSP页面中可以根据标签处理类doStartTag方法的返回值控制标签体内容是否执行。
2） 控制整个JSP页面是否执行

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

 
    [java] 
    view plain
    copy

//控制JSP页面是否执行  
public class TagDemo2 extends TagSupport {  
  
    @Override  
    public int doEndTag() throws JspException {  
          
//      return Tag.SKIP_PAGE;//不执行JSP页面  
        return Tag.EVAL_PAGE;//执行JSP页面  
    }         
}

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

     
    
     
   
//控制页面内容重复执行  
public class TagDemo3 extends TagSupport {  
  
    int i = 5;  
    @Override  
    public int doAfterBody() throws JspException {  
          
        i--;  
        if(i >= 0)   
            return IterationTag.EVAL_BODY_AGAIN;  
        else  
            return IterationTag.SKIP_BODY;  
    }  
  
    @Override  
    public int doStartTag() throws JspException {  
          
        return Tag.EVAL_BODY_INCLUDE;  
    }  
}  

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

     
    
     
   
//修改标签内容  
public class TagDemo4 extends BodyTagSupport {  
  
    @Override  
    public int doStartTag() throws JspException {  
  
        return BodyTag.EVAL_BODY_BUFFERED;  
          
    }  
      
    @Override  
    public int doEndTag() throws JspException {  
  
        //拿到标签体  
        String content = this.getBodyContent().getString();  
        String result = content.toUpperCase();  
          
        try {  
            this.pageContext.getOut().write(result);  
        } catch (IOException e) {  
            throw new RuntimeException(e);  
        }  
          
        return Tag.EVAL_PAGE;  
    }             
}  

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

4. 简单标签

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

 
    [java] 
    view plain
    copy

void doTag()  
JspTag getParent()  
void setJspBody(JspFragment jspBody)：把标签体通过该方法传递进来，我们可以在doTag方法中拿到jspBody对象即拿到了标签体，然后可以对标签体做想做的事。包括上面所有功能  
void setJspContext(JspContext pc)  
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

     
    
     
   
//控制标签体是否执行  
public class SimpleTagDemo1 extends SimpleTagSupport {  
  
    //用简单标签使用这个方法完成所有业务逻辑  
    @Override  
    public void doTag() throws JspException, IOException {  
          
        //得到代表标签体的JspFragment  
        JspFragment jf = this.getJspBody();  
          
//      PageContext pageContext = (PageContext)this.getJspContext();    //获得pageContext      
//      jf.invoke(pageContext.getOut());//将输出流放到invoke方法中，写给浏览器  
          
        jf.invoke(null);//null默认写给浏览器。不调用该方法即不运行标签体  
          
    }         
}<span style="font-family:Microsoft YaHei;">  
</span>  

在simple.tld文件中配置如下（与上面的基本一样的）：

 
    [html] 
    view plain
    copy

     
    
     
   
<?xml version="1.0" encoding="UTF-8" ?>  
  
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"  
    version="2.0">  
    <description>A tag library exercising SimpleTag handlers.</description>  
    <tlib-version>1.0</tlib-version>  
    <short-name>SimpleTagLibrary</short-name>  
    <uri>/simpleitcast</uri>  
      
    <tag>  
        <name>demo1</name>   
        <tag-class>web.simpletag.SimpleTagDemo1</tag-class>  
        <body-content>scriptless</body-content>  
    </tag>  
</taglib>  

2） 控制整个JSP页面是否执行

 
    [java] 
    view plain
    copy

public class SimpleTagDemo4 extends SimpleTagSupport {  
  
    @Override  
    public void doTag() throws JspException, IOException {  
  
        throw new SkipPageException();//抛出个SkipPageException异常即不会执行下面的JSP页面，否则会执行  
          
    }         
}

tld文件中的配置略，跟上面一样的……不再赘述。

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

 
    [java] 
    view plain
    copy

//控制标签体执行10次  
public class SimpleTagDemo<span style="font-family:Microsoft YaHei;">3</span> extends SimpleTagSupport {  
  
    @Override  
    public void doTag() throws JspException, IOException {  
  
        JspFragment jf = this.getJspBody();  
          
        for(int i = 0; i < 10; i++) {  
            jf.invoke(null);  
        }  
          
    }         
}

4）修改JSP页面内容输出

 
    [java] 
    view plain
    copy

     
    
     
   
//将标签体内容改成大写  
public class SimpleTagDemo3 extends SimpleTagSupport {  
  
    @Override  
    public void doTag() throws JspException, IOException {  
          
        JspFragment jf = this.getJspBody();  
        StringWriter sw = new StringWriter();  
        jf.invoke(sw);//不要invoke到浏览器，先invoke到自己的流里，然后修改修改再输出  
          
        String content = sw.getBuffer().toString();//获得标签体的String内容  
        content = content.toUpperCase();  
          
        PageContext pageContext = (PageContext)this.getJspContext();  
        pageContext.getOut().write(content);//再将流输出给浏览器  
          
    }  
}  

5. 带属性的标签

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

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

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

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

 
    [java] 
    view plain
    copy

     
    
     
   
//通过属性控制标签体的执行次数  
public class SimpleTagDemo5 extends SimpleTagSupport {  
      
    public int count; //<itcast:demo5 count="6"  
  
    public void setCount(int count) {//自动将属性传进来  
        this.count = count;  
    }  
  
    @Override  
    public void doTag() throws JspException, IOException {  
          
        for(int i = 0; i < count; i++){  
            this.getJspBody().invoke(null);  
        }  
    }     
}  

tld文件中配置如下：

 
    [html] 
    view plain
    copy

     
    
     
   
<tag>  
    <name>demo5</name>   
    <tag-class>web.simpletag.SimpleTagDemo5</tag-class>  
    <body-content>scriptless</body-content>         
    <attribute>  
        <name>count</name>  
        <required>true</required>  
        <rtexprvalue>true</rtexprvalue>  <!-- true的话jsp中该属性只可以为表达式，false只能为静态值 -->  
        <type>java.lang.Integer</type>  <!-- 指明参数的类型 -->  
    </attribute>  
</tag>  

在JSP页面中就可以使用标签

 
    [html] 
    view plain
    copy

<itcast:demo5 count="4">  
    xxxx  
</itcast>

xxxx被输出4次

6. JSTL案例

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

 
    [java] 
    view plain
    copy

     
    
     
   
public class RefererTag extends SimpleTagSupport {  
      
    private String site;  
    private String page;  
      
    public void setSite(String site) {  
        this.site = site;  
    }  
    public void setPage(String page) {  
        this.page = page;  
    }  
      
    @Override  
    public void doTag() throws JspException, IOException {  
  
        //看来访者是从哪个页面来的  
        PageContext pageContext = (PageContext)this.getJspContext();  
        HttpServletRequest request = (HttpServletRequest)pageContext.getRequest();  
                  
        String referer = request.getHeader("referer");//得到是从哪个页面来的  
          
        //判断是否从自己的主页过来的  
        if(referer == null || !referer.startsWith(site)) {  
              
            HttpServletResponse response = (HttpServletResponse)pageContext.getResponse();  
            String webroot = request.getContextPath(); //example  
            if(page.startsWith(webroot))  
                response.sendRedirect(page);  
            else  
                response.sendRedirect(webroot + page);  
              
            //重定向后，控制保护的页面不要执行  
            throw new SkipPageException();  
        }  
    }  
}  

看一下index.jsp页面：

 
    [html] 
    view plain
    copy

     
    
     
   
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
<html>  
  <head>  
    <title>My JSP 'index.jsp' starting page</title>   
  </head>    
  <body>  
    This is my JSP page. <br>  
    <a href="${pageContext.request.contextPath }/test.jsp">内容</a> <!--掉转到1.jsp-->  
  </body>  
</html>  

再看一下test.jsp：

 
    [html] 
    view plain
    copy

     
    
     
   
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
<%@ taglib uri="/simpleitcast" prefix="it"%>  
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
<it:referer site="http://localhost:8080/" page="/index.jsp"/>  
<html>  
  <head>     
    <title>防盗链</title>        
  </head>    
  <body>  
    这是内容  
  </body>  
</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

     
    
     
   
<!-- c:set标签 ：向web域中存数据，向map或Bean中存数据-->  
<c:set var="data" value="xxx" scope="page"/>  
${pageScope.data }  
  
<%   
    Map map = new HashMap();  
    request.setAttribute("map", map);  
%>  
<c:set property="data" value="yyy" target="${map }" />  
${map.data }  
  
<c:set property="name" value="eson_15" target="${person }"/>  
${person.name }  

3） <c:remove>

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

 
    [html] 
    view plain
    copy

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

4）<c:if>

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

 
    [html] 
    view plain
    copy

<c:if test="${user==null}" var="result" scope="page">  
    xxx  
</c:if>

如果test中的表达式为真则执行标签体，另外将test的值保存在page域中，保存参数为result，可以通过${result}获取保存的值。

5）<c:choose>

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

 
    [html] 
    view plain
    copy

     
    
     
   
<c:choose>  
    <c:when test="${count == 0}">  
        对不起，没有符合您要求的记录  
    </c:when>  
    <c:otherwise>  
        符合您要求的记录共有${count}条  
    </c:otherwise>  
</c:choose>  

6）<c:forEach>

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

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

 
    [html] 
    view plain
    copy

     
    
     
   
<!-- c:forEach标签 -->  
<c:forEach var="num" begin="1" end="10" step="1">   
${num }  <!-- 输出1-10 -->  
</c:forEach> <br>  
  
<%   
    List list = Arrays.asList("1","2");  
    request.setAttribute("list", list);  
%>  
<c:forEach var="index" begin="0" end="${fn.length(list) }">  
${list[index] }  
</c:forEach>  
  
<c:forEach var="index" items="${list}">  
${index}  
</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

<!-- c:url标签(重点) -->  
<a href="<c:url value="/servlet/servletDemo1"/>">点点</a>  
  
<c:url value="/servlet/servletDemo2" var="servletdemo2"><!-- 如果没有var，则会把地址直接打给浏览器 -->  
    <c:param name="name" value="中国"/> <!-- 中国两个字已经被url编码了 -->  
    <c:param name="password" value="我是一个"></c:param>  
</c:url>  
<a href="${servletdemo2}">点点</a>

<c:redirect>标签用于实现请求重定向。
url属性：指定要转发或重定向到的目标资源的url地址；

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

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

_____________________________________________________________________________________________________________________________________________________

-----乐于分享，共同进步！

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

JSTL自定义标签

1. 自定义标签简介

2. 一个简单实例

4. 简单标签

5. 带属性的标签

6. JSTL案例

7. 打包标签库

8. JSTL常用标签库

1）<c:out>

2）<c:set>

3） <c:remove>

4）<c:if>

5）<c:choose>

6）<c:forEach>

7）<c:param>标签

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

JSTL自定义标签

1. 自定义标签简介

2. 一个简单实例

4. 简单标签

5. 带属性的标签

6. JSTL案例

7. 打包标签库

8. JSTL常用标签库

1）<c:out>

2）<c:set>

3） <c:remove>

4）<c:if>

5）<c:choose>

6）<c:forEach>

7）<c:param>标签

热门文章

最新文章

相关电子书