BodyContent-Klasse |
Klassenname:
javax.servlet.jsp.tagext.BodyContent
Erweitert:
javax.servlet.jsp.JspWriter
Implementiert:
Keine
Implementiert von:
Interne containerabhängige Klasse
Beschreibung
Der Container erstellt eine Instanz der Klasse BodyContent zum Speichern der Ergebnisse, die beim Auswerten des Body-Inhalts des Elements entstehen, wenn die entsprechende Tag-Prozedur die Schnittstelle BodyTag implementiert. Der Container stellt der Tag-Prozedur die Instanz BodyContent durch einen Aufruf der Methode setBodyContent() zur Verfügung, damit die Tag-Prozedur den Body-Inhalt verarbeiten kann. Im Folgenden wird die Tag-Prozedurklasse, die die Klasse BodyTagSupport erweitert, genauer beschrieben. Die Klasse EncodeHTMLTag ist die Tag-Prozedurklasse für eine benutzerdefinierte Aktion namens <ora:encodeHTML>. Diese Aktion liest den Body, ersetzt alle Zeichen mit einer besonderen HTML-Bedeutung (wie einfache und doppelte Anführungszeichen, Symbole "Kleiner als" und "Größer als" sowie das &-Zeichen) durch die entsprechenden HTML-Zeichenentitäten (wie ', ", <, > und &) und fügt das Ergebnis in den Body der Antwort ein. Das folgende Beispiel zeigt, wie die Aktion in einer JSP-Seite verwendet werden kann:
    <%@ page language="java" %>
    <%@ taglib uri="/orataglib" prefix="ora" %>
    <html>
      <head>
        <title>Encoded HTML Example</title>
      </head>
      <body>
        <h1>Encoded HTML Example</h1>
        The following text is encoded by the
        <ora:encodeHTML> custom action:
        <pre>
          <ora:encodeHTML>
            HTML 3.2 Documents start with a <!DOCTYPE>
            declaration followed by an HTML element containing
            a HEAD and then a BODY element:

            <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
            <HTML>
            <HEAD>
            <TITLE>A study of population dynamics</TITLE>
            ... other head elements
            </HEAD>
            <BODY>
            ... document body
            </BODY>
            </HTML>
          </ora:encodeHTML>
        </pre>
      </body>
    </html>
Sie sehen, dass der Body der Aktion <ora:encodeHTML> im Beispiel der JSP-Seite HTML-Elemente enthält. Wenn die Sonderzeichen nicht in HTML-Zeichenentitäten konvertiert werden, interpretiert der Browser den HTML-Code und zeigt statt den Elementen selbst das Ergebnis dieser Interpretation an. Mit der Konvertierung durch die benutzerdefinierte Aktion wird gewährleistet, dass die Seite korrekt verarbeitet wird. Außer statischem Text kann der Body der Aktion jedes JSP-Element enthalten. Ein realistischeres Beispiel für die Verwendung dieser Aktion ist das Einfügen von Text aus einer Datenbank in eine JSP-Seite, wobei Sie sich nicht darum kümmern müssen, wie Sonderzeichen im Text vom Browser interpretiert werden. Die Tag-Prozedurklasse ist sehr einfach, wie hier gezeigt:
    package com.ora.jsp.tags.generic;

    import java.io.*;
    import javax.servlet.jsp.*;
    import javax.servlet.jsp.tagext.*;
    import com.ora.jsp.util.*;

    public class EncodeHTMLTag extends BodyTagSupport {

        public int doAfterBody() throws JspException {
            BodyContent bc = getBodyContent();
            JspWriter out = getPreviousOut();
            try {
                out.write(toHTMLString(bc.getString()));
            }
            catch (IOException e) {} // Ignore
            return SKIP_BODY;
        }

        private String toHTMLString(String in) {
            StringBuffer out = new StringBuffer();
            for (int i = 0; in != null & i < in.length();
              i++) {
                char c = in.charAt(i);
                if (c == '\'') {
                    out.append("'");
                }
                else if (c == '\"') {
                    out.append(""");
                }
                else if (c == '<') {
                    out.append("<");
                }
                else if (c == '>') {
                    out.append(">");
                }
                else if (c == '&') {
                    out.append("&");
                }
                else {
                    out.append(c);
                }
            }
            return out.toString();
        }
    }
Da die Aktion keine Attribute hat, benötigt die Tag-Prozedur keine Instanzenvariablen oder Methoden für den Zugriff auf Eigenschaften. Die Tag-Prozedur kann alle BodyTag-Methoden wieder verwenden, die von der Klasse BodyTagSupport implementiert werden, mit Ausnahme der Methode doAfterBody(). Zwei Dienstprogramm-Methoden der Klasse BodyTagSupport werden in der Methode doAfterBody() verwendet. Die Methode getBodyContent() gibt einen Verweis auf das Objekt BodyContent zurück, das die Ergebnisse enthält, die bei der Verarbeitung des Bodys der Aktion entstanden sind. Die Methode getPreviousOut() gibt das Objekt BodyContent der umschließenden Aktion zurück, falls vorhanden, oder das Hauptobjekt JspWriter für die Seite, wenn die Aktion sich auf der obersten Ebene befindet. Warum heißt die Methode getPreviousOut() und nicht getOut()? Mit dem Namen soll verdeutlicht werden, dass das zugewiesene Objekt als Ausgabe für das umschließende Element in einer Hierarchie verschachtelter Aktionselemente verwendet werden soll. Angenommen, Ihre Seite enthält die folgenden Aktionselemente:
      <xmp:foo>
        <xmp:bar>
          Some template text
        </xmp:bar>
    </xmp:foo>
Der Webcontainer erstellt zunächst das Objekt JspWriter und weist es der Variablen out für die Seite zu. Beim Auftreten der Aktion <xmp:foo> wird ein Objekt BodyContent erstellt und vorübergehend der Variablen out zugewiesen. Dann wird ein weiteres Objekt BodyContent für die Aktion <xmp:bar> erstellt und wiederum der Variablen out zugewiesen. Der Webcontainer verwaltet diese Hierarchie aus Ausgabeobjekten. Vorlagentexte und von den JSP-Standardelementen erzeugte Ausgaben werden im aktuellen Ausgabeobjekt abgelegt. Jedes Element kann auf sein eigenes Objekt BodyContent zugreifen, indem es die Methode getBodyContent() aufruft und dann den Inhalt liest. Beim Element <xmp:bar> besteht der Inhalt aus dem Vorlagentext. Nach der Verarbeitung des Inhalts kann er in den Body von <xmp:foo> geschrieben werden, indem das Objekt BodyContent für dieses Element über die Methode getPreviousOut() abgerufen wird. Schließlich kann das Element <xmp:foo> den Inhalt verarbeiten, der vom Element <xmp:bar> bereitgestellt wird, und den Inhalt dem Ausgabeobjekt oberster Ebene hinzufügen: dem Objekt JspWriter, das durch Aufrufen der Methode getPreviousOut() abgerufen wird. Die Tag-Prozedur in diesem Beispiel konvertiert alle Sonderzeichen, die sie in ihrem Objekt BodyContent findet, mit der Methode toHTMLString(). Unter Verwendung der Methode getString() wird der Inhalt des Objekts BodyContent abgerufen und als Argument für die Methode toHTMLString() eingesetzt. Das Ergebnis wird in das Objekt JspWriter geschrieben, das durch einen Aufruf von getPreviousOut() empfangen wird. Die Methode doAfterBody() in diesem Beispiel gibt SKIP_BODY zurück. Dadurch wird der Container angewiesen, mit einem Aufruf von doEndTag() fortzufahren. Bei einer Tag-Prozedur, die eine benutzerdefinierte Iterationsaktion implementiert, kann doAfterBody() stattdessen EVAL_BODY_TAG zurückgeben. Der Container wertet dann den Body des Elements noch einmal aus, schreibt die Ergebnisse in das Objekt BodyContent des Elements und ruft doAfterBody() auf. Der Vorgang wird so lange wiederholt, bis doAfterBody() den Wert SKIP_BODY zurückgibt.

clearBody() |
public void clearBody()
Entfernt den gesamten gepufferten Inhalt für diese Instanz.

flush() |
public void flush() throws java.io.IOException
Überschreibt das von JspWriter übernommene Verhalten, so dass immer eine Ausnahme IOException ausgelöst wird, da das Leeren einer Instanz von BodyContent nicht zulässig ist.

getEnclosingWriter() |
public JspWriter getEnclosingWriter()
Gibt das umschließende Objekt JspWriter zurück, das heißt entweder JspWriter der obersten Ebene oder JspWriter (Unterklasse BodyContent) der übergeordneten Tag-Prozedur.

getReader() |
public abstract java.io.Reader getReader()
Gibt den Wert dieses Objekts BodyContent als Reader zurück, und zwar mit dem Inhalt, der beim Auswerten vom Body dieses Elements entstanden ist.

getString() |
public abstract String getString()
Gibt den Wert dieses Objekts BodyContent als String zurück, und zwar mit dem Inhalt, der beim Auswerten vom Body dieses Elements entstanden ist.

writeOut() |
public abstract void writeOut(java.io.Writer out) throws java.io.IOException
Schreibt den Inhalt dieses Objekts BodyContent in ein Writer-Objekt.

BodyContent() |
protected BodyContent(JspWriter e)
Erstellt eine neue Instanz, die vom angegebenen Objekt JspWriter umschlossen wird.