jsp 自定义标签

最新推荐文章于 2022-11-20 20:33:20 发布

Terry_5008

最新推荐文章于 2022-11-20 20:33:20 发布

阅读量192

点赞数

分类专栏： JSP 文章标签： web.xml java

本文链接：https://blog.csdn.net/iteye_5008/article/details/82295365

版权

JSP 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

以下内容附件中也有

一、jsp自定义标签实例

   JSP自定义标签。在自定义标签的起始和结束标签之间的部分为标签体(Body)。
   标签处理程序类：定义标签的行为，并在JSP引擎遇到自定义标签时调用执行。
   标签库描述符（TLD）文件：描述标签库的XML文档，向JSP引擎提供有关自定义标签的标签处理程序的信息。tag标签相关属性：实现简单标签处理程序标签处理程序是一个在运行时调用的Java类,它包含在 JSP文件中使用的自定义标签的实现代码.标签处理程序必须实现或扩展javax.servlet.jsp.tagext包中的类和接口.javax.servlet.jsp.tagext含有允许标签处理程序类与JSP容器通信的接口和类。
其实对自定义标签已经早有接触了（Struts中使用了很多自定义标签，如html、bean等）使用这种技术的优点：取代了JSP中的Java程序，并且可以重复使用，方便不熟悉Java编程的网页设计人员。

实现步骤：

1、修改web.xml文件，增加自定义标签支持。

    <?xml version="1.0" encoding="UTF-8"?> 
    <web-app version="2.5"  
       xmlns="http://java.sun.com/xml/ns/javaee"  
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee  
        http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">   
      <jsp-config> 
        <taglib> 
            <taglib-uri>/tld/helloworld</taglib-uri> 
            <taglib-location>/WEB-INF/tlds/helloworld.tld</taglib-location> 
        </taglib> 
      </jsp-config>  
    </web-app>

2、创建标签库TLD文件 tlds\helloworld.tld 。

    <?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>1.2</jsp-version><!-- 这个标签库要求的JSP规范版本 --> 
       <short-name>mytag</short-name><!-- JSP页面编写工具可以用来创建助记名的可选名字 --> 
       <tag> 
          <name>helloworld</name><!-- 唯一标签名 --> 
          <tag-class>com.yd.mytag.HelloWorldTag</tag-class><!-- 标签HelloWorldTag类的完全限定名 --> 
          <body-content>empty</body-content><!-- 正文内容类型 --> 
       </tag> 
    </taglib>

这里注意：web.xml和xxx.tld这两个XML文件的头信息的版本匹配很重要，否则会导致页面报错找不到标签。

3、创建标签处理程序类 HelloWorldTag（重写doStartTag和doEndTag方法）。

    import java.io.IOException; 
    import javax.servlet.jsp.JspException; 
    import javax.servlet.jsp.JspTagException; 
    import javax.servlet.jsp.tagext.TagSupport; 
    /**
     * TagSupport与BodyTagSupport的区别:
     * 主要看标签处理类是否要读取标签体的内容和改变标签体返回的内容，如果不需要就用TagSupport，否则就用BodyTagSupport
     * 用TagSupport实现的标签，都可以用BodyTagSupport来实现，因为BodyTagSupport继承了TagSupport 
     */ 
    public class HelloWorldTag extends TagSupport { 
        private static final long serialVersionUID = 3174234039143531070L; 
        @Override 
        public int doStartTag() throws JspException {//这个方法不用所以直接返回值 
            return EVAL_BODY_INCLUDE; 
        } 
        @Override 
        public int doEndTag() throws JspException {//重点在这个方法上 
            try { 
                pageContext.getOut().write("Hello World!");//标签的返回值   
            } catch (IOException ex) { 
               throw new JspTagException("错误"); 
           } 
           return EVAL_PAGE; 
        } 
   }

补充：

    doStartTag()方法是遇到标签开始时会呼叫的方法，其合法的返回值是EVAL_BODY_INCLUDE与SKIP_BODY,前者表示将显示标签间的文字，后者表示不显示标签间的文字。
    doEndTag()方法是在遇到标签结束时呼叫的方法，其合法的返回值是EVAL_PAGE与SKIP_PAGE，前者表示处理完标签后继续执行以下的JSP网页，后者是表示不处理接下来的JSP网页。
    doAfterBody(),这个方法是在显示完标签间文字之后呼叫的，其返回值有EVAL_BODY_AGAIN与SKIP_BODY，前者会再显示一次标签间的文字，后者则继续执行标签处理的下一步。

EVAL_BODY_INCLUDE：把Body读入存在的输出流中，doStartTag()函数可用。
EVAL_PAGE：继续处理页面，doEndTag()函数可用。
SKIP_BODY：忽略对Body的处理，doStartTag()和doAfterBody()函数可用。
SKIP_PAGE：忽略对余下页面的处理，doEndTag()函数可用。
EVAL_BODY_BUFFERED：申请缓冲区，由setBodyContent()函数得到的BodyContent对象来处理tag的body，如果类实现了BodyTag，那么doStartTag()可用，否则非法。
EVAL_BODY_AGAIN：请求继续处理body，返回自doAfterBody()，这个返回值在你制作循环tag的时候是很有用的。

    预定的处理顺序是：doStartTag()返回SKIP_BODY,doAfterBodyTag()返回SKIP_BODY,doEndTag()返回EVAL_PAGE。如果继承了TagSupport之后，如果没有改写任何的方法，标签处理的执行顺序是：doStartTag() ->不显示文字 ->doEndTag()->执行接下来的网页。如果您改写了doStartTag(),则必须指定返回值，如果指定了EVAL_BODY_INCLUDE,则执行顺序是：doStartTag()->显示文字->doAfterBodyTag()->doEndTag()->执行下面的网页。

4、最终测试页面 hello.jsp 。

    <%@ page language="java" import="java.util.*" pageEncoding="utf-8"%> 
    <%@ taglib uri="/tld/helloworld" prefix="mytag"%><!-- 在页面中加以声明 --> 
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> 
    <html> 
      <head> 
        <title>MyJSP</title>     
      </head>   
      <body> 
        <h1>自定义标签:</h1><br> 
        <mytag:helloworld></mytag:helloworld> 
      </body> 
    </html>

二、JSP 自定义标签详解

一、基本概念：
　　1.标签(Tag):
　　标签是一种XML元素，通过标签可以使JSP网页变得简洁并且易于维护，还可以方便地实现同一个JSP文件支持多种语言版本。由于标签是XML元素，所以它的名称和属性都是大小写敏感的
　　2.标签库(Tag library):
　　由一系列功能相似、逻辑上互相联系的标签构成的集合称为标签库。
　　3.标签库描述文件(Tag Library Descriptor):
　　标签库描述文件是一个XML文件，这个文件提供了标签库中类和JSP中对标签引用的映射关系。它是一个配置文件，和web.xml是类似的。
　　4.标签处理类(Tag Handle Class):
　　标签处理类是一个Java类，这个类继承了TagSupport或者扩展了SimpleTag接口，通过这个类可以实现自定义JSP标签的具体功能

二、自定义JSP标签的格式：
　　1.　为了使到JSP容器能够使用标签库中的自定义行为，必须满足以下两个条件：
　　1)从一个指定的标签库中识别出代表这种自定义行为的标签
　　2)找到实现这些自定义行为的具体类
　　第一个必需条件－找出一个自定义行为属于那个标签库－是由标签指令的前缀(Taglib Directive's Prefix)属性完成，所以在同一个页面中使用相同前缀的元素都属于这个标签库。每个标签库都定义了一个默认的前缀，用在标签库的文档中或者页面中插入自定义标签。所以，你可以使用除了诸如jsp,jspx,java,servlet,sun,sunw(它们都是在JSP白皮书中指定的保留字)之类的前缀。　
　　uri属性满足了以上的第二个要求。为每个自定义行为找到对应的类。这个uri包含了一个字符串，容器用它来定位TLD文件。在TLD文件中可以找到标签库中所有标签处理类的名称
　　2. 当web应用程序启动时，容器从WEB-INF文件夹的目录结构的META-INF搜索所有以.tld结尾的文件。也就是说它们会定位所有的TLD文件。对于每个TLD文件，容器会先获取标签库的URI，然后为每个TLD文件和对应的URI创建映射关系。
　　在JSP页面中，我们仅需通过使用带有URI属性值的标签库指令来和具体的标签库匹配
　　

三、自定义JSP标签的处理过程：
　　1．在JSP中引入标签库：　　
　　2．在JSP中使用标签库标签
　　3．Web容器根据第二个步骤中的prefix，获得第一个步骤中声明的taglib的uri属性值
　　4．Web容器根据uri属性在web.xml找到对应的元素

5．从元素中获得对应的元素的值

6．Web容器根据元素的值从WEB-INF/目录下找到对应的.tld文件

7．从.tld文件中找到与tagname对应的元素

8．凑元素中获得对应的元素的值

9．Web容器根据元素的值创建相应的tag handle class的实例

10. Web容器调用这个实例的doStartTag/doEndTag方法完成相应的处理

四、创建和使用一个Tag Library的基本步骤：
　　1.创建标签的处理类(Tag Handler Class)
　　2.创建标签库描述文件(Tag Library Descrptor File)
　　3.在web.xml文件中配置元素 4.在JSP文件中引人标签库

五、TagSupport类简介：
　　1.处理标签的类必须扩展javax.servlet.jsp.TagSupport.
　　2.TagSupport类的主要属性：
　　 A.parent属性：代表嵌套了当前标签的上层标签的处理类
　　 B.pageContex属性：代表Web应用中的javax.servlet.jsp.PageContext对象
　　3.JSP容器在调用doStartTag或者doEndTag方法前，会先调用setPageContext和setParent方法，设置pageContext和parent。因此在标签处理类中可以直接访问pageContext变量
　　4.在TagSupport的构造方法中不能访问pageContext成员变量，因为此时JSP容器还没有调用
　　setPageContext方法对pageContext进行初始化

六、TagSupport处理标签的方法：
　　1. TagSupport类提供了两个处理标签的方法：
　　 public int doStartTag() throws JspException
　　 public int doEndTag() throws JspException
　　2. doStartTag：但JSP容器遇到自定义标签的起始标志，就会调用doStartTag()方法。
　　doStartTag()方法返回一个整数值，用来决定程序的后续流程。
　　A.Tag.SKIP_BODY：表示?>…之间的内容被忽略
　　B.Tag.EVAL_BODY_INCLUDE：表示标签之间的内容被正常执行
　　3. doEndTag：但JSP容器遇到自定义标签的结束标志，就会调用doEndTag()方法。doEndTag()方法也返回一个整数值，用来决定程序后续流程。
　　A.Tag.SKIP_PAGE：表示立刻停止执行网页，网页上未处理的静态内容和JSP程序均被忽略任何已有的输出内容立刻返回到客户的浏览器上。
　　B.Tag_EVAL_PAGE：表示按照正常的流程继续执行JSP网页

七、用户自定义的标签属性：
　　如果在标签中还包含了自定义的属性，那么在标签处理类中应该将这个属性作为成员变量，并且分别提供设置和读取属性的方法。

八、创建标签处理类的步骤：
　　1.创建包含JSP网页静态文本的文件(即是要替换自定义JSP标签的文本)
　　2.在Web应用启动时装载静态文本
　　3.创建标签处理类

九、如何创建包含JSP网页静态文本的文件：
　　1.使用java.util.Properties类来存放要替换网页中自定义JSP标签的静态文本
　　2.Properties类代表了一系列属性的集合，其实例既可以被保存到流中，也可以从流中加载。这些文本以key/value的形式存放在WEB-INF目录下，例如key=value，在属性列表中这些key/value都是String类型的

十、Properties类的常用API：
　　1.setProperty(String key, String value)：调用Hashtable类的put方法添加属性
　　2.getProperty(String key)：获取属性列表中key对应的属性值
　　3.load(InputStream in)：从输入流对象InputStream中读取属性列表(Properties list)
　　4.store(OutputStream out,String coMMent)：使用适当的格式将属性列表的属性对写入输出流对象中，默认使用ISO-88590-1编码格式,以行的方式处理输入。属性的key/value之间以”=、:”配对，以回车、换行分隔key/value配对

十一、ServletContext类的常用API：
　　1.getContext(String uripath)：返回服务器中uripath所代表的ServletContext对象
　　2.getInitParameter(String name)：返回ServletConfig对象中name参数的值
　　3.getMineType(String file)：返回file参数代表的文件的MIME类型
　　4.getRequestDispatcher(String path)：返回path代表的RequestDispacher对象
　　5.getResourceAsStream(String path)：以输入流的形式返回path对应的资源，在输入留中对象可以为任意形式的数据，path参数必须以“/”开始且相对于Context Root

十二、如何使用ServletContxt读取并保存属性文件：
　　1.创建java.util.Properties类对象
　　2.获取ServletContext对象
　　3.将属性文件以输入流的形式读入到某个输入流对象中
　　4.将输入流对象加载到Properties对象中
　　5.将Properties对象保存到ServletContext对象中

十三、如何在Web应用启动时装载静态文本：
　　1.创建继承了HttpServlet类的子类，在web.xml中配置这Servlet时设置load-on-startup属性：
　　someclass
　　somepackage.SomeClass1
　　2.在这个Servlet的init()方法中创建java.util.Properties类
　　3.获取当前Web应用的ServletContext对象
　　4.将WEB-INF目录下的属性文件读入到输入流InputStream中：
　　InputStream in = context.getResourceAsString("WEB-INF/someproperties.properties");
　　5.将输入流加载到属性对象中
　　ps.load(in);
　　6.将属性对象保存到上
　　context.setAttribute("attributeName",ps);

十四、如何创建标签处理类：
　　1.引入必需的资源：
　　   import javax.servlet.jsp.*;
　　   import javax.servlet.http.*;
　　   import java.util.*;
　　   import java.io.*;
　　2.继承TagSupport类并覆盖doStartTag()/doEndTag()方法
　　3.从ServletContext对象中获取java.util.Properties对象
　　4.从Properties对象中获取key对应的属性值
　　5.对获取的属性进行相应的处理并输出结果

十五、创建标签库描述文件(Tag Library Descriptor)：
　　1. 标签库描述文件，简称TLD，采用XML文件格式，定义了用户的标签库。TLD文件中的元素可以分成3类：
　　A.：标签库元素
　　B.：标签元素
　　C.：标签属性元素
　　2. 标签库元素用来设定标签库的相关信息，它的常用属性有：
　　A.shortname：指定Tag Library默认的前缀名(prefix)
　　B.uri：设定Tag Library的惟一访问表示符
　　3. 标签元素用来定义一个标签，它的常见属性有：
　　A.name：设定Tag的名字
　　B.tagclass：设定Tag的处理类
　　C.bodycontent：设定标签的主体(body)内容
　　1).empty：表示标签中没有body
　　2).JSP：表示标签的body中可以加入JSP程序代码
　　3).tagdependent：表示标签中的内容由标签自己去处理
　　4. 标签属性元素用来定义标签的属性，它的常见属性有：
　　A.name：属性名称
　　B.required：属性是否必需的，默认为false
　　C.rtexprvalue：属性值是否可以为request-time表达式，也就是类似于
　　5. prefix表示在JSP网页中引用这个标签库的标签时的前缀，uri用来指定Tag Library的标识符，它必须和web.xml中的属性保持一致。

重要

一个tag就是一个普通的java类，它惟一特别之处是它必须继承TagSupport或者 BodyTagSupport 类。这两个类提供了一些方法，负责jsp页面和你编写的类之间的交互，例如输入，输出。而这两个类是由jsp容器提供的，无须开发人员自己实现。换句话说，你只需把实现了业务逻辑的类继承TagSupport或者BodyTagSupport，再做一些特别的工作，你的类就是一个Tag。并且它自己负责和jsp 页面的交互，不用你多操心。

“特别的工作”通常有以下几个步骤：

[1] 提供属性的set方法，此后这个属性就可以在jsp页面设置。以jstl标签为例 <c:out value=""/>，这个value就是jsp数据到tag之间的入口。所以tag里面必须有一个setValue方法，具体的属性可以不叫value。例如setValue(String data){this.data = data;}
这个“value”的名称是在tld里以attribute元素存在的。
取什么名字都可以，只需tag里提供相应的set方法即可。

[2] 处理 doStartTag 或 doEndTag 。这两个方法是 TagSupport提供的。还是以c:out value=""/为例，当jsp解析这个标签的时候，在“<”处触发 doStartTag 事件，在“>”时触发 doEndTag 事件。通常在 doStartTag 里进行初始化,流程选择操作，在 doEndTag 里后续页面输出控制。
[3] 编写tld文件,就是把编写的tag组件的信息以xml形式告诉容器,它才好进一定步骤解释tag组件
[4]在jsp页面导入tld。这样，你的jsp页面就可以使用自己的tag组件了。

通常你会发现自己绝大多数活动都集中在 doStartTag 或 doEndTag方法里,如果在服务器端处理标签中的正文或则是嵌套标签时的话,还是过问一下doAfterBody。

一个简单的例子：OutputTag

package test;   
    import javax.servlet.jsp.JspException;   
    import javax.servlet.jsp.JspWriter;   
    import javax.servlet.jsp.tagext.TagSupport;   
      
    public class OutputTag extends TagSupport {   
    private String name=null;   
    public void setName(String name) {   
      this.name = name;   
    }   
    public int doEndTag() throws JspException   
    {   
    try {   
      JspWriter out = pageContext.getOut();   
      out.print("Hello! " + name);   
    } catch (Exception e) { throw new JspException(e); }   
    return EVAL_PAGE;   
    }   
    }

简要说明：
1 如何输出到jsp页面：调用JspWriter JspWriter out = pageContext.getOut();out.print......记住这个方法就可以了。
2 输出后如何作处理，函数会返回几个值之一。EVAL_PAGE 表示tag已处理完毕，返回jsp页面。还有几个值，例如 EVAL_BODY_AGAIN 和EVAL_BODY_INCLUDE等跟流程控制有关.

编写tld

<?xml version="1.0" encoding="ISO-8859-1" ?>   
    <!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>1.2</jsp-version>   
    <short-name>test</short-name>   
    <!--OutputTag-->   
    <tag>   
    <name>out</name>   
    <tag-class>test.OutputTag</tag-class>   
    <body-content>empty</body-content>   
    <attribute>   
    <name>name</name>   
    <required>false</required>   
    <rtexprvalue>false</rtexprvalue>   
    </attribute>   
    </tag> 
    </taglib>

在WEB-INF下新建tlds文件夹，把这个文件取名为test.tld，放到tlds文件夹下。引用时的路径应该这样：WEB-INF\tlds\test.tld

关于tld的简单说明：
short-name： taglib的名称，也称为前缀。比如“c:out value=""/” 里的“c”
name： tag的名字。例如“<c:out value=""/>” 里的"out”，我们的类也取名为out，由于有前缀作区分，不会同其他库的同名tag组件混淆
tag-class：完整的tag组件路径,记着带包名
body-content：指tag之间的内容。例如<c:out value="" ...... />c 起始和关闭标签之间就是body-content。由于没有处理body-content ，所以上面设为empty,如果是嵌套标签,或则是要在服务器端处理标签体的话,就是jsp了
“attribute”里的name：属性名字。例如<c:out value=""/>里的value。名字可任意取，只要类里提供相应的set方法即可。
required：是否必填属性。
rtexprvalue：是否支持运行时表达式取值就是是否可以<%=%>或则是${}方式传值。
这是tag的强大功能。
编写jsp页面

    <%@ page language="java"%>   
    <%@ taglib uri="/WEB-INF/tlds/test.tld" prefix="test"%>   
    <html>   
    <body>   
    Test Tag: <test:out name="TEST"/>   
    </body>   
    </html>

启动服务器，如果一切按照上面步骤的话，就能看到 Test Tag: Hello! TEST 字样。最简单的tag就这么出来了。并不难,是不是?
------------------------------------------------------------------
Tag 系列的 Interface 里定义的静态 int,通过他们也能一窥 tag 组键的执行流程,这几个静态值分别是：
SKIP_BODY ：跳过了开始和结束标签之间的代码,一般是在doStartTag中使用
EVAL_BODY_INCLUDE ：处理嵌套的标签,一般是在doStartTag中使用,由负责处理标签正文的tag接口提供
EVAL_BODY_BUFFERED : 对包含的内容进行解析一般是在doStartTag中使用,由负责处理标签正文的bodyTag接口提供,目的是通知jsp容器作好读取正文的工作(创建一个body- content包装正文和获取存放操作结果的out对象,便于以后的操作和输出).
EVAL_BODY_AGAIN: 处理标签正文,嵌套标签的iteratorTag接口的使用
SKIP_PAGE ：忽略剩下的页面,一般是在doEndTag中使用
EVAL_PAGE ：继续执行下面的页, 一般是在doEndTag中使用

调用顺序为：doStartTag setBodyContent doInitBody doAfterBody doEndTag

package newtag.wcw;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.TagSupport;
import java.io.*;
import javax.servlet.jsp.tagext.BodyContent;
import javax.servlet.jsp.tagext.BodyTagSupport;
public class TagBean extends BodyTagSupport {
    //开始
    public int doStartTag() {
        try {
            System.out.println("------------------------");
            System.out.println("doStartTag");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        // return SKIP_BODY;//跳过主体
        return EVAL_BODY_INCLUDE; //直接执行doAfterBody
        //return EVAL_BODY_BUFFERED; //顺序执行
    }
    //设置BodyContent
    public void setBodyContent(BodyContent bc) {
        super.setBodyContent(bc);
        try {
            System.out.println("setBodyContent");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    //主体之前
    public void doInitBody() {
        try {
            System.out.println("doInitBody");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    //逻辑判断
    public int doAfterBody() {
        try {
            System.out.println("doAfterBody");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        // return EVAL_BODY_AGAIN;//再次调用doAfterBody
        return SKIP_BODY; //跳过主体执行doEndTag
    }
    //结束
    public int doEndTag() {
        try {
            System.out.println("doEndTag");
            System.out.println("------------------------");
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        //return SKIP_PAGE;//跳过jsp页面
        return EVAL_PAGE; //继续jsp页面
    }
}

<!DOCTYPE taglib
PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
   "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
    <!-- 标签库描述符 -->
<taglib xmlns="http://java.sun.com/JSP/TagLibraryDescriptor">
<!--tlib版本-->
<tlib-version>1.0</tlib-version>
<!--jsp版本-->
<jsp-version>1.2</jsp-version>
<!--描述文件名 -->
<short-name>/TagBean</short-name>
<tag>
    <!--标签名字 -->
    <name>TagBean</name>
    <!--执行类-->
    <tag-class>newtag.wcw.TagBean</tag-class>
    <!--设置类型-->
    <body-content>JSP</body-content>
    <!--设置属性 -->
    <!--
      <attribute>
      <name></name>
      <required></required>
      <rtexprvalue></rtexprvalue>
      </attribute>
    -->
</tag>
</taglib>