moyanxuan_1993_2_24
moyanxuan_1993_2_24

自定义标签&&JSTL标签库详解

今天来看一下自定义标签的内容，自定义标签是JavaWeb的一部分非常重要的核心功能，我们之前就说过，JSP规范说的很清楚，就是Jsp页面中禁止编写一行Java代码，就是最好不要有Java脚本片段，下面就来看一下自定义标签的简介：

自定义标签主要用于移除Jsp页面中的java代码。
移除jsp页面中的java代码，只需要完成两个步骤：
编写一个实现Tag接口的Java类，并覆盖doStartTag方法，把jsp页面中的java代码写到doStartTag方法中。
编写标签库描述符（tld）文件，在tld文件中对自定义标签进行描述。
完成以上操作，即可在JSP页面中导入和使用自定义标签。
快速入门：使用自定义标签输出客户机IP
查看tag接口api文档，分析自定义标签的执行流程。


下面来看一下一个简单的Demo使用自定义标签打印客户机的IP地址

首先我们自定义标签类：ViewIpTag

[java]  view plain copy
  1. package com.weijia.traditionaltag;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.http.HttpServletRequest;  
  6. import javax.servlet.jsp.JspException;  
  7. import javax.servlet.jsp.JspWriter;  
  8. import javax.servlet.jsp.tagext.TagSupport;  
  9.   
  10. /** 
  11.  * 自定义标签，然后将这个标签映射到这个类:mytag:viewIP 
  12.  * 记得将自定义的标签绑定到一个url上面，这个url一般是公司的网址 
  13.  *  
  14.  */  
  15. public class ViewIpTag extends TagSupport{  
  16.   
  17.     private static final long serialVersionUID = 1L;  
  18.   
  19.     @Override  
  20.     public int doStartTag() throws JspException {  
  21.         //内置一个pageContext对象，我们之前说到pageContext对象，它里面是封装了9个隐式对象  
  22.         HttpServletRequest request = (HttpServletRequest)this.pageContext.getRequest();  
  23.         JspWriter out = this.pageContext.getOut();  
  24.         String ip = request.getRemoteAddr();  
  25.         try {  
  26.             out.print(ip);  
  27.         } catch (IOException e) {  
  28.             throw new RuntimeException(e);  
  29.         }  
  30.         return super.doStartTag();  
  31.     }  
  32.   
  33. }  

自定义tld文件,mytag.tld

[html]  view plain copy
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2.   
  3. <taglib xmlns="http://java.sun.com/xml/ns/j2ee"  
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd"  
  6.     version="2.0">  
  7.       
  8.   <description>JSTL 1.1 core library</description>  
  9.   <display-name>JSTL core</display-name>  
  10.   <tlib-version>1.1</tlib-version>  
  11.   <short-name>weijia</short-name>  
  12.   <uri>http://www.weijia.cn/mytag</uri>  
  13.   
  14.   <!-- 显示IP地址 -->  
  15.   <tag>  
  16.     <description>  
  17.         Catches any Throwable that occurs in its body and optionally  
  18.         exposes it.  
  19.     </description>  
  20.     <name>viewIP</name>  
  21.     <tag-class>com.weijia.traditionaltag.ViewIpTag</tag-class>  
  22.     <body-content>empty</body-content>  
  23.   </tag>  
  24. </taglib>  
这里我们将就自定义的标签类就注册好了，下面解释一下这些字段的含义：

首先看一下：

<short-name>这个标签是指定我们定义标签的简称，这个作用不大

<uri>这个标签是给这个标签文件指定一个访问路径，这个路径我们在Jsp页面中引入这个标签的时候需要用到

<tag-class>这个标签就是指定我们自定义的标签类的全称

<body-content>这个标签表明自定义标签是否有标签体内容(empty:没有,JSP:有)


我们注册之后标签类了，下面就在Jsp页面中进行使用了，这时候就要用到我们之前说到的Jsp的指令中的taglib了，格式如下：

[html]  view plain copy
  1. <%@ taglib uri="http://www.weijia.cn/mytag" prefix="mytag" %>  
这个就将我们定义的标签引入到Jsp页面中了，其中我们uri属性的值就是我们在标签定义文件mytag.tld中指定的那个uri那个标签值，当然这里的uri也可以直接指定mytag.tld文件的路径即：/WEB-INF/mytag.tld 也是可以的，其实我们查看翻译之后的Jsp代码可以看到，不管用那种方式，他其实加载的时候都是去找真是路径中文件：

自定义标签&&JSTL标签库详解_第1张图片

其中prefix属性的值是标签前缀名，这个名称就是我们在Jsp页面中使用的标签前缀，这个值一般和tld文件的文件名是保持一致的


下面就是在Jsp中使用标签：

[html]  view plain copy
  1. 客户机的IP地址是:<mytag:viewIP/>  
这样就是打印了客户机的IP地址，这里我们在Jsp页面中就没有Java代码了


上面我们介绍了一个简单的例子，下面我们来详细看一下这个自定义标签的执行原理：

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方法。

我可以查看我们上面的例子翻译后的Jsp代码：

[java]  view plain copy
  1. out.write("<body>  \r\n");  
  2. out.write("\t<!-- 显示客户机的IP地址 -->\r\n");  
  3. out.write("\t客户机的IP地址是:");  
  4. if (_jspx_meth_mytag_005fviewIP_005f0(_jspx_page_context))  
  5.     return;  
  6. out.write("\r\n");  
  7. out.write("\t\r\n");  


再来看一下那个if中的方法的代码：

[java]  view plain copy
  1. private boolean _jspx_meth_mytag_005fviewIP_005f0(PageContext _jspx_page_context)  
  2.           throws Throwable {  
  3.     PageContext pageContext = _jspx_page_context;  
  4.     JspWriter out = _jspx_page_context.getOut();  
  5.     //  mytag:viewIP  
  6.     com.weijia.traditionaltag.ViewIpTag _jspx_th_mytag_005fviewIP_005f0 = (com.weijia.traditionaltag.ViewIpTag) _005fjspx_005ftagPoo    l_005fmytag_005fviewIP_005fnobody.get(com.weijia.traditionaltag.ViewIpTag.class);  
  7.     _jspx_th_mytag_005fviewIP_005f0.setPageContext(_jspx_page_context);  
  8.     _jspx_th_mytag_005fviewIP_005f0.setParent(null);  
  9.     int _jspx_eval_mytag_005fviewIP_005f0 = _jspx_th_mytag_005fviewIP_005f0.doStartTag();  
  10.     if (_jspx_th_mytag_005fviewIP_005f0.doEndTag() == javax.servlet.jsp.tagext.Tag.SKIP_PAGE) {  
  11.       _005fjspx_005ftagPool_005fmytag_005fviewIP_005fnobody.reuse(_jspx_th_mytag_005fviewIP_005f0);  
  12.       return true;  
  13.     }  
  14.     _005fjspx_005ftagPool_005fmytag_005fviewIP_005fnobody.reuse(_jspx_th_mytag_005fviewIP_005f0);  
  15.     return false;  
  16.   }  
我们可以看到，首先这个方法接收的是一个pageContext变量对象，这个和我们之前说的一样，自定义标签类中有一个pageContext变量对象就可以操作其他对象了，下面来看一下那个方法的代码，首先他会去加载那个标签类，同时注意到首先是执行setPageContext()方法的，将pageContext变量传递到标签类中，然后看setParent()方法传递的是null,因为我们打印IP的标签没有父标签的，接下来执行doStartTag()方法，然后再执行doEndTag()方法，这里我们看到是做个判断，如果doEndTag方法返回的值是Tag.SKIP_PAGE的话，就是说余下的jsp页面不执行了，所以返回一个true,那么我们看到上面的if判断代码中，如果这个方法返回true的话，直接return，下面的代码就不执行了。大体流程就是这样的。


下面我们用自定义标签来实现一些特定需求的功能：

1、不执行标签体内容

自定义标签类：

[java]  view plain copy
  1. package com.weijia.traditionaltag;  
  2.   
  3. import javax.servlet.jsp.JspException;  
  4. import javax.servlet.jsp.tagext.TagSupport;  
  5.   
  6. /** 
  7.  * 是否输出标签体内容 
  8.  * @author weijiang204321 
  9.  * 
  10.  */  
  11. public class TagDemo1 extends TagSupport{  
  12.   
  13.     @Override  
  14.     public int doStartTag() throws JspException {  
  15.         return TagSupport.EVAL_BODY_INCLUDE;//输出标签体内容  
  16.         //return TagSupport.SKIP_BODY;//不输出标签体内容  
  17.     }  
  18.   
  19. }  

我们看到只要doStartTag方法返回TagSupport.EVAL_BODY_INCLUDE常量，就会执行标签体内容，如果返回的是TagSupport.SKIP_BODY常量，就不会执行标签体内容，代码很简单。


下面我们再来注册这个标签类：

[html]  view plain copy
  1. <!-- 是否显示标签体 -->  
  2.  <tag>  
  3.    <description>  
  4.        Catches any Throwable that occurs in its body and optionally  
  5.        exposes it.  
  6.    </description>  
  7.    <name>demo1</name>  
  8.    <tag-class>com.weijia.traditionaltag.TagDemo1</tag-class>  
  9.    <body-content>JSP</body-content>  
  10.  </tag>  

因为是有标签体内容的，所以<body-content>标签的值是JSP


在Jsp页面中使用：

[html]  view plain copy
  1. <!-- 不执行标签体 -->  
  2. <simpletag:demo1>  
  3.     aaaa  
  4. </simpletag:demo1>  


2、控制JSP余下页面的内容不执行

自定义标签类：

[java]  view plain copy
  1. package com.weijia.traditionaltag;  
  2.   
  3. import javax.servlet.jsp.JspException;  
  4. import javax.servlet.jsp.tagext.TagSupport;  
  5.   
  6. /** 
  7.  * 控制整个JSP是否输出 
  8.  * @author weijiang204321 
  9.  * 
  10.  */  
  11. public class TagDemo2 extends TagSupport{  
  12.   
  13.     @Override  
  14.     public int doStartTag() throws JspException {  
  15.         return super.doStartTag();  
  16.     }  
  17.   
  18.     @Override  
  19.     public int doEndTag() throws JspException {  
  20.         return TagSupport.EVAL_PAGE;  
  21.         //return TagSupport.SKIP_PAGE;不执行余下的jsp内容  
  22.     }  
  23.   
  24. }  
当doEndTag方法返回的是TagSupport.EVAL_PAGE常量的话就执行jsp余下的内容，如果返回的是TagSupport.SKIP_PAGE常量的话就不执行jsp余下的内容


在tld文件中注册这个自定义标签类：

[html]  view plain copy
  1. <!-- 控制是否显示jsp页面 -->  
  2. <tag>  
  3.   <description>  
  4.       Catches any Throwable that occurs in its body and optionally  
  5.       exposes it.  
  6.   </description>  
  7.   <name>demo2</name>  
  8.   <tag-class>com.weijia.traditionaltag.TagDemo2</tag-class>  
  9.   <body-content>empty</body-content>  
  10. </tag>  

在JSP页面中使用：

[html]  view plain copy
  1. <!-- 不执行余下的页面内容 -->  
  2. <simpletag:demo2/>  
这样使用之后，在这个标签之后的内容就不会执行了，我们在上面分析源代码的时候已经解析过了。页面都不会含有余下的内容了，如果我们将这个标签放在页面的第一行，那么这个页面就是一片空白，我们在浏览器中查看页面的源代码，也是发现一片空白的，因为out对象没有进行print了


3、重复执行标签体内容

自定义标签体类：

[java]  view plain copy
  1. package com.weijia.traditionaltag;  
  2.   
  3. import javax.servlet.jsp.JspException;  
  4. import javax.servlet.jsp.tagext.TagSupport;  
  5.   
  6. /** 
  7.  * 控制标签体重复执行 
  8.  * @author weijiang204321 
  9.  * 
  10.  */  
  11. public class TagDemo3 extends TagSupport{  
  12.   
  13.     private int count = 5;  
  14.       
  15.     @Override  
  16.     public int doStartTag() throws JspException {  
  17.         return TagSupport.EVAL_BODY_INCLUDE;  
  18.     }  
  19.       
  20.     @Override  
  21.     public int doAfterBody() throws JspException {  
  22.         count--;  
  23.         if(count > 0){  
  24.             return TagSupport.EVAL_BODY_AGAIN;//执行完之后接着执行doAfterBody()方法  
  25.         }else{  
  26.             return TagSupport.SKIP_BODY;  
  27.         }  
  28.     }  
  29.   
  30.     @Override  
  31.     public int doEndTag() throws JspException {  
  32.         return TagSupport.SKIP_BODY;  
  33.     }  
  34.   
  35. }  

这里我们需要在doAfterBody方法中操作了，因为这个方法的返回值为TagSupport.EVAL_BODY_AGAIN常量的话，这个方法还会被调用，直到这个方法返回TagSupport.SKIP_BODY，所以我们这里控制标签体内容执行5次，我们定义一个变量就可以了，然后控制doAfterBody方法的返回值，这里还要注意的是，在doStartTag方法中返回值是TagSupport.EVAL_BODY_INCLUDE常量，因为我们要执行标签体内容的。


注册自定义标签类：

[html]  view plain copy
  1. <!-- 控制标签体重复输出 -->  
  2. <tag>  
  3.   <description>  
  4.       Catches any Throwable that occurs in its body and optionally  
  5.       exposes it.  
  6.   </description>  
  7.   <name>demo3</name>  
  8.   <tag-class>com.weijia.traditionaltag.TagDemo3</tag-class>  
  9.   <body-content>JSP</body-content>  
  10. </tag>  

在Jsp页面中使用：

[html]  view plain copy
  1. <!-- 重复执行标签体内容 -->  
  2. <simpletag:demo3>  
  3.     aaaa  
  4. </simpletag:demo3>  
这时候在页面中就会输出5个aaaa


4、修改标签体内容

自定义标签类：

[java]  view plain copy
  1. package com.weijia.traditionaltag;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.jsp.JspException;  
  6. import javax.servlet.jsp.tagext.BodyContent;  
  7. import javax.servlet.jsp.tagext.BodyTagSupport;  
  8.   
  9. /** 
  10.  * 修改标签体内容 
  11.  * @author weijiang204321 
  12.  * 
  13.  */  
  14. public class TagDemo4 extends BodyTagSupport{  
  15.   
  16.     @Override  
  17.     public int doEndTag() throws JspException {  
  18.         BodyContent bc = this.getBodyContent();//获取标签体内容对象  
  19.         String content = bc.getString();  
  20.         content = content.toUpperCase();//将标签体内容转成大写  
  21.         try {  
  22.             this.pageContext.getOut().write(content);//在将转化之后的内容输出到浏览器中  
  23.         } catch (IOException e) {  
  24.             throw new RuntimeException(e);  
  25.         }  
  26.         return BodyTagSupport.EVAL_BODY_INCLUDE;  
  27.     }  
  28.   
  29.     @Override  
  30.     public int doStartTag() throws JspException {  
  31.         return BodyTagSupport.EVAL_BODY_BUFFERED;//这里返回缓存标签体内容常量  
  32.     }  
  33.   
  34. }  

这里我们要注意的是，我们继承的是BodyTagSupport类了，要在doStartTag方法中返回BodyTagSupport.EVAL_BODY_BUFFERED常量，才可以取出标签体内容缓存，然后再doEndTag方法中取出标签体内容然后进行操作之后再写到浏览器中。


注册我们的自定义标签类：

[html]  view plain copy
  1. <!-- 修改标签体内容 -->  
  2.   <tag>  
  3.     <description>  
  4.         Catches any Throwable that occurs in its body and optionally  
  5.         exposes it.  
  6.     </description>  
  7.     <name>demo4</name>  
  8.     <tag-class>com.weijia.traditionaltag.TagDemo4</tag-class>  
  9.     <body-content>JSP</body-content>  
  10.   </tag>  

在Jsp页面中使用：

[html]  view plain copy
  1. <!-- 修改标签体内容 -->  
  2. <simpletag:demo4>  
  3.     bbbb  
  4. </simpletag:demo4>  
这时候在浏览器中输出的是：BBBB


上面说到的是Jsp2.0以前的自定义标签的方法，从Jsp2.0以后，我们就开始使用了简单标签类SimpleTagSupport，因为我们可以看到Jsp2.0之前的是传统标签类的话，要想实现不同的功能，还需要继承不同的类，比如：TagSupport,BodyTagSupport，这样会增加开发成本，所以Jsp2.0之后引入了简单标签类SimpleTagSupport了，那么下面我们先来看一下简单标签的执行流程：

由于传统标签使用三个标签接口来完成不同的功能，显得过于繁琐，不利于标签技术的推广， SUN公司为降低标签技术的学习难度，在JSP 2.0中定义了一个更为简单、便于编写和调用的SimpleTag接口来实现标签的功能。实现SimpleTag接口的标签通常称为简单标签。简单标签共定义了5个方法：
setJspContext方法
setParent和getParent方法
setJspBody方法
doTag方法

下面来看一下这些方法的解释
setJspContext方法
用于把JSP页面的pageContext对象传递给标签处理器对象 
setParent方法
用于把父标签处理器对象传递给当前标签处理器对象 
getParent方法
用于获得当前标签的父标签处理器对象 
setJspBody方法
用于把代表标签体的JspFragment对象传递给标签处理器对象 
doTag方法
用于完成所有的标签逻辑，包括输出、迭代、修改标签体内容等。在doTag方法中可以抛出javax.servlet.jsp.SkipPageException异常，用于通知WEB容器不再执行JSP页面中位于结束标记后面的内容，这等效于在传统标签的doEndTag方法中返回Tag.SKIP_PAGE常量的情况。 

当web容器开始执行标签时，会调用如下方法完成标签的初始化
WEB容器调用标签处理器对象的setJspContext方法，将代表JSP页面的pageContext对象传递给标签处理器对象。
WEB容器调用标签处理器对象的setParent方法，将父标签处理器对象传递给这个标签处理器对象。注意，只有在标签存在父标签的情况下，WEB容器才会调用这个方法。
如果调用标签时设置了属性，容器将调用每个属性对应的setter方法把属性值传递给标签处理器对象。如果标签的属性值是EL表达式或脚本表达式，则WEB容器首先计算表达式的值，然后把值传递给标签处理器对象。
如果简单标签有标签体，容器将调用setJspBody方法把代表标签体的JspFragment对象传递进来。
执行标签时：
容器调用标签处理器的doTag()方法，开发人员在方法体内通过操作JspFragment对象，就可以实现是否执行、迭代、修改标签体的目的。

javax.servlet.jsp.tagext.JspFragment类是在JSP2.0中定义的，它的实例对象代表JSP页面中的一段符合JSP语法规范的JSP片段，这段JSP片段中不能包含JSP脚本元素。

WEB容器在处理简单标签的标签体时，会把标签体内容用一个JspFragment对象表示，并调用标签处理器对象的setJspBody方法把JspFragment对象传递给标签处理器对象。JspFragment类中只定义了两个方法，如下所示：

getJspContext方法
用于返回代表调用页面的JspContext对象.

public abstract void invoke(java.io.Writer out) 
用于执行JspFragment对象所代表的JSP代码片段
参数out用于指定将JspFragment对象的执行结果写入到哪个输出流对象中，如果传递给参数out的值为null，则将执行结果写入到JspContext.getOut()方法返回的输出流对象中。(简而言之，可以理解为写给浏览器)

JspFragment.invoke方法可以说是JspFragment最重要的方法，利用这个方法可以控制是否执行和输出标签体的内容、是否迭代执行标签体的内容或对标签体的执行结果进行修改后再输出。例如：
在标签处理器中如果没有调用JspFragment.invoke方法，其结果就相当于忽略标签体内容；
在标签处理器中重复调用JspFragment.invoke方法，则标签体内容将会被重复执行；
若想在标签处理器中修改标签体内容，只需在调用invoke方法时指定一个可取出结果数据的输出流对象（例如StringWriter），让标签体的执行结果输出到该输出流对象中，然后从该输出流对象中取出数据进行修改后再输出到目标设备，即可达到修改标签体的目的。


下面我们在来使用简单标签来实现上面的四个案例：

1、是否输出标签体内容

自定义标签类：

[java]  view plain copy
  1. package com.weijia.sampletag;  
  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.  * 控制标签体是否执行 
  11.  * @author weijiang204321 
  12.  * 
  13.  */  
  14. public class SimpleTagDemo1 extends SimpleTagSupport{  
  15.   
  16.     @Override  
  17.     public void doTag() throws JspException, IOException {  
  18.         JspFragment jf = this.getJspBody();  
  19.         //相当于jf.invoke(null);  
  20.         jf.invoke(this.getJspContext().getOut());  
  21.         //这里如果不想输出标签体内容的话，只需要不调用invoke方法即可  
  22.     }  
  23.   
  24. }  

我们看到这个和传统标签不一样，这里只有一个doTag方法了，在这个方法中我们通过是否调用jf.invoke方法来控制是否执行标签体内容，这里还有一个问题是如果我们想输出标签体内容，只需要调用invoke方法即可，同时这个方法传递的参数是一个Writer对象，所以如果我们想将标签体内容输出到浏览器中只需要传递out对象到这个方法即可，但是如果将这个方法的参数设置成null的话也是向浏览器中输出标签体内容的


注册标签体类：

[html]  view plain copy
  1. <!-- 是否显示标签体 -->  
  2.  <tag>  
  3.    <description>  
  4.        Catches any Throwable that occurs in its body and optionally  
  5.        exposes it.  
  6.    </description>  
  7.    <name>demo1</name>  
  8.    <tag-class>com.weijia.simpletag.SimpleTagDemo1</tag-class>  
  9.    <body-content>scriptless</body-content>  
  10.  </tag>  
这里的注册和传统标签不一样的就是<body-content>标签的值是scriptless而不是JSP了


在JSP页面使用：

[html]  view plain copy
  1. <simpletag:demo1>  
  2.     aaa  
  3. </simpletag:demo1>  


2、控制Jsp余下内容是否输出

自定义标签类：

[java]  view plain copy
  1. package com.weijia.sampletag;  
  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.  * 控制不执行余下的jsp内容 
  11.  * @author weijiang204321 
  12.  * 
  13.  */  
  14. public class SimpleTagDemo2 extends SimpleTagSupport{  
  15.   
  16.     @Override  
  17.     public void doTag() throws JspException, IOException {  
  18.         //直接抛出异常就不会执行余下的jsp内容  
  19.         throw new SkipPageException();  
  20.     }  
  21.   
  22. }  
我们只要在doTag方法中抛出一个SkipPageException异常就可以实现不执行余下的Jsp内容


注册标签类：

[html]  view plain copy
  1. <!-- 控制是否显示jsp页面 -->  
  2.  <tag>  
  3.    <description>  
  4.        Catches any Throwable that occurs in its body and optionally  
  5.        exposes it.  
  6.    </description>  
  7.    <name>demo2</name>  
  8.    <tag-class>com.weijia.simpletag.SimpleTagDemo2</tag-class>  
  9.    <body-content>empty</body-content>  
  10.  </tag>  

在Jsp页面中使用：
[html]  view plain copy
  1. <simpletag:demo2/>  
在这个标签之后的jsp页面内容就不会输出了


3、标签体重复执行

自定义标签类：

[java]  view plain copy
  1. package com.weijia.sampletag;  
  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.  * 迭代标签体 
  11.  * @author weijiang204321 
  12.  * 
  13.  */  
  14. public class SimpleTagDemo3 extends SimpleTagSupport{  
  15.   
  16.     @Override  
  17.     public void doTag() throws JspException, IOException {  
  18.         JspFragment jf = this.getJspBody();  
  19.         for(int i=0;i<5;i++){  
  20.             jf.invoke(null);  
  21.         }  
  22.     }  
  23.   
  24. }  
这里就比传统标签的操作简单了，直接写在for循环中，在循环中调用invoke方法即可


注册标签类：

[html]  view plain copy
  1. <!-- 控制标签体重复输出 -->  
  2. <tag>  
  3.   <description>  
  4.       Catches any Throwable that occurs in its body and optionally  
  5.       exposes it.  
  6.   </description>  
  7.   <name>demo3</name>  
  8.   <tag-class>com.weijia.simpletag.SimpleTagDemo3</tag-class>  
  9.   <body-content>scriptless</body-content>  
  10. </tag>  

在Jsp页面中使用：
[html]  view plain copy
  1. <simpletag:demo3>  
  2.     aaaa  
  3. </simpletag:demo3>  

4、修改标签体内容

[java]  view plain copy
  1. package com.weijia.sampletag;  
  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.  * 修改标签体 
  12.  * @author weijiang204321 
  13.  * 
  14.  */  
  15. public class SimpleTagDemo3 extends SimpleTagSupport{  
  16.   
  17.     @Override  
  18.     public void doTag() throws JspException, IOException {  
  19.         JspFragment jf = this.getJspBody();  
  20.         StringWriter sw = new StringWriter();  
  21.         jf.invoke(sw);  
  22.         String content = sw.toString();  
  23.         content = content.toUpperCase();  
  24.         this.getJspContext().getOut().write(content);  
  25.     }  
  26.   
  27. }  
我们将StringWriter对象传递到invoke方法中，然后再通过StringWriter对象得到标签体内容，进行操作，然后再通过out对象输出到浏览器中。


注册标签类：

[html]  view plain copy
  1. <!-- 修改标签体内容 -->  
  2. <tag>  
  3.   <description>  
  4.       Catches any Throwable that occurs in its body and optionally  
  5.       exposes it.  
  6.   </description>  
  7.   <name>demo4</name>  
  8.   <tag-class>com.weijia.simpletag.SimpleTagDemo4</tag-class>  
  9.   <body-content>scriptless</body-content>  
  10. </tag>  

在Jsp页面中使用：

[html]  view plain copy
  1. <!-- 修改标签体内容 -->  
  2. <simpletag:demo4>  
  3.     bbbb  
  4. </simpletag:demo4>  

这样我们就介绍了怎样使用传统标签和简单标签来编写自己的标签，这样我们就可以将任何java代码移到标签类中，然后在jsp页面中使用标签即可。那么最后再来看一下传统标签和简单标签的继承关系：

自定义标签&&JSTL标签库详解_第2张图片

1. JspTag接口

JspTag接口是所有自定义标签的父接口，它是JSP2.0中新定义的一个标记接口，没有任何属性和方法。JspTag接口有Tag和SimpleTag两个直接子接口，JSP2.0以前的版本中只有Tag接口，所以把实现Tag接口的自定义标签也叫做传统标签，把实现SimpleTag接口的自定义标签叫做简单标签。本书中如果没有特别说明，自定义标签泛指传统标签。

2. Tag接口

图6.5中的Tag接口是所有传统标签的父接口，其中定义了两个重要方法（doStartTag、doEndTag）方法和四个常量（EVAL_BODY_INCLUDE、SKIP_BODY、EVAL_PAGE、SKIP_PAGE），这两个方法和四个常量的作用如下：

（1）WEB容器在解释执行JSP页面的过程中，遇到自定义标签的开始标记就会去调用标签处理器的doStartTag方法，doStartTag方法执行完后可以向WEB容器返回常量EVAL_BODY_INCLUDE或SKIP_BODY。如果doStartTag方法返回EVAL_BODY_INCLUDE，WEB容器就会接着执行自定义标签的标签体；如果doStartTag方法返回SKIP_BODY，WEB容器就会忽略自定义标签的标签体，直接解释执行自定义标签的结束标记。

（2）WEB容器解释执行到自定义标签的结束标记时，就会调用标签处理器的doEndTag方法，doEndTag方法执行完后可以向WEB容器返回常量EVAL_PAGE或SKIP_PAGE。如果doEndTag方法返回常量EVAL_PAGE，WEB容器就会接着执行JSP页面中位于结束标记后面的JSP代码；如果doEndTag方法返回SKIP_PAGE，WEB容器就会忽略JSP页面中位于结束标记后面的所有内容。

从doStartTag和doEndTag方法的作用和返回值的作用可以看出，开发自定义标签时可以在doStartTag方法和doEndTag方法体内编写合适的Java程序代码来实现具体的功能，通过控制doStartTag方法和doEndTag方法的返回值，还可以告诉WEB容器是否执行自定义标签中的标签体内容和JSP页面中位于自定义标签的结束标记后面的内容。

2. IterationTag接口

IterationTag接口继承了Tag接口，并在Tag接口的基础上增加了一个doAfterBody方法和一个EVAL_BODY_AGAIN常量。实现IterationTag接口的标签除了可以完成Tag接口所能完成的功能外，还能够通知WEB容器是否重复执行标签体内容。对于实现了IterationTag接口的自定义标签，WEB容器在执行完自定义标签的标签体后，将调用标签处理器的doAfterBody方法，doAfterBody方法可以向WEB容器返回常量EVAL_BODY_AGAIN或SKIP_BODY。如果doAfterBody方法返回EVAL_BODY_AGAIN，WEB容器就会把标签体内容再重复执行一次，执行完后接着再调用doAfterBody方法，如此往复，直到doAfterBody方法返回常量SKIP_BODY，WEB容器才会开始处理标签的结束标记和调用doEndTag方法。

可见，开发自定义标签时，可以通过控制doAfterBody方法的返回值来告诉WEB容器是否重复执行标签体内容，从而达到循环处理标签体内容的效果。例如，可以通过一个实现IterationTag接口的标签来迭代输出一个集合中的所有元素，在标签体部分指定元素的输出格式。

在JSP API中也提供了IterationTag接口的默认实现类TagSupport，读者在编写自定义标签的标签处理器类时，可以继承和扩展TagSupport类，这相比实现IterationTag接口将简化开发工作。

3. BodyTag接口

BodyTag接口继承了IterationTag接口，并在IterationTag接口的基础上增加了两个方法（setBodyContent、doInitBody）和一个EVAL_BODY_BUFFERED常量。实现BodyTag接口的标签除了可以完成IterationTag接口所能完成的功能，还可以对标签体内容进行修改。对于实现了BodyTag接口的自定义标签，标签处理器的doStartTag方法不仅可以返回前面讲解的常量EVAL_BODY_INCLUDE或SKIP_BODY，还可以返回常量EVAL_BODY_BUFFERED。如果doStartTag方法返回EVAL_BODY_BUFFERED，WEB容器就会创建一个专用于捕获标签体运行结果的BodyContent对象，然后调用标签处理器的setBodyContent方法将BodyContent对象的引用传递给标签处理器，WEB容器接着将标签体的执行结果写入到BodyContent对象中。在标签处理器的后续事件方法中，可以通过先前保存的BodyContent对象的引用来获取标签体的执行结果，然后调用BodyContent对象特有的方法对BodyContent对象中的内容（即标签体的执行结果）进行修改和控制其输出。

在JSP API中也提供了BodyTag接口的实现类BodyTagSupport，读者在编写能够修改标签体内容的自定义标签的标签处理器类时，可以继承和扩展BodyTagSupport类，这相比实现BodyTag接口将简化开发工作。

4. SimpleTag接口

SimpleTag接口是JSP2.0中新增的一个标签接口。由于传统标签使用三个标签接口来完成不同的功能，显得过于繁琐，不利于标签技术的推广，因此，SUN公司为降低标签技术的学习难度，在JSP 2.0中定义了一个更为简单、便于编写和调用的SimpleTag接口。SimpleTag接口与传统标签接口最大的区别在于，SimpleTag接口只定义了一个用于处理标签逻辑的doTag方法，该方法在WEB容器执行自定义标签时调用，并且只被调用一次。那些使用传统标签接口所完成的功能，例如是否执行标签体、迭代标签体、对标签体内容进行修改等功能都可以在doTag方法中完成。关于SimpleTag接口的详细介绍本书将在第7章详细讲解。

在JSP API中也提供了SimpleTag接口的实现类SimpleTagSupport，读者在编写简单标签时，可以继承和扩展SimpleTagSupport类，这相比实现SimpleTag接口将简化开发工作。

 

为方便读者日后查询传统标签接口中的各个方法可以返回的返回值，笔者在表6.1列举了Tag接口、IterationTag接口和BodyTag接口中的主要方法及它们分别可以返回的返回值的说明。

自定义标签&&JSTL标签库详解_第3张图片


下面我们来看一下如何开发一个具有属性的自定义标签的内容：

要想让一个自定义标签具有属性，通常需要完成两个任务：
在标签处理器中编写每个属性对应的setter方法
在TLD文件中描术标签的属性
为自定义标签定义属性时，每个属性都必须按照JavaBean的属性命名方式，在标签处理器中定义属性名对应的setter方法，用来接收JSP页面调用自定义标签时传递进来的属性值。 例如属性url，在标签处理器类中就要定义相应的setUrl(String url)方法。
在标签处理器中定义相应的set方法后，JSP引擎在解析执行开始标签前，也就是调用doStartTag方法前，会调用set属性方法，为标签设置属性。

在TLD文件中的描述规格是为：

<tag>元素的<attribute>子元素用于描述自定义

标签的一个属性，自定义标签所具有的每个属性

都要对应一个<attribute>元素 。

<attribute>

  <description>description</description>

  <name>aaaa</name>

  <required>true</required>

  <rtexprvalue>true</rtexprvalue>

  <type>ObjectType</type>

</attribute>


其中的各个属性值的含义如下：

自定义标签&&JSTL标签库详解_第4张图片


那么下面就来看一个实例，通过一个属性值来控制标签体的内容输出的次数：

自定义标签类：

[java]  view plain copy
  1. package com.weijia.propertytag;  
  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. public class PropertyTag extends SimpleTagSupport{  
  10.   
  11.     private int count = 0;  
  12.       
  13.     public void setCount(int count){  
  14.         this.count = count;  
  15.     }  
  16.       
  17.     @Override  
  18.     public void doTag() throws JspException, IOException {  
  19.         JspFragment jf = this.getJspBody();  
  20.         for(int i=0;i<count;i++){  
  21.             jf.invoke(null);  
  22.         }  
  23.     }  
  24.   
  25. }  
这里需要定义一个变量来记录执行的次数，同时还需要提供set方法


注册这个标签：

[html]  view plain copy
  1. <tag>  
  2.     <description>  
  3.         Catches any Throwable that occurs in its body and optionally  
  4.         exposes it.  
  5.     </description>  
  6.     <name>demo</name>  
  7.     <tag-class>com.weijia.propertytag.PropertyTag</tag-class>  
  8.     <body-content>scriptless</body-content>  
  9.     <attribute>  
  10.         <description>  
  11.             Name of the exported scoped variable for the  
  12.             exception thrown from a nested action. The type of the  
  13.             scoped variable is the type of the exception thrown.  
  14.         </description>  
  15.         <name>count</name>  
  16.         <required>true</required>  
  17.         <rtexprvalue>true</rtexprvalue>  
  18.     </attribute>  
  19.   </tag>  
我们这里设置这个属性的名称是count,而且这个属性在标签中是必须设置的，同时这个标签可以使用表达式


在Jsp页面中使用：

[html]  view plain copy
  1. <propertytag:demo count="9">  
  2.     aaaaa  
  3. </propertytag:demo>  
在页面中输出9次aaaaa


虽然我们这里看到了输出的很简单，设置也很简单，但是这里面还是有很多内容的

首先来看一下，我们在Jsp页面中输入的是字符串，但是我们定义的count是int类型，没有报错，所以这里他做了类型转换，当然这个不是能够转换所有的类型的，只能转化8中基本类型，比如我们定义了一个属性是Date类型的，当我们在Jsp页面中传递"1990-08-01"这样就会报错的，当然我们可以使用脚本表达式进行属性的赋值是可以的，比如：

[html]  view plain copy
  1. <propertytag:demo count="<%=new Date()%>">  
  2.     aaaaa  
  3. </propertytag:demo>  

在来看一下，他是怎么定位到属性count的，这个其实在学习Java基础知识的时候就说过，在学习JavaBean的相关知识的时候，我们知道一个Bean对象的属性的概念，比如这里我们定义了一个count变量，同时设置了他的set方法，那么这个count就是一个属性，但是属性的概念不是通过变量名来定义的，而是通过set方法来定义的，比如我们这里可以将count变量名改成counts，但是setCount方法名不变，我们运行程序，仍然不会报错的，但是我们将setCount方法名改成setCounts的时候，运行程序就报错了，原因也很好理解，他在进行变量count进行设置值的时候，会通过set方法来进行设置，这时候就会通过setXXX来找到相对应的set方法，从而能够对每个变量的值设置正确。这个相关内容其实我们在之前介绍<jsp:setProperty>标签的时候讲到过，这个技术在JavaWeb中很常用的，专门用来操作Bean对象的(内省技术BeanUtils)


介绍完自定义标签的属性的相关知识后，接下来我们就来看看JSTL给我们提供的标签库，JSTL标签库可以分为以下几种：

1.核心标签库 
2.国际化标签
3.数据库标签 
4.XML标签
5.JSTL函数(EL函数)

现在用到最多的就是核心标签库和JSTL函数库了，其他的三种标签不是很常用(几乎抛弃)，所以这里就不做太多的介绍。


下面就先来看一下JSTL的核心标签库了，我们在使用JSTL标签库的时候需要导入两个jar：jstl.jar和standard.jar

我们在导入包之后我们可以查看他的tld标签描述文档的：

自定义标签&&JSTL标签库详解_第5张图片

我们看到他的核心库是c.tld，函数库是fn.tld，这样我们就可以通过这些标签描述文档中查找到有哪些标签可以使用，以及使用的方法

自定义标签&&JSTL标签库详解_第6张图片

我们看到了c.tld标签说明文件的uri是http://java.sun.com/jsp/jstl/core，所以我们如果要使用这个标签的话就只要在jsp中引入即可：

[html]  view plain copy
  1. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>  
前期工作搞定了，下面就来详细看一下每个标签的具体使用方法：

1、c:out标签的使用：

<c:out> 标签用于输出一段文本内容到pageContext对象当前保存的“out”对象中

自定义标签&&JSTL标签库详解_第7张图片

用法：

[html]  view plain copy
  1. <!-- c:out标签 -->  
  2.     <!-- 输出给浏览器，但是没必要这样输出是没意义的，可以直接输出的aaaaaa -->  
  3.     <c:out value="aaaa"></c:out>  
  4.     <!-- 转义之后输出/默认值，这样c:out标签才有意义-->  
  5.     <c:out value="<a href=''>点点</a>" default="aaa" escapeXml="true"></c:out>  
  6.     <%  
  7.         request.setAttribute("data","xxx");  
  8.      %>  
  9.      <c:out value="${data}" default="aaa"></c:out>  
这个标签很简单的，就是就是向浏览器中直接输出内容的，那么这个和使用EL表达式输出有什么区别呢，他有什么特别的好处呢？

他的好处就在于default和escapeXml这两个属性的使用，default属性可以设置输出的默认值，我们知道EL表达式在各个域中如果找不到属性值就会输出空字符串，但是我们通过这个属性就可以设置当从所有的域中找不到相应的属性值，就会输出默认值，同时还有一个escapeXml这个属性值，这个属性进行输出内容进行html转义，我们之前都是通过一个方法进行转义的：

[java]  view plain copy
  1. private String htmlFilter(String message){  
  2.     if(message == null){  
  3.         return null;  
  4.     }  
  5.       
  6.     char[] content = new char[message.length()];  
  7.     message.getChars(0, message.length(), content, 0);  
  8.     StringBuffer result = new StringBuffer(message.length()+50);  
  9.     for(int i=0;i<content.length;i++){  
  10.         switch(content[i]){  
  11.         case '<':  
  12.             result.append("<");  
  13.             break;  
  14.         case '>':  
  15.             result.append(">");  
  16.             break;  
  17.         case '&':  
  18.             result.append("&");  
  19.             break;  
  20.         case '"':  
  21.             result.append(""");  
  22.             break;  
  23.         default:  
  24.             result.append(content[i]);  
  25.         }  
  26.     }  
  27.     return result.toString();  
  28. }  
只要设置这个属性值为true的话，我们就不需要手动的进行转义了，所以说这个标签还是有他特定的功能的，可不能忘记他呀！


2、c:set标签

<c:set>标签用于把某一个对象存在指定的域范围内，或者设置Web域中的java.util.Map类型的属性对象或JavaBean类型的属性对象的属性

自定义标签&&JSTL标签库详解_第8张图片

用法：

[html]  view plain copy
  1. <!-- c:set标签 -->  
  2.     <!-- 向page域中存入到xxx -->  
  3.     <c:set var="data" value="xxx" scope="page"/>  
  4.     ${data}  
  5.     <!-- 向map中存入数据 -->  
  6.     <%  
  7.         Map map = new HashMap();  
  8.         request.setAttribute("map",map);  
  9.      %>  
  10.      <c:set property="name" value="uuu" target="${map}"/>  
  11.      ${map.name}  
  12.      <!-- 向javabean中存入数据 -->  
  13.      <%  
  14.         Person p = new Person();  
  15.         request.setAttribute("p",p);  
  16.       %>  
  17.      <c:set property="name" value="uuu" target="${p}"/>  
  18.      ${p.name}  
这个标签可以指定在四个域中设置属性值，同时设置的对象不仅只有基本类型，还可以设置对象类型，集合类型


3、c:remove标签

这个标签可以在四个域中删除指定的属性

其语法格式如下：
<c:remove var="varName" 
[scope="{page|request|session|application}"] /> 

用法：

[html]  view plain copy
  1. <!-- c:remove标签 -->  
  2.   <!-- 删除属性 -->  
  3.   <%  
  4.     request.setAttribute("data","xxx");  
  5.   %>  
  6.   <c:remove var="data" scope="request"/>  

4、c:catch标签

<c:catch>标签用于捕获嵌套在标签体中的内容抛出的异常，

其语法格式如下：

<c:catch [var="varName"]>nested actions</c:catch>
var属性用于标识<c:catch>标签捕获的异常对象，它将保存在page这个Web域中

用法：

[html]  view plain copy
  1. <!-- c:catch异常捕获 -->  
  2.      <!--var是存入异常对象的关键字 -->  
  3.      <c:catch var="myex">  
  4.      <%  
  5.         int x = 1/0;  
  6.      %>  
  7.      </c:catch>  
  8.      <!-- 异常对象必须要有message属性 -->  
  9.      ${myex.message}  

5、c:if标签

这个标签是控制标签内容的输出

自定义标签&&JSTL标签库详解_第9张图片

用法：

[html]  view plain copy
  1. <!-- c:if -->  
  2.     <!-- 将判断结果以aaa为关键字存入到域中 -->  
  3.     <%  
  4.         request.setAttribute("user",null);  
  5.      %>  
  6.      ${user}  
  7.     <c:if var="aaa" test="${user == null}",scope="page"/>  
  8.      ${aaa}   
同时可以将判断条件的值使用变量存起来


6、c:choose/c:when/c:other标签

这三个标签是一起使用的，实现效果和if...else是一样的

用法：

[html]  view plain copy
  1. <!-- c:choose标签 -->  
  2. <c:choose>  
  3.     <c:when test="${true}">  
  4.         aaaa  
  5.     </c:when>  
  6.     <c:otherwise>  
  7.         bbb  
  8.     </c:otherwise>  
  9. </c:choose>  

7、c:forEach标签

这个标签是用来迭代数据的，之前用过这个标签，但是他还有很多强大的功能：

自定义标签&&JSTL标签库详解_第10张图片

用法：

[html]  view plain copy
  1. <!-- c:forEach -->  
  2.     <%  
  3.         List list = new ArrayList();  
  4.         list.add("aaa");  
  5.         list.add("bbb");  
  6.         list.add("ccc");  
  7.         list.add("ddd");  
  8.         request.setAttribute("list",list);  
  9.      %>  
  10.       
  11.     <c:forEach var="str" items="${list}">  
  12.         ${str}  
  13.     </c:forEach>  
  14.       
  15.     <!-- 设置步长，分页功能 -->  
  16.     <c:forEach  var="num" items="${list}" begin="1" end="9" step="1">  
  17.         ${num}  
  18.     </c:forEach>  
  19.       
  20.     <!-- 记录迭代变量的值 -->  
  21.     <c:forEach var="str" items="${list}" varStatus="status">  
  22.         ${status.count}  
  23.     </c:forEach>  

这里我们通过这个标签迭代输出list集合中的数据，这个功能是最基础的，也是最简单的

他还有一些属性可以设置迭代的开始位置和结束位置以及迭代的步长信息

同时还有一个属性varStatus可以记录当前迭代信息，他保存的是一个对象，但是这个对象有以下的属性值：

自定义标签&&JSTL标签库详解_第11张图片
这个属性的功能我们可以实现表格中的奇数和偶数行的不同显示


8、c:param标签

这个标签是设置参数值的，这个标签是不能单独使用的，他是结合c:url或者c:redirect标签使用


9、c:url标签

这个标签可以实现url重写(在介绍Session的时候)和url编码

自定义标签&&JSTL标签库详解_第12张图片

用法：

[html]  view plain copy
  1. <!-- c:url标签 -->  
  2.     <!-- url重写 -->  
  3.     <c:url var="url" value="JspDemo/1.jsp"/>  
  4.         <a href='${url}'>购买</a>  
  5.     </c:url>  
  6.     <!-- url标签直接输出url -->  
  7.     <a href='<c:url value="/1.jsp"'>点点</a>  
  8.     <!-- c:url构建参数(自动url编码) -->  
  9.     <c:url var="index" value="/1.jsp">  
  10.         <c:param name="name" value="中国"/>  
  11.     </c:url>  

10.c:redirect标签

这个标签是用来实现重定向的

自定义标签&&JSTL标签库详解_第13张图片

用法：

[html]  view plain copy
  1. <c:redirect url="JspDemo/1.jsp">  
  2.     <c:param name="name" value="jiangwei"></c:param>  
  3. </c:redirect>  
我们在之前介绍的jsp标签中只有<jsp:forword>转发标签，而没有重定向的标签，那么这个就有重定向的标签了。

以上我们介绍了JSTL中的核心标签库的相关知识，下面再来看一下JSTL的函数库，其实这部分内容在我们之前的EL表达式一篇文章中的最后部分作了详细讲解：http://blog.csdn.net/jiangwei0910410003/article/details/23748131


下面还有一个重要的内容就是我们要通过我们上面学习到的自定义标签的知识来开发一套类似于JSTL的标签库，并将其进行打包，给其他项目使用，这里我们就是用简单标签了，而不是用传统标签。

1、开发if标签

[java]  view plain copy
  1. package com.weijia.iftag;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.jsp.JspException;  
  6. import javax.servlet.jsp.tagext.SimpleTagSupport;  
  7.   
  8. public class IfTag extends SimpleTagSupport{  
  9.   
  10.     private boolean test;  
  11.       
  12.     public void setTest(boolean test){  
  13.         this.test = test;  
  14.     }  
  15.       
  16.     @Override  
  17.     public void doTag() throws JspException, IOException {  
  18.         if(test){  
  19.             this.getJspBody().invoke(null);  
  20.         }  
  21.     }  
  22.   
  23. }  
我们定义一个boolean类型的test变量来保存判断值，然后通过这个判断值来控制是否输出标签体内容


2、开发choose/when/otherwise标签，在开发这套标签的时候，我们会发现遇到一个难处就是多个标签之间需要进行通信，比如说一个标签执行了标签体内容，那么其他标签体的内容就不能执行了，所以这里需要给多个标签体外面在套一个父标签(这也是一个父标签开发的案例)，通过那么每个子标签可以通过父标签中的一个变量来判断是否执行自己的标签体，原理就是这样的，下面是实现类，其中ChooseTag是父标签了，WhenTag和OtherWiseTag是子标签，同时给WhenTag标签定义一个boolean属性来接收外界的判断条件

ChooseTag:

[java]  view plain copy
  1. package com.weijia.choosetag;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.jsp.JspException;  
  6. import javax.servlet.jsp.tagext.SimpleTagSupport;  
  7.   
  8. public class ChooseTag extends SimpleTagSupport{  
  9.       
  10.     private boolean isDo;  
  11.   
  12.     public boolean isDo() {  
  13.         return isDo;  
  14.     }  
  15.   
  16.     public void setDo(boolean isDo) {  
  17.         this.isDo = isDo;  
  18.     }  
  19.   
  20.     @Override  
  21.     public void doTag() throws JspException, IOException {  
  22.         this.getJspBody().invoke(null);  
  23.     }  
  24.   
  25. }  

WhenTag：

[java]  view plain copy
  1. package com.weijia.choosetag;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.jsp.JspException;  
  6. import javax.servlet.jsp.tagext.SimpleTagSupport;  
  7.   
  8. public class WhenTag extends SimpleTagSupport {  
  9.   
  10.     private boolean test;  
  11.       
  12.     public void setTest(boolean test){  
  13.         this.test = test;  
  14.     }  
  15.       
  16.     @Override  
  17.     public void doTag() throws JspException, IOException {  
  18.         //获取到父标签  
  19.         ChooseTag parentTag = (ChooseTag)this.getParent();  
  20.         if(test && !parentTag.isDo()){  
  21.             this.getJspBody().invoke(null);  
  22.             parentTag.setDo(true);  
  23.         }  
  24.     }  
  25.   
  26. }  

OtherWiseTag：

[java]  view plain copy
  1. package com.weijia.choosetag;  
  2.   
  3. import java.io.IOException;  
  4.   
  5. import javax.servlet.jsp.JspException;  
  6. import javax.servlet.jsp.tagext.SimpleTagSupport;  
  7.   
  8. public class OtherWiseTag extends SimpleTagSupport{  
  9.   
  10.     @Override  
  11.     public void doTag() throws JspException, IOException {  
  12.         ChooseTag parentTag = (ChooseTag)this.getParent();  
  13.         if(parentTag.isDo()){  
  14.             this.getJspBody().invoke(null);  
  15.         }  
  16.     }  
  17.   
  18. }  


同时需要在tld文件中对这三个标签类进行描述：

[html]  view plain copy
  1. <tag>  
  2.     <name>choose</name>  
  3.     <tag-class>com.weijia.choosetag.ChooseTag</tag-class>  
  4.     <body-content>scriptless</body-content>  
  5.   </tag>  
  6.     
  7.   <tag>  
  8.     <name>when</name>  
  9.     <tag-class>com.weijia.choosetag.WhenTag</tag-class>  
  10.     <body-content>scriptless</body-content>  
  11.     <attribute>  
  12.         <name>test</name>  
  13.         <required>true</required>  
  14.         <rtexprvalue>true</rtexprvalue>  
  15.     </attribute>  
  16.   </tag>  
  17.     
  18.   <tag>  
  19.     <name>otherwise</name>  
  20.     <tag-class>com.weijia.choosetag.OtherWiseTag</tag-class>  
  21.     <body-content>scriptless</body-content>  
  22.   </tag>  


3、for:Each标签：

[java]  view plain copy
  1. package com.weijia.foreach;  
  2.   
  3. import java.io.IOException;  
  4. import java.lang.reflect.Array;  
  5. import java.util.ArrayList;  
  6. import java.util.Collection;  
  7. import java.util.Map;  
  8.   
  9. import javax.servlet.jsp.JspException;  
  10. import javax.servlet.jsp.tagext.SimpleTagSupport;  
  11.   
  12. import sun.text.CompactShortArray.Iterator;  
  13.   
  14. /** 
  15.  * ForEach标签 
  16.  * @author weijiang204321 
  17.  * 
  18.  */  
  19. public class ForEachTag extends SimpleTagSupport{  
  20.   
  21.     private Object items;  
  22.     private String var;  
  23.     private Collection collection;  
  24.       
  25.     public void setItems(Object items) {  
  26.         this.items = items;  
  27.         if(items instanceof Collection){  
  28.             collection = (Collection)items;  
  29.         }  
  30.           
  31.         if(items instanceof Map){  
  32.             Map map = (Map) items;  
  33.             collection = map.entrySet();  
  34.         }  
  35.         //这种判断数组的方式是不适合基本类型数组的，  
  36.         //同时Arrays.asList方法接收的是可变参数Object...所以对于基本类型的数组是没有效果的  
  37.         /*if(items instanceof Object[]){ 
  38.             Object[] obj = (Object[])items; 
  39.             collection = Arrays.asList(obj); 
  40.         }*/  
  41.         //使用反射技术可以判断基本类型的数据类型  
  42.         if(items.getClass().isArray()){  
  43.             int len = Array.getLength(items);  
  44.             collection = new ArrayList();  
  45.             for(int i=0;i<len;i++){  
  46.                 collection.add(Array.get(items, i));  
  47.             }  
  48.         }  
  49.     }  
  50.   
  51.     public void setVar(String var) {  
  52.         this.var = var;  
  53.     }  
  54.   
  55.     @Override  
  56.     public void doTag() throws JspException, IOException {  
  57.         Iterator it = (Iterator) collection.iterator();  
  58.         while(it.hasNext()){  
  59.             Object value = it.next();  
  60.             this.getJspContext().setAttribute(var, value);  
  61.         }  
  62.         this.getJspBody().invoke(null);  
  63.     }  
  64.   
  65. }  


这个是实现了forEach标签的，在tld文件中进行描述一下：

[html]  view plain copy
  1. <tag>  
  2.   <name>forEach</name>  
  3.   <tag-class>com.weijia.foreach.ForEachTag</tag-class>  
  4.   <body-content>scriptless</body-content>  
  5.   <attribute>  
  6.       <name>var</name>  
  7.       <required>true</required>  
  8.       <rtexprvalue>true</rtexprvalue>  
  9.   </attribute>  
  10.   <attribute>  
  11.       <name>items</name>  
  12.       <required>true</required>  
  13.       <rtexprvalue>true</rtexprvalue>  
  14.   </attribute>  
  15. </tag>  

关于这个forEach标签的知识我们要好好的解释一下，因为这里面有很多需要注意的地方, 这里我们定义了一个Object类型的items，这个变量是用来接收迭代对象的，还定义了一个String类型的var，这个是用来将每次迭代之后的值存入到域中的key名称。还定义了一个Collection类型的变量，这个变量只是一个辅助的变量，用来将迭代对象转化成集合类型(map类型可以转换、数组也可以转化)。这样我们就可以统一进行处理了。

我们看到setItems方法中，我们首先判断这个迭代对象是不是集合类型的，是的话，直接赋值到collections变量，如果不是，在判断是不是Map类型的，如果是的话，就将Map类型的变量转化成collections，如果不是，在判断是不是数组对象Object[]，是的话，就进行转化，这里使用了Arrays.asList(T...)这个方法，关于这个方法，我们看到他的参数是一个可变的对象类型参数，看着这个样的判断是可以了，涵盖了所有的迭代对象类型，但是我们其实发现了一个问题，那就是在最后一次判断数组的时候，我们发现这个是对象类型的数组，那么我们如果传递基本类型数组的话，会是什么样的情况呢？其实我们知道基本类型数组其实就是一个Object对象，所以不是Object[]，那么这里的涵盖的范围就有问题了，我们这里还需要单独的判断基本类型的数组，然后进行操作，那么我们来看一下jstl中的forEach标签的定义吧：

我们将standard.jar进行解压，然后找到forEach标签的定义类：我们可以从c.tld文件中找到forEach对应的类：

org.apache.taglibs.standard.tag.rt.core.ForEachTag，这时候我们需要去下载一个反编译工具，能够查看class文件的，叫做：jd-gui.exe

然后通过这个工具打开ForEachTag.class:

[java]  view plain copy
  1. package org.apache.taglibs.standard.tag.rt.core;  
  2.   
  3. import java.util.ArrayList;  
  4. import javax.servlet.jsp.JspTagException;  
  5. import javax.servlet.jsp.jstl.core.LoopTag;  
  6. import javax.servlet.jsp.tagext.IterationTag;  
  7. import org.apache.taglibs.standard.tag.common.core.ForEachSupport;  
  8.   
  9. public class ForEachTag extends ForEachSupport  
  10.   implements LoopTag, IterationTag  
  11. {  
  12.   public void setBegin(int paramInt)  
  13.     throws JspTagException  
  14.   {  
  15.     this.beginSpecified = true;  
  16.     this.begin = paramInt;  
  17.     validateBegin();  
  18.   }  
  19.   
  20.   public void setEnd(int paramInt)  
  21.     throws JspTagException  
  22.   {  
  23.     this.endSpecified = true;  
  24.     this.end = paramInt;  
  25.     validateEnd();  
  26.   }  
  27.   
  28.   public void setStep(int paramInt)  
  29.     throws JspTagException  
  30.   {  
  31.     this.stepSpecified = true;  
  32.     this.step = paramInt;  
  33.     validateStep();  
  34.   }  
  35.   
  36.   public void setItems(Object paramObject)  
  37.     throws JspTagException  
  38.   {  
  39.     if (paramObject == null)  
  40.       this.rawItems = new ArrayList();  
  41.     else  
  42.       this.rawItems = paramObject;  
  43.   }  
  44. }  


我们发现ForEach实现了IterationTag接口，我们在前面看到传统标签和简单标签类结构系统图中看到，这个适用于迭代输出标签体内容的接口，而且这个是传统标签，可见jstl中的ForEach标签是使用传统标签来实现的，我们知道如果是迭代的话，会实现相应的迭代方法，但是我们发现ForEachTag类中只有get/set方法，所以我们这时候可以查看他的父类ForEachSupport中核心的方法：

[java]  view plain copy
  1. protected ForEachIterator supportedTypeForEachIterator(Object paramObject)  
  2.     throws JspTagException  
  3.   {  
  4.     ForEachIterator localForEachIterator;  
  5.     if ((paramObject instanceof Object[]))  
  6.       localForEachIterator = toForEachIterator((Object[])paramObject);  
  7.     else if ((paramObject instanceof boolean[]))  
  8.       localForEachIterator = toForEachIterator((boolean[])paramObject);  
  9.     else if ((paramObject instanceof byte[]))  
  10.       localForEachIterator = toForEachIterator((byte[])paramObject);  
  11.     else if ((paramObject instanceof char[]))  
  12.       localForEachIterator = toForEachIterator((char[])paramObject);  
  13.     else if ((paramObject instanceof short[]))  
  14.       localForEachIterator = toForEachIterator((short[])paramObject);  
  15.     else if ((paramObject instanceof int[]))  
  16.       localForEachIterator = toForEachIterator((int[])paramObject);  
  17.     else if ((paramObject instanceof long[]))  
  18.       localForEachIterator = toForEachIterator((long[])paramObject);  
  19.     else if ((paramObject instanceof float[]))  
  20.       localForEachIterator = toForEachIterator((float[])paramObject);  
  21.     else if ((paramObject instanceof double[]))  
  22.       localForEachIterator = toForEachIterator((double[])paramObject);  
  23.     else if ((paramObject instanceof Collection))  
  24.       localForEachIterator = toForEachIterator((Collection)paramObject);  
  25.     else if ((paramObject instanceof Iterator))  
  26.       localForEachIterator = toForEachIterator((Iterator)paramObject);  
  27.     else if ((paramObject instanceof Enumeration))  
  28.       localForEachIterator = toForEachIterator((Enumeration)paramObject);  
  29.     else if ((paramObject instanceof Map))  
  30.       localForEachIterator = toForEachIterator((Map)paramObject);  
  31.     else if ((paramObject instanceof String))  
  32.       localForEachIterator = toForEachIterator((String)paramObject);  
  33.     else  
  34.       localForEachIterator = toForEachIterator(paramObject);  
  35.     return localForEachIterator;  
  36.   }  


我们发现他会对每个传递进来的对象进行判断，然后进行一些操作。同时对基本类型进行判断，但是我们发现这样的代码是有点不好看，我们为了体现出我们的技术，我们这里可以将代码改一下，并且是实现的比他还要好，就是以下的代码段：

[java]  view plain copy
  1. //使用反射技术可以判断基本类型的数据类型  
  2. if(items.getClass().isArray()){  
  3.     int len = Array.getLength(items);  
  4.     collection = new ArrayList();  
  5.     for(int i=0;i<len;i++){  
  6.         collection.add(Array.get(items, i));  
  7.     }  
  8. }  
这里我们使用反射技术来判断是不是数组类型，这里可以判断是基本类型数组还是对象类型数组，然后再使用Array这个工具类进行操作数组中的元素，这样我们看到这样的代码就比jstl中的代码简介明了，而且技术上也体现出一点高超。


下面我们在tld文件中进行描述一下：

[html]  view plain copy
  1. <tag>  
  2.     <name>forEach</name>  
  3.     <tag-class>com.weijia.foreach.ForEachTag</tag-class>  
  4.     <body-content>scriptless</body-content>  
  5.     <attribute>  
  6.         <name>var</name>  
  7.         <required>true</required>  
  8.         <rtexprvalue>true</rtexprvalue>  
  9.     </attribute>  
  10.     <attribute>  
  11.         <name>items</name>  
  12.         <required>true</required>  
  13.         <rtexprvalue>true</rtexprvalue>  
  14.     </attribute>  

在Jsp页面中使用：

[html]  view plain copy
  1. <span>  </span><%  
  2.         List list = new ArrayList();  
  3.         list.add("aaa");  
  4.         list.add("bbb");  
  5.         String[] strAry = new String[]{"aaa","bbb","ccc"};  
  6.         int[] intAry = new int[]{1,2,3,6};  
  7.      %>  
  8.       
  9.     <c:forEach var="item" items="<%=list%>">  
  10.         ${item}  
  11.     </c:forEach>  
  12.       
  13.     <br>  
  14.       
  15.     <c:forEach var="item" items="<%=strAry%>">  
  16.         ${item}  
  17.     </c:forEach>  
  18.       
  19.     <br>  
  20.       
  21.     <c:forEach var="item" items="<%=intAry%>">  
  22.         ${item}  
  23.     </c:forEach>  

我们使用Java代码模拟一个集合，对象类型的数组，基本类型数组，然后进行显示，显示结果

自定义标签&&JSTL标签库详解_第14张图片

在这里额外的插一句：我在做这个实验的时候犯了一个很低级的错误，就是在使用标签的时候，给items赋值的时候我已开始使用的是EL表达式(${list})，然后总是报空指针异常,纠结了好长时间，发现items是null,那么就是没有传递对象给他，后来发现EL表达式是从域中取数据的，我们没有将list存入到任何域中，所以肯定拿不到了，这时候改用脚本表达式就可以了，因为脚本表达式就是可以去取页面中脚本片段中定义的变量值的，所以最后发现这个错误真的很低级的！！！


以上就是我们实现了类似于jstl中的标签库的一些标签的功能，这里我们可以联系一下我们之前在开始介绍自定标签的时候实现的四个案例：

1、控制标签体是否输出

2、控制标签体重复输出

3、控制余下的Jsp页面是否显示

4、修改标签体内容

其实我们会发现，上面实现的If标签其实就是第一个案例的体现，choose/when/otherwise标签就是第一个案例的体现，但是这里面还有一个功能就是父标签的编写，forEach标签是第二个案例的实现以及第四个案例的实现。所以说我们为什么一开始要介绍那四个案例，其实是为这部分内容做铺垫的。


下面我们来进行打包操作了，我们需要将我们定义的tld文件一起打包，这个打包也是很简单的，我们只需要新建一个Java项目，将我们定义好的标签类都拷贝过去，同时在项目中新建一个META-INF文件夹，在将我们定义的的tld文件拷贝进去，虽然会提示很多错误(因为是Java项目，不是Web项目很多类是找不到的)但是我们不理会，因为我们知道我们的类的逻辑和语法是没有错误的，只是找不到相应的类，这时候我们进行打包，一定要将META-INF文件夹一起打包进去，这时候我们就可以使用这个我们自己定义的标签库包了。


总结：好了，JSTL和自定义标签的相关知识就介绍到这里的，同时我们JavaWeb学习篇也到这里就结束了，这一系列的文章写了半个月吧，从中学习到了很多的知识，在此将每个知识点整理出来供大家分享，如果有什么不正确的地方还请提出，我立即做出修改。谢谢！

你可能感兴趣的:(jsp,tag,jstl)

  • Low Power概念介绍-Voltage Area 飞奔的大虎
    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
  • 在Ubuntu中编译含有JSON的文件出现报错 芝麻糊76 Linuxkill_buglinuxubuntujson
    在ubuntu中进行JSON相关学习的时候，我发现了一些小问题，决定与大家进行分享，减少踩坑时候出现不必要的时间耗费截取部分含有JSON部分的代码进行展示char*str="{\"title\":\"JSONExample\",\"author\":{\"name\":\"JohnDoe\",\"age\":35,\"isVerified\":true},\"tags\":[\"json\",\"
  • 网络编程基础 记得开心一点啊 网络
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
  • Some jenkins settings SnC_
    Jenkins连接到特定gitlabproject的特定branch我采用的方法是在pipeline的script中使用git命令来指定branch。如下：stage('Clonerepository'){steps{gitbranch:'develop',credentialsId:'gitlab-credential-id',url:'http://gitlab.com/repo.git'}}
  • 斟一小组鸡血视频 和自己一起成长
    http://m.v.qq.com/play/play.html?coverid=&vid=c0518henl2a&ptag=2_6.0.0.14297_copy有一种努力叫做靠自己http://m.v.qq.com/play/play.html?coverid=&vid=i0547o426g4&ptag=2_6.0.0.14297_copy世界最励志短片https://v.qq.com/x/pa
  • 《Veronika decides to die》 Ooutstanding
    Whatismadness？——Madnessistheinabilitytocommunicate.Betweennormalityandmadness,whicharebasicallythesamething,thereexistsanintermediarystage：itiscalled"beingdifferent."Andpeoplewerebecomingmoreandmoreaf
  • PCIe进阶之TL：Memory, I/O, and Configuration Request Rules & TPH Rules 芯芯之火，可以燎原 PCIe进阶PCIe进阶硬件工程信息与通信
    1Memory,I/O,andConfigurationRequestRules下述规则适用于Memory请求、IO请求和配置请求。除了公共的header字段外，所有Memory请求、IO请求和配置请求还包括以下字段：（1）RequesterID[15:0]和Tag[9:0]，组成了TransactionID。（2）LastDWBE[3:0]和1stDWBE[3:0]字段。对于TH字段置1的Mem
  • [移动端自动化] AppAgent介绍 大卫软件测试 自动化
    AUITestAgentAUITestAgent/README_zh.mdatmain·bz-lab/AUITestAgent(github.com)1/MobileAgentX-PLUG/MobileAgent:Mobile-Agent:ThePowerfulMobileDeviceOperationAssistantFamily(github.com)2/AppAgentAppAgent/RE
  • 【自用25.1】C++-智能交友系统项目 .远_ 学习笔记C++Proc++算法开发语言
    注：项目类文章会陆续更新，请大家关注系列文章创建Girl类头文件#pragmaonce#includeusingnamespacestd;classBoy;classGirl{public:Girl();Girl(intage,stringname,intstyle);~Girl();intgetAge()const;stringgetName()const;intgetStyle()const;
  • Halo 开发者指南——容器私有化部署 SHENHUANJIE DockerHalo华为云SWRRegistry
    华为云SWR私有化部署镜像构建dockerbuild-thalo-dev/halo:2.20.0.上传镜像镜像标签sudodockertag{镜像名称}:{版本名称}swr.cn-south-1.myhuaweicloud.com/{组织名称}/{镜像名称}:{版本名称}sudodockertaghalo-dev/halo:2.20.0swr.cn-south-1.myhuaweicloud.co
  • Nuxt Kit 自动导入功能：高效管理你的模块和组合式函数 qcidyu 好用的工具集合代码效率前端技巧Vue开发组合式函数模块管理自动导入NuxtKit
    title:NuxtKit自动导入功能：高效管理你的模块和组合式函数date:2024/9/14updated:2024/9/14author:cmdragonexcerpt:通过使用NuxtKit的自动导入功能，您可以更高效地管理和使用公共函数、组合式函数和VueAPI。无论是单个导入、目录导入还是从第三方模块导入，您都可以通过简单的API调用轻松实现。categories:前端开发tags:N
  • 前端HTML+CSS+JS的入门学习 俊昭喜喜里 前端htmlcss
    一.HTMLHTML（HyperTextMarkupLanguage）即超文本标记语言，是用于创建网页和网页应用程序的标准标记语言。它不是一种编程语言，而是一种标记语言，通过一系列的元素（elements）来告诉浏览器如何显示网页上的内容，如文本、图片、链接、表格、列表等。HTML文档由一系列的标签（tags）组成，这些标签告诉浏览器如何显示内容。标签通常成对出现，例如和，其中是开始标签，表示一个
  • 【python版】示波器输出的csv文件（时间与电压数据）如何转换为频率与幅值【方法②】 cxylay pythonpython开发语言示波器csv文件频谱频域时域
    要将示波器输出的CSV文件中包含的时间与电压数据转换为频率与幅值数据，你可以按照以下步骤进行处理。这里假设你的数据是一个周期性信号，可以通过傅里叶变换来实现这种转换。1、准备数据①导入CSV文件首先，使用Python、Excel或任何数据处理工具导入你的CSV文件。CSV文件中应该有两列数据，分别为时间（time）和电压（voltage）。②检查数据确保时间列的单位是一致的（例如秒），电压列是以伏
  • 【网络安全 | 代码审计】JFinal之DenyAccessJsp绕过 秋说 网络安全web安全java代码审计漏洞挖掘
    未经许可，不得转载。文章目录前言代码审计推理绕过Tomcat解析JSP总结概念验证阐发前言JFinal是一个基于Java的轻量级MVC框架，用于快速构建Web应用程序。它的设计理念是追求极简、灵活、高效，旨在提高开发效率，减少冗余代码的编写，适合中小型项目以及对性能有较高要求的项目。在较新的JFinal版本中，默认情况下无法直接通过浏览器地址栏输入.jsp文件名来访问对应的JSP文件。也就是说，主
  • Docker 常用命令 C语言扫地僧 Linux专栏docker容器
    1Docker镜像命令1.1dockerimages#语法dockerimages[OPTIONS][REPOSITORY[:TAG]]#别名dockerimagels,dockerimagelist功能列出本地镜像。关键参数-a:列出本地所有的镜像（含中间映像层，默认情况下，过滤掉中间映像层）；--digests:显示镜像的摘要信息；-f:显示满足条件的镜像；--format:指定返回值的模板文
  • 钉钉自定义机器人 AlphaHinex
    原文地址：https://alphahinex.github.io/2022/03/06/dingtalk-custom-robot/description:"像发手机短信一样方便"date:2022.03.0610:34categories:-DevOpstags:[Dingtalk,Robot]keywords:dingtalk,robot,钉钉,机器人,聊天机器人聊天机器人从hubot起接触
  • java mongodb group分组使用 yank1225 mongodbjavamongodbgroup
    mongodb的关键字及介绍.mongodb的查询是有一定规则的,刚开始接触老是各种错误,参照以下内容有很多帮助https://docs.mongodb.com/manual/reference/sql-aggregation-comparison/另外出现这种错误时Apipelinestagespecificationobjectmustcontainexactlyonefield是因为条件不对
  • jsp 从后台Map中取值 yank1225 jsp从map取值jsp按key获取map中的对应值springmMVCjsp页面取得map值
    在jsp页面有的时候需要从后台传过来的Map中取特定值，并显示在页面上，网上有很多说怎么取值的，但是找了好久很多都是讲的怎么循环取值，如果你需要在table中显示值那该怎么办呢？很多都没有讲，我把我的方法简单介绍下。场景是这样的下面是table的行数据从后台controller返回分页信息，pageInfo.list是当前行数据，item.houseType是数据，但是这个是值（1或者2等等）并不
  • vue 生成PDF(A4标准PDF分页) qq_39016177 HTML2CanvasjsPDF导出PDF转换DOM操作
    1.先安装两个插件//页面转图片npminstall--savehtml2canvas//图片转PDFnpminstalljspdf--save 2.在需要导出的dom节点增加ref='pdf'例如  这是待转换的页面，点击导出点击导出PDF3.定义导出方法handleExport(){   downloadPDF(this.$refs.pdf);},4.在页面导入 import{download
  • SIPp常用脚本之三：UAC weixin_34075551 网络
    UAC是作为SIP消息的发起端，可以控制消息速率什么的，方便极了。一、uac.xml;tag=[call_number]To:Call-ID:[call_id]CSeq:1INVITEContact:sip:[field0]@[local_ip]:[local_port]Max-Forwards:70Subject:PerformanceTestContent-Type:application/s
  • 跟我一起写 SIPp XML scenario file 之二 无名387 os通讯
    就我个人的体会而言，貌似没什么秘诀，无非是：勤查手册拿到一个样本，进行临摹，多加练习分析有几个SIP事务如果SIPp做uas,totag是自己产生的fromtag,totag要不要颠倒过来requesturl的url来自何处如果uas主动发request,via是自己产生的要不要支持sipproxy目标是：拿到任意pcap文件，都可以写出对应的XMLscenariofile另：手册在这里：http
  • Upstage 将发布新一代 LLM “Solar Pro “预览版 吴脑的键客 人工智能人工智能
    SolarPro是最智能的LLM，经过优化可在单GPU上运行，性能超过微软、Meta和谷歌等科技巨头的模型。加州圣何塞2024年9月11日电/美通社/–Upstage今天宣布发布其下一代大型语言模型(LLM)SolarPro的预览版。加州圣何塞2024年9月11日电/美通社/–Upstage今天宣布发布其下一代大型语言模型(LLM)SolarPro的预览版。该预览版作为开源模型免费提供API访问，
  • Java程序的分层设计 天天进步2015 架构设计java开发语言
    Java程序的分层设计通常遵循分层架构（LayeredArchitecture）的原则，将应用程序分为多个相互独立但有依赖关系的层。这样设计有助于降低耦合度，提高可维护性和可扩展性。典型的Java分层设计包括以下几层：1.表示层（PresentationLayer/ViewLayer）功能：用户界面层，负责与用户交互。将用户输入的信息传递给业务层，同时将业务层返回的结果展示给用户。一般使用JSP、
  • 基于ssm框架的计算机毕业设计(论文+源码)_kaic 开心工作室V(kaic_kaic) 计算机文章毕业设计javaoracle开发语言前端旅游数据库actionscript
    编号ssmssm001高校专业信息管理系统设计与实现+jsp源码+数据库+PPT+开题+论文+说明文档ssm002ssm学院党员管理系统+jsp源码+数据库+开题+论文+说明文档ssm003ssm在线医疗服务系统+jsp源码+数据库+开题+论文+说明文档ssm004ssm新生报到系统+jsp源码+数据库+开题+论文+说明文档ssm005基于SSM框架的购物商城系统+jsp源码+数据库+开题+任务书
  • idea 启动tomcat 工程_使用IDEA创建JavaWeb项目 部署本地tomcat并运行 心在天上脚在地上 idea启动tomcat工程
    一、下载商业版IDEA二、新建JavaWeb项目1、在菜单栏找到File>>New>>Project2、在弹出的窗口中找到JavaEnterPrise>>WebApplication，点击Next3、填写项目名称，选择项目位置，然后Finish4、在左侧窗口可以看到IDEA创建JavaWeb工程的目录结构，在src中写java代码，在web目录下放jsp页面。三、下载tomacat下载完成后，解压
  • View-＞Bitmap缩放到自定义ViewGroup的任意区域(Matrix方式绘制Bitmap) Yang-Never Viewandroidkotlinandroidstudio开发语言
    Bitmap缩放和平移加载一张Bitmap可能为宽高相同的正方形，也可能为宽高不同的矩形缩放方向可以为中心缩放，左上角缩放，右上角缩放，左下角缩放，右下角缩放Bitmap中心缩放，包含了缩放和平移两个操作，不可拆开Bitmap其余四个方向的缩放，可以单独缩放不带平移，也可以缩放带平移XML文件Activity代码constvalTAG="Yang"classMainActivity:AppComp
  • 微信小程序之轮播图组件封装 鱼在在 vueuni-app微信小程序javascript
    目录封装组件——mp-rotationchat组件的属性与方法——swiper-rotation-chat.js组件的引入使用封装组件——mp-rotationchat文件目录components（所有组件位置）swiper-roatiton-chat（轮播图组件包）swiper-rotation-chat.wxmlswiper-rotation-chat.jspages（所有页面）index（初
  • Go中更安全的枚举 jzpfbpx golang安全开发语言
    iotaGo让你用iota来使用枚举。const(Guest=iotaMemberModeratorAdmin)虽然Go是明确的，但iota似乎相对模糊。如果你以任何其他方式对const组进行排序，你会引入副作用。在上面的例子中，你仅仅对第一个参数Guest赋值了。你可以显式地给每个值分配一个数字来避免这个问题，但这使iota变得过时。iota对于用位运算定义的参数也很有效。const(Guest
  • 网络编程 UDP发送数据 稻田里展望者 Java网络编程udp网络网络协议
    UDP通信原理不可靠的网络协议,在通信的两端各建立一个Socket对象(发送和接收数据)发送数据的步骤1.创建发送端的Socket对象(DatagramSocket)2.创建数据,并把数据打包3.调用DatagramSocket对象的方法发送数据4.关闭发送端//创建发送端的Socket对象(DatagramSocket)DatagramSocketds=newDatagramSocket();/
  • c# json使用 wiseyao1219 c#json前端
    安装包用NuGet安装包：Newtonsoft.Json对象转为Json字符串publicclassPerson{publicstringName{get;set;}publicintAge{get;set;}}Personperson=newPerson{Name="JohnDoe",Age=30};stringjson2=JsonConvert.SerializeObject(person);
  • 二分查找排序算法 周凡杨 java二分查找排序算法折半
    一：概念 二分查找又称 折半查找（ 折半搜索/ 二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而 查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表 分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
  • java中的BigDecimal bijian1013 javaBigDecimal
            在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。         原文地址：http://blog.csdn.net/ugg/article/de
  • Shell echo命令详解 daizj echoshell
    Shell echo命令 Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： echo string 您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: echo "It is a test" 这里的双引号完全可以省略，以下命令与上面实例效果一致： echo Itis a test 2.显示转义
  • Oracle DBA 简单操作 周凡杨 oracle dba sql
    --执行次数多的SQL select sql_text,executions from (      select sql_text,executions from v$sqlarea order by executions desc      ) where rownum<81;  &nb
  • 画图重绘 朱辉辉33 游戏
      我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。   在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
  • 线程之初体验 西蜀石兰 线程
    一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。 之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。 线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。 你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
  • linux集群互相免登陆配置 林鹤霄 linux
    配置ssh免登陆 1、生成秘钥和公钥    ssh-keygen -t rsa 2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub    其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密    c
  • mysql : Lock wait timeout exceeded; try restarting transaction aigo mysql
    原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html   原因是你使用的InnoDB   表类型的时候, 默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 因为有的锁等待超过了这个时间,所以抱错.   你可以把这个时间加长,或者优化存储
  • Socket编程 基本的聊天实现。 alleni123 socket
    public class Server { //用来存储所有连接上来的客户 private List<ServerThread> clients; public static void main(String[] args) { Server s = new Server(); s.startServer(9988); } publi
  • 多线程监听器事件模式(一个简单的例子) 百合不是茶 线程监听模式
        多线程的事件监听器模式   监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到        创建多线程的事件监听器模式 思路:    1, 创建线程并启动,在创建线程的位置设置一个标记     2,创建队
  • spring InitializingBean接口 bijian1013 javaspring
    spring的事务的TransactionTemplate，其源码如下： public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{ ... } TransactionTemplate继承了DefaultT
  • Oracle中询表的权限被授予给了哪些用户 bijian1013 oracle数据库权限
            Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 select t.table_name as "表名", t.grantee as "被授权的属组", t.owner as "对象所在的属组"
  • 【Struts2五】Struts2 参数传值 bit1129 struts2
    Struts2中参数传值的3种情况 1.请求参数绑定到Action的实例字段上 2.Action将值传递到转发的视图上 3.Action将值传递到重定向的视图上   一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上 Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
  • 【Kafka十四】关于auto.offset.reset[Q/A] bit1129 kafka
    I got serveral questions about  auto.offset.reset. This configuration parameter governs how  consumer read the message from  Kafka when  there is no initial offset in ZooKeeper or
  • nginx gzip压缩配置 ronin47 nginx gzip 压缩范例
    nginx gzip压缩配置 更多 0 nginx gzip 配置   随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
  • java-13.输入一个单向链表，输出该链表中倒数第 k 个节点 bylijinnan java
    two cursors. Make the first cursor go K steps first. /* * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点 */ public void displayKthItemsBackWard(ListNode head,int k){ ListNode p1=head,p2=head;
  • Spring源码学习-JdbcTemplate queryForObject bylijinnan javaspring
    JdbcTemplate中有两个可能会混淆的queryForObject方法： 1. Object queryForObject(String sql, Object[] args, Class requiredType) 2. Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 第1个方法是只查
  • [冰川时代]在冰川时代,我们需要什么样的技术? comsci 技术
         看美国那边的气候情况....我有个感觉...是不是要进入小冰期了?      那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段...   &nb
  • js 获取浏览器型号 cuityang js浏览器
    根据浏览器获取iphone和apk的下载地址 <!DOCTYPE html> <html> <head>     <meta charset="utf-8" content="text/html"/>     <meta name=
  • C# socks5详解 转 dalan_123 socketC#
    http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html  这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
  • 运维 Centos问题汇总 dcj3sjt126com 云主机
    一、sh 脚本不执行的原因 sh脚本不执行的原因 只有2个 1.权限不够 2.sh脚本里路径没写完整。   二、解决You have new mail in /var/spool/mail/root 修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 MailTo = MailFrom   三、查询连接数
  • Yii防注入攻击笔记 dcj3sjt126com sqlWEB安全yii
    网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号 这里有个转义对照表： http://blog.csdn.net/xinzhu1990/articl
  • MongoDB简介[一] eksliang mongodbMongoDB简介
    MongoDB简介 转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用        MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。        另外，不
  • zookeeper windows 入门安装和测试 greemranqq zookeeper安装分布式
    一、序言       以下是我对zookeeper 的一些理解：      zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。       栗子1号：       假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
  • Spring之使用事务缘由(2-注解实现) ihuning spring
      Spring事务注解实现   1. 依赖包：     1.1 spring包：           spring-beans-4.0.0.RELEASE.jar           spring-context-4.0.0.
  • iOS App Launch Option 啸笑天 option
    iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。   launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节 。 1、若用户直接
  • jdk与jre的区别（_） macroli javajvmjdk
    简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。  JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。 如果安装了JDK，会发同你
  • Updates were rejected because the tip of your current branch is behind qiaolevip 学习永无止境每天进步一点点众观千象git
    $ git push joe prod-2295-1 To [email protected]:joe.le/dr-frontend.git ! [rejected] prod-2295-1 -> prod-2295-1 (non-fast-forward) error: failed to push some refs to '[email protected]
  • [一起学Hive]之十四-Hive的元数据表结构详解 superlxw1234 hivehive元数据结构
    关键字：Hive元数据、Hive元数据表结构   之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。 本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。   文章最后面，会以一个示例来全面了解一下，
  • Spring 3.2.14，4.1.7，4.2.RC2发布 wiselyman Spring 3
      Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。   其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。   其中Spring 4.1.7主要包含这些更新内容。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他