【转】Jsp自定义标签详解

最新推荐文章于 2024-04-27 17:30:34 发布

weixin_34353714

最新推荐文章于 2024-04-27 17:30:34 发布

阅读量129

点赞数

文章标签： java web.xml 开发工具

原文链接：http://www.cnblogs.com/xdouby/p/7929749.html

版权

一、前言

　　原本是打算研究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，小杜比亚-博客园

转载于:https://www.cnblogs.com/xdouby/p/7929749.html

weixin_34353714

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【转】Jsp自定义标签详解

一、前言　　原本是打算研究EXtremeComponents这个jsp标签插件，因为这个是自定义的标签，且自身对jsp的自定义标签并不是非常熟悉，所以就打算继续进行扫盲，开始学习并且整理Jsp自定义标签的内容~我发现自己的学习之路有点儿像一则寓言：一个人本来准备做个桌子（具体是不是忘了，反正意思差不多），然后发现没有锯子，于是开始做锯子，做锯子的时候发现自己没有铁，于是开始铸铁，铸铁的时候，发...
复制链接

扫一扫