JSTL

最新推荐文章于 2017-04-20 09:49:18 发布

持之以恒111

最新推荐文章于 2017-04-20 09:49:18 发布

阅读量447

点赞数

分类专栏： V ：Servlet、JSP

V ：Servlet、JSP 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

一、自定义标签简介

自定义标签主要用于移除 Jsp 页面中的 Java 代码。使用自定义标签移除 Java 代码只需要两个步骤：编写一个实现了 Tag 接口的 Java 实现类（标签处理器类，通常不是直接继承 Tag 接口，而是继承 TagSupport 类）、编写标签描述文件（.tld文件），在 tld 文件中将标签处理器类描述成一个标签。

使用自定义标签向浏览器输出客户机的 IP 地址：

[java] view plain copy print ?

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%@taglib uri="/dk" prefix="dk" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>My JSP 'index.jsp' starting page</title>
</head>
<body>
您的 IP 是：<dk:viewIP />
</body>
</html>

[java] view plain copy print ?

package viewIP;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.TagSupport;
@SuppressWarnings("serial")
public class IPTag extends TagSupport {
public int doStartTag() throws JspException {
String ip = this.pageContext.getRequest().getRemoteAddr();
JspWriter out = this.pageContext.getOut();
try {
out.write(ip);
} catch (IOException e) {
throw new RuntimeException();
}
return super.doStartTag();
}
}

[java] view plain copy print ?

<?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/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
version="2.0">
<tlib-version>1.0</tlib-version>
<short-name>SimpleTagLibrary</short-name>
<uri>/dk</uri>
<tag>
<name>viewIP</name>
<tag-class>viewIP.IPTag</tag-class>
<body-content>empty</body-content>
</tag>
</taglib>

二、自定义标签的执行过程（传统标签体系）

1、浏览器向服务器发送请求。

2、服务器根据浏览器所请求的资源找到相应的 Jsp 文件。

3、服务器将 Jsp 文件翻译成 Servlet 文件，并执行 Servlet 代码。

4、当 Servlet 代码执行到有自定义标签的时候，服务器会创建一个标签处理器类的对象。

5、服务器将 pageContext 对象传递给标签处理器类。

6、服务器调用标签处理器对象的 setParent 方法将父标签传递给它，如果没有父标签则为 null。这里的父标签是指自定义标签的父标签。

7、Servlet 代码继续执行，当遇见自定义标签的开始标签时，会调用标签处理器对象的 doStartTag 方法，并执行方法体的内容。

8、Servlet 代码执行完开始标签以后开始执行标签体的内容。

9、当 Servlet 执行到结束标签的时候会调用标签处理器对象的 doEndTag 方法。

10、一般情况下当执行完结束标签时，服务器会调用标签处理器对象的 release 方法用以释放资源。

11、标签调用完成。服务器继续执行 Servlet 的其它代码。

三、传统标签的开发

自定义标签的功能：控制 Jsp 页面某一部分内容是否执行

控制整个 Jsp 页面是否执行

控制 Jsp 页面内容重复执行

修改 Jsp 页面内容输出

1、控制页面某一部分内容是否执行：doStartTag 方法的返回值可以是常量 EVAL_BODY_INCLUDE 和 SKIP_BODY，也就是说，如果想控制某一部分内容是否显示，我们可以用自定义标签将该部分内容包起来，然后在编写标签处理器类时将 doStartTag 方法的返回值设为 SKIP_BODY。

2、控制整个 Jsp 页面是否执行。doEndTag 方法也有整数的返回值，EVAL_PAGE 和 SKIP_PAGE，如果让整个 Jsp 页面都不显示的话，我们可以在 Jsp 页面的头部加入一个自定义标签，在标签处理器类的 doEndTag 方法的返回值中加入 SKIP_PAGE。

3、将 Jsp 中某一部分的内容重复输出：首先应从 doStartTag 方法去想，我们如果想让某个方法执行多次，那么我们必须将 doStartTag 方法的返回值改为 EVAL_BODY_INCLUDE，让表前体的内容能读取到。然后当标签体内容执行完第一次的时候，我们还需要让它继续多次执行，我们就要考虑另外一个方法，在 InteragtionTag 中有一个 doAfterBody 的方法，也就是当执行完方法体的时候该方法被调用。如果我们将该方法的返回值改为 EVAL_BODY_AGAIN，那么服务器会再次运行方法体中的内容，我们只需要设置一个全局变量来控制方法体的执行次数。

4、更改 Jsp 页面中的内容：我们要想修改 Jsp 的内容，必须先获得它。那么在标签处理器类我们要继承 BodyTagSupport 然后将 doStartTag 的返回值设为 EVAL_BODY_BUFFERED，这就改变了标签的运行过程。当服务器解析完开始标签后，会创建一个 BodyContent 标签。在解析标签体时会将表前体中的内容存放在 BodyContent 对象中，当标签体执行完以后，会调用 setBodyContent 将BodyContent 传递给标签处理器、标签处理器拿到了 BodyContent 后就可以对标签体内容进行操作。在 doEndTag 方法中通过 bodyContent.toString() 的方法获得 Jsp 页面的文本内容，修改过后通过 out 对象打印给客户机。Jsp 页面其他代码还是要执行的，所以 doEndTag 的返回值应为 EVAL_PAGE。

传统标签的体系关系：

四、简单标签开发技术

1、简单标签执行过程

(1) 客户机想服务器发送访问 Jsp 页面请求

(2) 服务器找到对应的 Jsp 并将 Jsp 翻译为 Servlet

(3) 服务器调用 Servlet 的 init() 方法进行初始化

(4) 服务器调用 Servlet 的 service() 方法

(5) 当服务器解析到自定义标签的时候，会先创建一个标签处理器对象。

(6) 服务器调用标签处理器对象的 setJspContext 方法将 JspContext 对象传递给标签处理器，也就是将 pageContext 对象传递过去。

(7) 服务器调用标签处理器的 setParent 方法将父标签传递过去。

(8) 服务器调用标签处理器的 setJspBody 将标签体以 JspFragment 形式传递过去。这样标签处理器就可以拿到标签体的内容。

(9) 服务器调用标签处理器的 doTag 方法开始执行自定义标签。

简单标签与传统标签：简单标签没有开始标签和结束标签之分，只要是调用标签，它就会调用 doTag 方法。在简单标签中，1、不输出 JspFragment 对象就可以不输出标签体，2、将标签体放在循环中就可以多次输出标签体，3、将标签体输出到缓冲中，然后获取到数据还可以修改标签体，4、如果不想输出标签下面的 Jsp 内容，可以采用直接抛异常的方式。 throws SkipPageException。

[java] view plain copy print ?

public class SimpleTagDemo extends SimpleTagSupport {
public void doTag() throws JspException, IOException {
// 不输出标签体，什么都不用写
// 控制整个jsp页面不输出
// throw new SkipPageException();
// 输出标签体
// JspFragment body = getJspBody();
// //body.invoke(null); //null就默认输出浏览器
// JspWriter out = this.getJspContext().getOut();
// body.invoke(out);
//重复输出标签体
// JspFragment body = this.getJspBody();
// JspWriter out = this.getJspContext().getOut();
// for (int i = 0; i < 10; i++) {
// body.invoke(out.append("<br>"));
// }
//修改标签体
JspFragment body = this.getJspBody();
StringWriter sw = new StringWriter();
body.invoke(sw);
String string = sw.toString();
string = string.toUpperCase();
this.getJspContext().getOut().write(string);
}
}

五、自定义标签的属性

自定义标签可以有一个或多个属性，这样在 Jsp 页面中可以设置属性值为标签处理器传递参数，从而提高代码复用性和灵活性。

[java] view plain copy print ?

package simpleTag;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;
public class ParamTag extends SimpleTagSupport {
private int count;
public void setCount(int count) {
this.count = count;
}
public void doTag() throws JspException, IOException {
JspFragment body = this.getJspBody();
for (int i = 0; i < count; i++) {
body.invoke(null);
}
}
}

[java] view plain copy print ?

<?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/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
version="2.0">
<tlib-version>1.0</tlib-version>
<short-name>SimpleTagLibrary</short-name>
<uri>/dk</uri>
<tag>
<name>pt</name>
<tag-class>simpleTag.ParamTag</tag-class>
<body-content>scriptless</body-content>
<attribute>
<name>count</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
</taglib>

六、案例

1、开发防盗链标签（练习移除 JSP 中 Java 代码和控制余下 Jsp 是否执行）

[java] view plain copy print ?

package link;
import java.io.IOException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.SimpleTagSupport;
public class Linked extends SimpleTagSupport {
private String site;
private String page;
public void setSite(String site) {
this.site = site;
}
public void setPage(String page) {
this.page = page;
}
public void doTag() throws JspException, IOException {
PageContext context = (PageContext) this.getJspContext();
HttpServletRequest request = (HttpServletRequest) context.getRequest();
HttpServletResponse response = (HttpServletResponse) context
.getResponse();
String referer = request.getHeader("referer");
String appPath = request.getContextPath();
if (referer == null || !referer.startsWith(site)) {
if (page.startsWith("/")) {
if (page.startsWith(appPath)) {
response.sendRedirect(page);
} else {
response.sendRedirect(appPath + page);
}
} else {
response.sendRedirect(appPath + "/" + page);
}
}
}
}

[java] view plain copy print ?

<?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/j2ee http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
version="2.0">
<tlib-version>1.0</tlib-version>
<short-name>SimpleTagLibrary</short-name>
<uri>/driverking</uri>
<tag>
<name>link</name>
<body-content>empty</body-content>
<tag-class>link.Linked</tag-class>
<attribute>
<name>site</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
<attribute>
<name>page</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
</taglib>

[java] view plain copy print ?

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>My JSP 'start.jsp' starting page</title>
</head>
<body>
首页
<a href='/Day_08_Jsp_Taglib/my.jsp'>隐私</a>
</body>
</html>

[java] view plain copy print ?

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%@taglib uri="/driverking" prefix="dk"%>
<dk:link site="http://localhost" page="start.jsp"/>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>My JSP 'my.jsp' starting page</title>
</head>
<body>
我
</body>
</html>

2、开发 <c:if> 标签（练习控制标签体是否执行，也就是控制页面某一部分是否执行）

[java] view plain copy print ?

package test;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;
public class CIf extends SimpleTagSupport {
private boolean test;
public void setTest(boolean test) {
this.test = test;
}
public void doTag() throws JspException, IOException {
if(test){
JspFragment body = this.getJspBody();
body.invoke(null);
}
}
}

3、开发 <c:if><c:else> 标签（练习父标签的操作）
在 if_else标签中，我们需要两个标签也就是两个标签处理器类来控制 Jsp 的内容是否显示。所以我们需要进行两个标签的控制。标签内，我们只能得到父级标签，所以我们需要用一个父级标签将两个 if_else 标签包围起来，这样在父标签中指定一个变量就可以控制他子标签的显示。

[java] view plain copy print ?

package test;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
public class Choose extends SimpleTagSupport {
private boolean isdo;
public boolean isIsdo() {
return isdo;
}
public void setIsdo(boolean isdo) {
this.isdo = isdo;
}
@Override
public void doTag() throws JspException, IOException {
this.getJspBody().invoke(null);
}
}

[java] view plain copy print ?

package test;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
public class When extends SimpleTagSupport {
private boolean test;
public void setTest(boolean test) {
this.test = test;
}
@Override
public void doTag() throws JspException, IOException {
Choose parent = (Choose)this.getParent();
if(test && !parent.isIsdo()){
this.getJspBody().invoke(null);
parent.setIsdo(true);
}
}
}

[java] view plain copy print ?

package test;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
public class Otherwise extends SimpleTagSupport {
@Override
public void doTag() throws JspException, IOException {
Choose parent = (Choose)this.getParent();
if(!parent.isIsdo()){
this.getJspBody().invoke(null);
parent.setIsdo(false);
}
}
}

4、开发 foreach 标签（练习迭代操作）

在开发 foreach 标签的时候，我们需要为标签指定不同的参数，第一种方法是：我们只需指定我们要迭代数据存在域中的名字，用以在标签处理器类中获取要迭代的数据。另一种方法是指定要迭代数据的名字和要迭代的数据，用以在 Jsp 中在其它位置可以重复使用。

首先我们应该知道，我们需要迭代的数据可以是 Collection 集合、Map 集合、String 数据、基本类型数组。由于我们先前无法知道谁会调用我们开发的标签，所以也就无法事先确定要迭代数据的类型。因此我们都以 Object 类型预设，在标签处理器类中维护一个 Collection 对象，如果要迭代的数据是 Collection 或它的子类，我们可以直接将数据赋值到 Collection 中。如果要迭代的数据是 Map 类型的，我们知道 Map 中的键值对可以用一个实体表示（Entry），在 Map 中可以获得这个实体的 set 集合，因为 Set 继承了 Collection 接口，所以我们可以将 entrySet 赋值给 Collection。如果要迭代的数据是一个数组，那么数组又分为字符串数组和基本类型数组，虽然在数组工具包中有一个 Arrays.asList 的方法，但是，这个方法只对字符串数组起作用，因为在 jdk1.5 中，该方法是以可变参的形式操作实参的，会把每个参数作为一个对象来看待。如果我们传递的是字符串数组，字符串本身是一个对象类型，所以传递进去的就是一个个 String。当我们传递的是基本类型数组的时候，编译器将数组拆开以后发现参数类型不是一个对象类型，所以就无法使用。查看 SUN 公司标签库的源码发现 SUN 公司的解决方案就是把 8 个基本类型一一进行处理。但是我们还有另外一中简单的方法。

我们首先拿到数据的 Class 字节码，然后在反射工具包中有一个 Array 操作数组的类，在这个类中有 getLenght 和 get 方法分别用以获取数组的长度和数组中每一个元素。有了这两个方法我们可以很轻松的用 for 循环来迭代数组，无论是什么类型的数组都可以。

[java] view plain copy print ?

package test;
import java.io.IOException;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.SimpleTagSupport;
public class Foreanch extends SimpleTagSupport {
private String key;
private Collection collecion;
public void setKey(String key) {
this.key = key;
}
@Override
public void doTag() throws JspException, IOException {
PageContext context = (PageContext) this.getJspContext();
Object obj = context.findAttribute(key);
if(obj instanceof Collection)
this.collecion = (Collection) obj;
else if(obj instanceof Map)
this.collecion = ((Map)obj).entrySet();
else if(obj.getClass().isArray()){
int length = Array.getLength(obj);
this.collecion = new ArrayList();
for (int i = 0; i < length; i++) {
this.collecion.add(Array.get(obj, i));
}
}
Iterator iterator = this.collecion.iterator();
while(iterator.hasNext()){
Object content = iterator.next();
this.getJspContext().setAttribute(key, content);
this.getJspBody().invoke(null);
}
}
}

哈哈，方力勋方老师果然彪悍！佩服得五体投地。再看 SUN 公司写的那一大堆 if...else 代码，好没技术含量啊，哈哈……不过相信 SUN 公司这样写是有他的道理的，不管那么多了，反正又学了一招。（注：在方哥讲怎么实现的时候，我已经想到要用反射来解决所有数组的问题了，哈哈，我也是蛮犀利的）

5、开发 HTML 转义标签（练习获取标签体内容和修改标签体内容）

简单标签的执行过程与传统标签不一样，在执行标签体的时候，它允许将执行完的内容放在一个输出流中，默认的情况是 null 也就是直接写到 JspWriter 中，但是我们为了获取到标签体的内容进行修改，我们必须找到一个既可以将数据写入又可以获取数据的流。StringWriter 是一个很不错的选择。当我们获取到标签体内容然后进行修改后，我们应调用 JspContext 的 getOut 方法，将修改后的内容打给客户机。

[java] view plain copy print ?

package test;
import java.io.IOException;
import java.io.StringWriter;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.SimpleTagSupport;
public class HtmlFilter extends SimpleTagSupport {
public void doTag() throws JspException, IOException {
StringWriter sw = new StringWriter();
this.getJspBody().invoke(sw);
String content = sw.toString();
content = filter(content);
this.getJspContext().getOut().write(content);
}
public static 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());
}
}

七、JSTL 核心标签库

自己开发完标签以后再看 SUN 公司提供的标签库，就像喝水一样消化了，哈哈。

1、<c : out> 用于输出一段文本内容到 pageContext 对象当前保存的 Out 对象中。也就是向浏览器输出。当然向浏览器输出，在 Jsp 文件中直接写就可以了，但是 c : out 标签还提供了两个属性，escapeXml 和 default。escape 可以将特殊土豪进行转义后再进行输出，默认为 true。default 如果 value 属性为 null 时，将输出 default 中的内容。

<c:out value="${url}" escape="true" default="driverking.com"></c : out>

2、<c : set> 用于把某一个对象存在制定的域范围内，还可以设置 Web 域中的 Map 对象或 JavaBean 对象的属性。也就是说通过 <c : set> 可以将对象存放在某个域中，或者可以操作域中的 Map 集合和 JavaBean 对象。注意：<c : set> 标签只能操作域内的对象。

3、<c : remove> 用于删除 Web 域中的属性

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

<% 10/0 %>

</c : catch>

5、<c : if> 可以构造结构条件

6、<c : choose> 用于指定多个条件选择的组合边界。它必须与 <c : when> 和 <c : otherwise> 一起使用

7、<c : forEach> 用于对一个集合对象中的元素进行迭代操作。

<c : forEach varStatus="status"><c : forEach>（varStatus将迭代信息存储在一个 status 变量中。）

8、<c : url> 用于在 Jsp 页面中构造一个 URL 地址，其主要目的是实现 URL 重写。URL 重写就是将会话标识号 JSESSIONID 以参数的形式附加在 URL 地址后面。

<c: param name="username" value="中国">

</c : url>

这个 url 标签很强大，因为在我们给定 url 的时候，不必指定工程路径，直接写单个页面路径就可以，param 标签是给 url 后面增加参数，可以直接写中文，不必担心乱码问题。

9、<c : redirect> 用于实现请求重定向，url 参数就是重定向的地址，context 可以重定向到其它的 Web 工程上去

10、<c : forTokens> 用于对字符串分割

转载自： http://blog.csdn.net/driverking/article/details/6712920

持之以恒111

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JSTL

一、自定义标签简介自定义标签主要用于移除 Jsp 页面中的 Java 代码。使用自定义标签移除 Java 代码只需要两个步骤：编写一个实现了 Tag 接口的 Java 实现类（标签处理器类，通常不是直接继承 Tag 接口，而是继承 TagSupport 类）、编写标签描述文件（.tld文件），在 tld 文件中将标签处理器类描述成一个标签。使用
复制链接

扫一扫