一、开发标签库
1.1、开发防盗链标签
1、编写标签处理器类：RefererTag.java
1 package me.gacl.web.simpletag;
2
3 import java.io.IOException;
4 import javax.servlet.http.HttpServletRequest;
5 import javax.servlet.http.HttpServletResponse;
6 import javax.servlet.jsp.JspException;
7 import javax.servlet.jsp.PageContext;
8 import javax.servlet.jsp.SkipPageException;
9 import javax.servlet.jsp.tagext.SimpleTagSupport;
10
11 /**
12 * @author gacl
13 * 防盗链标签RefererTag
14 */
15 public class RefererTag extends SimpleTagSupport {
16
17 /**
18 * 网站域名
19 */
20 private String site;
21
22 /**
23 * 要跳转的页面
24 */
25 private String page;
26
27 @Override
28 public void doTag() throws JspException, IOException {
29 //获取jsp页面的PageContext对象
30 PageContext pageContext = (PageContext) this.getJspContext();
31 //通过PageContext对象来获取HttpServletRequest对象
32 HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();
33 //获取请求的来路(Referer)
34 String referer = request.getHeader("referer");
35 //如果来路是null或者来路不是来自我们自己的site，那么就将请求重定向到page页面
36 if (referer == null || !referer.startsWith(site)) {
37 //获取HttpServletResponse对象
38 HttpServletResponse response = (HttpServletResponse)pageContext.getResponse();
39 String webRoot = request.getContextPath();
40 if (page.startsWith(webRoot)) {
41 //重定向到page页面
42 response.sendRedirect(page);
43 } else {
44 //重定向到page页面
45 response.sendRedirect(webRoot+page);
46 }
47 //重定向后，控制保护的页面不要执行
48 throw new SkipPageException();
49 }
50 }
51
52 public void setSite(String site) {
53 this.site = site;
54 }
55
56 public void setPage(String page) {
57 this.page = page;
58 }
59 }
2、在WEB-INF目录下tld文件中添加对该标签的描述，如下：
1 <?xml version="1.0" encoding="UTF-8"?>
2
3 <taglib version="2.0" 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
7 <description>孤傲苍狼开发的简单标签库</description>
8 <tlib-version>1.0</tlib-version>
9 <short-name>TagLib</short-name>
10 <uri>/gaclTagLib</uri>
11
12 <tag>
13 <!-- 标签名 -->
14 <name>referer</name>
15 <!-- 标签处理器类 -->
16 <tag-class>me.gacl.web.simpletag.RefererTag</tag-class>
17 <!-- 标签体允许的内容 -->
18 <body-content>empty</body-content>
19 <!-- 标签的属性描述 -->
20 <attribute>
21 <description>描述标签的site属性</description>
22 <!-- 标签的site属性 -->
23 <name>site</name>
24 <required>true</required>
25 <!-- rtexprvalue用来指示标签的属性值是否可以是一个表达式， 一般设置为true,true就表示允许标签的属性值可以是一个表达式 -->
26 <rtexprvalue>true</rtexprvalue>
27 </attribute>
28 <attribute>
29 <description>描述标签的page属性</description>
30 <!-- 标签的page属性 -->
31 <name>page</name>
32 <required>true</required>
33 <!-- rtexprvalue用来指示标签的属性值是否可以是一个表达式， 一般设置为true,true就表示允许标签的属性值可以是一个表达式 -->
34 <rtexprvalue>true</rtexprvalue>
35 </attribute>
36 </tag>
37
38 </taglib>
3、测试：在jsp页面中导入标签库并使用防盗链标签
1 <%@ page language="java" pageEncoding="UTF-8"%>
2 <%--在jsp页面中导入自定义标签库 --%>
3 <%@taglib uri="/gaclTagLib" prefix="gacl" %>
4 <%--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
5 <%@taglib uri="/WEB-INF/TagLib.tld" prefix="gacl"%>
6 --%>
7 <%--在Jsp页面中使用防盗链标签
8 当用户尝试直接通过URL地址(http://localhost:8080/JavaWeb_JspTag_study_20140816/simpletag/refererTagTest.jsp)访问这个页面时，
9 防盗链标签的标签处理器内部就会进行处理，将请求重定向到/index.jsp
10 --%>
11 <gacl:referer site="http://localhost:8080" page="/index.jsp"/>
12 <!DOCTYPE HTML>
13 <html>
14 <head>
15 <title>防盗链标签测试</title>
16 </head>
17
18 <body>
19 网站内部资料
20 </body>
21 </html>
运行效果如下：
1.2、开发<c:if>标签
1、编写标签处理器类：IFTag.java
1 package me.gacl.web.simpletag;
2
3 import java.io.IOException;
4 import javax.servlet.jsp.JspException;
5 import javax.servlet.jsp.tagext.SimpleTagSupport;
6
7 /**
8 * @author gacl
9 * 开发if标签
10 */
11 public class IFTag extends SimpleTagSupport {
12
13 /**
14 * if标签的test属性
15 */
16 private boolean test;
17
18 @Override
19 public void doTag() throws JspException, IOException {
20 if (test) {
21 this.getJspBody().invoke(null);
22 }
23 }
24
25 public void setTest(boolean test) {
26 this.test = test;
27 }
28 }
2、在WEB-INF目录下tld文件中添加对该标签的描述，如下：
1 <tag>
2 <description>if标签</description>
3 <name>if</name>
4 <tag-class>me.gacl.web.simpletag.IFTag</tag-class>
5 <body-content>scriptless</body-content>
6 <attribute>
7 <description>if标签的test属性</description>
8 <name>test</name>
9 <rtexprvalue>true</rtexprvalue>
10 <required>true</required>
11 </attribute>
12 </tag>
3、测试：在jsp页面中导入标签库并使用if标签
1 <%@ page language="java" pageEncoding="UTF-8"%>
2 <%--在jsp页面中导入自定义标签库 --%>
3 <%@taglib uri="/gaclTagLib" prefix="c" %>
4 <%--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
5 <%@taglib uri="/WEB-INF/TagLib.tld" prefix="c"%>
6 --%>
7 <!DOCTYPE HTML>
8 <html>
9 <head>
10 <title>if链标签测试</title>
11 </head>
12
13 <body>
14 <%--if标签的test属性值为true ,标签体的内容会输出--%>
15 <c:if test="true">
16 <h3>网站内部资料</h3>
17 </c:if>
18 <%--if标签的test属性值为false ,标签体的内容不会输出--%>
19 <c:if test="false">
20 这里的内部不输出
21 </c:if>
22 </body>
23 </html>
运行效果如下：
1.3、开发<c:when><c:otherwise>标签
这个标签的开发稍微有一点难度，因为这里面涉及到两个标签处理器类共享同一个变量的问题，如下：
1 <c:when test="${user != null}">
2 用户不为空
3 </c:when>
4 <c:otherwise>
5 用户为空
6 </c:otherwise>
<c:when>标签和<c:otherwise>标签对应着两个不同的标签处理器类，我们希望做到的效果是，如果<c:when>标签执行了，那么就<c:otherwise>标签就不要再执行，那么这里面就涉及到一个问题：<c:when>标签执行的时候该如何通知<c:otherwise>标签不要执行了呢？这个问题就涉及到了两个标签处理器类如何做到相互通讯的问题，如果<c:when>标签执行了，就要通过某种方式告诉<c:otherwise>标签不要执行，那么该如何做到这样的效果呢？让<c:when>标签处理器类和<c:otherwise>标签处理器类共享同一个变量就可以做到了，那么又该怎么做才能够让两个标签处理器类共享同一个变量呢，标准的做法是这样的：让两个标签拥有同一个父标签。
1、开发父标签：ChooseTag.java
1 package me.gacl.web.simpletag;
2
3 import java.io.IOException;
4 import javax.servlet.jsp.JspException;
5 import javax.servlet.jsp.tagext.SimpleTagSupport;
6
7 /**
8 * @author gacl
9 * when标签和otherwise标签的父标签
10 */
11 public class ChooseTag extends SimpleTagSupport {
12
13 /**
14 * 定义一个boolean类型的属性，该属性用于标识该标签下的某一个子标签是否已经执行过了，
15 * 如果该标签下的某一个子标签已经执行过了，就将该属性设置为true
16 */
17 private boolean isExecute;
18
19 @Override
20 public void doTag() throws JspException, IOException {
21 //输出标签体中的内容
22 this.getJspBody().invoke(null);
23 }
24
25 public boolean isExecute() {
26 return isExecute;
27 }
28
29 public void setExecute(boolean isExecute) {
30 this.isExecute = isExecute;
31 }
32 }
2、开发when标签和otherwise标签
WhenTag.java
1 package me.gacl.web.simpletag;
2
3 import java.io.IOException;
4 import javax.servlet.jsp.JspException;
5 import javax.servlet.jsp.tagext.SimpleTagSupport;
6
7 /**
8 * @author gacl
9 * when标签
10 */
11 public class WhenTag extends SimpleTagSupport {
12
13 /**
14 * test属性，该属性值为true时，输出标签体中的内容
15 */
16 private boolean test;
17
18 @Override
19 public void doTag() throws JspException, IOException {
20 //获取标签的父标签
21 ChooseTag parentTag = (ChooseTag) this.getParent();
22 if (test == true && parentTag.isExecute() == false) {
23 //输出标签体中的内容
24 this.getJspBody().invoke(null);
25 //将父标签的isExecute属性设置为true，告诉父标签，我(when标签)已经执行过了
26 parentTag.setExecute(true);
27 }
28 }
29
30 public void setTest(boolean test) {
31 this.test = test;
32 }
33 }
OtherWiseTag.java
1 package me.gacl.web.simpletag;
2
3 import java.io.IOException;
4 import javax.servlet.jsp.JspException;
5 import javax.servlet.jsp.tagext.SimpleTagSupport;
6
7 /**
8 * @author gacl
9 * otherwise标签
10 */
11 public class OtherWiseTag extends SimpleTagSupport {
12
13 @Override
14 public void doTag() throws JspException, IOException {
15 //获取标签的父标签
16 ChooseTag parentTag = (ChooseTag) this.getParent();
17 //如果父标签下的when标签没有执行过
18 if (parentTag.isExecute() == false) {
19 //输出标签体中的内容
20 this.getJspBody().invoke(null);
21 //设置父标签的isExecute属性为true，告诉父标签，我(otherwise标签)已经执行过了
22 parentTag.setExecute(true);
23 }
24 }
25 }
3、在WEB-INF目录下tld文件中添加对ChooseTag、WhenTag、OtherWiseTag这三对标签的描述，如下：
1 <tag>
2 <description>choose标签</description>
3 <name>choose</name>
4 <tag-class>me.gacl.web.simpletag.ChooseTag</tag-class>
5 <body-content>scriptless</body-content>
6 </tag>
7 <tag>
8 <description>when标签</description>
9 <name>when</name>
10 <tag-class>me.gacl.web.simpletag.WhenTag</tag-class>
11 <body-content>scriptless</body-content>
12 <attribute>
13 <description>when标签的test属性</description>
14 <name>test</name>
15 <rtexprvalue>true</rtexprvalue>
16 <required>true</required>
17 </attribute>
18 </tag>
19 <tag>
20 <description>otherwise标签</description>
21 <name>otherwise</name>
22 <tag-class>me.gacl.web.simpletag.OtherWiseTag</tag-class>
23 <body-content>scriptless</body-content>
24 </tag>
4、测试：在jsp页面中导入标签库并测试when和otherwise标签
1 <%@ page language="java" pageEncoding="UTF-8"%>
2 <%--在jsp页面中导入自定义标签库 --%>
3 <%@taglib uri="/gaclTagLib" prefix="c" %>
4 <%--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
5 <%@taglib uri="/WEB-INF/TagLib.tld" prefix="c"%>
6 --%>
7 <!DOCTYPE HTML>
8 <html>
9 <head>
10 <title>when和otherwise标签测试</title>
11 </head>
12
13 <body>
14 <c:choose>
15 <c:when test="${user==null}">
16 when标签标签体输出的内容：
17 <h3>用户为空</h3>
18 </c:when>
19 <c:otherwise>
20 用户不为空
21 </c:otherwise>
22 </c:choose>
23 <hr/>
24 <c:choose>
25 <c:when test="${user!=null}">
26 用户不为空
27 </c:when>
28 <c:otherwise>
29 otherwise标签标签体输出的内容：
30 <h3>用户为空</h3>
31 </c:otherwise>
32 </c:choose>
33 </body>
34 </html>
运行效果如下：
1.4、开发foreach迭代标签
1、编写标签处理器类：ForEachTag.java
1 package me.gacl.web.simpletag;
2
3 import java.io.IOException;
4 import java.util.Iterator;
5 import java.util.List;
6 import javax.servlet.jsp.JspException;
7 import javax.servlet.jsp.PageContext;
8 import javax.servlet.jsp.tagext.SimpleTagSupport;
9
10 /**
11 * @author gacl
12 * ForEach迭代标签
13 */
14 public class ForEachTag extends SimpleTagSupport {
15
16 /**
17 * 存储集合
18 */
19 private List items;
20
21 /**
22 * 迭代集合时使用的变量
23 */
24 private String var;
25
26 public void setItems(List items) {
27 this.items = items;
28 }
29
30 public void setVar(String var) {
31 this.var = var;
32 }
33
34 @Override
35 public void doTag() throws JspException, IOException {
36 PageContext pageContext = (PageContext) this.getJspContext();
37 Iterator it = items.iterator();
38 while (it.hasNext()) {
39 //得到一个迭代出来的对象
40 Object object = (Object) it.next();
41 //将迭代出来的对象存放到pageContext对象中
42 pageContext.setAttribute(var, object);
43 //输出标签体中的内容
44 this.getJspBody().invoke(null);
45 }
46 }
47 }
2、在WEB-INF目录下tld文件中添加对该标签的描述，如下：
1 <tag>
2 <description>foreach标签</description>
3 <name>foreach</name>
4 <tag-class>me.gacl.web.simpletag.ForEachTag</tag-class>
5 <body-content>scriptless</body-content>
6 <attribute>
7 <description>foreach标签的items属性</description>
8 <name>items</name>
9 <rtexprvalue>true</rtexprvalue>
10 <required>true</required>
11 </attribute>
12 <attribute>
13 <description>foreach标签的var属性</description>
14 <name>var</name>
15 <rtexprvalue>false</rtexprvalue>
16 <required>true</required>
17 </attribute>
18 </tag>
3、测试：在jsp页面中导入标签库并使用foreach标签
1 <%@page import="java.util.ArrayList"%>
2 <%@page import="java.util.List"%>
3 <%@ page language="java" pageEncoding="UTF-8"%>
4 <%--在jsp页面中导入自定义标签库 --%>
5 <%@taglib uri="/gaclTagLib" prefix="c" %>
6 <%--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
7 <%@taglib uri="/WEB-INF/TagLib.tld" prefix="c"%>
8 --%>
9 <!DOCTYPE HTML>
10 <html>
11 <head>
12 <title>foreach标签测试</title>
13 </head>
14
15 <%
16 List<String> data = new ArrayList<String>();
17 data.add("孤傲苍狼");
18 data.add("xdp");
19 //将集合存储到pageContext对象中
20 pageContext.setAttribute("data", data);
21 %>
22
23 <body>
24 <%--迭代存储在pageContext对象中的data集合 --%>
25 <c:foreach items="${data}" var="str">
26 ${str}<br/>
27 </c:foreach>
28 </body>
29 </html>
运行效果如下：
目前这个foreach标签的功能较弱，只能遍历list集合，下面我们改造一下，使我们的foreach标签可以遍历所有集合类型，修改后foreach标签的代码如下：
1 package me.gacl.web.simpletag;
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.Iterator;
8 import java.util.Map;
9
10 import javax.servlet.jsp.JspException;
11 import javax.servlet.jsp.PageContext;
12 import javax.servlet.jsp.tagext.SimpleTagSupport;
13
14 /**
15 * @author gacl
16 * ForEach迭代标签
17 */
18 public class ForEachTag extends SimpleTagSupport {
19
20 /**
21 * 存储数据
22 */
23 private Object items;
24
25 /**
26 * 迭代集合时使用的变量
27 */
28 private String var;
29
30 /**
31 * 集合，用于存储items中的数据
32 */
33 private Collection collection;
34
35 @Override
36 public void doTag() throws JspException, IOException {
37 PageContext pageContext = (PageContext) this.getJspContext();
38 //迭代collection集合
39 Iterator it = collection.iterator();
40 while (it.hasNext()) {
41 //得到一个迭代出来的对象
42 Object object = (Object) it.next();
43 //将迭代出来的对象存放到pageContext对象中
44 pageContext.setAttribute(var, object);
45 //输出标签体中的内容
46 this.getJspBody().invoke(null);
47 }
48 }
49
50 public void setVar(String var) {
51 this.var = var;
52 }
53
54 public void setItems(Object items) {
55 if (items instanceof Collection) {
56 collection = (Collection) items;//list
57 }else if (items instanceof Map) {
58 Map map = (Map) items;
59 collection = map.entrySet();//map
60 }else if (items.getClass().isArray()) {
61 collection = new ArrayList();
62 //获取数组的长度
63 int len = Array.getLength(items);
64 for (int i = 0; i < len; i++) {
65 //获取数组元素
66 Object object = Array.get(items, i);
67 collection.add(object);
68 }
69 }
70 this.items = items;
71 }
72 }
测试功能增强后的foreach标签，如下：
1 <%@page import="java.util.HashMap"%>
2 <%@page import="java.util.Map"%>
3 <%@page import="java.util.HashSet"%>
4 <%@page import="java.util.Set"%>
5 <%@page import="java.util.ArrayList"%>
6 <%@page import="java.util.List"%>
7 <%@ page language="java" pageEncoding="UTF-8"%>
8 <%--在jsp页面中导入自定义标签库 --%>
9 <%@taglib uri="/gaclTagLib" prefix="c" %>
10 <%--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
11 <%@taglib uri="/WEB-INF/TagLib.tld" prefix="c"%>
12 --%>
13 <!DOCTYPE HTML>
14 <html>
15 <head>
16 <title>foreach标签测试</title>
17 </head>
18
19 <%
20 //list集合
21 List<String> listData = new ArrayList<String>();
22 listData.add("孤傲苍狼");
23 listData.add("xdp");
24
25 //对象数组
26 Integer intObjArr[] = new Integer[]{1,2,3};
27
28 //基本数据类型数组
29 int intArr[] = new int[]{4,5,6};
30
31 //map集合
32 Map<String,String> mapData = new HashMap<String,String>();
33 mapData.put("a", "aaaaaa");
34 mapData.put("b", "bbbbbb");
35
36 //将集合存储到pageContext对象中
37 pageContext.setAttribute("listData", listData);
38 pageContext.setAttribute("intObjArr", intObjArr);
39 pageContext.setAttribute("intArr", intArr);
40 pageContext.setAttribute("mapData", mapData);
41 %>
42
43 <body>
44 <%--迭代存储在pageContext对象中的list集合 --%>
45 <c:foreach items="${listData}" var="str">
46 ${str}<br/>
47 </c:foreach>
48 <hr/>
49 <%--迭代存储在pageContext对象中的数组 --%>
50 <c:foreach items="${intObjArr}" var="num">
51 ${num}<br/>
52 </c:foreach>
53 <hr/>
54 <%--迭代存储在pageContext对象中的数组 --%>
55 <c:foreach items="${intArr}" var="num">
56 ${num}<br/>
57 </c:foreach>
58 <hr/>
59 <%--迭代存储在pageContext对象中的map集合 --%>
60 <c:foreach items="${mapData}" var="me">
61 ${me}<br/>
62 </c:foreach>
63 </body>
64 </html>
测试结果：
1.5、开发html转义标签
1、编写标签处理器类：HtmlEscapeTag.java
1 package me.gacl.web.simpletag;
2
3 import java.io.IOException;
4 import java.io.StringWriter;
5 import javax.servlet.jsp.JspException;
6 import javax.servlet.jsp.tagext.SimpleTagSupport;
7
8 /**
9 * @author gacl
10 * html转义标签
11 */
12 public class HtmlEscapeTag extends SimpleTagSupport {
13
14 /**
15 * @param message
16 * @return 转义html标签
17 */
18 private String filter(String message) {
19
20 if (message == null){
21 return (null);
22 }
23 char content[] = new char[message.length()];
24 message.getChars(0, message.length(), content, 0);
25 StringBuilder result = new StringBuilder(content.length + 50);
26 for (int i = 0; i < content.length; i++) {
27 switch (content[i]) {
28 case '<':
29 result.append("<");
30 break;
31 case '>':
32 result.append(">");
33 break;
34 case '&':
35 result.append("&");
36 break;
37 case '"':
38 result.append(""");
39 break;
40 default:
41 result.append(content[i]);
42 }
43 }
44 return (result.toString());
45 }
46
47 @Override
48 public void doTag() throws JspException, IOException {
49 StringWriter sw = new StringWriter();
50 //将标签体中的内容先输出到StringWriter流
51 this.getJspBody().invoke(sw);
52 //得到标签体中的内容
53 String content = sw.getBuffer().toString();
54 //转义标签体中的html代码
55 content = filter(content);
56 //输出转义后的content
57 this.getJspContext().getOut().write(content);
58 }
59 }
2、在WEB-INF目录下tld文件中添加对该标签的描述，如下：
1 <tag>
2 <description>HtmlEscape标签</description>
3 <name>htmlEscape</name>
4 <tag-class>me.gacl.web.simpletag.HtmlEscapeTag</tag-class>
5 <body-content>scriptless</body-content>
6 </tag>
3、测试：在jsp页面中导入标签库并使用htmlEscape标签
1 <%@ page language="java" pageEncoding="UTF-8"%>
2 <%--在jsp页面中导入自定义标签库 --%>
3 <%@taglib uri="/gaclTagLib" prefix="c" %>
4 <%--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
5 <%@taglib uri="/WEB-INF/TagLib.tld" prefix="c"%>
6 --%>
7 <!DOCTYPE HTML>
8 <html>
9 <head>
10 <title>html转义标签测试</title>
11 </head>
12
13 <body>
14 <c:htmlEscape>
15 <a href="http://www.cnblogs.com">访问博客园</a>
16 </c:htmlEscape>
17 </body>
18 </html>
运行结果：
1.6、开发out输出标签
1、编写标签处理器类：OutTag.java
1 package me.gacl.web.simpletag;
2
3 import java.io.IOException;
4
5 import javax.servlet.jsp.JspException;
6 import javax.servlet.jsp.tagext.SimpleTagSupport;
7
8 /**
9 * @author gacl
10 * 开发输出标签
11 */
12 public class OutTag extends SimpleTagSupport {
13
14 /**
15 * 要输出的内容
16 */
17 private String content;
18
19 /**
20 * 是否将内容中的html进行转义后输出
21 */
22 private boolean escapeHtml;
23
24 public void setContent(String content) {
25 this.content = content;
26 }
27
28 public void setEscapeHtml(boolean escapeHtml) {
29 this.escapeHtml = escapeHtml;
30 }
31
32 @Override
33 public void doTag() throws JspException, IOException {
34 if (escapeHtml == true) {
35 //转义内容中的html代码
36 content = filter(content);
37 //输出转义后的content
38 this.getJspContext().getOut().write(content);
39 }else {
40 this.getJspContext().getOut().write(content);
41 }
42 }
43
44 /**
45 * @param message
46 * @return 转义html标签
47 */
48 private String filter(String message) {
49
50 if (message == null){
51 return (null);
52 }
53 char content[] = new char[message.length()];
54 message.getChars(0, message.length(), content, 0);
55 StringBuilder result = new StringBuilder(content.length + 50);
56 for (int i = 0; i < content.length; i++) {
57 switch (content[i]) {
58 case '<':
59 result.append("<");
60 break;
61 case '>':
62 result.append(">");
63 break;
64 case '&':
65 result.append("&");
66 break;
67 case '"':
68 result.append(""");
69 break;
70 default:
71 result.append(content[i]);
72 }
73 }
74 return (result.toString());
75 }
76 }
2、在WEB-INF目录下tld文件中添加对该标签的描述，如下：
1 <tag>
2 <description>out标签</description>
3 <name>out</name>
4 <tag-class>me.gacl.web.simpletag.OutTag</tag-class>
5 <body-content>empty</body-content>
6 <attribute>
7 <description>out标签的content属性，表示要输出的内容</description>
8 <name>content</name>
9 <rtexprvalue>true</rtexprvalue>
10 <required>true</required>
11 </attribute>
12 <attribute>
13 <description>out标签的escapeHtml属性，表示是否将内容中的html进行转义后输出</description>
14 <name>escapeHtml</name>
15 <rtexprvalue>true</rtexprvalue>
16 <required>false</required>
17 </attribute>
18 </tag>
3、测试：在jsp页面中导入标签库并使用out标签
1 <%@ page language="java" pageEncoding="UTF-8"%>
2 <%--在jsp页面中导入自定义标签库 --%>
3 <%@taglib uri="/gaclTagLib" prefix="c" %>
4 <%--在jsp页面中也可以使用这种方式导入标签库，直接把uri设置成标签库的tld文件所在目录
5 <%@taglib uri="/WEB-INF/TagLib.tld" prefix="c"%>
6 --%>
7 <!DOCTYPE HTML>
8 <html>
9 <head>
10 <title>out标签测试</title>
11 </head>
12
13 <body>
14 <%--使用out标签输出content属性的内容 --%>
15 <c:out content="<a href='http://www.cnblogs.com'>访问博客园</a>"/>
16 <hr/>
17 <%--使用out标签输出 content属性的内容，内容中的html代码会进行转义处理--%>
18 <c:out content="<a href='http://www.cnblogs.com'>访问博客园</a>" escapeHtml="true"/>
19 </body>
20 </html>
运行效果如下：
二、打包开发好的标签库
我们的标签库开发好之后，为了方便别人使用，可以将开发好的标签库打包成一个jar包，具体的打包步骤如下：
1、新建一个普通的java工程，例如：taglib
2、将在JavaWeb_JspTag_study_20140816这个web工程中开发好标签库的java代码拷贝到普通java工程taglib项目中，如下：
此时，我们可以看到，拷贝到taglib项目的标签代码都有错误，这是因为taglib项目中缺少了javaEE的jar包，而标签类是是基于javaEE API进行开发的，所以还需要将javaEE的jar包添加到taglib项目中。
在taglib项目中创建一个【lib】文件夹，用于存放标签类依赖的javaEE的jar包。找到tomcat服务器目录下的lib文件夹，如下图所示：
将【jsp-api.jar】和【servlet-api.jar】这两个jar包拷贝到tagib项目中的lib文件夹中，然后添加【jsp-api.jar】和【servlet-api.jar】这两个jar包的引用，如下所示：
在taglib项目中引用了【jsp-api.jar】和【servlet-api.jar】这两个jar包后，标签类中的代码就不再报错了
3、在taglib项目中添加一个【META-INF】文件夹，如下所示：
将位于WEB-INF目录下的标签库对应的tld文件拷贝到taglib项目的【META-INF】文件夹中
4、将taglib项目打包成jar包
此时就可以看到我们打包好的jar包了，如下所示：
将标签库打包成jar包之后，以后哪个web项目要使用标签库，那么就将打包好的标签库jar包添加到web项目中就可以使用标签库中的标签了。