JSP中的自定义标签

时间：2022-11-28 18:55:26


目录

  • ​​目录​​
  • ​​简介​​
  • ​​入门案例​​
  • ​​自定义标签功能扩展​​
  • ​​传统自定义标签的运行原理​​
  • ​传统自定义标签的使用​
  • ​​控制JSP页面部分内容执行​​
  • ​​控制整个JSP页面是否执行​​
  • ​​控制标签体执行重复执行​​
  • ​​用标签修改JSP页面内容​​
  • ​​简单标签的运行原理​​
  • ​简单标签的使用​
  • ​​控制JSP页面部分内容执行​​
  • ​​控制整个JSP页面是否执行​​
  • ​​控制标签体执行重复执行​​
  • ​​用标签修改JSP页面内容​​
  • ​​开发带属性的标签​​


简介

　　自定义标签主要用于移除JSP页面中的Java代码。
　　要使用自定义标签移除JSP页面中的Java代码，需要完成以下两个步骤：

  • 编写一个实现Tag接口的Java类，并把页面中Java代码适当地转移到这个Java类中（标签处理类）。
  • 编写标签库描述符（tld）文件（放置在WEB-INF目录下），在tld文件中把标签处理器类描述成一个标签。

入门案例

  • 使用标签输出客户机IP
    实现Tag接口的Java类 ViewIPTag
package com.wm103.web.tag;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.TagSupport;
import java.io.IOException;

/**
 * Created by DreamBoy on 2017/5/14.
 */
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();
    }
}

在WEB-INF目录下定义标签库描述符文件 wm103.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/j2ee http://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>WM103</short-name>
    <uri>http://www.wm103.com</uri>
    <tag>
        <name>viewIP</name>
        <tag-class>com.wm103.web.tag.ViewIPTag</tag-class>
        <body-content>empty</body-content><!-- 标签体为空 -->
    </tag>
</taglib>

在JSP页面中使用标签 index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://www.wm103.com" prefix="wm103"%>
<html>
  <head>
    <title>自定义标签</title>
  </head>
  <body>
  <p>您的IP是：
  <%
    String ip = request.getRemoteAddr();
    out.print(ip);
  %>
  </p>

  <p>您的IP是：<wm103:viewIP/></p>
  </body>
</html>

自定义标签功能扩展

自定义标签除了可以移除JSP页面Java代码外，它也可以实现以下功能：
1. 控制JSP页面某一部分内容是否执行；
2. 控制整个JSP页面是否执行；
3. 控制JSP页面内容重复执行；
4. 修改JSP页面内容输出。

传统自定义标签的运行原理

（JSP2.0以前的Tag接口）
1. 用户请求服务器JSP页面；
2. 服务器接收到请求，解析对应的JSP页面；
3. 解析过程中，JSP引擎遇到自定义标签，首先实例化标签对应的标签处理器类的实例对象，然后按照JSP规范定义的通信规则依次调用它的方法；
4. 调用标签处理器类的​​​setPageContext​​​方法，把页面的​​pageContext​​​对象传递给标签处理器类；
5. 服务器判断该标签是否有父标签，如果存在父标签，则把父标签作为一个对象，调用标签处理器类的​​​setParent​​​方法传递给标签处理器类；如果没有，则传递一个​​null​​​到方法中；
6. 完成以上标签的初始化工作后，服务器就开始执行标签，调用标签处理类的​​​doStartTag​​​方法；
7. 如果标签有标签体，这时服务器一般会执行标签体；
8. 服务器遇到JSP页面结束标签，则调用标签处理器类的​​​doEndTag​​​方法；
9. 整个标签执行完后，服务器一般情况会调用​​​release()​​​方法释放标签工作时所占用的资源；（​​release​​​方法真正被调用的时候是在Web应用被销毁的时候，也就是第一次解析标签成功后，标签处理器类会驻留在内存中，为其他请求服务，直至停止Web应用时，Web容器才会调用​​release​​​方法）
10. 服务器接着再执行余下的JSP页面。

传统自定义标签的使用

注：以下案例是JSP2.0以前的实现方式！！

控制JSP页面部分内容执行

TagDemo1.java

package com.wm103.web.tag;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;

public class TagDemo1 extends TagSupport {
    @Override
    public int doStartTag() throws JspException {

        return Tag.SKIP_BODY; // 不执行标签体
        //return Tag.EVAL_BODY_INCLUDE; // 执行标签体
    }
}

wm103.tld（向上述提到的wm103.tld文件增加新的tag标签，如无其他特别说明，下面案例也是这样的做法）

<tag>
    <name>demo1</name>
    <tag-class>com.wm103.web.tag.TagDemo1</tag-class>
    <body-content>JSP</body-content><!-- 标签体为JSP内容 -->
</tag>

在JSP页面中的使用（记得先 ​​<%@ taglib uri="http://www.wm103.com" prefix="wm103"%>​​）

<wm103:demo1>
    <p>使用标签控制页面内容是否输出</p>
</wm103:demo1>

控制整个JSP页面是否执行

TagDemo2.java

package com.wm103.web.tag;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;

/**
 * Created by DreamBoy on 2017/5/14.
 */
public class TagDemo2 extends TagSupport {
    @Override
    public int doEndTag() throws JspException {
        return Tag.SKIP_PAGE; // 不执行余下JSP页面
        //return Tag.EVAL_PAGE; // 执行余下JSP页面
    }
}

wm103.tld

<tag>
    <name>demo2</name>
    <tag-class>com.wm103.web.tag.TagDemo2</tag-class>
    <body-content>empty</body-content>
</tag>

在JSP页面中的使用

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="http://www.wm103.com" prefix="wm103"%>
<wm103:demo2/>
<html>
<head>
    <title>用标签控制整个JSP是否输出</title>
</head>
<body>
    <p>用标签控制整个JSP是否输出！！！</p>
</body>
</html>

控制标签体执行重复执行

TagDemo3.java

package com.wm103.web.tag;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.IterationTag;
import javax.servlet.jsp.tagext.Tag;
import javax.servlet.jsp.tagext.TagSupport;
/**
 * Created by DreamBoy on 2017/5/14.
 * 控制标签体执行5次
 */
public class TagDemo3 extends TagSupport {
    @Override
    public int doStartTag() throws JspException {
        return Tag.EVAL_BODY_INCLUDE; // 让它执行标签体
    }

    int x = 5;
    @Override
    public int doAfterBody() throws JspException {
        x--;
        if(x > 0) {
            return IterationTag.EVAL_BODY_AGAIN;
        } else {
            x = 5; // 这句话不加的话，第二次用该标签时，就只会执行一次标签体。因为标签处理器类在第一次被使用时被实例化，再次使用会使用驻留在内存中的实例对象，x值仍为0。
            return IterationTag.SKIP_BODY;
        }
    }
}

wm103.tld

<tag>
    <name>demo3</name>
    <tag-class>com.wm103.web.tag.TagDemo3</tag-class>
    <body-content>JSP</body-content>
</tag>

在JSP页面中的使用

<p>
    <wm103:demo3>
        重复执行！
    </wm103:demo3>
</p>
<p>
    <wm103:demo3>
        重复执行！
    </wm103:demo3>
</p>

用标签修改JSP页面内容

TagDemo4.java

package com.wm103.web.tag;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.BodyContent;
import javax.servlet.jsp.tagext.BodyTag;
import javax.servlet.jsp.tagext.BodyTagSupport;
import java.io.IOException;

/**
 * Created by DreamBoy on 2017/5/14.
 * 修改标签体，把标签体内容修改为大写
 */
public class TagDemo4 extends BodyTagSupport {
    @Override
    public int doStartTag() throws JspException {
        return BodyTag.EVAL_BODY_BUFFERED; // 让执行标签体时调用setBodyContent方法
    }

    @Override
    public int doEndTag() throws JspException {
        BodyContent bc = this.getBodyContent(); // 获得标签体
        String content = bc.getString().toUpperCase();
        try {
            this.pageContext.getOut().write(content);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        return super.doEndTag(); // return Tag.EVAL_PAGE;
    }
}

wm103.tld

<tag>
    <name>demo4</name>
    <tag-class>com.wm103.web.tag.TagDemo4</tag-class>
    <body-content>JSP</body-content>
</tag>

在JSP页面中的使用

<wm103:demo4>
    DreamBoy
</wm103:demo4>

简单标签的运行原理

  1. 用户请求服务器JSP页面；
  2. 服务器接收到请求，解析对应的JSP页面；
  3. 解析过程中，遇到自定义标签，首先实例化标签对应的标签处理器类；
  4. 调用标签处理器类的​​setJspContext​​​方法，把页面的​​pageContext​​对象传递给标签处理器类；
  5. 服务器判断该标签是否有父标签，如果存在父标签，则把父标签作为一个对象，调用标签处理器类的​​setParent​​​方法传递给标签处理器类；如果没有，则传递一个​​null​​到方法中；
  6. 调用​​setJspBody​​​方法，将标签体封装为​​JspFragment​​实例对象，并传递给标签处理器类；
  7. 执行页面中的自定义标签，执行标签实际上就是调用​​doTag​​方法；
  8. 标签执行完成（这里跟传统自定义标签不同，被实例化的标签处理器对象不会驻留在内存中，而是使用完成后，由Java垃圾处理机制处理）；
  9. 服务器接着再执行余下的JSP页面。

简单标签的使用

控制JSP页面部分内容执行

SimpleTagDemo1.java

package com.wm103.web.simpletag;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;
import java.io.IOException;

public class SimpleTagDemo1 extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException, IOException {
        // 不显示标签体的话就不调用如下语句
        JspFragment jf = this.getJspBody();
        jf.invoke(null); // 等价于 // jf.invoke(this.getJspContext().getOut());
    }
}

simplewm103.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/j2ee http://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>WM103</short-name>
    <uri>/SimpleWm103</uri>

    <tag>
        <name>demo1</name>
        <tag-class>com.wm103.web.simpletag.SimpleTagDemo1</tag-class>
        <body-content>scriptless</body-content>
    </tag>
</taglib>

在JSP页面中的使用

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="/SimpleWm103" prefix="swm103"%>
<html>
<head>
    <title>使用简单标签控制页面内容（标签体）是否输出</title>
</head>
<body>
    <swm103:demo1>
        <p>使用简单标签控制页面内容是否输出</p>
    </swm103:demo1>
</body>
</html>

控制整个JSP页面是否执行

SimpleTagDemo2.java

package com.wm103.web.simpletag;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.SkipPageException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
import java.io.IOException;

public class SimpleTagDemo2 extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException, IOException {
        throw new SkipPageException();
    }
}

simplewm103.tld（在原来的simplewm103.tld中添加如下tag标签）

<tag>
    <name>demo2</name>
    <tag-class>com.wm103.web.simpletag.SimpleTagDemo2</tag-class>
    <body-content>scriptless</body-content>
</tag>

在JSP页面中的使用

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="/SimpleWm103" prefix="swm103"%>
<swm103:demo2/>
<html>
<head>
    <title>用简单标签控制整个JSP是否输出</title>
</head>
<body>
    <p>用简单标签控制整个JSP是否输出！！！</p>
</body>
</html>

控制标签体执行重复执行

SimpleTagDemo3.java

package com.wm103.web.simpletag;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;
import java.io.IOException;

public class SimpleTagDemo3 extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException, IOException {
        JspFragment jf = this.getJspBody();
        for (int i = 0; i < 5; i++) {
            jf.invoke(null);
        }
    }
}

simplewm103.tld（在原来的simplewm103.tld中添加如下tag标签）

<tag>
    <name>demo3</name>
    <tag-class>com.wm103.web.simpletag.SimpleTagDemo3</tag-class>
    <body-content>scriptless</body-content>
</tag>

在JSP页面中的使用

<swm103:demo3>
    重复执行！
</swm103:demo3>

用标签修改JSP页面内容

SimpleTagDemo4.java

package com.wm103.web.simpletag;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;
import java.io.IOException;
import java.io.StringWriter;

public class SimpleTagDemo4 extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException, IOException {
        JspFragment jf = this.getJspBody();
        StringWriter writer = new StringWriter();
        jf.invoke(writer);
        String content = writer.getBuffer().toString().toUpperCase();
        this.getJspContext().getOut().write(content);
    }
}

simplewm103.tld（在原来的simplewm103.tld中添加如下tag标签）

<tag>
    <name>demo4</name>
    <tag-class>com.wm103.web.simpletag.SimpleTagDemo4</tag-class>
    <body-content>scriptless</body-content>
</tag>

在JSP页面中的使用

<swm103:demo4>
    DreamBoy
</swm103:demo4>

开发带属性的标签

　　自定义标签可以定义一个或多个属性，通过这些属性向标签处理器传递参数信息。
　　为自定义标签定义属性时，每个属性都必须按照JavaBean的属性命名方式，在标签处理器中定义属性名对应的setter方法，用来接收JSP页面调用自定义标签时传递进来的属性值。
　　要想让一个自定义标签具有属性，通常需要进行如下操作：

  • 在标签处理器中编写每个属性对应的setter方法；
  • 在TLD文件中描述标签的属性。
    案例：
    标签处理器类 SimpleTagDemo5.java
package com.wm103.web.simpletag;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.JspFragment;
import javax.servlet.jsp.tagext.SimpleTagSupport;
import java.io.IOException;
import java.util.Date;

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 {
        this.getJspContext().getOut().write(this.date.toLocaleString() + "<br/>");

        JspFragment jf = this.getJspBody();
        for (int i = 0; i < count; i++) {
            jf.invoke(null);
        }
    }
}

simplewm103.tld（在原来的simplewm103.tld中添加如下tag标签）

<tag>
    <name>demo5</name>
    <tag-class>com.wm103.web.simpletag.SimpleTagDemo5</tag-class>
    <body-content>scriptless</body-content>
    <attribute>
        <name>count</name>
        <required>true</required> <!--属性是否必须-->
        <rtexprvalue>true</rtexprvalue> <!--设置为true后，count可以接收JSP脚本或EL表达式的值-->
    </attribute>
    <attribute>
        <name>date</name>
        <required>true</required>
        <rtexprvalue>true</rtexprvalue>
    </attribute>
</tag>

JSP页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ page import="java.util.Date" %>
<%@ taglib uri="/SimpleWm103" prefix="swm103"%>
<html>
<head>
    <title>开发带属性的标签</title>
</head>
<body>
<p>
    <swm103:demo5 count="10" date="<%= new Date()%>">
        <p>DreamBoy</p>
    </swm103:demo5>
</p>
</body>
</html>


标签：

相关文章