Jsp标签

最新推荐文章于 2023-03-17 06:30:00 发布
最新推荐文章于 2023-03-17 06:30:00 发布
阅读量194 收藏
点赞数
分类专栏： java基础

      
        首先我们需要大致了解开发自定义标签所涉及到的接口与类的层次结构(其中SimpleTag接口与SimpleTagSupport类是JSP2.0中新引入的)。

  


         （一） JSP自定义标签的定义步骤：

            1  创建标记处理类

            2   创建TLD文件

            3   在jsp页面通

                过指令引入标签库

    

 

 

 

 

1、处理标签的类必须扩展javax.servlet.jsp.TagSupport 或 BodyTagSupport。先来讨论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进行初始化。

 

先写一个扩展javax.servlet.jsp.TagSupport的标签类MyTag ：

Java代码   收藏代码
  1. package com.common.tag;  
  2.   
  3. import java.io.IOException;  
  4. import java.text.SimpleDateFormat;  
  5. import java.util.Date;  
  6.   
  7. import javax.servlet.jsp.JspException;  
  8. import javax.servlet.jsp.JspWriter;  
  9. import javax.servlet.jsp.tagext.TagSupport;  
  10.   
  11. public class MyTag extends TagSupport  
  12. {  
  13.     int i=1;  
  14.     String first;  
  15.     String date;  
  16.     JspWriter jw;  
  17. public int doStartTag() throws JspException {  
  18.     jw=super.pageContext.getOut();  
  19.     try {  
  20.         jw.print("this is first field :"+getFirst() +"<br/>");  
  21.         jw.print("this is first date :"+getDate() +"<br/>");  
  22.     } catch (IOException e) {  
  23.         e.printStackTrace();  
  24.     }  
  25.       
  26.     return TagSupport.EVAL_BODY_INCLUDE;  
  27. }  
  28.    
  29.   public int doAfterBody() throws JspException {  
  30.       try {  
  31.         jw.println(i++ + "     ：我想知道这里doafterbody都做了些什么了呢<br/>");  
  32.           
  33.     } catch (IOException e) {  
  34.         e.printStackTrace();  
  35.     }  
  36.       if(5==i)return TagSupport.SKIP_BODY;  
  37.      return TagSupport.EVAL_BODY_AGAIN;  
  38.     }  
  39.     
  40.   public int doEndTag() throws JspException {  
  41.       try {  
  42.         jw.print("最后的结束标签了，doendtag");  
  43.     } catch (IOException e) {  
  44.         e.printStackTrace();  
  45.     }  
  46.       return TagSupport.EVAL_PAGE;  
  47.     }  
  48.   public String getFirst() {  
  49.         return first;  
  50.     }  
  51.     public void setFirst(String first) {  
  52.         this.first = first;  
  53.     }  
  54.     public String getDate() {  
  55.         SimpleDateFormat sdf=new SimpleDateFormat(date);  
  56.         return sdf.format(new Date());  
  57.     }  
  58.     public void setDate(String date) {  
  59.         this.date = date;  
  60.     }  
  61.     
  62. }  
  63.    

 

 

 我们以Tomcat 6.0.20服务器为例，来看看最简单的myTag.jsp是怎么运行的。

    我们仅以myTag.jsp中的 <my:mytag/>标签的解析为例进行分析，看容器是怎样把这个自定义标签解析成HTML输出的。

Java代码   收藏代码
  1. <%@ taglib prefix="my" uri="/my-tags" %>  
  2. <html>  
  3.   <head>  
  4.     <base href="<%=basePath%>">  
  5.       
  6.     <title>My JSP 'index.jsp' starting page</title>  
  7.   </head>  
  8.     
  9.   <body>  
  10.        <br>  
  11.       
  12.     <my:mytag date="yyyy-MM-dd HH-mm-ss" first=" {这是我第一个属性}">  
  13.       
  14.       中间体执行吧。  
  15.       
  16.     </my:mytag>  
  17.       
  18.   </body>  
  19. </html>  

 

   先附上我执行的结果：

 

this is first field : {这是我第一个属性}
this is first date :2013-03-10 01-28-02
中间体执行吧。 1 ：我想知道这里doafterbody都做了些什么了呢
中间体执行吧。 2 ：我想知道这里doafterbody都做了些什么了呢
中间体执行吧。 3 ：我想知道这里doafterbody都做了些什么了呢
中间体执行吧。 4 ：我想知道这里doafterbody都做了些什么了呢
最后的结束标签了，doendtag

 

    让我们来看看Tomcat都做了什么。转到Tomcat的\work\Standalone\localhost\_目录下，可以找到如下的myTag_jsp.java，这个文件就是Tomcat解析myTag.jsp时生成的源文件：

 

Java代码   收藏代码
  1. public final class myTag_jsp extends org.apache.jasper.runtime.HttpJspBase  
  2.     implements org.apache.jasper.runtime.JspSourceDependent {  
  3.   
  4.   private static final JspFactory _jspxFactory = JspFactory.getDefaultFactory();  
  5.   
  6.   private static java.util.List _jspx_dependants;  
  7.   
  8.   static {  
  9.     _jspx_dependants = new java.util.ArrayList(1);  
  10.     _jspx_dependants.add("/WEB-INF/myTag.tld");  
  11.   }  
  12.   
  13.    //为所有的定制标签定义处理器池类的引用   
  14.   private org.apache.jasper.runtime.TagHandlerPool _005fjspx_005ftagPool_005fmy_005fmytag_0026_005ffirst_005fdate;  
  15.   
  16.   private javax.el.ExpressionFactory _el_expressionfactory;  
  17.   private org.apache.AnnotationProcessor _jsp_annotationprocessor;  
  18. ..................  
  19. .............  
  20. //为处理器池类赋值  
  21.  public void _jspInit() {  
  22.     _005fjspx_005ftagPool_005fmy_005fmytag_0026_005ffirst_005fdate = org.apache.jasper.runtime.TagHandlerPool.getTagHandlerPool(getServletConfig());  
  23.     _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();  
  24.     _jsp_annotationprocessor = (org.apache.AnnotationProcessor) getServletConfig().getServletContext().getAttribute(org.apache.AnnotationProcessor.class.getName());  
  25.   }  
  26.   public void _jspService(HttpServletRequest request, HttpServletResponse response)  
  27.         throws java.io.IOException, ServletException {  
  28.   
  29.     PageContext pageContext = null;  
  30.     HttpSession session = null;  
  31.     ServletContext application = null;  
  32.     ServletConfig config = null;  
  33.     JspWriter out = null;  
  34.     Object page = this;  
  35.     JspWriter _jspx_out = null;  
  36.     PageContext _jspx_page_context = null;  
  37.   
  38.   
  39.     try {  
  40.       response.setContentType("text/html;charset=UTF-8");  
  41.       pageContext = _jspxFactory.getPageContext(this, request, response,  
  42.                   null, true, 8192, true);  
  43.       _jspx_page_context = pageContext;  
  44.       application = pageContext.getServletContext();  
  45.       config = pageContext.getServletConfig();  
  46.       session = pageContext.getSession();  
  47.       out = pageContext.getOut();  
  48.       _jspx_out = out;  
  49.   
  50.       out.write("\r\n");  
  51.       out.write("\r\n");  
  52.   
  53. String path = request.getContextPath();  
  54. String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";  
  55.         ................  
  56.      .......................  
  57.       out.write("  <body>\r\n");  
  58.       out.write("    This is my JSP page. <br>\r\n");  
  59.       out.write("    \r\n");  
  60.       out.write("    ");  
  61.       if (_jspx_meth_my_005fmytag_005f0(_jspx_page_context)) //标签的处理，请往下看方法的实现。  
  62.         return;  
  63.       out.write("\r\n");  
  64.       out.write("    \r\n");  
  65.       out.write("    \r\n");  
  66.       out.write("  </body>\r\n");  
  67.       out.write("</html>\r\n");  
  68.     } catch (Throwable t) {  
  69.       if (!(t instanceof SkipPageException)){  
  70.         out = _jspx_out;  
  71.         if (out != null && out.getBufferSize() != 0)  
  72.           try { out.clearBuffer(); } catch (java.io.IOException e) {}  
  73.         if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);  
  74.       }  
  75.     } finally {  
  76.       _jspxFactory.releasePageContext(_jspx_page_context);  
  77.     }  
  78.   }  
  79.                  //真正处理标签<my:myTag  >方法  
  80.   private boolean _jspx_meth_my_005fmytag_005f0(PageContext _jspx_page_context)  
  81.           throws Throwable {  
  82.     PageContext pageContext = _jspx_page_context;  
  83.     JspWriter out = _jspx_page_context.getOut();  
  84.     //  my:mytag  
  85.     com.common.tag.MyTag _jspx_th_my_005fmytag_005f0 = (com.common.tag.MyTag) _005fjspx_005ftagPool_005fmy_005fmytag_0026_005ffirst_005fdate.get(com.common.tag.MyTag.class);  
  86. //JSP容器在调用doStartTag或者doEndTag方法前，会先调用setPageContext和setParent方法，设置pageContext和parent，而且也调用setFiled()方法设置标签的相关属性;  
  87.     _jspx_th_my_005fmytag_005f0.setPageContext(_jspx_page_context);  
  88.     _jspx_th_my_005fmytag_005f0.setParent(null);  
  89.     // /index.jsp(19,4) name = date type = java.lang.String reqTime = false required = false fragment = false deferredValue = false expectedTypeName = null deferredMethod = false methodSignature = null  
  90.     _jspx_th_my_005fmytag_005f0.setDate("yyyy-MM-dd HH-mm-ss");  
  91.     // /index.jsp(19,4) name = first type = java.lang.String reqTime = false required = false fragment = false deferredValue = false expectedTypeName = null deferredMethod = false methodSignature = null  
  92.     _jspx_th_my_005fmytag_005f0.setFirst(" {这是我第一个属性}");  
  93.     int _jspx_eval_my_005fmytag_005f0 = _jspx_th_my_005fmytag_005f0.doStartTag();   // JSP容器 处理                                                                                 //到自 定义标签的起始标志，就会调用doStartTag()方法  
  94.     if (_jspx_eval_my_005fmytag_005f0 != javax.servlet.jsp.tagext.Tag.SKIP_BODY) {  //如果doStartTag()方  
  95.                                                                                                // 法返回值不是Tag.SKIP_BODY就执行标签体  
  96.       do {  
  97.         out.write("\r\n");  
  98.         out.write("    \r\n");  
  99.         out.write("      中间体执行吧。\r\n");           
  100.         out.write("    \r\n");  
  101.         out.write("    ");  
  102.         int evalDoAfterBody = _jspx_th_my_005fmytag_005f0.doAfterBody();              //看到这里你应该知道  
  103.                                                                                                       //tomcat是怎么处理doAfterBody(); 了吧。  
  104.         if (evalDoAfterBody != javax.servlet.jsp.tagext.BodyTag.EVAL_BODY_AGAIN) //如果doAfterBody()返  
  105.                                                       //回值是EVAL_BODY_AGAIN，则再次执行方法体和doAfterBody()方法，  
  106.                                                                                                                                  // 直到doAfterBody()返  
  107.                                                                                                                      //回值为SKIP_BODY才跳出循环  
  108.           break;  
  109.       } while (true);  
  110.     }               //do{}while(true)无论doAfterBody()返回值如何都会执行方法体一次  
  111.     if (_jspx_th_my_005fmytag_005f0.doEndTag() == javax.servlet.jsp.tagext.Tag.SKIP_PAGE) {  
  112.       _005fjspx_005ftagPool_005fmy_005fmytag_0026_005ffirst_005fdate.reuse(_jspx_th_my_005fmytag_005f0);  
  113.       return true;  
  114.     }  
  115.     _005fjspx_005ftagPool_005fmy_005fmytag_0026_005ffirst_005fdate.reuse(_jspx_th_my_005fmytag_005f0);  
  116.     return false;  
  117.   }  
  118. }  

 

   生成的myTag_jsp.java继承于org.apache. jasper.runtime.HttpJspBase。研究这个文件为我们了解定制标签的运行机理提供了途径。 

　 　从上面可以看出，Tomcat在解析一个JSP页面时，首先为每一个定制标签定义并实例化了一个TagHandlerPool对象。页面的处理方法覆盖 父类的_ jspService()方法，_jspService方法首先初始化环境，为内置对象赋值。由于myTag.jsp页面整体由一 个<html:html/>标签包裹，Tomcat对每一个标签都产生一个私有方法加以实现。<html:html/>标签的处 理方法是_jspx_meth_html_html_0()。这个方法的命名规范大家也可以从这里看出，就是“_jspx_meth ＋ 标签的前缀 ＋ 标签名 ＋ 该标签在JSP页面同类标签中出现的序号”。其它标签都被包含在该标签中，所以其它标签在_jspx_meth_html_html_0()方法中进行解 析。

  在_jspx_meth_html_html_0()方法中，首先从_jspx_tagPool_html_html_locale池中得到一个 org.apache.struts.taglib.html.HtmlTag的实例，然后设置这个tag实例的页面上下文及上级标签，由于 html:html标签是页面的最顶层标签，所以它的parent是null。然后对该标签的内容进行解析。HTML代码直接输出，下面主要看 看<html:html></html:html>标签之间包含的<my:mybodyTag count="5" >标签的解析。

                对<my:mytag>标签的解析类似于html:html，Tomcat也将其放入一个 单独的方法_jspx_meth_my_005fmytag_005f0()中进行。

在myTag.jsp中定义了一个<my:mytag>标签，并设置了一个属性： <my:mytag date="yyyy-MM-dd HH-mm-ss" first=" {这是我第一个属性}">。Tomcat在解析时，调用MyTag对象的date和first属性设置方法setDate()和setFirst()，将该属性置 入。然后调用MyTag的doStartTag()和doEndTag()方法，完成解析。如果doEndTag()方法的返回值为 javax.servlet.jsp.tagext.Tag. SKIP_PAGE，表明已经完成解析，返回true，Tomcat将立即停止剩余页面代码的执行，并返回。如果doEndTag()方法的返回值为TagSupport.EVAL_PAGE ，表明还没完成解析，返回false,继续解析这个标签后面的内容。并在最后把该MyTag的实例放回池 中。 

　　标签类对象实例的池化 
　　为了提高运行效率，Tomcat对所有的定制标签类进行了池化，池化工作由org.apache.jasper. runtime.TagHandlerPool类完成。TagHandlerPool类主要有两个方法，代码如下： 

TagHandlerPool.java 

public class TagHandlerPool { 
private static final int MAX_POOL_SIZE = 5; 
private Tag[] handlers; 
public synchronized Tag get(Class handlerClass) throws JspException {……} 
public synchronized void reuse(Tag handler) {……} 
} 
　　 TagHandlerPool简单地实现了对标签类的池化，其中MAX_POOL_SIZE是池的初始大小，handlers是一个Tag的数组，存储标 签类的实例。get(Class handlerClass)得到一个指定标签类的实例，如果池中没有可用实例，则新实例化一个。reuse(Tag handler)把handler对象放回池中。 

　　至此，我们对JSP在容器中的运行过程已经了然于胸 了。虽然每种JSP容器的解析结果会有差异，但其中的原理都雷同。对于编写JSP应用，我们并不需要干涉容器中的运行过程，但如果你对整个底层的运行机制 比较熟悉，就能对JSP/Servlet技术有更深的认识。

 

  

     二   我们再来讨论标签类继承BodyTagSupport

我们仅以myBodyTag.jsp中的 <my:mybody/>标签的解析为例进行分析，看容器是怎样把这个自定义标签解析成HTML输出的。

Java代码   收藏代码
  1. <%@ taglib prefix="my" uri="/my-tags" %>  
  2.             <html>  
  3.   <head>  
  4.     <base href="<%=basePath%>">  
  5.       
  6.     <title>My JSP 'index.jsp' starting page</title>  
  7.   </head>  
  8.     
  9.   <body>  
  10.     <br/>      
  11.     <my:mybodyTag count="5" >  
  12.       
  13.                               中间体执行吧。<br/>  
  14.       
  15.     </my:mybodyTag>  
  16.   </body>  
  17. </html>  
  18.    

 

先附上执行后的结果：

---dostartTag---
---setBodyContent---
---doinitBody---

0 :---doAfterBody---

1 :---doAfterBody---

2 :---doAfterBody---

3 :---doAfterBody---

4 :---doAfterBody---

---doEndTag---
中间体执行吧。
中间体执行吧。
中间体执行吧。
中间体执行吧。
中间体执行吧。
中间体执行

 

          让我们来看看Tomcat都做了什么。转到Tomcat的\work\Standalone\localhost\_目录下，可以找到如下的myBodyTag_jsp.java，这个文件就是Tomcat解析myBodyTag.jsp时生成的源文件：

 

Java代码   收藏代码
  1. public final class myBodyTag_jsp extends org.apache.jasper.runtime.HttpJspBase  
  2.     implements org.apache.jasper.runtime.JspSourceDependent {  
  3.   
  4.   private static final JspFactory _jspxFactory = JspFactory.getDefaultFactory();  
  5.   
  6.   private static java.util.List _jspx_dependants;  
  7.   
  8.   static {  
  9.     _jspx_dependants = new java.util.ArrayList(1);  
  10.     _jspx_dependants.add("/WEB-INF/myTag.tld"); //加载标签描述文件  
  11.   }  
  12.            //为所有的定制标签定义处理器池类的引用   
  13.   private org.apache.jasper.runtime.TagHandlerPool _005fjspx_005ftagPool_005fmy_005fmybodyTag_0026_005fcount;  
  14.   
  15.   private javax.el.ExpressionFactory _el_expressionfactory;  
  16.   private org.apache.AnnotationProcessor _jsp_annotationprocessor;  
  17.   
  18.   public Object getDependants() {  
  19.     return _jspx_dependants;  
  20.   }  
  21.   
  22.   public void _jspInit() {  
  23.     _005fjspx_005ftagPool_005fmy_005fmybodyTag_0026_005fcount = org.apache.jasper.runtime.TagHandlerPool.getTagHandlerPool(getServletConfig());//给处理池类赋值  
  24.     _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();  
  25.     _jsp_annotationprocessor = (org.apache.AnnotationProcessor) getServletConfig().getServletContext().getAttribute(org.apache.AnnotationProcessor.class.getName());  
  26.   }  
  27.   
  28.   public void _jspDestroy() {  
  29.     _005fjspx_005ftagPool_005fmy_005fmybodyTag_0026_005fcount.release();  
  30.   }  
  31.   
  32.   public void _jspService(HttpServletRequest request, HttpServletResponse response)  
  33.         throws java.io.IOException, ServletException {  
  34.   
  35.     PageContext pageContext = null;  
  36.     HttpSession session = null;  
  37.     ServletContext application = null;  
  38.     ServletConfig config = null;  
  39.     JspWriter out = null;  
  40.     Object page = this;  
  41.     JspWriter _jspx_out = null;  
  42.     PageContext _jspx_page_context = null;  
  43.   
  44.   
  45.     try {  
  46.       response.setContentType("text/html; charset=UTF-8");  
  47.       pageContext = _jspxFactory.getPageContext(this, request, response,  
  48.                   null, true, 8192, true);  
  49.       _jspx_page_context = pageContext;  
  50.       application = pageContext.getServletContext();  
  51.       config = pageContext.getServletConfig();  
  52.       session = pageContext.getSession();  
  53.       out = pageContext.getOut();  
  54.       _jspx_out = out;  
  55.   
  56.       out.write("\r\n");  
  57.       out.write("\r\n");  
  58.   
  59. String path = request.getContextPath();  
  60. String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";  
  61.   
  62.       out.write("\r\n");  
  63.       out.write("\r\n");  
  64.       out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");  
  65.       out.write("<html>\r\n");  
  66.       out.write("  <head>\r\n");  
  67.       out.write("    <base href=\"");  
  68.       out.print(basePath);  
  69.       out.write("\">\r\n");  
  70.       out.write("    \r\n");  
  71.       out.write("    <title>My JSP 'index.jsp' starting page</title>\r\n");  
  72.       out.write("  </head>\r\n");  
  73.       out.write("  \r\n");  
  74.       out.write("  <body>\r\n");  
  75.       out.write("    <br/>    \r\n");  
  76.       out.write("    ");  
  77.       if (_jspx_meth_my_005fmybodyTag_005f0(_jspx_page_context))  
  78.         return;             //标签被处理的方法  
  79.       out.write("\r\n");  
  80.       out.write("    \r\n");  
  81.       out.write("    \r\n");  
  82.       out.write("  </body>\r\n");  
  83.       out.write("</html>\r\n");  
  84.     } catch (Throwable t) {  
  85.       if (!(t instanceof SkipPageException)){  
  86.         out = _jspx_out;  
  87.         if (out != null && out.getBufferSize() != 0)  
  88.           try { out.clearBuffer(); } catch (java.io.IOException e) {}  
  89.         if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);  
  90.       }  
  91.     } finally {  
  92.       _jspxFactory.releasePageContext(_jspx_page_context);  
  93.     }  
  94.   }  
  95.   
  96.   private boolean _jspx_meth_my_005fmybodyTag_005f0(PageContext _jspx_page_context)  
  97.           throws Throwable {  
  98.     PageContext pageContext = _jspx_page_context;  
  99.     JspWriter out = _jspx_page_context.getOut();  
  100.     //  my:mybodyTag  
  101.     com.common.tag.MyBodyTag _jspx_th_my_005fmybodyTag_005f0 = (com.common.tag.MyBodyTag) _005fjspx_005ftagPool_005fmy_005fmybodyTag_0026_005fcount.get(com.common.tag.MyBodyTag.class);  
  102.     _jspx_th_my_005fmybodyTag_005f0.setPageContext(_jspx_page_context);  
  103.     _jspx_th_my_005fmybodyTag_005f0.setParent(null);  
  104.     // /myBodyTag.jsp(18,4) name = count type = java.lang.String reqTime = false required = false fragment = false deferredValue = false expectedTypeName = null deferredMethod = false methodSignature = null  
  105.     _jspx_th_my_005fmybodyTag_005f0.setCount(5);  
  106.     int _jspx_eval_my_005fmybodyTag_005f0 = _jspx_th_my_005fmybodyTag_005f0.doStartTag();          //执行.doStartTag()  
  107.     if (_jspx_eval_my_005fmybodyTag_005f0 != javax.servlet.jsp.tagext.Tag.SKIP_BODY) {                           //继承BodyTagSupport处继承TagSupport不同之处就是以下标为棕色的代码了。  
  108.       if (_jspx_eval_my_005fmybodyTag_005f0 != javax.servlet.jsp.tagext.Tag.EVAL_BODY_INCLUDE) {      
  109.         out = _jspx_page_context.pushBody();   //如果dostartTag()返回BodyTagSupport.EVAL_BODY_BUFFERED; 注意了此时的out 引用已经被改赋值为BodyContent对象了。它会把它会通过out.print()设置标签体的内容缓存起来，  
  110. 直到super.bodyContent.writeOut(getPreviousOut())执行到再输出标签体的内容  
  111.                                                                       
  112.         _jspx_th_my_005fmybodyTag_005f0.setBodyContent((javax.servlet.jsp.tagext.BodyContent) out); //setBodyContent()方法用于设置标签体内容，如果在此之前要作一些初始化工作，  
  113.                                                                                                                                                                      //则在doInitBody()方法中完成  
  114.         _jspx_th_my_005fmybodyTag_005f0.doInitBody();  
  115.       }  
  116.       do {  
  117.         out.write("\r\n");  
  118.         out.write("    \r\n");  
  119.         out.write("                              中间体执行吧。<br/>\r\n");  
  120.         out.write("    \r\n");  
  121.         out.write("    ");  
  122.         int evalDoAfterBody = _jspx_th_my_005fmybodyTag_005f0.doAfterBody();           //这里在讲继承TagSupport处理类时是一样的，请看前面  
  123.         if (evalDoAfterBody != javax.servlet.jsp.tagext.BodyTag.EVAL_BODY_AGAIN)  
  124.           break;  
  125.       } while (true);  
  126.       if (_jspx_eval_my_005fmybodyTag_005f0 != javax.servlet.jsp.tagext.Tag.EVAL_BODY_INCLUDE) {  
  127.         out = _jspx_page_context.popBody();  
  128.       }  
  129.     }  
  130.     if (_jspx_th_my_005fmybodyTag_005f0.doEndTag() == javax.servlet.jsp.tagext.Tag.SKIP_PAGE) {  //这里执行了.doEndTag()方法//如果 此方法中没有super.bodyContent.writeOut(getPreviousOut());这一句时，  
  131.                                                                                                                                                                //则标签体内容没有输出！  
  132.       _005fjspx_005ftagPool_005fmy_005fmybodyTag_0026_005fcount.reuse(_jspx_th_my_005fmybodyTag_005f0);  
  133.       return true;  
  134.     }  
  135.     _005fjspx_005ftagPool_005fmy_005fmybodyTag_0026_005fcount.reuse(_jspx_th_my_005fmybodyTag_005f0);  
  136.     return false;  
  137.   }  
  138. }  

 

 最后总结一下BodyTagSupport执行流程：

他们执行顺序如下： 
doStartTag()—>doInitBody()-->setBodyContent()-->doAfterBody()-->doEndTag() 


doStartTag()方法可返回EVAL_BODY_INCLUDE或SKIP_BODY，还有EVAL_BODY_BUFFERED; 
如果返回EVAL_BODY_INCLUDE则继续执行； 如果返回EVAL_BODY_BUFFERED; 注意了此时的out 引用已经被改赋值为BodyContent对象了。它会把它会通过out.print()设置标签体的内容缓存起来，

直到super.bodyContent.writeOut(getPreviousOut())执行到再输出标签体的内容
如果返回SKIP_BODY则接下来的setBodyContent(), doInitBody(),doAfterBody()三个方法不会被执行， 
而直接执行doEndTag()方法。 
setBodyContent()方法用于设置标签体内容，如果在此之前要作一些初始化工作，则在doInitBody()方法中完成。 
标签体内容执行完后，会调用doAfterBody()方法，此方法可返回EVAL_BODY_TAG, SKIP_BODY, 
EVAL_PAGE或SKIP_PAGE。 
如果返回EVAL_BODY_TAG则会再次设置标签体内容，直到返回SKIP_BODY； 
如果返回EVAL_PAGE则标签体执行完后会继续执行JSP页面中接下来的部分； 
如果返回SKIP_PAGE，则JSP页面的后续内容将不再执行。

 

        附上MyBodyTag类：

          

Java代码   收藏代码
  1.  package com.common.tag;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.jsp.JspException;  
  6. import javax.servlet.jsp.JspWriter;  
  7. import javax.servlet.jsp.tagext.BodyContent;  
  8. import javax.servlet.jsp.tagext.BodyTagSupport;  
  9.   
  10. public class MyBodyTag extends BodyTagSupport  
  11. {  
  12.     int count;  
  13.     int iteraterCount;  
  14.   
  15.     JspWriter jw;  
  16.     BodyContent bc;  
  17.     
  18.     public int doStartTag() throws JspException {  
  19.         try {  
  20.             jw=super.pageContext.getOut();  
  21.             jw.print("---dostartTag---<br/>");  
  22.         } catch (IOException e) {  
  23.             e.printStackTrace();  
  24.         }  
  25.           
  26.         return BodyTagSupport.EVAL_BODY_BUFFERED;  
  27.     }  
  28.       
  29.     public void doInitBody() throws JspException {  
  30.         try {  
  31.             jw.print("---doinitBody---<br/><br/>");  
  32.         } catch (IOException e) {  
  33.             e.printStackTrace();  
  34.         }  
  35.           
  36.     }  
  37.     public void setBodyContent(BodyContent b) {  
  38.         try {  
  39.             jw.print("---setBodyContent---<br/>");  
  40.         } catch (IOException e) {  
  41.             e.printStackTrace();  
  42.         }  
  43.         super.setBodyContent(b);  
  44.    }  
  45.     public int doAfterBody() throws JspException {  
  46.       if(iteraterCount<count){  
  47.           try {  
  48.             jw.print(iteraterCount++ +" :---doAfterBody---<br/><br/>");  
  49.         } catch (IOException e) {  
  50.             e.printStackTrace();  
  51.         }  
  52.           
  53.             
  54.           return BodyTagSupport.EVAL_BODY_AGAIN;  
  55.       }else {  
  56.         return BodyTagSupport.SKIP_BODY;  
  57.     }  
  58.       
  59.     }  
  60.     public int doEndTag() throws JspException {//如果 此方法没有，则标签体内容没有输出！  
  61.         try {  
  62.         jw.print("---doEndTag---<br/>");  
  63.     if(super.bodyContent!=null){  
  64.                 super.bodyContent.writeOut(getPreviousOut());  
  65.         }  
  66.       
  67.         } catch (IOException e) {  
  68.             e.printStackTrace();  
  69.         }  
  70.         iteraterCount=0;  
  71.         return BodyTagSupport.EVAL_PAGE;  
  72.     }  
  73.   
  74.   
  75.     public int getCount() {  
  76.         return count;  
  77.     }  
  78.   
  79.     public void setCount(int count) {  
  80.         this.count = count;  
  81.     }  
  82. }  

 

          附上myTag.TLD:

Java代码   收藏代码
  1. <?xml version="1.0" encoding="UTF-8" standalone="no"?>  
  2. <taglib xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.0" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd">  
  3.   <description><![CDATA["To make it easier to access dynamic data;  
  4.                         the Apache Struts framework includes a library of custom tags.  
  5.                         The tags interact with the framework's validation and internationalization features;  
  6.                         to ensure that input is correct and output is localized.  
  7.                         The Struts Tags can be used with JSP FreeMarker or Velocity."]]></description>  
  8.   <display-name>"my Tags"</display-name>  
  9.   <tlib-version>1.0</tlib-version>  
  10.   <short-name>mytag</short-name>  
  11.   <uri>/my-tags</uri>  
  12.     
  13.   <tag>  
  14.     <description><![CDATA[Execute an action from within a view]]></description>  
  15.     <name>mytag</name>  
  16.     <tag-class>com.common.tag.MyTag</tag-class>  
  17.     <body-content>JSP</body-content>  
  18.     <attribute>  
  19.       <description><![CDATA[Whether the result of this action (probably a view) should be executed/rendered]]></description>  
  20.       <name>first</name>  
  21.       <required>false</required>  
  22.       <rtexprvalue>false</rtexprvalue>  
  23.     </attribute>  
  24.     <attribute>  
  25.       <description><![CDATA[Whether the writer should be flush upon end of action component tag, default to true]]></description>  
  26.       <name>date</name>  
  27.       <required>false</required>  
  28.       <rtexprvalue>false</rtexprvalue>  
  29.     </attribute>  
  30. </tag>  
  31.   
  32.   
  33. <tag>  
  34. <name>mybodyTag</name>  
  35. <tag-class>com.common.tag.MyBodyTag</tag-class>  
  36. <body-content>JSP</body-content>  
  37.   
  38.  <attribute>  
  39.       <name>count</name>  
  40.       <required>false</required>  
  41.       <rtexprvalue>false</rtexprvalue>  
  42.     </attribute>  
  43. </tag>  
  44. </taglib>  
  45.        
night_china
关注
专栏目录
jsp标签源码jsp标签源码jsp标签源码
12-09
**JSP标签源码解析** JSP（JavaServer Pages）是一种动态网页技术，它允许开发者在HTML、XML或其他标记语言中嵌入Java代码，从而实现服务器端的逻辑处理。JSP标签是JSP的一种扩展机制，它使得页面设计更加结构化，...
自定义JSP标签
04-07
自定义JSP标签是Java服务器页面（JSP）技术中的一种高级特性，它允许开发者创建自己的可重用组件，以增强网页的可维护性和代码复用性。在JSP中，自定义标签与HTML标签类似，但它们可以执行更复杂的业务逻辑，提供了...
JSP自定义标签
明思齐的博客
06-17 999
1. 标签语言特点 标签体 空标签： 2. 自定义标签的开发及使用步骤1）创建一个标签助手类(继承BodyTagSupport)标签属性必须与助手类的属性对应、且要提供对应get/set方法2）创建标签库描述文件(tld)，添加自定义标签的配置 3）在页面通过taglib指令导入标签库，并通过指定后缀访问自定义标签3、标签生命周期 流程A：.........
JSP Tag
whitesock
02-18 95
本文基于Apache Tomcat v5.0。 1 Tag handler 1．1 重用    Tag handler被保存在org.apache.jasper.runtime.TagHandlerPool对象池中，以下是TagHandlerPool的几个方法：   public TagHandlerPool() 用缺省容量构造TagHandlerPool public Tag ...
JSP学习-09-自定义标签
weixin_34114823的博客
10-16 117
JSP 自定义标签 自定义标签是用户定义的JSP语言元素。当JSP页面包含一个自定义标签时将被转化为servlet，标签转化为对被 称为tag handler的对象的操作，即当servlet执行时Web container调用那些操作。 JSP标签扩展可以让你创建新的标签并且可以直接插入到一个JSP页面。 JSP 2.0规范中引入Simple Tag Handlers来编写这些自定义标记。 ...
JSP(二)
yangzongzhuan的专栏
12-09 1123
自定义标签: 1.为什么用自定义标签 第一，用自定义标签可以增加jsp文件的维护性能 第二，用于处理复杂的业务逻辑，并提高可重用性   2.工作原理： 第一，我们需要在tld文件中定义标签 第二，这些定义好的标签到底能做什么需要由标签处理器来负责，所以要创建一个标签处理器 第三，在一个jsp文件中使用自定义标签，需要先引入这个标签的标签库，并指定前缀名，然后直接使用   当我们
JSP（二）
Sara_2007的专栏
07-10 717
   来自：http://blog.csdn.net/yuchen2008/archive/2007/03/30/1546460.aspx      JSP（二）自定义标签:1.为什么用自定义标签第一，用自定义标签可以增加jsp文件的维护性能第二，用于处理复杂的业务逻辑，并提高可重用性 2.工作原理：第一，我们需要在tld文件中定义标签第二，这些定义好的标签
JSP标签
qq_67669509的博客
04-05 1834
1.什么是jsp标签？ 是一种注释文本的语言，以便于计算机操作。例如：HTML,XML,XHTML,VMl等待。 2.jsp的标签库 封装通用功能 3.处理流程 jsp自定义标签生命周期 4.如何自定义标签 ①编写助手类 ②编写标签库描述标签（tld） ③在页面上引入标签使用 (tagdemo包 下面标签的类 lib下面的mytag.tld tagtest.jsp) outTag标签类（创建助手类） package com.zking.je09.tagdemo.tag;...
jsp标签详解
bihansheng2010的博客
09-10 4126
学习jsp不得不学习jsp标签，一般来说，对于一个jsp开发者，可以理解为jsp页面中出现的java代码越少，对jsp的掌握就越好，而替换掉java代码的重要方式就是使用jsp标签。  jsp标签的分类： 　　1）内置标签（动作标签）： 不需要在jsp页面导入标签 　　2）jstl标签： 需要在jsp页面中导入标签 　　3）自定义标签 ： 开发者自行定义，需要在jsp页面导入标签   1...
jsp标签
LFSenior
07-27 3484
1、jsp标签 8.1 jsp标签的作用 jsp标签作用：替换jsp脚本。 1）流程判断（if   for循环） 2）跳转页面（转发，重定向） 3）。。。。。   8.2 Jsp标签分类 1）内置标签（动作标签）： 不需要在jsp页面导入标签 2）jstl标签： 需要在jsp页面中导入标签 3）自定义标签 ： 开发者自行定义，需要在jsp页面导入标签 8.3
如何在JavaScript中使用JSP标签
独码乐，不如众码乐，乐享其中
03-17 1751
面对“古老”的项目，延续其生命并发挥最大价值，是件很苦逼的事儿。如何在JS中使用JSP标签？如何使ES6模板字符串 含有 JSP标签、EL表达式、JS变量 正常识别？如何解决JSP的EL表达式和 ES6模板字符串 语法冲突？本文将遇到的几处难点做梳理、并结合实际案例深入剖析。
jsp标签解析与示例
03-05
博文链接：https://congpeixue.iteye.com/blog/158164
第四周实践课-课堂笔记.pdf
09-16
第四周实践课-课堂笔记
第5周玩转案例分析(2).pdf
09-16
第5周玩转案例分析(2)
第7周实践课安排.pdf
09-16
第7周实践课安排
基于MATLAB m编程的发动机最优工作曲线计算程序（OOL），在此工作曲线下，发动机燃油消耗最小 文件内含：1、发动机最优工
09-16
基于MATLAB m编程的发动机最优工作曲线计算程序（OOL），在此工作曲线下，发动机燃油消耗最小。 文件内含：1、发动机最优工作曲线计算程序m文件；2、发动机万有特性数据excel文件 注：附赠电机效率map绘制程序（m程序）与对应电机效率map数据（excel ）
前端监控SDK，可用来收集并上报：代码报错、性能数据、页面录屏、用户行为、白屏检测等个性化指标数据_web-see.zip
最新发布
09-16
前端监控SDK，可用来收集并上报：代码报错、性能数据、页面录屏、用户行为、白屏检测等个性化指标数据_web-see
自定义JSP标签详解与实践
"关于JSP标签的详细解释与实践" 在Java服务器页面（JSP）技术中，自定义标签（Tag）是一种强大的工具，它允许开发者创建可重用的代码片段，以提高代码的可读性和可维护性。"jsp标签说明"主要探讨了如何创建和使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值