【轉】Jsp自定義標簽詳解

本文轉載自查看原文 2017-12-01 10:23 1891 java

一、前言

　　原本是打算研究EXtremeComponents這個jsp標簽插件，因為這個是自定義的標簽，且自身對jsp的自定義標簽並不是非常熟悉，所以就打算繼續進行掃盲，開始學習並且整理Jsp自定義標簽的內容~我發現自己的學習之路有點兒像一則寓言：一個人本來准備做個桌子（具體是不是忘了，反正意思差不多），然后發現沒有鋸子，於是開始做鋸子，做鋸子的時候發現自己沒有鐵，於是開始鑄鐵，鑄鐵的時候，發現沒有柴火，然后就去砍柴，終於把柴砍好了，最后卻忘了最初要做啥了~當然，幸好我還記得我原本還需要做啥，這篇博文結束之后就正式開始學習EXtremeComponents架構設計~

　　本篇博文（我博文前言很少分段的，嗯，看來我廢話越來越多了，哈哈哈），是筆者搜羅網上幾篇比較好的博文整理而成，主要目的是對jsp自定義標簽有個比較全面的覆蓋，方便讀者對於自定義標簽能有一個一站式解決的方式，也方便自己以后復習的時候不用再次到網絡上搜來搜去~

　　博文有點兒長，筆者不喜歡將一次性寫完的內容分好幾篇博文，如果讀者覺得有用，請耐心讀下去，我盡量排版清楚，請根據需要自行選擇內容進行研讀~

　　說下本文的包含的內容吧：

　　1.筆者自己的小Demo

　　2.三種自定義jsp標簽的方式（轉）

　　3.JSP自定義標簽開發入門（轉）

　　4.自定義標簽運行原理（轉）

二、正文

1. 筆者自己的小Demo

　　要自定義Jsp的標簽，需要有以下幾個步驟：

1）引入需要的jar:jsp-api.jar
2）編寫自定義的標簽處理類
3）注冊自實現的標簽處理類
4）在jsp頁面引入標簽，並且使用標簽

　　筆者先拋磚再引玉，先上一下本機測試驗證的環境和代碼。筆者開發環境：

1）apache-maven-3.2.1
2）Jdk 1.6
3）eclipse Version: Mars.2 Release (4.5.2)
4）servlet-api-3.0-alpha-1.jar
5）jsp-api-2.2.jar

　　pom.xml文件依賴部分的配置如下：

................................................
<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>3.0-alpha-1</version>
        <scope>provided</scope>
    </dependency>
    
    <dependency>  
        <groupId>javax.servlet.jsp</groupId>  
        <artifactId>jsp-api</artifactId>  
        <version>2.2</version>  
        <scope>provided</scope>  
    </dependency>  
    <dependency>
        <groupId>opensymphony</groupId>
        <artifactId>sitemesh</artifactId>
        <version>2.4.2</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>Sitemesh</finalName>
    <plugins>
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.2</version>
            <configuration>
              <port>8080</port>
              <path>/</path>
              <uriEncoding>UTF-8</uriEncoding>
            </configuration>
          </plugin>
    </plugins>
  </build>
................................................

　　MyTag.java

package com.tab.cn;

import java.io.IOException;

import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;

public class MyTag extends TagSupport  {
    private static final long serialVersionUID = 1L;

    @Override
    public int doStartTag(){
        try {
            this.pageContext.getOut().write("Hello,this is MyTag");
        } catch (IOException e) {
            e.printStackTrace();
            return Tag.SKIP_BODY;
        }
        return Tag.EVAL_BODY_INCLUDE;
    }
    
    @Override
    public int doEndTag(){
        return Tag.EVAL_PAGE;
    }
}

　　編寫完標簽處理類，就需要注冊一下這個類，才能在jsp頁面進行引用。web應用目錄下，找到WEB-INF文件夾，在里面新建一個tld類型的文件，然后在里面注冊你的標簽，文件名隨意，筆者這邊不對tld文件配置進行講解，有需要的童鞋找度娘：

　　MyTag.xml

<?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">
      <tlib-version>1.0</tlib-version>
    <jsp-version>2.0</jsp-version>
    <short-name>Example TLD</short-name>
    <uri>http://localhost/mytag</uri>
    <tag>
        <name>myTag</name><!-- 標簽名字，頁面引用之用 -->
        <tag-class>com.tab.cn.MyTag</tag-class><!-- 指定標簽處理的實現類 -->
        <body-content>empty</body-content><!-- 標簽內容為空 -->
    </tag>
    
</taglib>

　　頁面進行標簽引用：

　　index.jsp

<%@page contentType="text/html;charset=utf-8" %>
<%@ taglib prefix="mt" uri="http://localhost/mytag" %>
<html>
    <head>
        <meta name="decorator" value="default">
        <title>Sitemesh測試</title>
    </head>
    <body>
        <mt:myTag />
    </body>
</html>

　　頁面輸出：

　　Ok，到目前為止一個簡單的標簽處理已經完成，下面我就要來整理下網絡上各路大神寫的博文了~（筆者這個小Demo其實是自定義標簽中的一種，詳情見下文）

2. 三種自定義jsp標簽的方式（轉）

　　1.1 通過tld文件，自定義方法標簽

　　tld的這種用法，讓我們可以在jsp里直接使用類中定義的方法（特別注意：這個方法必須是靜態的）。引入方式示例，直接在jsp上引入tld標簽文件：

  <%@ taglib prefix="fns" uri="/WEB-INF/tlds/fns.tld" %>

　　寫法示例（文件名fns.tld，存放位置在上面的uri中有定義）：

<?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>JSTL 1.1 functions library</description>
  <display-name>JSTL functions sys</display-name>
  <tlib-version>1.1</tlib-version>
  <short-name>fns</short-name>
  <uri>http://java.sun.com/jsp/jstl/functionss</uri>

  <!-- DictUtils -->
  
  <function>
    <description>獲取字典對象列表</description>
    <name>getDictList</name>
    <function-class>com.sdyy.base.sys.utils.DictUtils</function-class>
    <function-signature>java.util.List getDictList(java.lang.String)</function-signature>
    <example>${fns:getDictList(typeCode)}</example>  
  </function>
  
  <function>
    <description>獲取字典對象列表</description>
    <name>getDictListJson</name>
    <function-class>com.sdyy.base.sys.utils.DictUtils</function-class>
    <function-signature>java.lang.String getDictListJson(java.lang.String)</function-signature>
    <example>${fns:getDictListJson(typeCode)}</example>  
  </function>
  
  
  <function>
    <description>對象變json</description>
    <name>toJSONString</name>
    <function-class>com.alibaba.fastjson.JSON</function-class>
    <function-signature>java.lang.String toJSONString(java.lang.Object)</function-signature>
  </function>
</taglib>

　　function-class就是該方法的實體所在類路徑，

　function-signature就是該方法的方法名，值得一提的是，這個方法必須是個static方法。

　 example就是使用方式寫法示例

　 1.2 通過tag文件自定義控件標簽(感謝評論區一樓指正）

　此類標簽，讓我們可以在jsp里，通過傳入一些參數，動態的生成jsp代碼

　引入方式示例：

<%@ taglib prefix="sys" tagdir="/WEB-INF/tags/sys" %>

　注意，這里引入的是一個路徑

　如此 tags目錄下的sys目錄下的所有tag(感謝評論區一樓指正）都會自動被加載，標簽tag寫法示例（寫法其實類似jsp）：

<%@ tag language="java" pageEncoding="UTF-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@ taglib prefix="fns" uri="/WEB-INF/tlds/fns.tld" %>
<%@ attribute name="typeCode" type="java.lang.String" required="true" description="字典code"%>
<%@ attribute name="defaultValue" type="java.lang.String" description="默認選中"%>
<%@ attribute name="style" type="java.lang.String" description="默認選中"%>
<%@ attribute name="cls" type="java.lang.String" description="默認選中"%>
<%@ attribute name="name" type="java.lang.String" description="默認選中"%>
<select style="${style}" class="${cls}" name="${name}" id="${name}" >
    <option value="" >請選擇...      </option>
    <c:if test="${not empty typeCode}">
        <c:forEach items="${fns:getDictList(typeCode)}" var='dict'>
            <option value='${dict.VALUE}' ${defaultValue==dict.VALUE?'selected':''}>${dict.TEXT}</option>
        </c:forEach>
    </c:if>
</select>

　　這里我引入了兩個taglib，是為了在該文件中使用它們，attribute則相當於參數，定義這些參數才能在使用的時候動態傳入，注意還有一些關鍵字，比如這里的“cls”，就是因為“class”是關鍵字
　　如此，tag名就是標簽名，例如這個tag叫 select.tag，那么它的用法就是：

 <sys:select cls="formselect" name="MODULE_TYPE" typeCode="HOME_MODULE_TYPE" defaultValue="${record.MODULE_TYPE }" />

　　其中 “sys:select” 中【sys】是我們在上面【引入方式示例】中定義的prefix，select和【select.tag】的紅字部分是對應的

　　1.3 通過 tld文件自定義判斷標簽、控件標簽（偷個懶，寫一塊了）

　　引入方式和1相同，寫法示例如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"   
    "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
    <tlib-version>1.0</tlib-version>
    <jsp-version>2.0</jsp-version>
    <short-name>bgt</short-name>
    <!-- backGroundTag -->
    <uri>http://www.sdyy.tag</uri>
    <tag>
        <name>hasUrlPerm</name>
        <tag-class>com.sdyy.common.tags.HasUrlPermissionTag</tag-class>
        <attribute>
            <name>link</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue><!-- 是否支持惡劣表達式 -->
            <type>java.lang.String</type>
            <description>示例：acApplication/forMain.do</description>
        </attribute>
        
    </tag>
</taglib>

　　A、【判斷標簽】HasUrlPermissionTag標簽是一個判斷標簽，通過該標簽來決定標簽包裹的內容是否顯示，寫法如下：

package com.sdyy.common.tags;



import javax.servlet.http.HttpServletRequest;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.BodyTagSupport;

import com.sdyy.common.spring.interceptor.PermissionInterceptor;
/**
 * 
 * @ClassName: HasUrlPermissionTag
 * @Description: 根據url判斷權限標簽
 * @author: liuyx
 * @date: 2015年12月21日上午11:15:32
 */
public class HasUrlPermissionTag extends BodyTagSupport {

    private String link;//  acApplication/forMain.do

    @Override
    public int doStartTag() throws JspException { // 在標簽開始處出發該方法
        
        HttpServletRequest request=(HttpServletRequest) pageContext.getRequest();
        //獲取session中存放的權限
        
        //判斷是否有權限訪問
        if (PermissionInterceptor.isOperCanAccess(request, link)) {
            //允許訪問標簽body
            return BodyTagSupport.EVAL_BODY_INCLUDE;// 返回此則執行標簽body中內容，SKIP_BODY則不執行
        } else {
            return BodyTagSupport.SKIP_BODY;
        }

    }

    @Override
    public int doEndTag() throws JspException {
        return BodyTagSupport.EVAL_BODY_INCLUDE;
    }

    public String getLink() {
        return link;
    }

    public void setLink(String link) {
        this.link = link;
    }

}

　　在JSP中的使用方式：

<bgt:hasUrlPerm link="abc.do">
    <div>tttttttttttttttttest</div>
</bgt:hasUrlPerm>

　　B、【控件標簽】，這種標簽直接返回一個控件，不過是通過java代碼生成的控件內容，寫法示例：

package com.sdyy.common.tags;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.BodyTagSupport;

/*import com.sdyy.base.ac.ac_permission.model.AcPermission;*/

public class ButtonUrlTag extends BodyTagSupport {
    private static final long serialVersionUID = -7811902545513255473L; 


    //標簽屬性用戶名
    private String user = null;
    //標簽屬性操作url
    private String url = null;
    //標簽屬性 js方法
    private String jsmethod = null;
    //標簽屬性image 按鈕圖片
    private String image = null;
    //標簽屬性 alt 提示
    private String alt = null;
    //標簽屬性操作value 按鈕文本
    private String value  = null;




    /* 標簽初始方法 */
    public int doStartTag() throws JspTagException{
        return super.EVAL_BODY_INCLUDE;
    }


    /* 標簽結束方法 */
    public int doEndTag() throws JspTagException{
        
        Boolean b = false;
        List list = new ArrayList();
        /*AcPermission p = new AcPermission();*/
        /*JDBCHibernate jdbca = new JDBCHibernate();*/
        try {
            /*list = jdbca.getHaveURLByUsernameList(user);*/
        } catch (Exception e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        for(int i = 0;i < list.size(); i++){
            /*p = (AcPermission) list.get(i);*/
            if(1==1) {//p.getUrl().trim().equals(url.trim())){
                b = true;
                //如果jsmethod屬性不為null 則把超鏈接href改為調用js
                if(jsmethod!=null){
                    url = jsmethod;
                }
            }
        }
        JspWriter out = pageContext.getOut();
        if(b){
            try {
                //有權限 顯示操作按鈕
                out.println("<a href='" +url+ "' class='regular'><img src='" + image + "' alt='" + alt +"' />" + value + "</a>");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return super.SKIP_BODY;
    }

    /* 釋放資源 */
    public void release(){
        super.release();
    }


    public String getUser() {
        return user;
    }


    public void setUser(String user) {
        this.user = user;
    }


    public String getUrl() {
        return url;
    }


    public void setUrl(String url) {
        this.url = url;
    }


    public String getImage() {
        return image;
    }


    public void setImage(String image) {
        this.image = image;
    }


    public String getAlt() {
        return alt;
    }


    public void setAlt(String alt) {
        this.alt = alt;
    }


    public String getValue() {
        return value;
    }


    public void setValue(String value) {
        this.value = value;
    }

    public String getJsmethod() {
        return jsmethod;
    }


    public void setJsmethod(String jsmethod) {
        this.jsmethod = jsmethod;
    }
}

　　綜上標簽一般都是通過tld和tag定義的，本文只是對其中幾種基礎用法羅列，希望對大家有所幫助。

3. JSP自定義標簽開發入門（轉）

　　一般情況下開發jsp自定義標簽需要引用以下兩個包

import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;

　　首先我們需要大致了解開發自定義標簽所涉及到的接口與類的層次結構(其中SimpleTag接口與SimpleTagSupport類是JSP2.0中新引入的)

　　目標1:自定義一個用表格顯示用戶信息的簡單標簽

　　效果圖：

　　在jsp頁面使用此自定義標簽：

　　假設我們有一個UserInfo的javabean，那么在JSP頁面使用此標簽只需調用此標簽即可

<!-- 創建需要展現UserInfo的實例（用於測試數據） -->
    <%
    UserInfo user = new UserInfo();
    user.setUserName("Xuwei");
    user.setAge(33);
    user.setEmail("test@test.test");
    pageContext.setAttribute("userinfo", user);  
%>
<!-- 給標簽設置user屬性綁定要展現的UserInfo對象  -->
<cc:showUserInfo user="${pageScope.userinfo }" />

　　開發步驟：

　　簡單標簽的開發我們只要實現Tag接口即可，為了簡單起見可以直接繼承實現了此接口的TagSupport類

　　1）創建自定義標簽類

public class UserInfoTag extends TagSupport {
    private UserInfo user;
    @Override
    public int doStartTag() throws JspException {
        try {
            JspWriter out = this.pageContext.getOut();
            if(user == null) {
                out.println("No UserInfo Found...");
                return SKIP_BODY;
            }
            out.println("<table width='500px' border='1' align='center'>");
            out.println("<tr>");
            out.println("<td width='20%'>Username:</td>");
            out.println("<td>" + user.getUserName() + "</td>");
            out.println("</tr>");
            out.println("<tr>");
            out.println("<td>Age:</td>");
            out.println("<td>" + user.getAge() + "</td>");
            out.println("</tr>");
            out.println("<tr>");
            out.println("<td>Email:</td>");
            out.println("<td>" + user.getEmail() + "</td>");
            out.println("</tr>");
            out.println("</table>");
        } catch(Exception e) {
            throw new JspException(e.getMessage());
        }
        return SKIP_BODY;
    }

    @Override
    public int doEndTag() throws JspException {
        return EVAL_PAGE;
    }

    @Override
    public void release() {
        super.release();
        this.user = null;
    }

    //getter and setters
    public UserInfo getUser() {
        return user;
    }

    public void setUser(UserInfo user) {
        this.user = user;
    }
}

　　2）在Web-Inf創建標簽庫描述文件.tdl(Tag Library Description)

<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.0" 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 web-jsptaglibrary_2_0.xsd">
　　<tlib-version>1.0</tlib-version>
　　<jsp-version>2.0</jsp-version>
　　<short-name>cc</short-name>
　　<uri>/mytaglib</uri>
　　<tag>
    　　<name>showUserInfo</name>
    　　<tag-class>com.mytags.UserInfoTag</tag-class>
    　　<body-content>empty</body-content>
    　　<attribute>
        　　<name>user</name>
         　 <required>false</required>
         　　<rtexprvalue>true</rtexprvalue>
    　　</attribute>
 　　</tag>
</taglib>

　　3）配置web.xml（筆者補充：其實這步也可不必，直接在jsp頁面中引入）

<jsp-config>
    <taglib>
        <taglib-uri>/mytaglib</taglib-uri>
        <taglib-location>/WEB-INF/mytaglib.tld</taglib-location>
    </taglib>
</jsp-config>

　　4）在需要使用此標簽的jsp頁面頭部引入

 <%@ taglib uri="/mytaglib" prefix="cc"%>

　　5）使用（參照上面的使用步驟）

　　此致，一個簡單的JSP標簽開發完成

　　標簽類說明：

我們創建的UserInfoTag類繼承了TagSupport類，而它又實現了Tag接口，Tag接口的生命周期由其所在的容器控制，如下：

setPageContext() 將所在jsp頁面的pageContext注入進來，目的是為了在后面的方法中可以訪問到jsp頁面對象的pageContext屬性

setParent() 設置此標簽的父標簽

setAttribute() 將標簽中的屬性注入到此class的屬性，不需要自己實現但要提供屬性的get與set方法

doStartTag() 在開始標簽屬性設置后調用，如果返回SKIP_BODY則忽略標簽之中的內容，如果返回EVAL_BODY_INCLUDE則將標簽體的內容進行輸出

doEndTag() 在結束標簽之前調用，返回SKIP_PAGE跳過整個jsp頁面后面的輸出，返回EVAL_PAGE執行頁面余下部分

release() 生命周期結束時調用

　　特別說明：在tomcat4.1之后的版本中默認開啟了標簽緩沖池(websphere和weblogic並不會這么做)，所以執行完標簽后並不會執行release()方法（_jspDestroy()時才釋放），也就是說同一個jsp頁面自定義標簽不管使用多少次只會存在一個實例，但也並不是每一個標簽都會為其創建一個緩沖池，要根據參數來判斷，例如：

<cc:UserInfoTag user=”…” />
<cc:UserInfoTag />

　　上面例子中由於參數不同就會創建兩個標簽緩沖池。

　　這個問題可以通過設定tomcat的配置文件加以解決：
　　在%tomcat%\conf\web.xml加入enablePooling參數，並設置為false（不緩存自定義標簽）

<init-param>
  <param-name>enablePooling</param-name>
  <param-value>false</param-value>
</init-param>

　　清空%tomcat%\conf\目錄

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

TagSupport類已經為我們實現並擴展了一些方法(比如在上述方法中我們可以直接使用pageContext對象，調用父標簽getParent()等)，所以一般情況下我們只需重寫doStartTag()，doEndTag() 即可

TLD文件說明：

<!--版本號-->
<tlib-version>1.0</tlib-version>
<jsp-version>2.0</jsp-version>
<short-name>cc</short-name>
<tag>
<!—指定標簽名 -->
    <name>showUserInfo</name>
    <!—指定標簽類文件的全路徑 -->
    <tag-class>com.mytags.UserInfoTag</tag-class>
    <!--如果不需要標簽體則設置empty，反之設定jsp -->
    <body-content>empty</body-content>
   <!—設定屬性(如果有的話) -->
    <attribute>
        <!—指定標簽名 -->
       <name>user</name>
        <!—是否是必須，如果非必須沒設置則為空 -->
        <required>false</required>
         <rtexprvalue>true</rtexprvalue><!—是否可在屬性中使用表達式 -->
    </attribute>
</tag>

Web.xml文件說明：

<jsp-config>
    <taglib>
<!--
標簽庫的uri路徑
即jsp頭文件中聲明<%@ taglib uri="/mytaglib" prefix="cc"%>
的uri
 -->
        <taglib-uri>/mytaglib</taglib-uri>
        <!—tld文件所在的位置-->
        <taglib-location>/WEB-INF/mytaglib.tld</taglib-location>
    </taglib>
</jsp-config>

　　目標2:自定義一個類似於Asp.Net中的Reapter控件的標簽

　　效果圖：

　　在jsp頁面使用此自定義標簽：

<!-- 創建需要展現javabean（UserInfo）集合的實例（用於測試數據） -->

<%
    List<UserInfo> users = new ArrayList<UserInfo>();   
    users.add(new UserInfo("Zhangsan", 12, "Zhangsan@163.com"));
    users.add(new UserInfo("Lisi", 22, "Lisi@sina.com"));
    users.add(new UserInfo("Wangwu", 33, "Wangwu@qq.com"));
    pageContext.setAttribute("users", users);
%>

<!-- 給標簽綁定數據源  -->
<table width='500px' border='1' align='center'>
    <tr>
        <td width='20%'>UserName</td>
        <td width='20%'>Age</td>
        <td>Email</td>
    </tr>
    <cc:repeater var="item" items="${pageScope.users }">
        <tr>
            <td>${item.userName }</td>
            <td>${item.age }</td>
            <td>${item.email }</td>
        </tr>
    </cc:repeater>
</table>

　　開發步驟：

　　要完成此控件我們需要實現一個迭代接口，即IterationTag，由於TagSupport同樣實現了此接口，所以我們繼承此類

　　1）創建自定義標簽類

public class Repeater extends TagSupport {
    private Collection items;
    private Iterator it;
    private String var;

    @Override
    public int doStartTag() throws JspException {
        if(items == null || items.size() == 0) return SKIP_BODY;
        it = items.iterator();  
        if(it.hasNext()) {
            pageContext.setAttribute(var, it.next());
        }
        return EVAL_BODY_INCLUDE;
    }

 
    @Override
    public int doAfterBody() throws JspException {
        if(it.hasNext()) {
            pageContext.setAttribute(var, it.next());
            return EVAL_BODY_AGAIN;
        }
        return SKIP_BODY;
    }

    @Override
    public int doEndTag() throws JspException {
        return EVAL_PAGE;
    }

    public void setItems(Collection items) {
        this.items = items;
    }

    public void setVar(String var) {
        this.var = var;
    }
}

　　2）在Web-Inf創建標簽庫描述文件.tdl(Tag Library Description)

　　由於目標1種已經創建了此文件，我們只需增加此標簽的配置即可

<tag>
    <name>repeater</name>
    <tag-class>com.mytags.Repeater</tag-class>
    <body-content>jsp</body-content>
    <attribute>
        <name>items</name>
        <required>false</required>
        <rtexprvalue>true</rtexprvalue>
    </attribute>
    <attribute>
        <name>var</name>
        <required>true</required>
        <rtexprvalue>true</rtexprvalue>
    </attribute>
 </tag>

　　3）配置web.xml （目標1中已完成，無需修改）

　　4）在需要使用此標簽的jsp頁面頭部引入

 <%@ taglib uri="/mytaglib" prefix="cc"%>

　　5）使用（參照上面的使用步驟）

　　標簽類說明：

　我們用到了迭代接口，以下是容器處理此接口的流程

　　作為目標1中的補充：在doAfterBody()如果返回值是EVAL_BODY_AGAIN那么將重新執行此方法

　　目標3:使用BodyTagSupport

　　此目標並不會使用實際例子進行顯示，主要是說明為什么，什么情況下需要使用到BodyTag接口或者BodyTagSupport類？

　　如果我們需要在<test> …. </test>之間的標簽體的頭部和尾部加上一些標記或者是其他處理，一般的處理方法是在doStartTag和doEndTag方法中進行，但是如果是個迭代標簽，標簽體的每段內容在循環輸出時每次都需要在頭部和尾部加上一些標記，我們使用BodyTagSupport就很方便了，

　　此接口在doStartTag()方法返回值多了一個EVAL_BODY_BUFFERED,它將對主體進行計算，並輸出到緩沖區(注：此處是緩沖區並非直接輸出到客戶端，需要我們手動（this.bodyContent.getEnclosingWriter().write(this.bodyContent.getString());）進行輸出客戶端的調用，否則主體內容不會進行顯示)

　　標簽類說明：

　　關於BodyTagSupport接口的說明：

　　目標4:自定義的函數庫

　　1）創建函數庫類

public class MyFunctions {
    public static String formatMyName(String name) {
       return "your name is " + name;
    }
    public static int add(int a, int b) {
       return a+b;
    }
}

　　2）在TLD文件中配置 (引用於目標1中的tld文件)

<function>
    <name>formatMyName</name>
    <function-class>com.taglib.MyFunctions</function-class>
    <function-signature>java.lang.String formatMyName(java.lang.String)</function-signature>
 </function>

<function>
    <name>add</name>
    <function-class>com.taglib.MyFunctions</function-class>
    <function-signature>java.lang.String add(int, int)</function-signature>
 </function>

　　3）JSP中調用

 ${cc:formatMyName("wangfei") }
 ${cc:add(12, 34) }

4. 自定義標簽運行原理（轉）

1）當服務器打開時，就會加載WEB-INF下的資源文件，包括web.xml 和 tld文件，把它們加載到內存用一個Map存儲，key就是tld文件中的uri

2）我們在瀏覽器輸入http://localhost:8080/TestArea/testit.jsp來訪問jsp頁面

3）服務器讀取testit.jsp里的內容，當讀到<%@taglib uri="http://vmaxtam.com/mytag" prefix="mmt" %>這一句的時候，就會在內存中找是否存在uri為http://vmaxtam.com/mytag 的tld文件，找不到就會報錯

4）繼續讀取jsp頁面，讀到<mmt:mytag>這個標簽的時候，就會通過uri去找到tld文件，在tld文件中找到mytab是否被定義，是的話就得到它的tag-class的內容，然后去找到它對應的標簽處理程序

5）實例化標簽處理程序，利用生成的對象調用它里面的方法

這里服務器對標簽處理程序里的方法也有一定的調用順序

　　A)void setPageContext(PageContext pc) --傳入pageContext對象

　 B)void setParent(Tag t) --如果有父標簽，傳入父標簽對象，如果沒有，則傳入null

　 C)int doStartTag() --開始執行標簽時調用。

　 D)int doEndTag() --結束標簽時調用

　 E)void release() --釋放資源

　　以下標簽調用圖供參考：

　　當然我們還可以通過查看jsp編譯后的servlet代碼來印證上述的結論（這邊就以筆者自己的demo來講述）：

  1 package org.apache.jsp;
  2 
  3 import com.tab.cn.MyTag;
  4 import java.io.IOException;
  5 import java.util.HashMap;
  6 import java.util.Map;
  7 import javax.el.ExpressionFactory;
  8 import javax.servlet.ServletConfig;
  9 import javax.servlet.ServletException;
 10 import javax.servlet.http.HttpServletRequest;
 11 import javax.servlet.http.HttpServletResponse;
 12 import javax.servlet.jsp.JspApplicationContext;
 13 import javax.servlet.jsp.JspFactory;
 14 import javax.servlet.jsp.JspWriter;
 15 import javax.servlet.jsp.PageContext;
 16 import javax.servlet.jsp.SkipPageException;
 17 import org.apache.jasper.runtime.HttpJspBase;
 18 import org.apache.jasper.runtime.InstanceManagerFactory;
 19 import org.apache.jasper.runtime.JspSourceDependent;
 20 import org.apache.jasper.runtime.TagHandlerPool;
 21 import org.apache.tomcat.InstanceManager;
 22 
 23 public final class index_jsp extends HttpJspBase
 24   implements JspSourceDependent
 25 {
 26   private static final JspFactory _jspxFactory = JspFactory.getDefaultFactory();
 27 
 28   private static Map<String, Long> _jspx_dependants = new HashMap(1);
 29   private TagHandlerPool _005fjspx_005ftagPool_005fmt_005fmyTag_005fnobody;
 30   private ExpressionFactory _el_expressionfactory;
 31   private InstanceManager _jsp_instancemanager;
 32 
 33   static
 34   {
 35     _jspx_dependants.put("/WEB-INF/MyTab.tld", Long.valueOf(1512028380582L));
 36   }
 37 
 38   public Map<String, Long> getDependants()
 39   {
 40     return _jspx_dependants;
 41   }
 42 
 43   public void _jspInit() {
 44     this._005fjspx_005ftagPool_005fmt_005fmyTag_005fnobody = TagHandlerPool.getTagHandlerPool(getServletConfig());
 45     this._el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
 46     this._jsp_instancemanager = InstanceManagerFactory.getInstanceManager(getServletConfig());
 47   }
 48 
 49   public void _jspDestroy() {
 50     this._005fjspx_005ftagPool_005fmt_005fmyTag_005fnobody.release();
 51   }
 52 
 53   public void _jspService(HttpServletRequest request, HttpServletResponse response)
 54     throws IOException, ServletException
 55   {
 56     JspWriter out = null;
 57 
 58     JspWriter _jspx_out = null;
 59     PageContext _jspx_page_context = null;
 60     try
 61     {
 62       response.setContentType("text/html;charset=utf-8");
 63       PageContext pageContext = _jspxFactory.getPageContext(this, request, response, 
 64         null, true, 8192, true);
 65       _jspx_page_context = pageContext;
 66       pageContext.getServletContext();
 67       pageContext.getServletConfig();
 68       pageContext.getSession();
 69       out = pageContext.getOut();
 70       _jspx_out = out;
 71 
 72       out.write("\r\n");
 73       out.write("\r\n");
 74       out.write("<html>\r\n");
 75       out.write("\t<head>\r\n");
 76       out.write("\t\t<meta name=\"decorator\" value=\"default\">\r\n");
 77       out.write("\t\t<title>Sitemesh測試</title>\r\n");
 78       out.write("\t</head>\r\n");
 79       out.write("\t<body>\r\n");
 80       out.write("\t\t");
 81       if (_jspx_meth_mt_005fmyTag_005f0(_jspx_page_context))
 82         return;
 83       out.write("\r\n");
 84       out.write("\t</body>\r\n");
 85       out.write("</html>\r\n");
 86     } catch (Throwable t) {
 87       if (!(t instanceof SkipPageException)) {
 88         out = _jspx_out;
 89         if ((out != null) && (out.getBufferSize() != 0)) try {
 90             out.clearBuffer(); } catch (IOException localIOException) {
 91           } if (_jspx_page_context != null) _jspx_page_context.handlePageException(t); else
 92           throw new ServletException(t);
 93       }
 94     } finally {
 95       _jspxFactory.releasePageContext(_jspx_page_context);
 96     }
 97   }
 98 
 99   private boolean _jspx_meth_mt_005fmyTag_005f0(PageContext _jspx_page_context)
100     throws Throwable
101   {
102     _jspx_page_context.getOut();
103 
104     MyTag _jspx_th_mt_005fmyTag_005f0 = (MyTag)this._005fjspx_005ftagPool_005fmt_005fmyTag_005fnobody.get(MyTag.class);//加載標簽處理類
105     _jspx_th_mt_005fmyTag_005f0.setPageContext(_jspx_page_context);//調用setPageContext類
106     _jspx_th_mt_005fmyTag_005f0.setParent(null);//設置Parent為null
107     _jspx_th_mt_005fmyTag_005f0.doStartTag();//調用doStartTag
108     if (_jspx_th_mt_005fmyTag_005f0.doEndTag() == 5) {//調用doEndTag
109       this._005fjspx_005ftagPool_005fmt_005fmyTag_005fnobody.reuse(_jspx_th_mt_005fmyTag_005f0);
110       return true;
111     }
112     this._005fjspx_005ftagPool_005fmt_005fmyTag_005fnobody.reuse(_jspx_th_mt_005fmyTag_005f0);
113     return false;
114   }
115 }

三、參考鏈接

https://www.cnblogs.com/flying607/p/5063207.html

　　https://www.cnblogs.com/zhaoyang/archive/2011/12/25/2301108.html

　　http://blog.csdn.net/acmman/article/details/51071894

　　https://www.cnblogs.com/vmax-tam/p/4145334.html

四、聯系本人

　　為方便沒有博客園賬號的讀者交流，特意建立一個企鵝群（純公益，非利益相關），讀者如果有對博文不明之處，歡迎加群交流：261746360，小杜比亞-博客園

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 jsp 自定義標簽 JSP自定義標簽開發+TLD文件元素詳解 JSP自定義標簽——傳統標簽 JSP自定義標簽——簡單標簽(1) jsp標簽--自定義分頁標簽 JSP自定義標簽/自定義標簽打包 [JSP]自定義標簽庫taglib JSP入門之自定義標簽 Jsp 自定義tag標簽 jsp2自定義標簽+屬性