本文查閱方法：
一、查閱目錄 —— 查閱本文目錄，肯定想要查閱的目錄標題
二、快捷「查找」 —— 在當前瀏覽器頁面，按鍵 「Ctrl+F」 按鍵組合，開啓瀏覽器的查找功能，
在查找搜索框中 輸入須要查閱的 目錄標題，即可以直接到達 標題內容 的位置。
三、學習小結 —— 文中的學習小結內容，是筆者在學習以後總結出的，開發時可直接參考其進行應用開發的內容， 進一步加快了本文的查閱 速度。（水平有限，僅供參考。）html
本文目錄java
學習筆記 web
一、自定義標籤簡介瀏覽器
二、Tag接口的執行流程session
三、自定義標籤調用圖解app
四、自定義標籤體系樹狀圖less
五、自定義標籤體系中五個接口的 介紹 jsp
六、TLD標籤描述文件 模版 ide
七、自定義標籤——傳統標籤Tag接口 Demo樣例 函數
(1)控制jsp頁面某一部份內容是否執行。（權限控制）
(2) 控制整個jsp頁面是否執行。（權限控制）
(3) 控制jsp頁面內容重複執行。
(4) 修改jsp頁面內容輸出。
(5)其餘案例：使用標籤輸出客戶機IP。
八、簡單標籤(SimpleTag接口)介紹
九、SimpleTag接口中的 方法介紹
十、SimpleTag接口方法的執行順序
十一、JspFragment類詳解
十二、invoke方法詳解
1三、自定義標籤——簡單標籤SimpleTag接口 Demo樣例
(1)控制jsp頁面某一部份內容是否執行。
(2)控制整個jsp頁面是否執行 。（權限控制）
(3)控制jsp頁面內容重複執行。
(4)修改jsp頁面內容輸出。
1四、開發帶屬性的標籤
1五、在TLD中描述標籤屬性 attribute
1六、開發帶屬性的標籤Demo樣例
1七、自定義標籤案例Demo（SimpleTag 接口及其實現類 SimpleTagSupport ）
(1)開發防盜鏈標籤——是否執行餘下JSP
(2)開發<c:if>標籤——是否執行標籤
(3)開發<c:if><c:else>標籤——演示父標籤操做
(4)開發迭代標籤——重複執行標籤體
(5)開發html轉義標籤——修改標籤體
學習筆記
(1)自定義標籤的流程
(a)建立Java類，繼承 SimpleTagSupport類。如有屬性，則爲其設定setter()方法。
(b)複寫toTag()方法。並在方法內進行鍼對JSP頁面的邏輯控制編碼。
(c)在TLD文件中註冊 Tag標籤。
(d)在JSP頁面中使用<%@tag uri="" prefix=""%> 指令 引入自定義標籤。
(e)在目標位置調用自定義標籤。
(2)TLD文件模版
tld文件模版：my.tld ：
<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2eehttp://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
version="2.0">
<description>A tag library exercising SimpleTag handlers.</description>
<tlib-version>1.0</tlib-version>
<short-name>SimpleTagLibrary</short-name>
<uri>/my</uri> //注：該部分uri能夠自定義修改。
//自定義標籤 描述部分
<tag>
<name>demo1</name>
<tag-class>cn.sina.web.tag.TagDemo1</tag-class>
<body-content>JSP</body-content>
<attribute>
<name>site</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue> //支持EL表達式
</attribute>
</tag>
//自定義標籤函數 描述部分
<function>
<name>add</name>
<function-class>cn.sina.demo.MyEL</function-class>
<function-signature>java.lang.String add( java.lang.String,java.lang.String )</function-signature>
</function>
</taglib>
(3)Demo樣例：開發防盜鏈標籤——是否執行餘下JSP
標籤處理器類：
public class RefererTag extends SimpleTagSupport {
private String site; //重定向的頁面： 定義JSP頁面端，自定義標籤的屬性
private String page; //重定向的站點名稱：定義JSP頁面端，自定義標籤的屬性
public void setSite(String site) {
this.site = site;
}
public void setPage(String page) {
this.page = page;
}
@Override
public void doTag() throws JspException, IOException {
PageContext pageContext = (PageContext) this.getJspContext();
HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
HttpServletResponse response = (HttpServletResponse) pageContext.getResponse();
//1.獲得來訪問者referer
String referer = request.getHeader("referer");
//2.判斷來訪者的頁面是否是要防盜鏈的網站
if(referer==null || !referer.startsWith(site)){
if(page.startsWith(request.getContextPath())){
response.sendRedirect(page);
}else if(page.startsWith("/")){
response.sendRedirect(request.getContextPath() + page);
}else{
response.sendRedirect(request.getContextPath() + "/" + page);
}
throw new SkipPageException();
}
}
}
TLD文件：
<tag>
<name>referer</name>
<tag-class>cn.sina .web.tag.example.RefererTag</tag-class>
<body-content>empty</body-content>
<attribute>
<name>site</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue> //支持EL表達式
</attribute>
<attribute>
<name>page</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="/example" prefix="e" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<e:referer site="http://localhost" page="index.jsp"/>
<html>
<head>
<title>My JSP '1.jsp' starting page</title>
</head>
<body>
採訪鳳姐xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx採訪鳳姐！！！
</body>
</html>
一、自定義標籤簡介
自定義標籤主要用於移除Jsp頁面中的java代碼。
使用自定義標籤移除jsp頁面中的java代碼，只須要完成如下兩個步驟：
(1)編寫一個實現Tag接口的Java類(標籤處理器類)。
(2)編寫標籤庫描述符（tld）文件，在tld文件中對標籤處理器類描述成一個標籤。
二、Tag接口的執行流程
JSP引擎將遇到自定義標籤時，首先建立標籤處理器類的實例對象，而後按照JSP規範定義的通訊規則依次調用它的方法。
(1)public void setPageContext(PageContext pc)， JSP引擎實例化標籤處理器後，將調用setPageContext方法將JSP頁面的pageContext對象傳遞給標籤處理器，標籤處理器之後能夠經過這個pageContext對象與JSP頁面進行通訊。
(2) public void setParent(Tag t)，setPageContext方法執行完後，WEB容器接着調用的setParent方法將當前標籤的父標籤傳遞給當前標籤處理器，若是當前標籤沒有父標籤，則傳遞給setParent方法的參數值爲null。
(3) public int doStartTag()，調用了setPageContext方法和setParent方法以後，WEB容器執行到自定義標籤的開始標記時，就會調用標籤處理器的doStartTag方法。
(4) public int doEndTag()，WEB容器執行完自定義標籤的標籤體後，就會接着去執行自定義標籤的結束標記，此時，WEB容器會去調用標籤處理器的doEndTag方法。
(5) public void release()，一般WEB容器執行完自定義標籤後，標籤處理器會駐留在內存中，爲其它請求服務，直至中止web應用時，web容器纔會調用release方法。
三、自定義標籤調用圖解
四、自定義標籤體系樹狀圖
五、自定義標籤體系中五個接口的 介紹
(1) JspTag接口
JspTag接口是全部自定義標籤的父接口，它是JSP2.0中新定義的一個標記接口，沒有任何屬性和方法。JspTag接口有Tag和SimpleTag兩個直接子接口，JSP2.0之前的版本中只有Tag接口，因此把實現Tag接口的自定義標籤也叫作傳統標籤，把實現SimpleTag接口的自定義標籤叫作簡單標籤。本文中若是沒有特別說明，自定義標籤泛指傳統標籤。
(2) Tag接口
上圖中的Tag接口是全部傳統標籤的父接口，其中定義了兩個重要方法（doStartTag、doEndTag）方法和四個常量（EVAL_BODY_INCLUDE、SKIP_BODY、EVAL_PAGE、SKIP_PAGE），這兩個方法和四個常量的做用以下：
（a）WEB容器在解釋執行JSP頁面的過程當中，遇到自定義標籤的開始標記就會去調用標籤處理器的doStartTag方法，doStartTag方法執行完後能夠向WEB容器返回常量EVAL_BODY_INCLUDE或SKIP_BODY。若是doStartTag方法返回EVAL_BODY_INCLUDE，WEB容器就會接着執行自定義標籤的標籤體；若是doStartTag方法返回SKIP_BODY，WEB容器就會忽略自定義標籤的標籤體，直接解釋執行自定義標籤的結束標記。
（b）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頁面中位於自定義標籤的結束標記後面的內容。
(3) 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接口將簡化開發工做。
(4) 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接口將簡化開發工做。
(5) SimpleTag接口
SimpleTag接口是JSP2.0中新增的一個標籤接口。因爲傳統標籤使用三個標籤接口來完成不一樣的功能，顯得過於繁瑣，不利於標籤技術的推廣，所以，SUN公司爲下降標籤技術的學習難度，在JSP 2.0中定義了一個更爲簡單、便於編寫和調用的SimpleTag接口。SimpleTag接口與傳統標籤接口最大的區別在於，SimpleTag接口只定義了一個用於處理標籤邏輯的doTag方法，該方法在WEB容器執行自定義標籤時調用，而且只被調用一次。那些使用傳統標籤接口所完成的功能，例如是否執行標籤體、迭代標籤體、對標籤體內容進行修改等功能均可以在doTag方法中完成。
在JSP API中也提供了SimpleTag接口的實現類SimpleTagSupport，讀者在編寫簡單標籤時，能夠繼承和擴展SimpleTagSupport類，這相比實現SimpleTag接口將簡化開發工做。
爲方便讀者往後查詢傳統標籤接口中的各個方法能夠返回的返回值，在下表中列舉了Tag接口、IterationTag接口和BodyTag接口中的主要方法及它們分別能夠返回的返回值的說明。
六、TLD標籤描述文件 模版
tld文件模版：my.tld ：
<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2eehttp://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
version="2.0">
<description>A tag library exercising SimpleTag handlers.</description>
<tlib-version>1.0</tlib-version>
<short-name>SimpleTagLibrary</short-name>
<uri>/my</uri> //注：該部分uri能夠自定義修改。
//自定義標籤 描述部分
<tag>
<name>demo1</name>
<tag-class>cn.sina.web.tag.TagDemo1</tag-class>
<body-content>JSP</body-content>
</tag>
//自定義標籤函數 描述部分
<function>
<name>add</name>
<function-class>cn.sina.demo.MyEL</function-class>
<function-signature>java.lang.String add( java.lang.String,java.lang.String )</function-signature>
</function>
</taglib>
七、自定義標籤——傳統標籤接口 Demo樣例
開發人員在編寫Jsp頁面時，常常還須要在頁面中引入一些邏輯，例如：
(1)控制jsp頁面某一部份內容是否執行。（權限控制）
Demo樣例：
標籤處理器類：
public class TagDemo1 extends TagSupport {
@Override
public int doStartTag() throws JspException {
return Tag.SKIP_BODY;
}
}
TLD文件：
<tag>
<name>demo1</name>
<tag-class>cn.sina .web.tag.TagDemo1</tag-class>
<body-content>JSP</body-content>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="http://www.sina .cn" prefix="sina " %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>使用標籤控制頁面內容(標籤體)是否輸出</title>
</head>
<body>
<sina :demo1>
aaaaa
</sina :demo1>
</body>
</html>
(2) 控制整個jsp頁面是否執行。（權限控制）
Demo樣例：
標籤處理器類：
public class TagDemo2 extends TagSupport {
@Override
public int doEndTag() throws JspException {
return Tag.EVAL_PAGE;
}
}
TLD文件：
<tag>
<name>demo2</name>
<tag-class>cn.sina .web.tag.TagDemo2</tag-class>
<body-content>empty</body-content>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="http://www.sina .cn" prefix="sina " %>
<sina :demo2/>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>用標籤控制整個jsp是否輸出</title>
</head>
<body>
This is my JSP page. <br>
</body>
</html>
(3) 控制jsp頁面內容重複執行。
Demo樣例：
標籤處理器類：
//控制標籤體執行5次
public class TagDemo3 extends TagSupport {
int x = 5;
@Override
public int doStartTag() throws JspException {
return Tag.EVAL_BODY_INCLUDE;
}
@Override
public int doAfterBody() throws JspException {
x--;
if(x>0){
return IterationTag.EVAL_BODY_AGAIN;
}else{
return IterationTag.SKIP_BODY;
}
}
}
TLD文件：
<tag>
<name>demo3</name>
<tag-class>cn.sina .web.tag.TagDemo3</tag-class>
<body-content>JSP</body-content>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="http://www.sina .cn" prefix="sina " %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>用標籤控制標籤體重複執行</title>
</head>
<body>
<sina :demo3>
This is my JSP page. <br>
</sina :demo3>
</body>
</html>
(4) 修改jsp頁面內容輸出。
Demo樣例：
標籤處理器類：
//修改標籤體(把標籤體改成大寫)
public class TagDemo4 extends BodyTagSupport {
@Override
public int doStartTag() throws JspException {
// TODO Auto-generated method stub
return BodyTag.EVAL_BODY_BUFFERED;
}
@Override
public int doEndTag() throws JspException {
BodyContent bc = this.getBodyContent(); //獲得標籤體
String content = bc.getString();
content = content.toUpperCase();
try {
this.pageContext.getOut().write(content);
} catch (IOException e) {
throw new RuntimeException(e);
}
return Tag.EVAL_PAGE;
}
}
TLD文件：
<tag>
<name>demo4</name>
<tag-class>cn.sina sina .web.tag.TagDemo4</tag-class>
<body-content>JSP</body-content>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="http://www.sina .cn" prefix="sina " %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>用標籤修改jsp頁面內容</title>
</head>
<body>
<sina :demo4>
aaaaaa
</sina :demo4>
</body>
</html>
(5)其餘案例：使用標籤輸出客戶機IP。
Demo樣例：
標籤處理器類：
public class ViewIPTag extends TagSupport {
@Override
public int doStartTag() throws JspException {
HttpServletRequest request = (HttpServletRequest) this.pageContext.getRequest();
JspWriter out = this.pageContext.getOut();
String ip = request.getRemoteAddr();
try {
out.print(ip);
}catch (IOException e) {
throw new RuntimeException(e);
}
return super.doStartTag();
}
}
TLD文件：
<tag>
<name>viewIP</name>
<tag-class>cn.sina .web.tag.ViewIPTag</tag-class>
<body-content>empty</body-content>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="http://www.sina .cn" prefix="sina " %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>My JSP '1.jsp' starting page</title>
</head>
<body>
您的ip是：<sina :viewIP/>
</body>
</html>
自定義標籤除了能夠移除jsp頁面java代碼外，它也能夠實現以上功能。
tld文件中的四種標籤體類型：
EMPTY ： 沒有標籤體 （傳統標籤和簡單標籤 通用）
JSP ： 標籤體爲JSP片斷 (傳統標籤Tag接口中使用)
scriptless ： 沒有腳本代碼 (簡單標籤SimpleTag接口中使用)
tagdepentend ：
八、簡單標籤(SimpleTag接口)介紹
因爲傳統標籤使用三個標籤接口來完成不一樣的功能，顯得過於繁瑣，不利於標籤技術的推廣，SUN公司爲下降標籤技術的學習難度，在JSP 2.0中定義了一個更爲簡單、便於編寫和調用的SimpleTag接口來實現標籤的功能。實現SimpleTag接口的標籤一般稱爲簡單標籤。簡單標籤共定義了5個方法：
setJspContext方法
setParent和getParent方法
setJspBody方法
doTag方法
九、SimpleTag接口中的 方法介紹
(1)setJspContext方法
用於把JSP頁面的pageContext對象傳遞給標籤處理器對象
(2) setParent方法
用於把父標籤處理器對象傳遞給當前標籤處理器對象
(3) getParent方法
用於得到當前標籤的父標籤處理器對象
(4) setJspBody方法
用於把表明標籤體的JspFragment對象傳遞給標籤處理器對象
(5) doTag方法
用於完成全部的標籤邏輯，包括輸出、迭代、修改標籤體內容等。
在doTag方法中能夠拋出javax.servlet.jsp.SkipPageException異常，用於通知WEB容器再也不執行JSP頁面中位於結束標記後面的內容，這等效於在傳統標籤的doEndTag方法中返回Tag.SKIP_PAGE常量的狀況。
十、SimpleTag接口方法的執行順序
當web容器開始執行標籤時，會調用以下方法完成標籤的初始化
(1)WEB容器調用標籤處理器對象的setJspContext方法，將表明JSP頁面的pageContext對象傳遞給標籤處理器對象。
(2) WEB容器調用標籤處理器對象的setParent方法，將父標籤處理器對象傳遞給這個標籤處理器對象。注意，只有在標籤存在父標籤的狀況下，WEB容器纔會調用這個方法。
(3) 若是調用標籤時設置了屬性，容器將調用每一個屬性對應的setter方法把屬性值傳遞給標籤處理器對象。若是標籤的屬性值是EL表達式或腳本表達式，則WEB容器首先計算表達式的值，而後把值傳遞給標籤處理器對象。
(4) 若是簡單標籤有標籤體，容器將調用setJspBody方法把表明標籤體的JspFragment對象傳遞進來。
(5) 執行標籤時，容器調用標籤處理器的doTag()方法，開發人員在方法體內經過操做JspFragment對象，就能夠實現是否執行、迭代、修改標籤體的目的。
十一、JspFragment類詳解
javax.servlet.jsp.tagext.JspFragment類是在JSP2.0中定義的，它的實例對象表明JSP頁面中的一段符合JSP語法規範的JSP片斷，這段JSP片斷中不能包含JSP腳本元素。
WEB容器在處理簡單標籤的標籤體時，會把標籤體內容用一個JspFragment對象表示，並調用標籤處理器對象的setJspBody方法把JspFragment對象傳遞給標籤處理器對象。JspFragment類中只定義了兩個方法，以下所示：
(1) getJspContext方法
用於返回表明調用頁面的JspContext對象.
(2) public abstract void invoke(java.io.Writer out)
用於執行JspFragment對象所表明的JSP代碼片斷
備註：參數out用於指定將JspFragment對象的執行結果寫入到哪一個輸出流對象中，若是傳遞給參數out的值爲null，則將執行結果寫入到JspContext.getOut()方法返回的輸出流對象中。(簡而言之，能夠理解爲寫給瀏覽器)
十二、invoke方法詳解
JspFragment.invoke方法是JspFragment最重要的方法，利用這個方法能夠控制是否執行和輸出標籤體的內容、是否迭代執行標籤體的內容或對標籤體的執行結果進行修改後再輸出。例如：
(1) 在標籤處理器中若是沒有調用JspFragment.invoke方法，其結果就至關於忽略標籤體內容；
(2) 在標籤處理器中重複調用JspFragment.invoke方法，則標籤體內容將會被重複執行；
(3) 若想在標籤處理器中修改標籤體內容，只需在調用invoke方法時指定一個可取出結果數據的輸出流對象（例如StringWriter），讓標籤體的執行結果輸出到該輸出流對象中，而後從該輸出流對象中取出數據進行修改後再輸出到目標設備，便可達到修改標籤體的目的。
1三、自定義標籤——SimpleTag接口 Demo樣例
(1)控制jsp頁面某一部份內容是否執行。
Demo樣例：
標籤處理器類：
//控制標籤體是否執行
public class SimpleTagDemo1 extends SimpleTagSupport {
@Override
public void doTag() throws JspException, IOException {
JspFragment jf = this.getJspBody();
//jf.invoke(this.getJspContext().getOut());
}
}
TLD文件：
<tag>
<name>demo1</name>
<tag-class>cn.sina .web.simpletag.SimpleTagDemo1</tag-class>
<body-content>scriptless</body-content>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="/simpletag" prefix="ssina" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>用簡單標籤控制是否執行標籤體</title>
</head>
<body>
<ssina :demo1>
aaaaa
</ssina :demo1>
</body>
</html>
(2)控制整個jsp頁面是否執行 。（權限控制）
Demo樣例：
標籤處理器類：
//控制標籤餘下的jsp不執行
public class SimpleTagDemo4 extends SimpleTagSupport {
@Override
public void doTag() throws JspException, IOException {
throw new SkipPageException();
}
}
TLD文件：
<tag>
<name>demo4</name>
<tag-class>cn.sina .web.simpletag.SimpleTagDemo4</tag-class>
<body-content>empty</body-content>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="/simpletag" prefix="ssina " %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<ssina :demo4/>
<html>
<head>
<title>控制整個jsp頁面是否執行 </title>
</head>
<body>
ssss
</body>
</html>
(3)控制jsp頁面內容重複執行。
Demo樣例：
標籤處理器類：
//控制jsp頁面內容重複執行
public class SimpleTagDemo2 extends SimpleTagSupport {
@Override
public void doTag() throws JspException, IOException {
JspFragment jf = this.getJspBody();
for(int i=0;i<5;i++){
jf.invoke(null);
//jf.invoke(this.getJspContext().getOut());
}
}
}
TLD文件：
<tag>
<name>demo2</name>
<tag-class>cn.sina .web.simpletag.SimpleTagDemo2</tag-class>
<body-content>scriptless</body-content>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="/simpletag" prefix="ssina " %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>迭代標籤體</title>
</head>
<body>
<ssina :demo2>
This is my JSP page. <br>
</ssina :demo2>
</body>
</html>
(4)修改jsp頁面內容輸出。
Demo樣例：
標籤處理器類：
//修改標籤體
public class SimpleTagDemo3 extends SimpleTagSupport {
@Override
public void doTag() throws JspException, IOException {
JspFragment jf = this.getJspBody();
StringWriter sw = new StringWriter();
jf.invoke(sw);
String content = sw.toString();
content = content.toUpperCase();
this.getJspContext().getOut().write(content);
}
}
TLD文件：
<tag>
<name>demo3</name>
<tag-class>cn.sina .web.simpletag.SimpleTagDemo3</tag-class>
<body-content>scriptless</body-content>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="/simpletag" prefix="ssina " %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>修改標籤體</title>
</head>
<body>
<ssina :demo3>
aaaaaaa
</ssina :demo3>
</body>
</html>
1四、開發帶屬性的標籤
自定義標籤能夠定義一個或多個屬性，這樣，在JSP頁面中應用自定義標籤時就能夠設置這些屬性的值，經過這些屬性爲標籤處理器傳遞參數信息，從而提升標籤的靈活性和複用性。
要想讓一個自定義標籤具備屬性，一般須要完成兩個任務：
(1)在標籤處理器中編寫每一個屬性對應的setter方法
(2)在TLD文件中描術標籤的屬性
爲自定義標籤 定義屬性時，每一個屬性都必須按照JavaBean的屬性命名方式，在標籤處理器中定義屬性名對應的setter方法，用來接收JSP頁面調用自定義標籤時傳遞進來的屬性值。 例如屬性url，在標籤處理器類中就要定義相應的setUrl(String url)方法。
在標籤處理器中定義相應的set方法後，JSP引擎在解析執行開始標籤前，也就是調用doStartTag方法前，會調用set屬性方法，爲標籤設置屬性。
1五、在TLD中描述標籤屬性 attribute
<tag>元素的<attribute>子元素用於描述自定義標籤的一個屬性，自定義標籤所具備的每一個屬性都要對應一個<attribute>元素 。
<attribute>
<description>description</description>
<name>aaaa</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
<type>ObjectType</type>
</attribute>
各屬性詳解
1六、開發帶屬性的標籤Demo樣例
Demo樣例：
標籤處理器類：
public class SimpleTagDemo5 extends SimpleTagSupport {
private int count;
private Date date;
public void setCount(int count) {
this.count = count;
}
public void setDate(Date date) {
this.date = date;
}
@Override
public void doTag() throws JspException, IOException {
JspFragment jf = this.getJspBody();
this.getJspContext().getOut().write(date.toLocaleString() + "<br/>");
for(int i=0;i<count;i++){
jf.invoke(null);
}
}
}
TLD文件：
<tag>
<name>demo5</name>
<tag-class>cn.sina .web.simpletag.SimpleTagDemo5</tag-class>
<body-content>scriptless</body-content>
<attribute>
<name>count</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
<attribute>
<name>date</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="/simpletag" prefix="ssina " %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>開發帶屬性的標籤</title>
</head>
<body>
<ssina :demo5 count="3" date="<%=new Date() %>">
aaaaaa
</ssina :demo5>
</body>
</html>
1七、自定義標籤案例Demo（SimpleTag 接口及其實現類 SimpleTagSupport ）
(1)開發防盜鏈標籤——是否執行餘下JSP
Demo樣例：
標籤處理器類：
public class RefererTag extends SimpleTagSupport {
private String site; //重定向的頁面： 定義JSP頁面端，自定義標籤的屬性
private String page; //重定向的站點名稱：定義JSP頁面端，自定義標籤的屬性
public void setSite(String site) {
this.site = site;
}
public void setPage(String page) {
this.page = page;
}
@Override
public void doTag() throws JspException, IOException {
PageContext pageContext = (PageContext) this.getJspContext();
HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
HttpServletResponse response = (HttpServletResponse) pageContext.getResponse();
//1.獲得來訪問者referer
String referer = request.getHeader("referer");
//2.判斷來訪者的頁面是否是要防盜鏈的網站
if(referer==null || !referer.startsWith(site)){
if(page.startsWith(request.getContextPath())){
response.sendRedirect(page);
}else if(page.startsWith("/")){
response.sendRedirect(request.getContextPath() + page);
}else{
response.sendRedirect(request.getContextPath() + "/" + page);
}
throw new SkipPageException();
}
}
}
TLD文件：
<tag>
<name>referer</name>
<tag-class>cn.sina .web.tag.example.RefererTag</tag-class>
<body-content>empty</body-content>
<attribute>
<name>site</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue> //支持EL表達式
</attribute>
<attribute>
<name>page</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="/example" prefix="e" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<e:referer site="http://localhost" page="index.jsp"/>
<html>
<head>
<title>My JSP '1.jsp' starting page</title>
</head>
<body>
鳳姐xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx鳳姐！！！
</body>
</html>
(2)開發<c:if>標籤——是否執行標籤
Demo樣例：
標籤處理器類：
public class IfTag extends SimpleTagSupport {
private boolean test;
public void setTest(boolean test) {
this.test = test;
}
@Override
public void doTag() throws JspException, IOException {
if(test){
this.getJspBody().invoke(null);
}
}
}
TLD文件：
<tag>
<name>if</name>
<tag-class>cn.sina .web.tag.example.IfTag</tag-class>
<body-content>scriptless</body-content>
<attribute>
<name>test</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="/example" prefix="c" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>My JSP '2.jsp' starting page</title>
</head>
<body>
<%
session.setAttribute("user","aaa");
%>
<c:if test="${user==null }">
aaaaa
</c:if>
<c:if test="${user!=null }">
bbbbb
</c:if>
</body>
</html>
(3)開發<c:if><c:else>標籤——演示父標籤操做
Demo樣例：
標籤處理器類：
//標籤<c:choose> 的處理器類
public class ChooseTag extends SimpleTagSupport {
private boolean isDo;
public boolean isDo() { //get
return isDo;
}
public void setDo(boolean isDo) { //set
this.isDo = isDo;
}
@Override
public void doTag() throws JspException, IOException {
this.getJspBody().invoke(null);
}
}
//標籤<c:when test="${user==null }"> 的處理器類
public class WhenTag extends SimpleTagSupport {
private boolean test;
public void setTest(boolean test) {
this.test = test;
}
@Override
public void doTag() throws JspException, IOException {
ChooseTag parent = (ChooseTag) this.getParent();
if(test && !parent.isDo()){
this.getJspBody().invoke(null);
parent.setDo(true);
}
}
}
//標籤<c:otherwise> 的處理器類
public class OtherWiseTag extends SimpleTagSupport {
@Override
public void doTag() throws JspException, IOException {
ChooseTag parent = (ChooseTag) this.getParent();
if(!parent.isDo()){
this.getJspBody().invoke(null);
parent.setDo(true);
}
}
}
TLD文件：
<tag>
<name>choose</name>
<tag-class>cn.sina .web.tag.example.ChooseTag</tag-class>
<body-content>scriptless</body-content>
</tag>
<tag>
<name>when</name>
<tag-class>cn.sina .web.tag.example.WhenTag</tag-class>
<body-content>scriptless</body-content>
<attribute>
<name>test</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
<tag>
<name>otherwise</name>
<tag-class>cn.sina .web.tag.example.OtherWiseTag</tag-class>
<body-content>scriptless</body-content>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="/example" prefix="c" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>My JSP '3.jsp' starting page</title>
</head>
<body>
<c:choose>
<c:when test="${user==null }">
aaaa
</c:when>
<c:otherwise>
bbbb
</c:otherwise>
</c:choose>
</body>
</html>
(4)開發迭代標籤——重複執行標籤體
Demo樣例：
標籤處理器類：
public class ForeachTag2 extends SimpleTagSupport {
private String var;
private Object items;
private Collection collection;
public void setItems(Object items) { //int[]
this.items = items; //int[]
if(items instanceof Collection){ //list set
collection = (Collection) items;
}
if(items instanceof Map){
Map map = (Map) items;
collection = map.entrySet(); //set
}
if(items.getClass().isArray()){
this.collection = new ArrayList();
int length = Array.getLength(items);
for(int i=0;i<length;i++){
Object value = Array.get(items, i);
this.collection.add(value);
}
}
/*
if(items instanceof Object[]){ //int[]
Object obj[] = (Object[]) items;
collection = Arrays.asList(obj);
}
if(items instanceof int[]){
int arr[] = (int[]) items;
this.collection = new ArrayList();
for(int i : arr){
this.collection.add(i);
}
}
*/
}
public void setVar(String var) {
this.var = var;
}
@Override
public void doTag() throws JspException, IOException {
Iterator it = this.collection.iterator();
while(it.hasNext()){
Object value = it.next();
this.getJspContext().setAttribute(var, value);
this.getJspBody().invoke(null);
}
}
}
TLD文件：
<tag>
<name>foreach2</name>
<tag-class>cn.sina .web.tag.example.ForeachTag2</tag-class>
<body-content>scriptless</body-content>
<attribute>
<name>items</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
<attribute>
<name>var</name>
<required>true</required>
<rtexprvalue>false</rtexprvalue>
</attribute>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="/example" prefix="c" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>My JSP '4.jsp' starting page</title>
</head>
<body>
<%
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("dddd");
request.setAttribute("list",list);
%>
<c:foreach2 var="str" items="${list }">
${str }
</c:foreach2>
<br/>------------------------------------<br/>
<%
Map map = new HashMap();
map.put("aa","111");
map.put("bb","222");
map.put("cc","333");
map.put("dd","444");
request.setAttribute("map",map);
%>
<c:foreach2 var="entry" items="${map}" >
${entry.key } = ${entry.value }
</c:foreach2>
<br/>------------------------------------<br/>
<%
Integer num[] = {1,2,3,4};
request.setAttribute("num",num);
%>
<c:foreach2 var="i" items="${num}" >
${i}
</c:foreach2>
<br/>------------------------------------<br/>
<%
int arr[] = {1,2,3,4};
request.setAttribute("arr",arr);
%>
<c:foreach2 var="i" items="${arr}" >
${i}
</c:foreach2>
<br/>------------------------------------<br/>
<%
boolean b[] = {true,false,true};
request.setAttribute("b",b);
%>
<c:foreach2 var="i" items="${b}" >
${i}
</c:foreach2>
</body>
</html>
(5)開發html轉義標籤——修改標籤體
Demo樣例：
標籤處理器類：
public class HtmlFilterTag extends SimpleTagSupport {
@Override
public void doTag() throws JspException, IOException {
StringWriter sw = new StringWriter();
JspFragment jf = this.getJspBody();
jf.invoke(sw);
String content = sw.getBuffer().toString(); //<a href="">點點</a>
content = filter(content);
this.getJspContext().getOut().write(content);
}
public String filter(String message) {
if (message == null)
return (null);
char content[] = new char[message.length()];
message.getChars(0, message.length(), content, 0);
StringBuffer result = new StringBuffer(content.length + 50);
for (int i = 0; i < content.length; i++) {
switch (content[i]) {
case '<':
result.append("<");
break;
case '>':
result.append(">");
break;
case '&':
result.append("&");
break;
case '"':
result.append(""");
break;
default:
result.append(content[i]);
}
}
return (result.toString());
}
}
TLD文件：
<tag>
<name>htmlfilter</name>
<tag-class>cn.sina .web.tag.example.HtmlFilterTag</tag-class>
<body-content>scriptless</body-content>
</tag>
JSP頁面調用：
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@taglib uri="/example" prefix="c" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>My JSP '6.jsp' starting page</title>
</head>
<body>
<c:htmlfilter>
<a href="">點點</a>
</c:htmlfilter>
</body>
</html>
敬請評論
（1）若您以爲本文較好 —— 請留言評論相告其餘 IT童鞋們 本文的有用之處，以堅決他們閱讀本文的信心。
（2）若您以爲本文很差 —— 請留言評論相告筆者本文須要改進之處，以便共同爲咱們你們整理更加好用的筆記。