Der 48. Tag von Java, Taglib von Jsp, detaillierte Erklärung benutzerdefinierter Tags

Mobile 2023-08-19 20:21:20 views: null

Theoretisches Wissen

1. Was ist der Kern des Labels?

Ein benutzerdefiniertes Tag ist eigentlich eine Java-Klasse, die eine bestimmte Schnittstelle implementiert. Es kapselt einige allgemeine Funktionen und wird zur Laufzeit durch den entsprechenden Code ersetzt; der größte Unterschied zwischen ihm und JavaBean besteht darin, dass JavaBean keinen Standardkontext (JspContext) hat, sondern das Tag haben.

Ein benutzerdefiniertes Tag besteht aus einem Tag-Handler und einer Tag-Beschreibung;

  • Tag-Handler: Wenn ein bestimmtes Tag gefunden wird, teilt der Tag-Handler dem System mit, was zu tun ist, und die Klasse enthält den auszuführenden Java-Code
  • Labelbeschreibung: erklärt, wie dieses Label verwendet wird
  • Tag: Kann Attribute und Körper haben, diese Attribute und Körper sind optional, das einfachste Tag ist weder Attribut noch Körper

2. Einführung in die Etikettenschnittstelle

Alle JSP-Tags implementieren die Schnittstelle javax.servlet.jsp.tagext.JspTag ; die beiden direkten Unterschnittstellen dieser Schnittstelle sind wie folgt:

  • SimpleTag ===> JSP2.0 neu hinzugefügte Schnittstelle (im Folgenden zusammenfassend als einfache Tags bezeichnet)
  • Tag ===> Es handelt sich um eine klassische Schnittstelle, die implementiert werden muss. Sie verfügt über eine direkte Unterschnittstelle, nämlich IterationTag (im Folgenden gemeinsam als traditionelle Tags bezeichnet).

Die Tag-Schnittstelle verfügt über eine direkte Unterschnittstelle IterationTag (im Folgenden gemeinsam als traditionelle Tags bezeichnet), die die Tag-Schnittstelle erbt.

Die Tag-Schnittstelle verfügt über eine direkte Unterschnittstelle TagSupport, die die Tag-Schnittstelle implementiert; (die TagSupport-Schnittstelle verfügt über eine direkte Unterschnittstelle, BodyTagSupport; sie ermöglicht Tags mit einem Körper)

3. Grundlegende theoretische Kenntnisse der benutzerdefinierten Tag-Bibliothek

1. Architektur der benutzerdefinierten Tag-Bibliothek

 2. Benutzerdefinierte Tag-Handler-Komponente

 3. Grundkonzepte

  • Tag (Tag): Lassen Sie die JSP-Seite bestimmte Funktionen implementieren. Durch das Tag kann die JSP-Webseite prägnant und leicht zu pflegen gestaltet werden. Es handelt sich um ein XML-Element, dessen Name und Attribute zwischen Groß- und Kleinschreibung unterscheiden.
  • Tag-Bibliothek (Tag-Bibliothek): Eine Sammlung von Tags mit ähnlichen Funktionen und logischen Beziehungen. Das „Präfix“ derselben Tag-Bibliothek ist dasselbe
  • Beschreibungsdatei der Tag-Bibliothek (Tag Library Descriptor): Es handelt sich um eine XML-Datei, die die Zuordnungsbeziehung zwischen Klassen in der Tag-Bibliothek und Tag-Referenzen in JSP bereitstellt. Es handelt sich außerdem um eine Konfigurationsdatei, ähnlich wie web.xm
  • Tag-Handle-Klasse: Es handelt sich um eine Java-Klasse, die die Tag-Schnittstelle direkt oder indirekt erbt und möglicherweise auch Tag oder seine Unterschnittstellen implementiert. Über diese Klasse können die spezifischen Funktionen von JSP-Tags selbst definiert werden.

4. Lebenszyklus beschriften

  1. Wenn der Container eine neue Etiketteninstanz erstellt, legen Sie den Seitenkontext des Etiketts über setPageContext fest
  2. Verwenden Sie die setParent-Methode, um die übergeordnete Beschriftung dieser Beschriftung festzulegen. Wenn keine vorherige Verschachtelung vorhanden ist, setzen Sie sie auf Null
  3. Das Attribut des Tags wird in der Beschreibungsdatei der Tag-Bibliothek definiert
  4. Rufen Sie die doStartTag-Methode auf, die EVAL_BODY_INCLUDE und SKIP_BODY zurückgibt (EVAL_BODY_INCLUDE: Den Textkörper des Tags berechnen; SKIP_BODY: Den Textkörper des Tags nicht berechnen)
  5. Rufen Sie die doEndTag-Methode auf, die EVAL_PAGE oder SKIP_PAGE zurückgibt (EVAL_PAGE: Der Container berechnet am Ende weiterhin andere Teile der JSP-Seite; SKIP_PAGE: Der Container stoppt die Berechnung anderer Teile der JSP-Seite, wenn das Tag endet.)
  6. Rufen Sie die Methode realse() auf, um alle vom Label-Programm belegten Ressourcen freizugeben

Die Bedeutung jeder Funktion und jedes Schlüsselworts im Lebenszyklus:

1.doStartTag()

Wenn Sie auf das Start-Tag eines benutzerdefinierten Tags stoßen, rufen Sie die Methode der Tag-Verarbeitungsklasse auf. Die Bedeutung des Rückgabewerts ist wie folgt

  • EVAL_ BODY_INCLUDE (gibt an, dass der Tag-Hauptteil ausgeführt werden soll und das Ausführungsergebnis im aktuellen Ausgabestream platziert wird)
  • SKP_BODY (Tag-Body nicht ausführen)

2.doEndTag()

Wenn Sie auf das End-Tag eines benutzerdefinierten Tags stoßen, rufen Sie die Methode der Tag-Verarbeitungsklasse auf. Der Rückgabewert und seine Bedeutung lauten wie folgt:

  • EVAL_PAGE: Der verbleibende Inhalt der JSP-Seite wird weiterhin ausgeführt
  • SKIP_PAGE: Der verbleibende Inhalt der Jsp-Seite wird nicht ausgeführt

3.doAfterBody()

Es handelt sich um eine der IterationTag-Schnittstelle hinzugefügte Methode, die aufgerufen wird, nachdem der Tag-Körper ausgeführt wurde. Wenn kein Tag-Körper vorhanden ist, wird diese Methode nicht aufgerufen. Der Rückgabewert dieser Methode und ihre Bedeutung sind wie folgt:

  • SKIP_BODY: Den Tag-Text überspringen
  • EVAL_BODY_AGAIN: wiederholte Ausführung des Tag-Bodys

4.setBodyContent()

Dabei handelt es sich um die Methode zum Festlegen der bodyContent-Eigenschaft in der BodyTag-Schnittstelle, um später den Inhalt des Tag-Körpers zu erhalten. Sie wird nur ausgeführt, wenn doStartTag() EVAL_BODY _BUFFERED zurückgibt

5. Schritte zum Erstellen eines benutzerdefinierten Etiketts

  1. Erstellen Sie eine Etikettenverarbeitungsklasse
  2. Schreiben und Bereitstellen von TLD-Dateien (Tag Library Description).
  3. Konfigurieren Sie die Tag-Bibliotheksinformationen in der Datei web.xml
  4. Verwendung der Tag-Bibliothek in der JSP-Datei

6. Tag-Bibliotheksbeschreibungsdatei (TLD).

(1) Funktion

Die Rolle der Tag-Bibliotheksbeschreibungsdatei (TLD) besteht darin, die entsprechende Tag-Verarbeitungsklasse anhand des Tags zu finden

(2) Vorsichtsmaßnahmen

Die Erweiterung der TLD-Datei (Tag Library Description) ist tld, eine XML-Datei. Sie wird normalerweise in META INF oder WEB-INF oder deren Unterverzeichnis abgelegt, kann jedoch nicht im Verzeichnis WEB\INF\classes gespeichert werden WEB-INF\Iib-Verzeichnis Mitte

(3) Hauptmarke

URL-Tag ===> Suchen Sie die entsprechende Verarbeitungsklasse für jedes benutzerdefinierte Tag. uri enthält eine Zeichenfolge, die vom Container zum Auffinden der TLD-Datei verwendet wird. In der TLD-Datei sind die Namen aller Tag-Verarbeitungsklassen in der Tag-Bibliothek zu finden und können auch in web.xml festgelegt werden

Beschreibungs-Tag ===> Beschreibungsinformationen

display-name-Tag ===> Name, der vom Visualizer angezeigt werden soll (optional)

tlib-version tag ===> Version dieser Tag-Bibliothek

Das Kurznamen-Tag ===> das „Präfix“ des Tags; wird zur Identifizierung der Tag-Bibliothek verwendet, das Präfix derselben Tag-Bibliothek ist dasselbe

Tag-Markierung ===> Etikett

Das Tag-Tag kann die folgenden Unter-Tags enthalten

<name>标签名</name>

<tag-class>Paketname.Tag-Verarbeitungsklasse</tag-class>

<attibute>...</attribute>: Sie können den Attributnamen festlegen, ob er erforderlich ist, ob der Attributwert zur Laufzeit ein Ausdruck ist usw.

<body-content>..</body-content>

Der <body-content/>-Tag-Körper kann 4 Werte haben:

  • leer (kein Etikettenkörper)
  • JSP (standardmäßig kann der Tag-Körper JSP-Code enthalten)
  • skriptlos (der Tag-Körper kann EL- und JSP-Standardaktionen, aber keine Skripte enthalten)
  • tagabhängig (der Tag-Körper wird vom Tag verwaltet)

(4) Der Aufrufprozess des benutzerdefinierten Etiketts

  1. Der Webcontainer erhält den Wert des uri-Attributs in der taglib-Anweisung entsprechend dem Tag-Präfix
  2. Der Webcontainer findet das entsprechende <taglib>-Element in web.xml entsprechend dem uri-Attribut
  3. Rufen Sie den Wert des entsprechenden <taglib-location>-Elements aus dem <taglib>-Element ab
  4. Der Webcontainer findet die entsprechende td-Datei im Verzeichnis WEB-INF/ entsprechend dem Wert des Elements <taglib-location>
  5. Suchen Sie das <tag>-Element, das dem Tag-Namen entspricht, aus der tld-Datei
  6. Rufen Sie den Wert des entsprechenden <tag-class>-Elements aus dem <tag>-Element ab
  7. Der Webcontainer erstellt die entsprechende Tag-Verarbeitungsklasseninstanz entsprechend dem Wert des <tag-class>-Elements
  8. Der Webcontainer ruft die Methode doStartTag/doEndTag dieser Instanz auf, um die entsprechende Verarbeitung abzuschließen

Technischer Kampf

1. Entwickeln Sie benutzerdefinierte Tags basierend auf der Tag-Schnittstelle (kein Attribut, kein Tag-Körper).

1. Erstellen Sie eine Etikettenverarbeitungsklasse

package taglib;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.Tag;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class MyTaglib implements Tag {

    private PageContext pageContext;
    private Tag parent;

    public MyTaglib() {
        super();
    }

    @Override
    public void setPageContext(PageContext pageContext) {
        this.pageContext = pageContext;
    }

    @Override
    public void setParent(Tag tag) {
        this.parent = tag;
    }

    @Override
    public Tag getParent() {
        return this.parent;
    }

    @Override
    public int doStartTag() throws JspException {
        //返回 SKIP_BODY，表示不计算标签体
        return SKIP_BODY;
    }

    @Override
    public int doEndTag() throws JspException {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat();
            sdf.applyPattern("yyyy-MM-dd HH:mm:ss");
            Date date = new Date();// 获取当前时间
            pageContext.getOut().write(sdf.format(date));
        } catch (IOException e) {
            throw new JspTagException(e.getMessage());
        }
        return EVAL_PAGE;
    }

    @Override
    public void release() {

    }
}

2. Schreiben und Bereitstellen von TLD-Dateien (Tag Library Description).

<?xml version="1.0" encoding="ISO-8859-1" ?>
<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>学习如何使用 Tag 接口</description>
    <tlib-version>1.0</tlib-version>
    <!--该属性是设置该标签库下所有标签的前缀-->
    <short-name>tools</short-name>
    <!--该属性是设置该标签库的唯一 url-->
    <uri>/learnTag</uri>



    <!--为标签库添加 标签-->
    <tag>
        <description>基于 Tag 接口的自定义标签</description>
        <!--为本标签设置所在标签库下唯一标签名-->
        <name>showTime</name>
        <!--指明标签处理类的位置-->
        <tag-class>taglib.MyTaglib</tag-class>
        <!--因为没有标签体所以设为 empty-->
        <body-content>empty</body-content>
    </tag>
</taglib>

3. Konfigurieren Sie die Tag-Bibliotheksinformationen in der Datei web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--配置taglib-->
  <taglib>
    <!--设置标签库唯一 url ；这里的 url 必须与 tld 文件中的 url 一致-->
    <taglib-uri>/learnTag</taglib-uri>
    <!--指明 tld 标签库描述文件的位置-->
    <taglib-location>/WEB-INF/tlds/MyTaglib.tld</taglib-location>
  </taglib>
  <!---->
</web-app>

4. Verwenden Sie die Tag-Bibliothek in der JSP-Datei

<!--配置 taglib 标签库的前缀与 url，这里的前缀与 url 必须与 tld 文件的一致-->
<%@ taglib prefix="tools" uri="/learnTag" %>
<html>
<body>
    <!--采取 标签库名:标签名 格式使用指定标签库下的指定标签-->
    <tools:showTime/>
</body>
</html>

2. Entwickeln Sie benutzerdefinierte Tags basierend auf der abstrakten Klasse TagSupport (kein Attribut, kein Tag-Körper).

1. Erstellen Sie eine Etikettenverarbeitungsklasse

Hinweis: Wenn Sie die abstrakte Klasse TagSupport erben, um benutzerdefinierte Tags zu implementieren, müssen Sie nur die Methoden implementieren, die Sie verwenden müssen, d. h. Sie müssen keine unnötigen Methoden implementieren

package tagSupport;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.tagext.TagSupport;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class MyTaglibSupport extends TagSupport {

    @Override
    public int doEndTag() throws JspException {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat();
            sdf.applyPattern("yyyy-MM-dd HH:mm:ss");
            Date date = new Date();// 获取当前时间
            pageContext.getOut().write(sdf.format(date));
        } catch (IOException e) {
            throw new JspTagException(e.getMessage());
        }
        return EVAL_PAGE;
    }
}

2. Schreiben und Bereitstellen von TLD-Dateien (Tag Library Description).

<?xml version="1.0" encoding="ISO-8859-1" ?>
<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>学习如何使用 Tag 接口</description>
    <tlib-version>1.0</tlib-version>
    <!--该属性是设置该标签库下所有标签的前缀-->
    <short-name>tools</short-name>
    <!--该属性是设置该标签库的唯一 url-->
    <uri>/learnTag</uri>



    <!--为标签库添加 标签-->
    <tag>
        <description>基于 Tag 接口的自定义标签</description>
        <!--为本标签设置所在标签库下唯一标签名-->
        <name>showTime</name>
        <!--指明标签处理类的位置-->
        <tag-class>taglib.MyTaglib</tag-class>
        <!--因为没有标签体所以设为 empty-->
        <body-content>empty</body-content>
    </tag>

    <!--为标签库添加新的标签-->
    <tag>
        <!--为本标签设置所在标签库下唯一标签名-->
        <name>showTimeV2</name>
        <!--指明标签处理类的位置-->
        <tag-class>tagSupport.MyTaglibSupport</tag-class>
        <!--因为没有标签体所以设为 empty-->
        <body-content>empty</body-content>
    </tag>
</taglib>

3. Konfigurieren Sie die Tag-Bibliotheksinformationen in der Datei web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--配置taglib-->
  <taglib>
    <!--设置标签库唯一 url ；这里的 url 必须与 tld 文件中的 url 一致-->
    <taglib-uri>/learnTag</taglib-uri>
    <!--指明 tld 标签库描述文件的位置-->
    <taglib-location>/WEB-INF/tlds/MyTaglib.tld</taglib-location>
  </taglib>
  <!---->
</web-app>

4. Verwenden Sie die Tag-Bibliothek in der JSP-Datei

<%@ taglib prefix="tools" uri="/learnTag" %>
<html>
<body>
    <!--采取 标签库名:标签名 指明要使用的标签-->
    <tools:showTimeV2/>
</body>
</html>

3. Entwickeln Sie benutzerdefinierte Tags basierend auf der abstrakten Klasse TagSupport (mit Attributen, ohne Tag-Körper).

1. Erstellen Sie eine Etikettenverarbeitungsklasse

package tagSupport;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.tagext.TagSupport;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class MyTaglibSupportAttr extends TagSupport {

    // 对于有属性的标签，需要在标签处理类中设置同名的属性，并为属性设置 get 和 set 方法
    private String country;
    private String city;

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public int doEndTag() throws JspException {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat();
            sdf.applyPattern("yyyy-MM-dd HH:mm:ss");
            Date date = new Date();// 获取当前时间
            pageContext.getOut().write(country + "-" + city + ": " + sdf.format(date));
        } catch (IOException e) {
            throw new JspTagException(e.getMessage());
        }
        return EVAL_PAGE;
    }
}

2. Schreiben und Bereitstellen von TLD-Dateien (Tag Library Description).

<?xml version="1.0" encoding="ISO-8859-1" ?>
<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>学习如何使用 Tag 接口</description>
    <tlib-version>1.0</tlib-version>
    <!--该属性是设置该标签库下所有标签的前缀-->
    <short-name>tools</short-name>
    <!--该属性是设置该标签库的唯一 url-->
    <uri>/learnTag</uri>



    <!--为标签库添加 标签-->
    <tag>
        <description>基于 Tag 接口的自定义标签</description>
        <!--为本标签设置所在标签库下唯一标签名-->
        <name>showTime</name>
        <!--指明标签处理类的位置-->
        <tag-class>taglib.MyTaglib</tag-class>
        <!--因为没有标签体所以设为 empty-->
        <body-content>empty</body-content>
    </tag>

    <!--为标签库添加新的标签-->
    <tag>
        <!--为本标签设置所在标签库下唯一标签名-->
        <name>showTimeV2</name>
        <!--指明标签处理类的位置-->
        <tag-class>tagSupport.MyTaglibSupport</tag-class>
        <!--因为没有标签体所以设为 empty-->
        <body-content>empty</body-content>
    </tag>

    <tag>
        <name>showTimeV3</name>
        <tag-class>tagSupport.MyTaglibSupportAttr</tag-class>
        <body-content>empty</body-content>

        <attribute>
            <!--设置属性名，必须与标签处理类中的属性名一致-->
            <name>country</name>
            <!--设置该属性是否必须-->
            <required>true</required>
            <!--设置是否支持 EL 表达式赋值-->
            <rtexprvalue>true</rtexprvalue>
        </attribute>

        <attribute>
            <!--设置属性名，必须与标签处理类中的属性名一致-->
            <name>city</name>
            <!--设置该属性是否必须-->
            <required>true</required>
            <!--设置是否支持 EL 表达式赋值-->
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>
</taglib>

3. Konfigurieren Sie die Tag-Bibliotheksinformationen in der Datei web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--配置taglib-->
  <taglib>
    <!--设置标签库唯一 url ；这里的 url 必须与 tld 文件中的 url 一致-->
    <taglib-uri>/learnTag</taglib-uri>
    <!--指明 tld 标签库描述文件的位置-->
    <taglib-location>/WEB-INF/tlds/MyTaglib.tld</taglib-location>
  </taglib>
  <!---->
</web-app>

4. Verwenden Sie die Tag-Bibliothek in der JSP-Datei

<%@ taglib prefix="tools" uri="/learnTag" %>
<html>
<body>
    <!--采取 标签库名:标签名 指明要使用的标签-->
    <tools:showTimeV3 country="china" city="shi_jia_zhuang"/>
</body>
</html>

4. Entwickeln Sie benutzerdefinierte Tags basierend auf der abstrakten Klasse BodyTagSupport (mit Attributen und Tag-Körper).

1. Vorsichtsmaßnahmen

Ein Tag mit einem Körper muss die Schnittstelle javax.servlet.jsp.tagext.BodyTag implementieren, und die Schnittstelle BodyTag definiert Methoden zur Verarbeitung von Tags.

2. Der Lebenszyklus eines Tags mit Tag-Body:

  1. Wenn der Container eine neue Etiketteninstanz erstellt, legen Sie den Kontext der Etikettenseite über setPageContext fest
  2. Verwenden Sie die setParent-Methode, um die übergeordnete Beschriftung dieser Beschriftung festzulegen. Wenn keine vorherige Verschachtelung vorhanden ist, setzen Sie sie auf Null
  3. Legen Sie die Attribute des Etiketts fest, die in der Beschreibungsdatei des Etiketts definiert sind
  4. Rufen Sie die doStartTag-Methode auf. Wenn EVAL_BODY_INCLUDE zurückgegeben wird, wird der BODY des Tags berechnet. Wenn SKIP_BODY zurückgegeben wird, wird der Body des Tags nicht berechnet
  5. Rufen Sie setBodyContent auf, um den aktuellen BodyContent festzulegen
  6. Rufen Sie doInitBody auf. Wenn bei der Berechnung von BodyContent eine Initialisierung erforderlich ist, führen Sie dies in dieser Methode aus
  7. Rufen Sie doAfterBody jedes Mal nach der Berechnung des BodyTag auf. Wenn EVAL_BODY_TAG zurückgegeben wird, bedeutet dies, dass der Bodytag einmal weiter berechnet wird und Schritt 8 erst ausgeführt wird, wenn SKIP_BODY zurückgegeben wird
  8. Wenn beim Aufruf der doEndTag-Methode EVAL_PAGE zurückgegeben wird, berechnet der Container nach dem Ende des Tags weiterhin andere Teile der JSP-Seite. Wenn SKIP_PAGE zurückgegeben wird, stoppt der Container die Berechnung anderer Teile der JSP-Seite, wenn das Tag endet
  9. Rufen Sie die Methode realse() auf, um alle vom Label-Programm belegten Ressourcen freizugeben

3.BodyTagSupport-Klasse

① BodyTagSupport erbt von der TagSupport-Klasse und implementiert die BodyTag-Schnittstelle

② Diese Klasse fügt eine Mitgliedsvariable BodyContent hinzu. Die BodyContent-Klasse ist eine Unterklasse von JspWriter, die hauptsächlich zum Zugriff auf den Tag-Körper und zum Speichern der Verarbeitungsergebnisse des Tag-Körpers verwendet wird

③ Diese Klasse fügt die Methoden setBodyContent(BodyContent b), doInitBody() und doAfterBody() hinzu

4. Analysieren Sie die Schritte zum Ändern des Tag-Körpers

  1. Erben Sie die BodyTagSupport-Klasse oder implementieren Sie die BodyTag-Schnittstelle 
  2. doStartTag() gibt EVAL_BODY_BUFFERED zurück (was anzeigt, dass der Tag-Hauptteil ausgeführt werden soll und das Ausführungsergebnis im aktuellen Ausgabestream platziert wird)
  3. Verarbeiten Sie den Tag-Körper in der Methode doAfterBody () (rufen Sie getBodyContent () und verwandte Methoden von BodyContent auf, rufen Sie den Inhalt des Tag-Körpers ab und speichern Sie das Ergebnis der Programmverarbeitung im Ausgabestream

Wie aus dem Obigen hervorgeht, ist zum Abrufen und Ändern des Inhalts des Tag-Körpers eine wichtige Klasse erforderlich – BodyContent, die über zwei wichtige Methoden verfügt

String getString(): gibt den Inhalt des Tag-Bodys als String zurück

public JspWriter getEnclosingWriter(): Ruft das gekapselte JspWriter-Objekt ab

1. Erstellen Sie eine Etikettenverarbeitungsklasse

package tagSupport;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.tagext.BodyTagSupport;
import javax.servlet.jsp.tagext.TagSupport;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class MyTaglibSupportAttrBody extends BodyTagSupport {

    // 对于有属性的标签，需要在标签处理类中设置同名的属性，并为属性设置 get 和 set 方法
    private String country;
    private String city;

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public int doStartTag() throws JspException {
        return EVAL_BODY_BUFFERED;
    }

    @Override
    public int doEndTag() throws JspException {
        return EVAL_PAGE;
    }

    @Override
    public void doInitBody() throws JspException {
        super.doInitBody();
    }

    @Override
    public int doAfterBody() throws JspException {

        JspWriter out = bodyContent.getEnclosingWriter();
        try {
            out.println(bodyContent.getString() + country + "-" +city + "<br/>");
        } catch (IOException e) {
            e.printStackTrace();
        }
        bodyContent.clearBody();
        return super.doAfterBody();
    }
}

2. Schreiben und Bereitstellen von TLD-Dateien (Tag Library Description).

<?xml version="1.0" encoding="ISO-8859-1" ?>
<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>学习如何使用 Tag 接口</description>
    <tlib-version>1.0</tlib-version>
    <!--该属性是设置该标签库下所有标签的前缀-->
    <short-name>tools</short-name>
    <!--该属性是设置该标签库的唯一 url-->
    <uri>/learnTag</uri>



    <!--为标签库添加 标签-->
    <tag>
        <description>基于 Tag 接口的自定义标签</description>
        <!--为本标签设置所在标签库下唯一标签名-->
        <name>showTime</name>
        <!--指明标签处理类的位置-->
        <tag-class>taglib.MyTaglib</tag-class>
        <!--因为没有标签体所以设为 empty-->
        <body-content>empty</body-content>
    </tag>

    <!--为标签库添加新的标签-->
    <tag>
        <!--为本标签设置所在标签库下唯一标签名-->
        <name>showTimeV2</name>
        <!--指明标签处理类的位置-->
        <tag-class>tagSupport.MyTaglibSupport</tag-class>
        <!--因为没有标签体所以设为 empty-->
        <body-content>empty</body-content>
    </tag>

    <tag>
        <name>showTimeV3</name>
        <tag-class>tagSupport.MyTaglibSupportAttr</tag-class>
        <body-content>empty</body-content>

        <attribute>
            <!--设置属性名，必须与标签处理类中的属性名一致-->
            <name>country</name>
            <!--设置该属性是否必须-->
            <required>true</required>
            <!--设置是否支持 EL 表达式赋值-->
            <rtexprvalue>true</rtexprvalue>
        </attribute>

        <attribute>
            <!--设置属性名，必须与标签处理类中的属性名一致-->
            <name>city</name>
            <!--设置该属性是否必须-->
            <required>true</required>
            <!--设置是否支持 EL 表达式赋值-->
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>showTimeV4</name>
        <tag-class>tagSupport.MyTaglibSupportAttrBody</tag-class>
        <body-content>JSP</body-content>

        <attribute>
            <!--设置属性名，必须与标签处理类中的属性名一致-->
            <name>country</name>
            <!--设置该属性是否必须-->
            <required>true</required>
            <!--设置是否支持 EL 表达式赋值-->
            <rtexprvalue>true</rtexprvalue>
        </attribute>

        <attribute>
            <!--设置属性名，必须与标签处理类中的属性名一致-->
            <name>city</name>
            <!--设置该属性是否必须-->
            <required>true</required>
            <!--设置是否支持 EL 表达式赋值-->
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>
</taglib>

3. Konfigurieren Sie die Tag-Bibliotheksinformationen in der Datei web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--配置taglib-->
  <taglib>
    <!--设置标签库唯一 url ；这里的 url 必须与 tld 文件中的 url 一致-->
    <taglib-uri>/learnTag</taglib-uri>
    <!--指明 tld 标签库描述文件的位置-->
    <taglib-location>/WEB-INF/tlds/MyTaglib.tld</taglib-location>
  </taglib>
  <!---->
</web-app>

4. Verwenden Sie die Tag-Bibliothek in der JSP-Datei

<%@ taglib prefix="tools" uri="/learnTag" %>
<html>
<body>
    <!--采取 标签库名:标签名 指明要使用的标签-->
    <tools:showTimeV4 country="china" city="shi_jia_zhuang">
        My home is in :
    </tools:showTimeV4>
</body>
</html>

5. Entwickeln Sie benutzerdefinierte Tags basierend auf der SimpleTag-Schnittstelle (mit Attributen, ohne Tag-Body).

SimpleTag ist ein neuer Tag-Typ, der der JSP2.0-Spezifikation hinzugefügt wurde und die komplexen Vorgänge bei der herkömmlichen Tag-Entwicklung vereinfacht.

JSP 2.0 wurde eine neue API zum Erstellen selbst erstellter Tags hinzugefügt, und javax.servlet.jsp.tagext.SimpleTag definiert eine Schnittstelle zum Implementieren einfacher Tags. Im Gegensatz zu den vorhandenen Schnittstellen in JSP 1.2 verwendet die SimpleTag-Schnittstelle nicht die Methoden doStartTag() und doEndTag(), sondern stellt eine einfache doTag()-Methode bereit. Diese Methode wird beim Aufruf dieses Markers nur einmal verwendet. Alle Logik, Schleifen und Auswertung von Tag-Körpern, die in einem selbst erstellten Tag implementiert werden müssen, werden in dieser Methode implementiert.

Unter diesem Aspekt können SimpleTag und IterationTag den gleichen Effekt erzielen. Die Methoden und der Verarbeitungszyklus von SimpleTag sind jedoch viel einfacher. Es gibt auch die Methoden seJspBody() und getJspBody(), die zum Festlegen von JSP-Inhalten in SimpleTag verwendet werden. Der Webcontainer verwendet die Methode setJspBody(), um ein JspFragment-Objekt zu definieren, das den JSP-Inhalt darstellt. Das Programm, das das SimpleTag-Tag implementiert, kann die Methode getJspBody().invoke() so oft wie nötig in der doTag-Methode aufrufen, um den JSP-Inhalt zu verarbeiten

Rückgabetyp Methodenname Methodenbeschreibung
Leere doTag() Hier wird die Methode zur Ausführung der Geschäftsverarbeitung und die gesamte Logikverarbeitung ausgeführt
statisches JspTag findAncestorWithClass(JspTag from, Class klass) findet die Instanz des angegebenen Klassentyps, die der angegebenen Instanz am nächsten kommt
geschütztes JspFragment getJspBody() Geben Sie den vom Container über setJspBody übergebenen Körper zurück
geschützter JspContext getJspContext() Gibt den vom Container über setJspContext übergebenen Seitenkontext zurück
JspTag getParent() Für gemeinsame Zwecke wird das übergeordnete Element dieses Tags zurückgegeben
Leere setJspBody(JspFragment jspBody) Speichern Sie das bereitgestellte JspFragment
Leere setJspContext(JspContext pc) Speichern Sie den bereitgestellten JSP-Kontext im privaten jspContext-Feld
Leere setParent(JspTag parent) Legt das übergeordnete Element dieser Bezeichnung für die Zusammenarbeit fest

SimpleTagSupport-Lebenszyklus

  1. Jedes Mal, wenn ein Tag angetroffen wird, erstellt der Container eine Instanz von SimpleTag, und dieser Konstruktor hat keine Parameter. Wie herkömmliche Tags kann SimpleTag nicht gepuffert werden, sodass es nicht wiederverwendet werden kann und jedes Mal eine neue Instanz erstellt werden muss
  2. Rufen Sie nach dem Aufruf des Konstruktors die Methoden setJspContext() und setParent() auf und rufen Sie die Methode setParent nur auf, wenn sich die Beschriftung innerhalb einer anderen Beschriftung befindet
  3. Der Container ruft die Setter-Methode jeder Eigenschaft auf, um den Wert dieser Eigenschaften festzulegen
  4. Wenn ein Text vorhanden ist, verwenden Sie die Methode setJspBody, um den Tag-Text dieses Tags festzulegen.
  5. Der Container ruft die doTag-Methode auf. Die gesamte Tag-Logik, Iteration und Body-Berechnung befindet sich in dieser Methode
  6. Wenn die doTag-Methode zurückkehrt, sind alle Parameter gesperrt
     

1. Erstellen Sie eine Etikettenverarbeitungsklasse

package simpleTablib;

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

public class MySimpleTaglib extends SimpleTagSupport {

    private String userName;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @Override
    public void doTag() throws JspException, IOException {
        getJspContext().getOut().println("Your name is " + userName);
    }
}

2. Schreiben und Bereitstellen von TLD-Dateien (Tag Library Description).

<?xml version="1.0" encoding="ISO-8859-1" ?>
<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>学习如何使用 Tag 接口</description>
    <tlib-version>1.0</tlib-version>
    <!--该属性是设置该标签库下所有标签的前缀-->
    <short-name>tools</short-name>
    <!--该属性是设置该标签库的唯一 url-->
    <uri>/learnTag</uri>



    <!--为标签库添加 标签-->
    <tag>
        <description>基于 Tag 接口的自定义标签</description>
        <!--为本标签设置所在标签库下唯一标签名-->
        <name>showTime</name>
        <!--指明标签处理类的位置-->
        <tag-class>taglib.MyTaglib</tag-class>
        <!--因为没有标签体所以设为 empty-->
        <body-content>empty</body-content>
    </tag>

    <!--为标签库添加新的标签-->
    <tag>
        <!--为本标签设置所在标签库下唯一标签名-->
        <name>showTimeV2</name>
        <!--指明标签处理类的位置-->
        <tag-class>tagSupport.MyTaglibSupport</tag-class>
        <!--因为没有标签体所以设为 empty-->
        <body-content>empty</body-content>
    </tag>

    <tag>
        <name>showTimeV3</name>
        <tag-class>tagSupport.MyTaglibSupportAttr</tag-class>
        <body-content>empty</body-content>

        <attribute>
            <!--设置属性名，必须与标签处理类中的属性名一致-->
            <name>country</name>
            <!--设置该属性是否必须-->
            <required>true</required>
            <!--设置是否支持 EL 表达式赋值-->
            <rtexprvalue>true</rtexprvalue>
        </attribute>

        <attribute>
            <!--设置属性名，必须与标签处理类中的属性名一致-->
            <name>city</name>
            <!--设置该属性是否必须-->
            <required>true</required>
            <!--设置是否支持 EL 表达式赋值-->
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>showTimeV4</name>
        <tag-class>tagSupport.MyTaglibSupportAttrBody</tag-class>
        <body-content>JSP</body-content>

        <attribute>
            <!--设置属性名，必须与标签处理类中的属性名一致-->
            <name>country</name>
            <!--设置该属性是否必须-->
            <required>true</required>
            <!--设置是否支持 EL 表达式赋值-->
            <rtexprvalue>true</rtexprvalue>
        </attribute>

        <attribute>
            <!--设置属性名，必须与标签处理类中的属性名一致-->
            <name>city</name>
            <!--设置该属性是否必须-->
            <required>true</required>
            <!--设置是否支持 EL 表达式赋值-->
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>

    <tag>
        <name>showName</name>
        <tag-class>simpleTablib.MySimpleTaglib</tag-class>
        <body-content>empty</body-content>

        <attribute>
            <!--设置属性名，必须与标签处理类中的属性名一致-->
            <name>userName</name>
            <!--设置该属性是否必须-->
            <required>true</required>
            <!--设置是否支持 EL 表达式赋值-->
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>
</taglib>

3. Konfigurieren Sie die Tag-Bibliotheksinformationen in der Datei web.xml

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--配置taglib-->
  <taglib>
    <!--设置标签库唯一 url ；这里的 url 必须与 tld 文件中的 url 一致-->
    <taglib-uri>/learnTag</taglib-uri>
    <!--指明 tld 标签库描述文件的位置-->
    <taglib-location>/WEB-INF/tlds/MyTaglib.tld</taglib-location>
  </taglib>
  <!---->
</web-app>

4. Verwenden Sie die Tag-Bibliothek in der JSP-Datei

<%@ taglib prefix="tools" uri="/learnTag" %>
<html>
<body>
    <!--采取 标签库名:标签名 指明要使用的标签-->
    <tools:showName userName="John"/>
</body>
</html>

Supongo que te gusta

Origin blog.csdn.net/ITlanyue/article/details/118674805
Recomendado
Clasificación
Diario
Más
2024-05-21(34)
2024-05-20(5)
2024-05-19(0)
2024-05-18(30)
2024-05-17(4)
2024-05-16(22)
2024-05-15(5)
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)

Code World

© 2018 codetd.com