JSP标签库使用指南：内置与自定义标签详解

李大锤同学

于 2025-08-08 13:26:43 发布

阅读量1k

点赞数 11

CC 4.0 BY-SA版权

本文链接：https://blog.csdn.net/weixin_36123300/article/details/150102759

本文还有配套的精品资源，点击获取

简介：JSP技术中的标签库使开发者能够创建可重用的组件，提高代码的可读性和可维护性。本主题包括JSP内置标签和自定义标签的使用方法。内置标签如表达式标签、注释标签、声明标签和脚本元素标签，以及用于包含和转发页面的 <jsp:include> 和 <jsp:forward> 标签。自定义标签的实现涉及TLD文件、标签处理类和标签文件。另外，JSTL和EL的使用可以增强JSP页面的功能和简洁性。学习JSP标签库对于Web开发至关重要，有助于构建高效动态网页。

1. JSP内置标签使用方法

简介

JSP内置标签是Java Server Pages技术中预定义的一组标签，它们被广泛用于简化JSP页面中的常见操作。这些标签不仅易于理解和使用，还能帮助开发者提高开发效率。

常见内置标签

在JSP中，一些常用的内置标签包括：

<jsp:include> ：用于在当前页面中包含另一个页面的内容。
<jsp:forward> ：用于将请求转发到另一个页面。
<jsp:param> ：用于向 <jsp:include> 或 <jsp:forward> 标签传递参数。
<jsp:useBean> ：用于在JSP页面中创建或查找JavaBean实例。

使用方法

例如，使用 <jsp:include> 标签包含一个名为 header.jsp 的页面：

<jsp:include page="header.jsp" />

这行代码会将 header.jsp 页面的内容包含到当前页面中。

内置标签的使用可以减少Java代码的编写，使页面结构更清晰，易于维护。掌握这些内置标签的使用对于JSP开发人员来说是基础且必要的技能。在下一章中，我们将深入探讨如何创建自定义标签来满足更复杂的业务需求。

2. JSP自定义标签的构成与实现

2.1 自定义标签的基本概念

2.1.1 标签的定义和作用

在JavaServer Pages (JSP) 技术中，自定义标签提供了一种机制，允许开发者通过编写自己的标签扩展JSP的功能，从而简化页面内容的生成，并提高代码的可读性和可维护性。自定义标签本质上是一段可重用的Java代码，它们通过在JSP页面中被调用执行特定任务。

自定义标签通常被设计成执行某种特定的业务逻辑，可以实现数据封装、数据处理、页面布局控制等任务。一个标签可以类比于一个函数或方法，但它在JSP页面上的使用就像HTML标签一样简单。这样做的好处是可以将复杂的业务逻辑封装在一个标签内，然后通过简单的标签属性和体内容配置来使用，从而提高代码的复用性和分离了表现层与逻辑层。

2.1.2 标签的生命周期

JSP自定义标签的生命周期可以分为几个主要阶段：

标签库描述符(TLD)加载阶段 ：在JSP页面被处理前，容器会加载标签库描述符文件（.tld），并解析标签库中的信息。
标签处理类初始化阶段 ：实例化标签处理类，并调用init方法进行初始化。
标签处理阶段 ：处理标签的开始标签（start tag）和结束标签（end tag）。在处理开始标签时，容器会调用doStartTag方法；处理结束标签时，容器会调用doEndTag方法。此外，还可能调用release方法来处理标签的清理工作。
标签的销毁阶段 ：当标签处理类不再需要时，会调用destroy方法进行销毁。

每个阶段中，标签处理类都提供了相应的生命周期方法供开发者实现，以实现标签所需的具体行为。

2.2 自定义标签的开发步骤

2.2.1 创建标签处理类

在自定义标签开发中，首先需要创建一个继承自SimpleTagSupport的Java类，这个类即是标签处理类。例如：

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;

public class MyTag extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException {
        // 在这里编写标签的逻辑
        getJspContext().getOut().write("Hello, this is a custom tag!");
    }
}

在这段代码中，我们创建了一个名为 MyTag 的自定义标签类，并重写了 doTag() 方法。在这个方法中，我们向页面输出了字符串。

2.2.2 编写TLD文件

TLD（Tag Library Descriptor）文件是自定义标签的描述文件，它告诉容器关于自定义标签的元数据信息，例如标签的名称、类路径、标签属性和使用方法。

一个简单的TLD文件示例如下：

<taglib xmlns="http://java.sun.com/xml/ns/javaee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                            http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
        version="2.1">
    <tlib-version>1.0</tlib-version>
    <short-name>mytags</short-name>
    <uri>http://www.example.com/mytags</uri>
    <tag>
        <name>mytag</name>
        <tag-class>com.example.MyTag</tag-class>
        <body-content>empty</body-content>
    </tag>
</taglib>

在这个TLD文件中，我们定义了一个标签库版本 <tlib-version> ，一个简短的名称 <short-name> ，一个唯一标识符 <uri> ，以及一个具体的标签定义，包括标签名 <name> 、标签类路径 <tag-class> 和标签体内容类型 <body-content> 。

2.2.3 在JSP中使用自定义标签

在编写了自定义标签处理类和TLD文件之后，接下来就可以在JSP页面中使用这个自定义标签了。这需要在JSP页面中声明标签库，然后使用标签：

<%@ taglib prefix="mt" uri="http://www.example.com/mytags" %>
<mt:mytag />

在这段代码中， <%@ taglib %> 指令声明了我们使用的标签库，并使用了 prefix 属性来指定标签库的前缀。然后我们使用了自定义标签，并在页面上输出了“Hello, this is a custom tag!”。

2.3 自定义标签的高级特性

2.3.1 标签属性的定义与使用

标签属性可以为标签提供参数，增加标签的灵活性。自定义标签属性的定义通常在TLD文件中的 <tag> 元素内部通过 <attribute> 元素来完成。

一个具有属性的自定义标签TLD文件示例如下：

<tag>
    <name>mytag</name>
    <tag-class>com.example.MyTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <name>message</name>
        <required>false</required>
        <rtexprvalue>true</rtexprvalue>
        <type>java.lang.String</type>
    </attribute>
</tag>

在此TLD定义中， <attribute> 定义了一个名为 message 的属性，这个属性不是必须的（ <required>false</required> ），可以使用运行时表达式来设置（ <rtexprvalue>true</rtexprvalue> ），并且它的类型是 java.lang.String 。

在标签处理类中，我们可以这样获取这个属性的值：

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;

public class MyTag extends SimpleTagSupport {
    private String message;
    public void setMessage(String message) {
        this.message = message;
    }
    @Override
    public void doTag() throws JspException {
        if (message != null) {
            getJspContext().getOut().write(message);
        } else {
            getJspContext().getOut().write("No message provided.");
        }
    }
}

在JSP页面中，我们可以这样使用带有属性的自定义标签：

<%@ taglib prefix="mt" uri="http://www.example.com/mytags" %>
<mt:mytag message="Hello, this is a custom tag with a message attribute!" />

2.3.2 标签体的处理机制

标签体指的是JSP页面中位于开始标签和结束标签之间的内容。自定义标签可以处理标签体的内容，这在需要对内容进行动态处理时非常有用。

处理标签体通常涉及到SimpleTag接口中的 doTag() 方法。当标签体存在时，可以通过调用 getJspBody().invoke(null) 来执行标签体的内容。如果标签体不存在，例如一个空标签，那么 doTag() 方法内就不需要执行任何操作，或者提供一个默认操作。

下面是一个处理标签体的示例：

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;

public class MyTag extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException {
        JspFragment body = getJspBody();
        if (body != null) {
            try {
                body.invoke(null);  // 执行标签体内容
            } catch (IOException e) {
                throw new JspException("Could not invoke body of tag", e);
            }
        }
    }
}

在这个例子中， getJspBody() 方法获取了标签体的JspFragment对象，随后调用了 invoke(null) 来执行标签体中的内容。如果标签体为空， getJspBody() 方法会返回null，此时不需要执行任何操作。

3. 标签库描述符文件（TLD）

在上一章中，我们已经初步了解了JSP自定义标签的构成和开发步骤。这一章将深入探讨标签库描述符文件（Tag Library Descriptor，简称TLD），它是自定义标签与容器之间的桥梁，也是定义标签库属性和行为的关键。

3.1 TLD文件结构解析

3.1.1 TLD文件的基本组成

TLD文件是一个XML格式的文件，它描述了标签库的元数据信息，包括标签库的版本、前缀、URI以及所有的标签。TLD文件通常放在WEB-INF目录下的tags目录中，或者放在jar文件的META-INF目录下。

一个TLD文件至少包含以下元素：
- <taglib> 根元素，包含其它所有标签。
- <tlib-version> 标签库的版本号。
- <short-name> 标签库的简短名称。
- <uri> 标签库的唯一标识符。
- <tag> 标签，描述一个自定义标签的信息。

下面是一个简单的TLD文件示例：

<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">
  <display-name>Simple Tags</display-name>
  <tlib-version>1.0</tlib-version>
  <short-name>simple</short-name>
  <uri>http://example.com/simpletags</uri>
  <tag>
    <name>helloWorld</name>
    <tag-class>com.example.tags.HelloWorldTag</tag-class>
    <body-content>empty</body-content>
    <display-name>Hello World Tag</display-name>
    <description>Simple tag that prints Hello World!</description>
  </tag>
</taglib>

3.1.2 各元素的作用与配置

<taglib> 是整个TLD的根元素，它定义了标签库的命名空间和其他属性。它的属性包括：

version : 指定TLD的版本号。
xmlns : 声明标签库所用的XML命名空间。
xmlns:xsi : 声明与XML Schema实例关联的命名空间。
xsi:schemaLocation : 指向TLD文件的XML模式定义。

<tlib-version> 指定标签库的版本号，这是可选的，主要用于库的更新追踪。

<short-name> 提供一个简短的、易记的标签库名称。

<uri> 是标签库的唯一标识符，通常使用域名反转的方式来命名，确保其唯一性。

<tag> 元素描述了自定义标签的详细信息。它包含以下子元素：

name : 标签的名称。
tag-class : 标签类的完全限定名。
body-content : 标签体内容类型，有 empty 、 tagdependent 、 scriptless 和 templateText 几种类型。
display-name : 为标签提供一个友好的显示名称。
description : 对标签功能的描述。
attribute : 定义标签的属性，可以有多个。

3.2 TLD文件的创建与管理

3.2.1 TLD文件的编写规范

编写TLD文件时，我们需要遵循一些基本规则和最佳实践。首先，应该遵循XML的语法规则，确保文件格式正确。TLD的属性值应使用正确的数据类型，并确保所有命名空间和模式声明正确无误。

其次，标签类的完全限定名（ tag-class ）必须正确指向实现了 javax.servlet.jsp.tagext.Tag 接口的Java类。对于 <attribute> 元素，需要指定 name 和 type ， required 属性表明属性是否必须指定，而 rtexprvalue 属性则指明属性值是否可以由运行时表达式提供。

3.2.2 TLD文件的错误调试

TLD文件中的错误可能会导致JSP页面在运行时出现难以理解的异常。调试TLD文件时，常见的错误包括：

不正确的XML格式。
未声明或错误声明的XML命名空间。
错误的标签类完全限定名或未找到指定的类。
属性配置错误，如不存在的属性、类型不匹配等。

要调试TLD文件，可以使用JSP容器提供的日志记录功能，或者利用支持XML验证的编辑器进行检查。一些集成开发环境（IDE）还提供了图形化的TLD编辑和验证工具，可以辅助开发者快速定位和修正TLD文件中的错误。

以上内容主要介绍了TLD文件的结构和组成，以及创建和管理TLD文件的一些基本规范和调试技巧。在下一章节中，我们将继续探讨标签处理类的作用与实现，这将有助于我们深入理解JSP标签的工作原理。

4. 标签处理类的作用与实现

4.1 标签处理类的生命周期方法

4.1.1 doStartTag与doEndTag方法

在JSP自定义标签的开发中，标签处理类（Tag Handler）扮演着至关重要的角色，它是自定义标签逻辑的载体。每个标签处理类都必须实现JSP规范中的 javax.servlet.jsp.tagext.Tag 或其子接口。标签处理类的生命周期由几个关键方法共同定义，这些方法包括 doStartTag 、 doEndTag 以及可选的 doAfterBody 。

doStartTag() 方法在标签开始时被调用。它返回一个整数值，该值指示标签处理器是应该继续执行直到标签体结束（ Tag.EVAL_PAGE ），还是立即停止处理并返回上一个标签处理器（ Tag.SKIP_PAGE ）。具体来说：

public int doStartTag() throws JspException {
    // 初始化标签的属性值
    // 这里可以执行标签开始处理的逻辑代码
    return EVAL_PAGE; // 继续执行标签体内容
}

如果返回 EVAL_PAGE ，则标签处理类会调用 doAfterBody （如果此方法存在），之后继续执行标签体内容，直到 doEndTag() 方法被调用。

doEndTag() 方法在标签结束时被调用，它同样返回一个整数值。返回 EVAL_PAGE 将导致容器继续执行页面上剩余的内容；返回 SKIP_PAGE 则会跳过剩余的页面内容并结束标签处理。例如：

public int doEndTag() throws JspException {
    // 执行标签结束时需要的清理工作
    return EVAL_PAGE; // 或 SKIP_PAGE
}

在 doStartTag 和 doEndTag 中的逻辑代码执行过程中，可以设置变量和执行特定的业务逻辑，这两者共同构建了标签处理类的核心功能。

4.1.2 其他生命周期方法的介绍

除了 doStartTag 和 doEndTag ， Tag 接口还提供了其他的生命周期方法。例如：

doAfterBody() ：如果标签体可以多次评估，此方法会在每次评估后被调用。返回 EVAL_BODY_AGAIN 允许标签体再次被评估；返回 SKIP_BODY 则跳过标签体余下内容。
release() ：此方法在标签库描述符（TLD）中声明为可选，用于在标签处理器实例被重用之前释放资源。
setParent(Tag parent) 和 getParent() ：用于设置和获取父标签处理器，这允许标签处理器之间的通信。

通过这些生命周期方法的合理使用，我们可以构建出灵活且功能强大的自定义标签，满足各种复杂的页面需求。

4.2 标签属性处理

4.2.1 设置和获取标签属性

在自定义标签中，属性提供了一种机制，允许在标签使用时向其传递参数。在标签处理类中，这些属性值需要被正确地保存和访问。通常，属性值在标签开始时被设置，并可在整个标签生命周期中使用。

要正确处理属性，首先需要在标签处理类中声明相应的属性变量，并提供相应的 setter 和 getter 方法。例如，如果我们要创建一个名为 myTag 的自定义标签，并希望它拥有 name 和 value 两个属性，则可以这样做：

private String name;
private String value;

public void setName(String name) {
    this.name = name;
}

public String getName() {
    return name;
}

public void setValue(String value) {
    this.value = value;
}

public String getValue() {
    return value;
}

接着，在标签库描述符（TLD）文件中声明这些属性，例如：

<tag>
  <name>myTag</name>
  <tag-class>com.example.MyTag</tag-class>
  <body-content>empty</body-content>
  <attribute>
    <name>name</name>
    <required>true</required>
    <rtexprvalue>true</rtexprvalue>
  </attribute>
  <attribute>
    <name>value</name>
    <required>true</required>
    <rtexprvalue>true</rtexprvalue>
  </attribute>
</tag>

在实际的标签处理类中，我们可以通过覆盖 setPageContext() 方法来实现属性值的初始化：

@Override
public void setPageContext(PageContext pageContext) {
    super.setPageContext(pageContext);
    // 可以在这里初始化属性值，例如从pageContext获取
}

最后，在 doStartTag() 或其他方法中，我们可以使用这些已经设置好的属性值。

4.2.2 属性验证与默认值

除了设置和获取属性值，有时还需要在标签处理类中进行属性验证，并为属性提供默认值。例如，一个属性可能必须满足特定的字符串模式，或者在未显式设置时应具有默认值。属性验证可以通过覆盖 Tag 接口的 setPageContext() 和 setParent() 方法来实现。而默认值则可以在属性的 getter 方法中设置。

例如，如果我们的 myTag 标签需要 value 属性是非空字符串，我们可以这样实现：

public String getValue() {
    if (this.value == null) {
        // 如果 value 属性未设置，返回默认值
        return "默认值";
    }
    return value;
}

对于更复杂的验证逻辑，可以实现 javax.servlet.jsp.tagext.validation.Validator 接口，并在标签的 TLD 文件中进行声明。

标签属性的正确处理是构建有效自定义标签的关键。通过在标签处理类中合理地使用属性验证和默认值，可以提高标签的可用性和健壮性。

4.3 标签体内容处理

4.3.1 处理标签体内的输出

在JSP自定义标签中，标签体可以包含输出内容或者自定义逻辑。为了处理标签体内的内容，标签处理类提供了 doAfterBody() 方法，该方法会在标签体内容每次执行完毕后被调用。这样，可以实现对标签体内容的多次评估和动态处理。

例如，如果要处理一个迭代标签， doAfterBody() 方法可以用来决定是否继续评估标签体：

public int doAfterBody() throws JspException {
    // 业务逻辑来决定是否再次评估标签体
    boolean continueEvaluating = shouldContinueEvaluating();
    if (continueEvaluating) {
        return EVAL_BODY_AGAIN;
    } else {
        return SKIP_BODY;
    }
}

此方法可以多次返回 EVAL_BODY_AGAIN ，直到不再需要重新评估标签体为止，此时返回 SKIP_BODY 。

4.3.2 标签体的包含与排除

在某些情况下，我们可能需要在标签处理类中完全忽略标签体，或者只包含标签体中特定部分的输出。这通常用于自定义标签，如条件标签、空白标签等。

要忽略标签体，可以重写 doStartTag() 方法并返回 SKIP_BODY ：

public int doStartTag() throws JspException {
    // 指示容器忽略标签体内容
    return SKIP_BODY;
}

要包含标签体中的特定部分，可以使用标签库描述符（TLD）中的 body-content 元素和 tagdependent 属性。例如，如果标签体包含原始的XML或HTML代码，可以设置 body-content 为 tagdependent ：

<tag>
  <name>rawContentTag</name>
  <tag-class>com.example.RawContentTag</tag-class>
  <body-content>scriptless</body-content>
</tag>

上述配置中， scriptless 表示标签体仅包含静态内容，不含脚本代码。标签处理类需要将这些静态内容输出到响应流中，而 tagdependent 表示标签体内容的处理完全由标签类负责，容器不会对其做任何处理。

通过灵活地处理标签体内容，开发者可以实现各种自定义逻辑和行为，从而创建功能丰富且用户友好的自定义标签库。

5. 标签文件的定义与使用

5.1 标签文件的创建与结构

标签文件是JSP技术中的一个扩展功能，它允许开发者创建可重用的代码片段，这些片段可以被嵌入到JSP页面中使用。它的优点是使得代码的可维护性提高，并且可以将页面逻辑与显示逻辑分离。

5.1.1 标签文件的基本规则

标签文件需要符合以下基本规则：

标签文件必须是JSP文件，通常以 .tag 作为文件扩展名。
标签文件的主体必须包含在一个标准的JSP脚本元素 <body> 中。
在JSP声明元素 <%! ... %> 中定义的变量或方法不能在标签文件的主体中直接访问，它们需要通过标签属性来实现数据的输入输出。

一个简单的标签文件示例如下：

<%@ tag language="java" pageEncoding="UTF-8" %>
<%@ attribute name="title" required="true" type="java.lang.String" %>
<%@ attribute name="content" required="true" type="java.lang.String" %>
<html>
<head>
    <title>${title}</title>
</head>
<body>
    <h1>${content}</h1>
</body>
</html>

5.1.2 标签文件与JSP页面的关系

标签文件的创建使得开发者可以将一些常见的页面片段封装成独立的组件，然后在多个JSP页面中重复使用。这不仅简化了页面的维护工作，还提高了代码的复用性。在JSP页面中引入标签文件时，需要使用标准的JSP标签库指令（ <%@ taglib ... %> ）来声明标签库，然后使用自定义标签的方式来调用标签文件。

例如，将上述的标签文件 simple.tag 放在WEB-INF/tags目录下，那么在JSP页面中使用如下：

<%@ taglib uri="/WEB-INF/tags" prefix="mytags" %>
<mytags:simple title="Hello World" content="This is a simple tag file example." />

5.2 标签文件的嵌入与执行

5.2.1 在JSP中嵌入标签文件

要将标签文件嵌入到JSP页面中，首先需要使用 <%@ taglib ... %> 指令来声明标签库，并指定标签库的位置和前缀。然后，通过自定义标签语法来调用标签文件。在JSP页面中嵌入标签文件的过程简单直接，开发者可以像使用标准JSP标签一样使用自定义的标签文件。

5.2.2 标签文件的作用域和执行流程

标签文件的作用域是它所在的JSP页面。当JSP页面被请求时，标签文件会被解析并执行，其执行流程如下：

解析JSP页面中的自定义标签。
根据标签文件中定义的属性和表达式语言（EL）进行数据传递。
执行标签文件中的JSP代码片段，输出结果到响应流中。
控制权返回给JSP页面，继续执行后续的代码或标签。

5.3 标签文件的高级应用

5.3.1 结合EL和JSTL使用标签文件

结合EL和JSTL可以使得标签文件的功能更加强大。EL表达式提供了获取作用域内属性值的能力，而JSTL标签可以执行复杂的逻辑操作和格式化数据。

例如，利用JSTL的 <c:out> 标签在上面定义的标签文件中输出内容：

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ attribute name="title" required="true" type="java.lang.String" %>
<%@ attribute name="content" required="true" type="java.lang.String" %>
<html>
<head>
    <title>${title}</title>
</head>
<body>
    <c:out value="${content}" />
</body>
</html>

5.3.2 标签文件与表达式语言的交互

标签文件可以与EL进行交互，通过EL表达式可以访问标签文件中定义的属性和变量，实现更丰富的交互和动态内容的展示。

标签文件可以包含脚本表达式，如 ${} ，用于输出表达式的结果。标签文件的属性可以被EL表达式访问，从而可以在JSP页面中动态地设置和获取这些属性。

在标签文件中，如果想要输出一个表达式的结果，可以直接使用EL表达式，如 ${someVariable} 。在JSP页面中，可以通过自定义标签的属性来传递值：

<mytags:simple title="A Dynamic Title" content="${someVariable}" />

在这里， someVariable 是JSP页面中的一个EL表达式，它将被替换为相应的值，然后传递给标签文件。

本文还有配套的精品资源，点击获取