Beispiele einer JSP+XML-strukturierten Website
Autor：Eve Cole
Aktualisierungszeit：2009-07-02 17:11:58
XML (Extensible Markup Language) mag wie eine Art W3C-Standard aussehen – es hat derzeit kaum praktische Auswirkungen, und wenn es sich später als nützlich erweist, wird es lange auf sich warten lassen. Aber tatsächlich wird es bereits genutzt. Warten Sie also nicht, bis XML zu Ihrem bevorzugten HTML-Editor hinzugefügt wurde, um mit der Verwendung zu beginnen. Es kann jetzt verschiedene interne Probleme und B2B-Systemprobleme lösen.
Bei Sparks.com verwenden wir XML, um die Datendarstellung über unterschiedliche Systeme hinweg zu standardisieren, von Java-Objekten bis hin zu HTML-Datenanzeigen.
Wir haben insbesondere festgestellt, dass Daten einfacher geteilt und bearbeitet werden können, wenn sie auf einer sehr einfachen XML-Struktur standardisiert sind. Dabei entdeckten wir viele effektive Möglichkeiten, XML zu nutzen. Im Folgenden wird unsere aktuelle Anwendung im Detail beschrieben.
Standardisieren Erstellen Sie vor der Verwendung von XML ein XML-Datenformat, das sich von den Informationen unterscheidet, die Sie verwenden möchten.
Generieren Sie dynamisches XML
Das Generieren von HTML aus einer Datenbank ist nicht neu, das Generieren von XML jedoch schon. Hier stellen wir die spezifischen Generierungsschritte vor.
Verwendung von XSL als Vorlagensprache
XSL (Extensible Stylesheet Language) ist eine gute Möglichkeit, das Format für die Anzeige von XML-Daten zu definieren, und es wäre effizienter, wenn es in mehreren statischen Vorlagen geschrieben würde.
Generieren Sie HTML
XML plus XSL entspricht HTML. Das klingt vielleicht nicht richtig, aber unsere HTML-Seiten, die Benutzer sehen, sind tatsächlich das Ergebnis der Kombination von XML und XSL.
1. Standardisierung
Die Stärke von XML liegt in seiner Flexibilität. Aber leider ist es manchmal so flexibel, dass man mit einer leeren Seite zurückbleibt und sich fragt, wie man das Problem lösen kann.
In jedem XML-Projekt besteht der erste Schritt darin, ein Standarddatenformat zu erstellen. Dazu müssen Sie folgende Entscheidungen treffen:
&&&
Bestätigen Sie die Daten:
Da es kein Standard-XML-Format gibt, können Entwickler ihre eigenen Formate entwickeln. Wenn Ihr Format jedoch nur von einer Anwendung erkannt wird, können Sie nur diese Anwendung ausführen, um das Format zu verwenden. Es wäre natürlich hilfreicher, wenn es andere Programme gäbe, die Ihr XML-Format ebenfalls lesen könnten. Wenn ein XML-Format geändert wird, muss möglicherweise auch das System, das es verwendet, geändert werden. Daher sollten Sie das Format so vollständig wie möglich erstellen. Da die meisten Systeme Tags ignorieren, die sie nicht erkennen, besteht die sicherste Möglichkeit, das Format einer XML-Datei zu ändern, darin, Tags hinzuzufügen, anstatt sie zu ändern.
Klicken Sie hier, um Beispiele für XML-Datenformate anzuzeigen
Bei Sparks.com haben wir uns alle Produktdaten angesehen, die für verschiedene Produktpräsentationen benötigt werden. Obwohl nicht alle Seiten alle Daten verwenden, haben wir ein sehr vollständiges XML-Datenformat entwickelt, das für alle Daten geeignet ist. Auf unserer Produktdetailseite werden beispielsweise mehr Daten angezeigt als auf unserer Produktbrowserseite. Allerdings verwenden wir in beiden Fällen immer noch dasselbe Datenformat, da die XSL-Vorlage jeder Seite nur die Felder verwendet, die sie benötigt.
Ob DTD verwendet werden soll
Bei Sparks.com verwenden wir gut organisiertes XML und nicht nur korrektes XML, da ersteres keine DTD erfordert. DTD fügt eine Verarbeitungsebene zwischen dem Klicken des Benutzers und dem Anzeigen der Seite hinzu. Wir fanden, dass diese Ebene zu viel Verarbeitung erforderte. Natürlich ist es immer noch schön, DTDs zu verwenden, wenn man mit anderen Unternehmen im XML-Format kommuniziert. Denn DTD kann sicherstellen, dass die Datenstruktur beim Senden und Empfangen korrekt ist.
Auswählen einer Parsing-Engine Nun gibt es mehrere Parsing-Engines, die verwendet werden können. Für welches Sie sich entscheiden, hängt fast ausschließlich von Ihren Anwendungsanforderungen ab. Wenn Sie sich für die Verwendung einer DTD entscheiden, muss die Parsing-Engine die Validierung Ihres XML durch die DTD ermöglichen. Sie könnten die Validierung in einem separaten Prozess durchführen, aber das würde sich auf die Leistung auswirken.
SAX und DOM sind zwei grundlegende Parsing-Modelle. SAX ist ereignisbasiert, d. h. beim Parsen des XML werden Ereignisse an die Engine gesendet. Als nächstes werden die Ereignisse mit der Ausgabedatei synchronisiert. Die DOM-Parsing-Engine erstellt eine hierarchische Baumstruktur für dynamische XML-Daten und XSL-Stylesheets. Durch den zufälligen Zugriff auf den DOM-Baum können XML-Daten bereitgestellt werden, als ob sie durch ein XSL-Stylesheet bestimmt würden. Die Debatte über das SAX-Modell konzentriert sich hauptsächlich auf die übermäßige Speicherreduzierung der DOM-Struktur und die Beschleunigung der XSL-Stylesheet-Analysezeit.
Wir haben jedoch festgestellt, dass viele Systeme, die SAX verwenden, es nicht in vollem Umfang nutzen. Diese Systeme verwenden es, um die DOM-Struktur aufzubauen und Ereignisse über die DOM-Struktur zu senden. Bei diesem Ansatz muss das DOM vor der XML-Verarbeitung aus dem Stylesheet erstellt werden, wodurch die Leistung beeinträchtigt wird.
2. Generieren Sie dynamisches XML
Sobald das XML-Format eingerichtet ist, benötigen wir eine Möglichkeit, es dynamisch aus der Datenbank zu portieren.
Das Generieren von XML-Dokumenten ist relativ einfach, da lediglich ein System erforderlich ist, das mit Zeichenfolgen umgehen kann. Wir haben ein System mit Java-Servlets, Enterprise JavaBean-Server, JDBC und RDBMS (relationales Datenbankverwaltungssystem) erstellt.
&&&&
(Weitere Informationen zur Anwendung von XSL finden Sie unter XSL als Vorlagensprache.)
Beispiel für das Generieren von XML Der eigentliche Code zum Erstellen eines XML-Dokumentstrings in Java kann in mehrere Methoden und Klassen unterteilt werden.
Der Code, der den XML-Generierungsprozess startet, wird in der EJB-Methode platziert. Diese Instanz erstellt sofort einen StringBuffer zum Speichern der generierten XML-Zeichenfolge.
StringBuffer xml = new StringBuffer();
xml.append(XmlUtils.beginDocument("/browse_find/browse.xsl", "browse", request));
xml.append(product.toXml());
xml.append(XmlUtils.endDocument("browse");
out.print(xml.toString());
Die folgenden drei xml.append()-Variablen selbst sind Aufrufe anderer Methoden.
Generieren des Dateiheaders Die erste zusätzliche Methode ruft die XmlUtils-Klasse auf, um den XML-Dateiheader zu generieren. Der Code in unserem Java-Servlet lautet wie folgt:
öffentlicher statischer String beginDocument(String-Stylesheet, String-Seite)
{
StringBuffer xml = new StringBuffer();
xml.append("<?xml version="1.0"?> ")
.append("<?xml-stylesheet href="")
.append(stylesheet).append(""")
.append(" type ="text/xsl"?> ");
xml.append("<").append(page).append("> ");
return xml.toString();
}
Dieser Code generiert den XML-Dateiheader. Das Tag <?xml> definiert diese Datei als XML-Datei, die Version 1.0 unterstützt. Die zweite Codezeile zeigt auf den Speicherort des richtigen Stylesheets zum Anzeigen der Daten. Das Letzte, was enthalten ist, ist das Tag auf Elementebene (<browse> in diesem Beispiel). Am Ende der Datei muss nur noch das Tag <browse> geschlossen werden.
<?xml version="1.0"?> <?xml-stylesheet href="/browse_find/browse.xsl" type="text/xsl"?> <browse>
Nachdem Sie die Produktinformationen eingegeben und den Dateikopf vervollständigt haben, ruft die Steuermethode das Java-Objekt auf, um dessen XML zu generieren. In diesem Beispiel wird das Produktobjekt aufgerufen. Das Produktobjekt verwendet zwei Methoden, um seine XML-Darstellung zu generieren. Die erste Methode toXML() erstellt den Produktknoten durch Generieren der Tags <product> und </product>. Anschließend wird internalXML() aufgerufen, das den erforderlichen Inhalt für das Produkt-XML bereitstellt. internalXML() ist eine Reihe von StringBuffer.append()-Aufrufen. Der StringBuffer wird ebenfalls in einen String konvertiert und an die Steuermethode zurückgegeben.
öffentlicher String toXml()
{
StringBuffer xml = new StringBuffer("<product> ");
xml.append(internalXml());
xml.append("</product> ");
return xml.toString();
}
public String internalXml()
{
StringBuffer xml = neu
StringBuffer(" ")
.append(productType).append(" ");
xml.append(" ").append(idValue.trim())
.append(" ");
xml.append(" ").append(idName.trim())
.append(" ");
xml.append(" ").append(page.trim())
.append(" ");
Stich?
xml.append(" ").append(amount).append(" ");
xml.append(" ").append(vendor).append(" ");
xml.append(" ");
xml.append(" ").append(pubDesc).append(" ");
xml.append(" ").append(venDesc).append(" ";
Stich?
return xml.toString();
}
Abschließend wird nach dem Schließen der Datei die Methode XMLUtils.endDocument() aufgerufen. Dieser Aufruf schließt (in diesem Fall) das XML-Tag und vervollständigt schließlich die strukturierte XML-Datei. Der gesamte StringBuffer aus der Steuermethode wird ebenfalls in einen String konvertiert und an das Servlet zurückgegeben, das die ursprüngliche HTTP-Anfrage verarbeitet hat.
3. Verwenden Sie XSL als Vorlagensprache
Um eine HTML-Ausgabe zu erhalten, kombinieren wir die generierte XML-Datei mit einer XSL-Vorlage, die steuert, wie die XML-Daten dargestellt werden. Unsere XSL-Vorlagen bestehen aus sorgfältig organisierten XSL- und HTML-Tags.
Beginnen Sie mit dem Erstellen der Vorlage. Der Anfang unserer XSL-Vorlage ähnelt dem folgenden Code. Die erste Codezeile ist erforderlich und definiert diese Datei als XSL-Stylesheet. Das Attribut xmlns:xsl= verweist auf den von dieser Datei verwendeten XML-Namespace und das Attribut version= definiert die Versionsnummer des Namespace. Am Ende der Datei schließen wir das Tag.
Die zweite Codezeile, die mit <xsl:template> beginnt, bestimmt das Muster der XSL-Vorlage. Das Match-Attribut ist erforderlich und verweist hier auf das XML-Tag <basketPage>. In unserem System enthält das <basketPage>-Tag das <product>-Tag, das es der XSL-Vorlage ermöglicht, auf die im <product>-Tag eingebetteten Produktinformationen zuzugreifen. Auch hier müssen wir das Tag <xsl:template> am Ende der Datei schließen.
Werfen wir als Nächstes einen Blick auf gut organisiertes HTML. Da es von einer XML-Parsing-Engine verarbeitet wird, muss es allen Regeln gut organisierten XMLs entsprechen. Im Wesentlichen bedeutet dies, dass alle öffnenden Tags über ein entsprechendes schließendes Tag verfügen müssen. Beispielsweise muss ein <P>-Tag, das nicht normalerweise geschlossen ist, mit </P> geschlossen werden.
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
version="1.0">
<xsl:template match="basketPage">
<html>
<Kopf>
<title>Warenkorb / Menge anpassen</title>
</head>
<body bgcolor="
</xsl:template>
</xsl:stylesheet>
Im Hauptteil der Vorlage gibt es viele XSL-Tags, die zur Bereitstellung der Logik für die Datenpräsentation verwendet werden. Im Folgenden werden zwei häufig verwendete Tags erläutert.
Wählen
Das <xsl:choose>-Tag ähnelt dem Anfang einer If-Then-Else-Struktur in herkömmlichen Programmiersprachen. In XSL gibt das Tag „select“ an, dass in dem Teil, in den der Code eintritt, die Zuweisung die Aktion auslöst. Das <xsl:when>-Tag mit zugewiesenen Attributen folgt dem Choose-Tag. Bei korrekter Zuweisung wird der Inhalt zwischen dem öffnenden und schließenden Tag von <xsl:when> verwendet. Bei falscher Zuweisung wird der Inhalt zwischen dem öffnenden und schließenden Tag von <xsl:otherwise> verwendet. Der gesamte Abschnitt endet mit </xsl:choose>.
In diesem Beispiel überprüft das When-Tag das XML auf das Quantity-Tag. Wenn das Mengen-Tag ein Fehlerattribut mit dem Wert „true“ enthält, zeigt das Mengen-Tag die unten aufgeführten Tabellenzellen an. Wenn der Wert des Attributs nicht wahr ist, zeigt XSL andernfalls den Inhalt zwischen den Tags an. Wenn im Beispiel unten das Fehlerattribut nicht wahr ist, wird nichts angezeigt.
<xsl:choose>
<xsl:when test="quantity[@error='true']">
<td bgcolor="src=""/></td>
<td valign="top" bgcolor="<font face="Verdana, Arial" size="1" color="<b>*Nicht genügend auf Lager Ihre Menge wurde entsprechend angepasst.</b></font>
</td>
</xsl:when>
<xsl:sonst>
</xsl:sonst>
</xsl:choose>
Für-jeden
Das <xsl:for-each>-Tag kann verwendet werden, um dasselbe Stylesheet auf mehrere Situationen ähnlicher XML-Daten anzuwenden. Für uns können eine Reihe von Produktinformationen aus der Datenbank entnommen und einheitlich auf der Webseite aufbereitet werden. Hier ist ein Beispiel:
<xsl:for-each select="package">
<xsl:apply-templates select="product"/>
</xsl:for-each>
Die for-each-Schleife beginnt, wenn das Programm auf eine Bezeichnung stößt. Diese Schleife wird beendet, wenn das Programm auf ein Label stößt. Sobald diese Schleife ausgeführt wird, wird diese Vorlage jedes Mal angewendet, wenn das Etikett angezeigt wird.
4. Generieren Sie HTML
Irgendwann in der Zukunft werden Browser XML-Parsing-Engines integrieren. An diesem Punkt können Sie XML- und XSL-Dateien direkt an den Browser senden, und der Browser zeigt die XML-Daten gemäß den im Stylesheet aufgeführten Regeln an. Bis dahin müssen Entwickler jedoch Parsing-Funktionen in ihren serverseitigen Systemen erstellen.
Bei Sparks.com haben wir einen XML-Parser in das Java-Servlet integriert. Dieser Parser verwendet einen Mechanismus namens XSLT (XSL-Transformation), um XML-Daten zur XSL-Vorlage hinzuzufügen, wie durch das XSL-Tag angegeben.
Wenn unser Java-Servlet eine HTTP-Anfrage verarbeitet, ruft das Servlet das dynamisch generierte XML ab, das dann an die Parsing-Engine übergeben wird. Basierend auf den Anweisungen in der XML-Datei sucht die Parsing-Engine nach dem geeigneten XSL-Stylesheet. Der Parser erstellt aus der DOM-Struktur eine HTML-Datei und sendet diese Datei dann an den Benutzer, der die HTTP-Anfrage stellt.
Wenn Sie sich für die Verwendung des SAX-Modells entscheiden, liest der Parser die XML-Quelle und erstellt ein Ereignis für jedes XML-Tag. Ereignisse entsprechen XML-Daten, und die Daten werden schließlich gemäß XSL-Tags in das Stylesheet eingefügt.
