12 JSP标签：内置、自定义、JSTL_jps中自定义标签-优快云博客

本文链接：https://blog.youkuaiyun.com/japson_iot/article/details/80043225

JSP标签：内置、自定义、JSTL

标签（空格分隔）： JavaWeb

JSP标签内置自定义JSTL

jsp标签的作用是替换jsp页面中的java代码，通过通过简短的语法，表达式，实现java代码的功能。一方面讲，在jsp中写java代码不但麻烦，而且编译速度慢；另一方面，要对前端和美工友好。总之，jsp页面中出现的java代码越少越好。

jsp标签的分类

内置标签（动作标签）：不需要在jsp页面导入标签
JSTL标签：标准库，包含核心标签，需要在jsp页面中导入标签
自定义标签：开发者自行定义，需要在jsp页面导入标签

内置标签

转发标签

在jsp页面中将请求转发至路径

<jsp:forward page="/MyJsp001.jsp"></jsp:forward>

相当于java代码：

request.getRequestDispatcher("/MyJsp001.jsp").forward(request, response);

注意：
在java代码中，我们可以使用带参数的url，例如/MyJsp001.jsp?name=tom，但是在转发标签中不可以这样使用。我们可以借助于参数标签。

参数标签

传递一个参数，参数标签一般与其他标签组合使用，作为其他标签的子标签使用。

<jsp:param value="jxf" name="name"/>

例如，如果我们想在请求转发中带一个参数，其用法如下：

<jsp:forward page="/MyJsp001.jsp">
　　<jsp:param value="tom" name="name"/>
</jsp:forward>

包含标签

其作用是将参数传递给包含进来的页面。

<jsp:include page="/MyJsp001.jsp">
        <%--可以将参数传递给包含进来的页面--%>
        <jsp:param value="jxf" name="tom"/>
</jsp:include>

注意：

jsp中还有一个长相语气非常类似的指令，包含指令，使一个页面包含另一个页面。

它们之前的区别为:

语法不同

<jsp:include page="/MyJsp001.jsp">
`<%@inclue file="被包含的页面"%>

<jsp:include>可以传递参数，<%@inclue%>不可以
<jsp:include>：包含页面与被包含页面分别编译为两个java源文件，在运行时引用，<%@inclue%>：包含页面与被包含页面合并编译为一个java源文件

JSTL标签

JSTL (java standard tag libarary：java标准标签库)。包括：
1. 核心标签库（c标签库，主要用到的）
2. 国际化标签库（fmt标签库）
3. EL函数库（fn函数库）

使用JSTL标签库的前提

这里以c标签库为例：

1. 导入jstl支持包

以IDEA为例，在网上下载jakarta-taglibs-standard-1.1.2.zip解压，并将standaed.jar和jstl.jar加入到项目的lib中。

此时能够使用jstl标签，但是IDEA并不认识它，所以需要进行设置：
选择File—>Setting在Setting下找到languages&Frameworks—->Schemas and DTDs,在右边的External Schemas and DTDs框下点击+,然后在URI中填入http://java.sun.com/jsp/jstl/core在explorer中找到解压文件的tld目录下的c.tld文件，并选择。

2. 导入标签库

在jsp页面的头部中使用Taglib指令导入标签库，其中uri:tld是文件中的uri名称，prefix是标签前缀

<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

主要标签的使用

<c:set>标签：用于保存数据到域对象中。var为属性名 value为属性值，scope为保存属性到那个域对象，默认为page域。

    <c:set var="name" value="tom"  scope="page"></c:set>
    <%--EL表达式输出page域中的name属性值--%>
    ${name}

相当于java代码<%= pageContext.setAttribute("name", "jxf") %>。

<c:out>标签：显示数据。其中value为输出到浏览器的值，${name}EL表达式取出域对象属性值为name的值，defaul表示当value值为null时显示的默认值，escapeXml表示是否转义为xml格式（也可以理解为普通文本格式），true表示转义，默认false

<c:out value="${name}" default="<h1>标题h1<h1>" escapeXml="false"></c:out>

`·标签：单条件判断，支持EL表达式

    <c:if test="${true}">
        条件成立！
    </c:if>

<c:choose>+<c:when>+<c:otherwise>标签：多条件判断，相当于if else结构，当有一条件满足后其他条件都不满足。

      <c:choose>
          <c:when test="${10>5}">
              10>5<br />
          </c:when>
          <c:when test="${6>2}">
              6>2<br />
          </c:when>
          <c:otherwise>
              条件都不成立
          </c:otherwise>
      </c:choose>

标签：遍历集合，其中有两个常用属性：var：为遍历到的元素的名称，items：需要遍历的集合。其余的属性有begin：其实元素，默认为0，end：结束元素，默认为最后一个，step步长，默认为1.

      <%--遍历list --%>
      <c:forEach var="student" begin="0" end="2" items="${list}" step="1" varStatus="varSta">
          name:${student.name}---age:${student.age}<br/>
      </c:forEach>

      <%--遍历map --%>
      <c:forEach var="student" begin="0" end="2" items="${map}" step="1" varStatus="varSta">
          key:${student.key}---name:${student.value.name}---age:${student.value.age}<br/>
      </c:forEach>

      <%--遍历array --%>
      <c:forEach var="student" begin="0" end="2" items="${array}" step="1" varStatus="varSta">
          name:${student.name}---age:${student.age}<br/>
      </c:forEach>

      <%--一般遍历集合或者数组都是全部遍历，所以只写2个属性var和items,其他取默认值 --%>
      <c:forEach var="student" items="${array}">
          name:${student.name}---age:${student.age}<br/>
      </c:forEach>

<c:forTokens>标签：切割字符串,相当于split函数。其中var切割出来的每一部分字符串；items：要切割的字符串；delims：分割的字符，若内容为字符串，则这个字符串的每个字符都会当作一个分割的字符。

<%
      String str = "a-b-c=d=e";
      pageContext.setAttribute("str", str);
 %>
    <c:forTokens var="item" items="${str}" delims="-=">
        ${item}<br />
    </c:forTokens>

自定义标签

当JSTL标签库已经无法满足我们的需求时候，就需要自己开发自定义标签，来满足我们的需求。

我们首先创建一个自定义标签库，实际上是一个普通的java类，继承SimpleTagSupport类。然后我们通过tld文件声明并配置我们自定义的标签库，之后，我们就可以在jsp中导入并使用我们自定义的标签了。

SimpleTag接口

SimpleTagSupport类继承自SimpleTag接口，而SimpleTag接口主要有以下4个方法，也可将这四个方法理解为标签处理器类的生命周期：

public interface SimpleTag extends JspTag {　　　

    // 执行标签时调用的方法，一定会调用
    public void doTag() throws javax.servlet.jsp.JspException, java.io.IOException;

    // 设置父标签对象，传入父标签对象，当标签存在父标签时会调用
    public void setParent( JspTag parent );

    // 设置JspContext对象，其实他真实传入的是其子类PageContext
    public void setJspContext( JspContext pc );

    // 设置标签体内容。标签体内容封装到JspFragment对象 中，然后传入JspFragment对象
    public void setJspBody( JspFragment jspBody );

}

SimpleTagSupport类

SimpleTagSupport类在其基础上封装出了3个方法，方便自定义标签类编写，该方法实现也比较简单，无非就是内部维护一个变量，通过set方法将其赋值，再返回该对象，这样继承SimpleTagSupport拿到如PageContext对象就直接调用getJspContext()即可。

/*SimpleTagSupport 类的一部分*/
public class SimpleTagSupport implements SimpleTag
{
    /** Reference to the enclosing tag. */
    private JspTag parentTag;

    /** The JSP context for the upcoming tag invocation. */
    private JspContext jspContext;

    /** The body of the tag. */
    private JspFragment jspBody;

    public void setParent( JspTag parent ) {
        this.parentTag = parent;
    }

    public JspTag getParent() {
        return this.parentTag;
    }

    public void setJspContext( JspContext pc ) {
        this.jspContext = pc;
    }

    protected JspContext getJspContext() {
        return this.jspContext;
    }

    public void setJspBody( JspFragment jspBody ) {
        this.jspBody = jspBody;
    }

    protected JspFragment getJspBody() {
        return this.jspBody;
    }
}

编写自定义标签的步骤

以写一个自定义标签为例：功能：向浏览器输出：“你好”。

1. 编写自定义标签库

编写一个普通的java类（OutInfo.java），继承SimpleTagSupport类，并重写doTag方法。

/*
 * OutInfo.java
 */
public class OutInfo extends SimpleTagSupport {

    @Override
    public void doTag() throws JspException, IOException {
        PageContext pageContext = (PageContext)getJspContext();
        pageContext.getOut().write("你好");
    }
}

2. 建立tld文件

在web项目的WEB-INF目录下建立tld文件（myTaglib.tld），这个tld文件为标签库的声明文件，并配置好相应的信息。（可以参考核心标签库的tld文件，如：项目/Java EE 5 Libraries/jstl-1.2jar/META-INF/c.tld）

<?xml version="1.0" encoding="UTF-8" ?>

<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">

  <description>JSTL 1.1 core library</description>
  <display-name>JSTL core</display-name>
  <tlib-version>1.1</tlib-version>

  <!--标签库前缀 taglib指令中的prefix属性 -->
  <short-name>myTaglib</short-name>
  <!--tld文件的唯一标记 taglib指令中的uri属性 -->
  <uri>http://myTaglib.tag</uri>

  <tag>
    <description>
        这是自定义标签的描述信息
    </description>
    <!-- 标签名 -->
    <name>outInfo</name>
    <!-- 标签类的完名 -->
    <tag-class>myTaglib.OutInfo</tag-class>
    <body-content>scriptless</body-content>
    <!-- <attribute>
        <description>
            这是属性的描述信息          
        </description>
        <name>var</name>
        <required>false</required>
        <rtexprvalue>false</rtexprvalue>
    </attribute> -->
  </tag>

</taglib>

3. 导入自定义标签库

在jsp页面的头部导入自定义标签库

<%@taglib uri="http://myTaglib.tag" prefix="myTaglib" %>

4. 使用自定义标签

在jsp中使用自定义标签　

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%@taglib uri="http://jxf.tag" prefix="jxf" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>自定义标签</title>
  </head>
  <body>
    <myTaglib:outInfo></myTaglib:outInfo>
  </body>
</html>