您的位置: 首页  >  文章  >  自定义标签的编写

自定义标签的编写

分类: 文章 • 2022-12-01 00:12:52

原文地址：http://blog.csdn.net/before_morning/article/details/44515397

到不同的公司工作，都会遇到每个公司自己的标签，也即自定义的标签。其实，自定义标签主要用于移除Jsp页面中的java代码 。

要实现自己自定义的标签，只需要完成以下两个步骤：

1.编写一个实现Tag接口的Java类(标签处理器类)

2.编写标签库描述符（tld）文件，在tld文件中对标签处理器类描述成一个标签

3.在jsp页面上引入再使用

在介绍自定义标签的开发时，先提前说下，对于自定义标签的开发有两种方式：

1.传统标签【了解】

步骤：

a.写一个类实现Tag接口

b.写一个tld文件，描述写好的类

c.在jsp页面中引入tld文件，然后就可以使用自定义的标签了。

在传统标签中，分为doStartTag 和 doEndTag方法来分别处理发现开始标签和发现结束标签时的代码,在doStartTag可以通过返回值来控制标签体是否允许执行,

在doEndTag方法里可以通过返回值控制标签之后的剩余页面是否允许执行。

         传统标签的这种开发方式,需要我们分析发现开始标签和发现结束标签时都需要执行什么代码,还需要分析到底要返回什么样的标签体控制程序执行,相对来说相当的繁琐。

Tag接口的执行流程为：

JSP引擎将遇到自定义标签时，首先创建标签处理器类的实例对象，然后按照JSP规范定义的通信规则依次调用它的方法。

1、public void setPageContext(PageContext pc)， JSP引擎实例化标签处理器后，将调用setPageContext方法将JSP页面的pageContext对象传递给标签处理器，标签

处理器以后可以通过这个pageContext对象与JSP页面进行通信。

2、public void setParent(Tag t)，setPageContext方法执行完后，WEB容器接着调用的setParent方法将当前标签的父标签传递给当前标签处理器，如果当前标签没

有父标签，则传递给setParent方法的参数值为null。

3、public int doStartTag()，调用了setPageContext方法和setParent方法之后，WEB容器执行到自定义标签的开始标记时，就会调用标签处理器的doStartTag方法。

4、public int doEndTag()，WEB容器执行完自定义标签的标签体后，就会接着去执行自定义标签的结束标记，此时，WEB容器会去调用标签处理器的doEndTag 方法。

5、public void release()，通常WEB容器执行完自定义标签后，标签处理器会驻留在内存中，为其它请求服务器，直至停止web应用时，web容器才会调用release 方法。

下面就举一个简单的例子来说明一下，使用传统标签自定义标签：

首先编写一个类实现Tag接口

[java] view plain copy
  1. package com.jjyy.tag;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.jsp.JspException;  
  6. import javax.servlet.jsp.PageContext;  
  7. import javax.servlet.jsp.tagext.Tag;  
  8. /** 
  9.  * 传统标签 
  10.  * @author JiangYu 
  11.  * 
  12.  */  
  13. public class PrintIp implements Tag {  
  14.     private PageContext pc = null;  
  15.   
  16.     public int doEndTag() throws JspException {  
  17.         return 0;  
  18.     }  
  19.   
  20.     public int doStartTag() throws JspException {  
  21.         String ip = pc.getRequest().getRemoteAddr();  
  22.         try {  
  23.             pc.getOut().write(ip);  
  24.         } catch (IOException e) {  
  25.             e.printStackTrace();  
  26.         }  
  27.         return 0;  
  28.     }  
  29.   
  30.     public Tag getParent() {  
  31.         return null;  
  32.     }  
  33.   
  34.     public void release() {  
  35.     }  
  36.   
  37.     public void setPageContext(PageContext pc) {  
  38.         this.pc = pc;  
  39.     }  
  40.   
  41.     public void setParent(Tag t) {  
  42.     }  
  43.   
  44. }  
然后，编写一个tld文件，放在WEB-INF目录下，如图

自定义标签的编写

其中内容为：

[html] view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee"  
  3.  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">  
  4.  <tlib-version>1.0</tlib-version>  
  5.  <short-name>ip</short-name>  
  6.  <uri>http://www.jjyy.com/MyTag</uri>  
  7.  <tag>  
  8.   <name>showIp</name>  
  9.   <tag-class>com.jjyy.tag.PrintIp</tag-class>  
  10.   <body-content>empty</body-content>  
  11.  </tag>  
  12. </taglib>  

最后，编写一个jsp页面，在其中引入自定义的标签，在页面上使用：

[html] view plain copy
  1. <%@ page language="java" contentType="text/html; charset=utf-8"  
  2.     pageEncoding="utf-8"%>  
  3. <%@ taglib uri="http://www.jjyy.com/MyTag" prefix="ip" %>  
  4. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  5. <html>  
  6. <head>  
  7. <meta http-equiv="Content-Type" content="text/html; charset=utf-8">  
  8. <title>Insert title here</title>  
  9. </head>  
  10. <body>  
  11.     传统标签输出IP:<ip:showIp/>  
  12.     <br>  
  13.       
  14. </body>  
  15. </html>  

到此，实现自定义的标签过程就是上面三步了。

2.简单标签

上面简单的介绍了一下传统的标签，由于传统标签使用三个标签接口来完成不同的功能，显得过于繁琐，不利于标签技术的推广， SUN公司为降低标签技术的学习难度，在JSP 2.0中定义了一个更为简单、便于编写和调用的SimpleTag接口来实现标签的功能。

我们可以看下，Tag接口的层次机构和里面的方法：

自定义标签的编写自定义标签的编写 

实现SimpleTag接口的标签通常称为简单标签。下面也介绍一下简单标签的使用

      (1)写一个类实现SimpleTag接口(继承SimpleTag接口的默认实现类SimpleTagSupport)

        (2)写一个tld文件,描述写好的类

         (3)在jsp页面中引入tld文件,就可以在jsp页面中使用自定义标签了

SimpleTag中有五个方法：分别介绍下

1.setJspContext方法----用于把JSP页面的pageContext对象传递给标签处理器对象

2.setParent方法----用于把父标签处理器对象传递给当前标签处理器对象 

3.getParent方法----用于获得当前标签的父标签处理器对象 

4.setJspBody方法----用于把代表标签体的JspFragment对象传递给标签处理器对象

5.doTag方法----用于完成所有的标签逻辑，包括输出、迭代、修改标签体内容等。在doTag方法中可以抛出javax.servlet.jsp.SkipPageException异常，用

于通知WEB容器不再执行JSP页面中位于结束标记后面的内容，这等效于在传统标签的doEndTag方法中返回Tag.SKIP_PAGE常量的情况。

     简单标签的原理

         1.当jsp在执行的过程中,每当遇到一个简单标签时都会创建一个处理类对象.

         2.调用setJspContext传入当前jsp页面的PageContext对象.

         3.如果当前标签有父标签则调用setParent方法将父标签传入,如果没有父标签则这个方法不会被调用.

         4.如果该标签具有属性,调用属性的setXXX方法将属性的值传入

         5.如果当前标签具有标签体,则会调用setJspBody将封装了标签体信息的JspFragment传入,如果没有标签体,这个方法不执行

         6.最后调用doTag方法,在这个方法里我们可以书写处理标签事件的java代码

         7.当自定义标签执行完成后,简单标签对象就销毁掉了.

自定义标签的编写

下面就写一个Demo来操作一下简单标签的开发过程：

首先还是一样，编写一个类实现simpleTag，其中有五个方法，但是sun为了避免我们写过多的代码，所以提供了一个SimpleTagSupport类，其实现了SimpleTag接

口，所以我们直接可以继承SimpleTagSupport类，重写doTag方法就可以了。

[java] view plain copy
  1. package com.jjyy.simpletag;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.StringWriter;  
  5.   
  6. import javax.servlet.jsp.JspException;  
  7. import javax.servlet.jsp.SkipPageException;  
  8. import javax.servlet.jsp.tagext.JspFragment;  
  9. import javax.servlet.jsp.tagext.SimpleTagSupport;  
  10. /** 
  11.  * 简单自定义标签 
  12.  * @author JiangYu 
  13.  */  
  14. public class SimpleTag01 extends SimpleTagSupport {  
  15.       
  16.     @Override  
  17.     public void doTag() throws JspException, IOException {  
  18.           
  19.     }  
  20. }  
然后编写tld文件：

[html] view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee"  
  3.  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">  
  4.  <tlib-version>1.0</tlib-version>  
  5.  <short-name>ip</short-name>  
  6.  <uri>http://www.jjyy.com/MyTag</uri>  
  7.  <tag>  
  8.   <name>simpleTag1</name>  
  9.   <tag-class>com.jjyy.simpletag.SimpleTag01</tag-class>  
  10.   <body-content>scriptless</body-content>  
  11.   <attribute>  
  12.     <name>times</name>  
  13.     <required>true</required>  
  14.     <rtexprvalue>true</rtexprvalue>  
  15.     <type>int</type>  
  16.   </attribute>  
  17.  </tag>  
  18. </taglib>  
最后在jsp页面中引入：

[html] view plain copy
  1. <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>  
  2. <%@ taglib uri="http://www.jjyy.com/MyTag" prefix="ip" %>  
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  4. <html>  
  5. <head>  
  6. <meta http-equiv="Content-Type" content="text/html; charset=utf-8">  
  7. <title>Insert title here</title>  
  8. </head>  
  9. <body>  
  10.     标签之前  
  11.     <ip:simpleTag1>标签体</ip:simpleTag1>  
  12.     标签之后  
  13.   
  14. </body>  
  15. </html>  


通过上面的代码，基本上就把简单标签开发的过程也写了一遍，其实和传统标签的使用时类似的。但是，如果我们要我们自定义的标签实现特定的功能，应该怎么去实现呢？下面就逐一来介绍：

要实现自己想要的功能我们只需要修改doTag方法就可以了。期望实现的功能：

1.控制标签体是否执行


[java] view plain copy
  1. package com.jjyy.simpletag;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.jsp.JspException;  
  6. import javax.servlet.jsp.tagext.JspFragment;  
  7. import javax.servlet.jsp.tagext.SimpleTagSupport;  
  8. /** 
  9.  * 简单自定义标签 
  10.  * @author JiangYu 
  11.  */  
  12. public class SimpleTag01 extends SimpleTagSupport {  
  13.     @Override  
  14.     public void doTag() throws JspException, IOException {  
  15.         //1.控制标签体是否执行  
  16.         //控制标签体执行--只要调用封装着标签体的JSPFragment对象的invoke()方法即可  
  17.         JspFragment fragment = super.getJspBody();  
  18.         //fragment.invoke(super.getJspContext().getOut());  
  19.         fragment.invoke(null);  
  20.     }  
  21. }  
自定义标签的编写    

2.控制标签之后的内容是否执行

[java] view plain copy
  1. package com.jjyy.simpletag;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.jsp.JspException;  
  6. import javax.servlet.jsp.SkipPageException;  
  7. import javax.servlet.jsp.tagext.SimpleTagSupport;  
  8. /** 
  9.  * 简单自定义标签 
  10.  * @author JiangYu 
  11.  */  
  12. public class SimpleTag01 extends SimpleTagSupport {  
  13.     @Override  
  14.     public void doTag() throws JspException, IOException {  
  15.         //2.控制标签之后的内容是否执行  
  16.         //控制标签之后的内容执行：什么都不做，标签之后的内容就会执行  
  17.         //控制标签之后的内容不执行：抛出SkipPageException这样的一个异常就可以控制标签之后的内容不执行  
  18.         throw new SkipPageException();  
  19.     }  
  20. }  
  自定义标签的编写

3.控制标签体重复执行

[java] view plain copy
  1. package com.jjyy.simpletag;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.jsp.JspException;  
  6. import javax.servlet.jsp.tagext.JspFragment;  
  7. import javax.servlet.jsp.tagext.SimpleTagSupport;  
  8. /** 
  9.  * 简单自定义标签 
  10.  * @author JiangYu 
  11.  */  
  12. public class SimpleTag01 extends SimpleTagSupport {  
  13.     private int times;//对应tld文件中的attribute  
  14.     @Override  
  15.     public void doTag() throws JspException, IOException {  
  16.         //3.控制标签体重复执行  
  17.         JspFragment fragment = super.getJspBody();  
  18.         for(int i=0;i<times;i++){  
  19.             fragment.invoke(null);  
  20.         }  
  21.     }  
  22.     public void setTimes(int times) {  
  23.         this.times = times;  
  24.     }  
  25. }  
修改jsp页面

[html] view plain copy
  1. <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>  
  2. <%@ taglib uri="http://www.jjyy.com/MyTag" prefix="ip" %>  
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
  4. <html>  
  5. <head>  
  6. <meta http-equiv="Content-Type" content="text/html; charset=utf-8">  
  7. <title>Insert title here</title>  
  8. </head>  
  9. <body>  
  10. <!--  
  11.     标签之前  
  12.     <ip:simpleTag1 times="6">标签体</ip:simpleTag1>  
  13.     标签之后  
  14. -->  
  15.     <ip:simpleTag1 times="6">jjyy  </ip:simpleTag1>  
  16. </body>  
  17. </html>  

输出的结果为：

自定义标签的编写

4.修改标签体后进行输出

[java] view plain copy
  1. package com.jjyy.simpletag;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.StringWriter;  
  5.   
  6. import javax.servlet.jsp.JspException;  
  7. import javax.servlet.jsp.tagext.JspFragment;  
  8. import javax.servlet.jsp.tagext.SimpleTagSupport;  
  9. /** 
  10.  * 简单自定义标签 
  11.  * @author JiangYu 
  12.  */  
  13. public class SimpleTag01 extends SimpleTagSupport {  
  14.     @Override  
  15.     public void doTag() throws JspException, IOException {  
  16.         //4.修改标签体后进行输出  
  17.         StringWriter sw = new StringWriter();  
  18.         JspFragment fragment = super.getJspBody();  
  19.         fragment.invoke(sw);  
  20.         String str = sw.toString();  
  21.         str = "jjyy 测试自定义标签！！";  
  22.         getJspContext().getOut().write(str);  
  23.     }  
  24. }  

输出结果为：

自定义标签的编写

通过上面的演示，基本上我们也可以开发自己定义的标签了。最后还是分析一下tld文件：

自定义标签的编写

相关推荐