white__cat
white__cat

JavaWeb学习篇之----自定义标签&&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代码可以看到，不管用那种方式，他其实加载的时候都是去找真是路径中文件：

JavaWeb学习篇之----自定义标签&&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页面中使用标签即可。那么最后再来看一下传统标签和简单标签的继承关系：

JavaWeb学习篇之----自定义标签&&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接口中的主要方法及它们分别可以返回的返回值的说明。

JavaWeb学习篇之----自定义标签&&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>


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

JavaWeb学习篇之----自定义标签&&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标签描述文档的：

JavaWeb学习篇之----自定义标签&&JSTL标签库详解_第5张图片

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

JavaWeb学习篇之----自定义标签&&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”对象中

JavaWeb学习篇之----自定义标签&&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类型的属性对象的属性

JavaWeb学习篇之----自定义标签&&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标签

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

JavaWeb学习篇之----自定义标签&&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标签

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

JavaWeb学习篇之----自定义标签&&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可以记录当前迭代信息，他保存的是一个对象，但是这个对象有以下的属性值：

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


8、c:param标签

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


9、c:url标签

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

JavaWeb学习篇之----自定义标签&&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标签

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

JavaWeb学习篇之----自定义标签&&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代码模拟一个集合，对象类型的数组，基本类型数组，然后进行显示，显示结果

JavaWeb学习篇之----自定义标签&&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学习篇也到这里就结束了，这一系列的文章写了半个月吧，从中学习到了很多的知识，在此将每个知识点整理出来供大家分享，如果有什么不正确的地方还请提出，我立即做出修改。谢谢！

你可能感兴趣的:(JavaWeb学习篇之----自定义标签&&JSTL标签库详解)

  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿 小鹿_33
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
  • 《大清方方案》| 第二话 谁佐清欢
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
  • 《庄子.达生9》 钱江潮369
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 2020-04-12每天三百字之连接与替代 冷眼看潮
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
  • 东南林氏之九牧林候选父系 祖缘树TheYtree
    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
  • 大伟说成语之唉声叹气 求索大伟
    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • 怎么做淘客赚钱(2022最新免费淘客盈利的方法) 高省_飞智666600
    很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 锁之缘 尘缘诗词原创作品
    是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • ARM驱动学习之5 LEDS驱动 JT灬新一 嵌入式C底层arm开发学习单片机
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
  • ARM驱动学习之4小结 JT灬新一 嵌入式C++arm开发学习linux
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • 2020-12-24 我和我的天使们
    阅读《老子的心事》391—403“将欲取之，必固与之”：想要得到什么，首先就要送出什么。我常常对孩子们说，你希望别人怎样对你你就怎样对待别人。想要得到别人的尊重，首先要尊重别人。我希望她们可以不迟到，因为不迟到是对别人的尊重，我就自己就先做到不迟到。哪怕是约朋友逛街，我尽量准时赴约。我严格要求孩子们，也同样严格要求自己，我跟孩子们一起把好的品格变成习惯。“是谓微明”：这就是微妙的智慧。看起来很少很
  • 18、架构-可观测性之聚合度量 大树~~ 架构javapython后端架构
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
  • 学习“论语”-第59天 春峰轩
    12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
  • 2021-11-15 宙火
    我给宋小姐写了首诗，是我在课上因思恋宋小姐而写的。“自古多情是唐宋，从来双飞归巢燕。邻家小女相聘婷，常使春意荡漾我。不知单思可为爱，惟愿一心付之汝。”我拿给宋小姐看了，她说我写得很棒。我很开心，但又不是那么开心。宋小姐是回复我了，但也只是说我写得很棒，对我诗句中蕴藏的真切感情，不知道是真的没发现，还是装作没发现。但我不深究，只是这样，我就很开心了。我答应宋小姐，一天给她写一首诗。
  • 《我的青葱岁月之缘来是你》 第二章 迎新晚会 思源思缘思怨
    “怎么你也来了这里？”我愉快的问到，想着这是上天给的缘分吗？我还没去找他竟然就相遇了。那个让我开心的老乡。“你好，我也是舞蹈社的新人啊！”他说，笑起来回答我，眼睛弯弯的。“这么巧，我叫吴倩，你叫啥？”“我叫韩欢，你也是B市人吧，c中毕业的？”“我不是，我是f中的，不然肯定会认识你的”“是吗？以后多多关照了”他还冲我眨了眨眼睛。内心一阵悸动，这是……回到寝室，我兴奋的告诉我的室友这个事情，我再次觉得
  • 数据结构之哈希表 X同学的开始 数据结构数据结构散列表
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
  • 厦门自由行之第一天: 大苏子在广漂
    厦门三人行之杂记出发前一天:12️28日下午15:00从广州粗发，来深圳集合！但是中间发生一个小插曲，验票时候发现车票不见了，或许也是一场恶作剧，对于不排队的人，忍不住说了一下，接下来就发现车票不见了，已经是拿在手上！不过还好，可以凭借购票订单查看到信息，所以有惊无险，顺利进站！晚上三个人一起去吃了柠檬鱼，说实话，那会，感觉美吃饱，啊哈哈！晚上回来，两个人又开始彻夜长谈，发现身边优秀的人，一大把，
  • “这才好”麻辣香锅 能够增加人身体的免疫能力 小补文知
    我就来介绍一种香锅，那就是“这才好”麻辣香锅，它产出于著名的蜀地文化，具有悠久的历史土家风味，麻辣鲜香，健康安全。采用传统秘制麻辣香锅油辣子，还有贴心加料“孜然包”满足人们的不同口味需求，香锅底料辣椒，微辣且香，含有丰富微量元素和维生素，具有辣而不躁，味道纯正，醇厚温和。花椒采用历史悠久，被列为宫廷供品的“贡椒”的汉源花椒。我们还挑选了“川菜之魂”郫县豆瓣的鼻祖品牌豆瓣，保留最原始的郫县豆瓣味道，
  • 《太虚游》第六十二章。玄牝之威。 古楼臭道士
    “好好好，流云这孩子深得我心，想必长爻知道是你的话定然会惊喜不已的。”白玄牝听得风流云应了下来，脸色慈和，伸手在他头顶轻轻抚了抚，如同抚在怀中九尾小狐一样自然，极其温柔。身后的四位青丘长老同时一怔，嘴角微动，似要开口劝阻。风流云只感到一道霞光瑞气如有实质一般顺着头顶百会大穴直沉在下丹田内，随后这股气息又逐渐凝聚，似乎给自己吃了什么东西一般。啊喔不好，这祖奶奶该不会是看中我这肉身，像人魔一样，要给她
  • 生命如花 坦释空
    每个人的心中都有一株妙莲花。这是禅家语。禅家总是站在理性的高处，以超越红尘的洒脱来参悟人生和自省生命。那么，凡俗中人呢？生如夏花之绚丽，死如秋叶之静美。这是诗人语。多少人在赞美：姑娘好像花一样！又有多少人在咏歌：花儿与少年。的确，人生如花。花一样的生命，理应自诞生之日起，就一瓣一瓣地绽放她的美丽与清香，使这个原本死寂荒凉的世界五彩缤纷，充满快乐。事实上，人类自诞生起，就一代一代地做着这方面的努力，
  • 二婚到底是领证好还是不领证好？ 孟妃青
    伟人讲过，不以结婚为目的的谈恋爱，都是耍流氓！离婚了，再找对象，感情到了一定程度，领证结婚是水到渠成的事，再说我中华泱泱大国，有礼仪之邦的称谓，领证更是体现了尊重男女双方的行为。如果认为二婚就没必要领证了，只能说明，男女之间都暗藏心思，心不往一处走，日子过不好的。即便他们感情再深，都不是合法夫妻，只是名不正言不顺的同居关系。假如不要二人共同的孩子还好，就怕有了孩子，没领证，到时给孩子上户口都成问题
  • 《华杉讲透王阳明传习录》 微微微微神
    〔5〕希渊问：“圣人可学而至。然伯夷伊尹于孔子，才力终不同。其同谓之圣者安在”？先生曰，“圣人之所以为圣，只是其心纯乎天理，而无人欲之杂。犹精金之所以为精，但以其成色足而无铜铅之杂也。人到纯乎天理方是圣。金到足色方是精。然圣人之才力，亦有大小不同。犹金之分两有轻重。尧舜犹万镒。文王孔子犹九千镒。禹汤武王犹七八千镒。伯夷伊尹犹四五千镒。才力不同，而纯乎天理则同。皆可谓之圣人。犹分两虽不同，而足色则同
  • 解线性方程组 qiuwanchi
    package gaodai.matrix; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Test { public static void main(String[] args) { Scanner scanner = new Sc
  • 在mysql内部存储代码 annan211 性能mysql存储过程触发器
    在mysql内部存储代码 在mysql内部存储代码，既有优点也有缺点，而且有人倡导有人反对。 先看优点： 1 她在服务器内部执行，离数据最近，另外在服务器上执行还可以节省带宽和网络延迟。 2 这是一种代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性。 3 可以简化代码的维护和版本更新。 4 可以帮助提升安全，比如提供更细
  • Android使用Asynchronous Http Client完成登录保存cookie的问题 hotsunshine android
    Asynchronous Http Client是android中非常好的异步请求工具 除了异步之外还有很多封装比如json的处理，cookie的处理 引用 Persistent Cookie Storage with PersistentCookieStore This library also includes a PersistentCookieStore whi
  • java面试题 Array_06 java面试
    java面试题 第一，谈谈final, finally, finalize的区别。 final-修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能
  • 网站加速 oloz 网站加速
    前序:本人菜鸟，此文研究总结来源于互联网上的资料，大牛请勿喷！本人虚心学习，多指教. 1、减小网页体积的大小，尽量采用div+css模式，尽量避免复杂的页面结构，能简约就简约。 2、采用Gzip对网页进行压缩；    GZIP最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。我们在Linux中经常会用到后缀为.gz
  • 正确书写单例模式 随意而生 java 设计模式 单例
    　　单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了吧。但是其中的坑却不少，所以也常作为面试题来考。本文主要对几种单例写法的整理，并分析其优缺点。很多都是一些老生常谈的问题，但如果你不知道如何创建一个线程安全的单例，不知道什么是双检锁，那这篇文章可能会帮助到你。 　　懒汉式，线程不安全 　　当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样
  • 单例模式 香水浓 java
    懒汉  调用getInstance方法时实例化 public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if(null == ins
  • 安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" AdyZhang apachehttp server
    安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" 每次到这一步都很小心防它的端口冲突问题，结果，特意留出来的80端口就是不能用，烦。 解决方法确保几处： 1、停止IIS启动 2、把端口80改成其它 （譬如90，800，，，什么数字都好） 3、防火墙(关掉试试) 在运行处输入 cmd 回车，转到apa
  • 如何在android 文件选择器中选择多个图片或者视频？ aijuans android
    我的android app有这样的需求，在进行照片和视频上传的时候，需要一次性的从照片/视频库选择多条进行上传 但是android原生态的sdk中，只能一个一个的进行选择和上传。 我想知道是否有其他的android上传库可以解决这个问题，提供一个多选的功能，可以使checkbox之类的，一次选择多个 处理方法 官方的图片选择器(但是不支持所有版本的androi，只支持API Level
  • mysql中查询生日提醒的日期相关的sql baalwolf mysql
    SELECT sysid,user_name,birthday,listid,userhead_50,CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')),CURDATE(),  dayofyear( CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')))-dayofyear(
  • MongoDB索引文件破坏后导致查询错误的问题 BigBird2012 mongodb
    问题描述： MongoDB在非正常情况下关闭时，可能会导致索引文件破坏，造成数据在更新时没有反映到索引上。 解决方案：   使用脚本，重建MongoDB所有表的索引。 var names = db.getCollectionNames(); for( var i in names ){ var name = names[i]; print(name);
  • Javascript Promise bijian1013 JavaScriptPromise
            Parse JavaScript SDK现在提供了支持大多数异步方法的兼容jquery的Promises模式，那么这意味着什么呢，读完下文你就了解了。 一.认识Promises         “Promises”代表着在javascript程序里下一个伟大的范式，但是理解他们为什么如此伟大不是件简
  • [Zookeeper学习笔记九]Zookeeper源代码分析之Zookeeper构造过程 bit1129 zookeeper
       Zookeeper重载了几个构造函数，其中构造者可以提供参数最多，可定制性最多的构造函数是     public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolea
  • 【Java命令三】jstack bit1129 jstack
    jstack是用于获得当前运行的Java程序所有的线程的运行情况(thread dump），不同于jmap用于获得memory dump   [hadoop@hadoop sbin]$ jstack Usage: jstack [-l] <pid> (to connect to running process) jstack -F
  • jboss 5.1启停脚本　动静分离部署 ronin47
    以前启动jboss，往各种xml配置文件，现只要运行一句脚本即可。start nohup sh /**/run.sh -c servicename  -b ip -g  clustername   -u broatcast jboss.messaging.ServerPeerID=int  -Djboss.service.binding.set=p
  • UI之如何打磨设计能力? brotherlamp UIui教程ui自学ui资料ui视频
      在越来越拥挤的初创企业世界里，视觉设计的重要性往往可以与杀手级用户体验比肩。在许多情况下，尤其对于 Web 初创企业而言，这两者都是不可或缺的。前不久我们在《右脑革命：别学编程了，学艺术吧》中也曾发出过重视设计的呼吁。如何才能提高初创企业的设计能力呢?以下是 9 位创始人的体会。 1.找到自己的方式 如果你是设计师，要想提高技能可以去设计博客和展示好设计的网站如D-lists或
  • 三色旗算法 bylijinnan java算法
    import java.util.Arrays; /** 问题： 假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序， 您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳 子上进行这个动作，而且一次只能调换两个旗子。 网上的解法大多类似： 在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来
  • 警告:No configuration found for the specified action: \'s chiangfai configuration
    1.index.jsp页面form标签未指定namespace属性。 <!--index.jsp代码--> <%@taglib prefix="s" uri="/struts-tags"%> ... <s:form action="submit" method="post"&g
  • redis -- hash_max_zipmap_entries设置过大有问题 chenchao051 redishash
    使用redis时为了使用hash追求更高的内存使用率，我们一般都用hash结构，并且有时候会把hash_max_zipmap_entries这个值设置的很大，很多资料也推荐设置到1000，默认设置为了512，但是这里有个坑   #define ZIPMAP_BIGLEN 254 #define ZIPMAP_END 255     /* Return th
  • select into outfile access deny问题 daizj mysqltxt导出数据到文件
    本文转自：http://hatemysql.com/2010/06/29/select-into-outfile-access-deny%E9%97%AE%E9%A2%98/ 为应用建立了rnd的帐号，专门为他们查询线上数据库用的，当然，只有他们上了生产网络以后才能连上数据库，安全方面我们还是很注意的，呵呵。 授权的语句如下： grant select on armory.* to rn
  • phpexcel导出excel表简单入门示例 dcj3sjt126com PHPExcelphpexcel
    <?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE);   if (PHP_SAPI == 'cli') die('This example should only be run from a Web Brows
  • 美国电影超短200句 dcj3sjt126com 电影
    1. I see． 我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too． 我也是。5. My god! 天哪!6. No way! 不行!7. Come on． 来吧(赶快)8. Hold on． 等一等。9. I agree。 我同意。10. Not bad． 还不错。11. Not yet． 还没。12. See you． 再见。13. Shut up!
  • Java访问远程服务 dyy_gusi httpclientwebservicegetpost
        随着webService的崛起，我们开始中会越来越多的使用到访问远程webService服务。当然对于不同的webService框架一般都有自己的client包供使用，但是如果使用webService框架自己的client包，那么必然需要在自己的代码中引入它的包，如果同时调运了多个不同框架的webService，那么就需要同时引入多个不同的clien
  • Maven的settings.xml配置 geeksun settings.xml
    settings.xml是Maven的配置文件，下面解释一下其中的配置含义： settings.xml存在于两个地方： 1.安装的地方：$M2_HOME/conf/settings.xml 2.用户的目录：${user.home}/.m2/settings.xml 前者又被叫做全局配置，后者被称为用户配置。如果两者都存在，它们的内容将被合并，并且用户范围的settings.xml优先。
  • ubuntu的init与系统服务设置 hongtoushizi ubuntu
    转载自：  http://iysm.net/?p=178 init Init是位于/sbin/init的一个程序，它是在linux下，在系统启动过程中，初始化所有的设备驱动程序和数据结构等之后，由内核启动的一个用户级程序，并由此init程序进而完成系统的启动过程。 ubuntu与传统的linux略有不同，使用upstart完成系统的启动，但表面上仍维持init程序的形式。 运行
  • 跟我学Nginx+Lua开发目录贴 jinnianshilongnian nginxlua
    使用Nginx+Lua开发近一年的时间，学习和实践了一些Nginx+Lua开发的架构，为了让更多人使用Nginx+Lua架构开发，利用春节期间总结了一份基本的学习教程，希望对大家有用。也欢迎谈探讨学习一些经验。    目录 第一章 安装Nginx+Lua开发环境 第二章 Nginx+Lua开发入门 第三章 Redis/SSDB+Twemproxy安装与使用 第四章 L
  • php位运算符注意事项 home198979 位运算PHP&
    $a = $b = $c = 0; $a & $b = 1; $b | $c = 1  问a,b,c最终为多少?   当看到这题时，我犯了一个低级错误，误 以为位运算符会改变变量的值。所以得出结果是1 1 0 但是位运算符是不会改变变量的值的，例如： $a=1;$b=2; $a&$b;  这样a,b的值不会有任何改变
  • Linux shell数组建立和使用技巧 pda158 linux
    1.数组定义 　　[chengmo@centos5 ~]$ a=(1 2 3 4 5) 　　[chengmo@centos5 ~]$ echo $a 　　1 　　一对括号表示是数组，数组元素用“空格”符号分割开。 　　 2.数组读取与赋值 　　得到长度： 　　[chengmo@centos5 ~]$ echo ${#a[@]} 　　5 　　用${#数组名[@或
  • hotspot源码(JDK7) ol_beta javaHotSpotjvm
    源码结构图，方便理解：   ├─agent                            Serviceab
  • Oracle基本事务和ForAll执行批量DML练习 vipbooks oraclesql
    基本事务的使用： 从账户一的余额中转100到账户二的余额中去，如果账户二不存在或账户一中的余额不足100则整笔交易回滚 select * from account; -- 创建一张账户表 create table account( -- 账户ID id number(3) not null, -- 账户名称 nam
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他