Überblick: eXtensible Markup Language (XML) wird in der Branche immer häufiger verwendet. Sie hat sich zu einem weit verbreiteten Standard für die Beschreibung und den Austausch von Daten in einem Format entwickelt, das unabhängig von Plattform, Sprache und Protokoll ist. XML und seine Hilfsspezifikationen können verwendet werden, um die Dokumentdarstellung von Daten zu beschreiben, die Einschränkungen von XML-Dokumenttypen zu beschreiben, die Verknüpfungen zwischen XML-Dokumenten und -Ressourcen zu beschreiben und die automatische Konvertierung und Formatierung von XML-Dokumenten zu beschreiben.
Wie entwickle ich eine benutzerdefinierte Tag-Bibliothek?
Ich verwende JSP- und ASP-Programmierung seit langem. Unter den beiden serverseitigen Programmiermethoden habe ich zunehmend das Gefühl, dass JSP viel leistungsfähiger ist. Ganz zu schweigen von etwas anderem: Die Tag-Bibliothek von JSP ist der Grund, warum ich JSP als bevorzugtes Tool für die serverseitige Entwicklung von Webanwendungen wähle. Warum? Denn: Geschwindigkeit der Wartung und Entwicklung. Innerhalb einer einzelnen Serverseite können Sie verschiedene Skriptmethoden und -objekte kombinieren und anpassen. Wie „Beton“ macht diese Mischung das serverseitige Skripting leistungsstark und ermöglicht es serverseitigen Programmierern, sehr flexible und dynamische Webseiten zu entwerfen. Allerdings hat diese kostenlose Mischung auch ihre Nachteile, nämlich dass sie sehr umständlich zu warten ist. Vor allem, wenn das Projekt größer wird, da das Endprodukt von einem traditionellen Webdesigner gepflegt wird, und noch schlimmer, die Geschwindigkeit der Entwicklung steigt, wenn die Komplexität des Codes zunimmt. Dies wird langsamer und ist für die Entwicklung mittlerer und mittlerer Größe nicht förderlich Nach der Entwicklung großer Webanwendungen muss die Website noch qualifizierte Programmierer finden, um diese recht komplexen Codes zu verwalten.
Glücklicherweise bietet JSP eine gute Lösung. Tag-Bibliotheken bieten eine einfache Möglichkeit, einen wiederverwendbaren Codeblock zu erstellen. Sobald eine Tag-Bibliothek entworfen ist, kann sie in vielen Projekten wieder verwendet werden. Noch praktischer ist, dass Sie im Gegensatz zu COM und J2EE keine weiteren Fähigkeiten erlernen müssen, um eine Tag-Bibliothek zu erstellen! Solange Sie wissen, wie man JSP schreibt, können Sie eine Tag-Bibliothek erstellen. Tag-Bibliotheken können auch die Wartung von Webanwendungen verbessern. Dank der benutzerdefinierten Tags der JSP-Seite handelt es sich um eine einfache XML-Schnittstelle. Auf diese Weise können Webdesigner sogar JSP-Webanwendungen erstellen, ohne über JSP-Kenntnisse zu verfügen. Diese offene Webentwicklung ist für den Teambetrieb sehr effektiv. JSP-Programmierer können benutzerdefinierte Tags und Hintergrundcodemodule erstellen, während Webdesigner benutzerdefinierte Tags verwenden können, um Webanwendungen zu erstellen und sich auf das Webdesign zu konzentrieren.
1. Definition der Tag-Bibliothek Die JSP-Tag-Bibliothek (auch benutzerdefinierte Bibliothek genannt) kann als eine Reihe von Methoden zum Generieren von XML-basierten Skripten betrachtet werden, die von JavaBeans unterstützt werden. Vom Konzept her sind Tag-Bibliotheken sehr einfache und wiederverwendbare Codekonstrukte.
Tag-Beispiele und HTML-Seiten, die eine XML/XSL-Konvertierung durchführen
<%@ taglib uri=" http://www.jspinsider.com/jspkit/JAXP " prefix="JAXP"%>
c:/xml/example.xml
c:/xml/example.xsl
In diesem Beispiel wird durch die Verwendung einfacher Tags für den Zugriff auf den leistungsfähigeren Code hinter den Kulissen ein XML geladen und ein Ergebnis über eine XSL-Datei generiert und an den Client gesendet, alles über Dies geschieht mit einem einfachen Tag-Aufruf.
Benutzerdefinierte Tags ermöglichen die Erstellung einfach wiederverwendbaren Codes in JSP-Projekten. Sie benötigen lediglich eine Tag-Bibliothek und deren Dokumentation.
2. Tag-Komponenten Obwohl die Tag-Bibliothek sehr einfach zu verwenden ist, ist es ziemlich kompliziert, ein internes Design zur Unterstützung der Tag-Bibliothek zu erstellen, zumindest komplizierter als das Erstellen einer einfachen JavaBean. Die Komplexität ergibt sich aus der Tatsache, dass die Tag-Bibliothek aus mehreren Teilen besteht. Sie müssen jedoch nur Java und JSP beherrschen.
Ein einfaches Tag besteht aus folgenden Elementen:
⑴ JavaBeans: Um die inhärenten objektorientierten Vorteile von Java zu nutzen, sollte wiederverwendbarer Code in einem unabhängigen Codecontainer platziert werden. Diese JavaBeans sind nicht Teil der Tag-Bibliothek. Aber es ist der grundlegende Codeblock, den Ihre Codebasis zum Ausführen verwandter Aufgaben verwendet.
⑵ Tag-Verarbeitung: Dies ist der eigentliche Kern der Tag-Bibliothek. Ein Tag-Handler verweist auf alle benötigten Ressourcen (Ihre JavaBeans) und greift auf alle Informationen über Ihre JSP-Seite (das pageContext-Objekt) zu. Die JSP-Seite übermittelt außerdem alle festgelegten Tag-Attribute und den Inhalt des Tag-Körpers auf der JSP-Seite an den Tag-Prozessor. Nachdem der Tag-Prozessor die Verarbeitung abgeschlossen hat, sendet er die Ausgabe zur Verarbeitung an Ihre JSP-Seite zurück.
⑶ Beschreibung der Tag-Bibliothek (tld-Datei): Dies ist eine einfache XML-Datei, die die Attribute, Informationen und den Standort des Tag-Prozessors aufzeichnet. Der JSP-Container verwendet diese Datei, um zu wissen, wo und wie eine Tag-Bibliothek aufgerufen werden soll.
⑷ Datei web.xml der Website: Dies ist die Initialisierungsdatei Ihrer Website. In dieser Datei definieren Sie die auf der Website verwendeten benutzerdefinierten Tags und welche tld-Datei zur Beschreibung jedes benutzerdefinierten Tags verwendet wird.
⑸ Verteilungsdatei (eine WAR- oder JAR-Datei): Wenn Sie benutzerdefinierte Tags wiederverwenden möchten, benötigen Sie eine Möglichkeit, sie von einem Projekt auf ein anderes zu übertragen. Das Packen der Tag-Bibliothek in eine JAR-Datei ist eine einfache und effektive Möglichkeit.
⑹ Erstellen Sie eine Tag-Bibliotheksdeklaration in Ihrer JSP-Datei: Wenn Sie dieses Tag verwenden möchten, deklarieren Sie es einfach auf der Seite. Anschließend können Sie es an einer beliebigen Stelle auf der JSP-Seite verwenden.
Es scheint eine Menge Arbeit zu sein, aber eigentlich ist es gar nicht so schwierig. Dabei geht es nicht um die Codierung, sondern darum, die Teile richtig zu organisieren. Diese Schichtung ist jedoch wichtig, da sie die Verwendung von Etiketten flexibler macht und die Übertragung erleichtert. Noch wichtiger ist, dass diese Ebenen dazu dienen, den Prozess der Tag-Erstellung über eine JSP-IDE (JSP Integrated Development Environment) zu automatisieren. Es wird erwartet, dass zukünftige JSP-IDEs den Großteil der Arbeit zum Erstellen eines benutzerdefinierten Tags automatisch erledigen können, sodass Sie nur Code schreiben und die Tag-Verarbeitung durchführen müssen.
Hinweis: Ein Tag-Handler definiert nur ein benutzerdefiniertes Tag; eine Tag-Bibliothek ist eine Sammlung mehrerer Tag-Prozessoren, die dieselbe Aufgabe erledigen.
3. Erstellen Sie Ihre eigenen Tags. Im Folgenden erfahren Sie Schritt für Schritt, wie Sie benutzerdefinierte Tags erstellen. Das konkrete Beispiel besteht darin, JSP so zu erweitern, dass es über eine eigene HTML-Codierungsfunktion verfügt. Diese Funktion ersetzt alle <- und >-Zeichen durch HTML-Code. Es kann leicht erweitert werden, um andere Codierungsverarbeitungen durchzuführen. Zur Vereinfachung werden in diesem Beispiel nur die grundlegenden Elemente zum Erstellen eines benutzerdefinierten Tags erläutert.
⑴ Erstellen Sie eine JavaBean
Jeder wiederverwendbare Teil Ihres Codes sollte in einer JavaBean platziert werden. Dies ist wichtig, da Sie diesen Code häufig an anderer Stelle im Projekt verwenden. Jeder in einem Tag-Handler platzierte Code ist außerhalb des Tags nicht wiederverwendbar. Daher ist es wichtig, die wiederverwendbaren Codeteile zu isolieren. In diesem Beispiel ist die für HTML codierte Logik üblich und wird daher in einem JavaBean platziert.
⑵ HTML-Kodierung JavaBean
/* HTML_Format.Java */
öffentliche Klasse HTML_Format erweitert Objekt implementiert Java.io.Serializable {
/** Neues HTML_Format erstellen */
öffentliches HTML_Format() {}
/** Ersetzen Sie alle <- und >-Zeichen in einer Zeichenfolge durch die HTML-Kodierung der Antwort */
öffentlicher String HTML_Encode(String as_data)
{
int li_len = as_data.length();
/*Die Länge des Zeichenfolgenpuffers ist länger als die ursprüngliche Zeichenfolge*/
StringBuffer lsb_encode = new StringBuffer(li_len + (li_len/10));
/* Schleife zum Ersetzen aller <- und >-Zeichen*/
for(int li_count = 0; li_count < li_len; li_count++)
{ String ls_next = String.valueOf(as_data.charAt(li_count));
if (ls_next.equals("<")) ls_next = "<";
if (ls_next.equals(">")) ls_next = ">";
lsb_encode.append(ls_next);
}
return(lsb_encode.toString());
}
}
⑶ Erstellen Sie einen Tag-Prozessor. Der Tag-Prozessor verwendet den folgenden Code:
HTML-Codierungs-Tag-Prozessor
import Java.io.IOException;
import Javax.servlet.jsp.*;
import Javax.servlet.jsp.tagext.*;
Die öffentliche Klasse HTML_FormatTag erweitert BodyTagSupport
{
/* 1} Diese Funktion wird am Ende des Tags aufgerufen*/
public int doEndTag() löst eine JspTagException aus
{
versuchen
{ /* 2} Holen Sie sich den Text im Etikett */
BodyContent l_tagbody = getBodyContent();
String ls_output = "";
/* 3} Wenn der Tag-Körper Text enthält, verarbeiten Sie ihn */
if(l_tagbody != null)
{ HTML_Format l_format = neues HTML_Format();
/* 3a} Konvertieren Sie den Inhalt des Tag-Bodys in einen String */
String ls_html_text = l_tagbody.getString();
ls_output = l_format.HTML_Encode(ls_html_text);
}
/* 4}Ergebnisse zurück in den Datenstrom schreiben*/
pageContext.getOut().write(ls_output.trim());
}
Catch (IOException e)
{ throw new JspTagException("Tag Error:" + e.toString());
}
/* Lassen Sie JSP den Inhalt der folgenden Seiten weiter verarbeiten*/
return EVAL_PAGE;
}
}
Diese Verarbeitung ist sehr einfach und umfasst Folgendes:
o Lesen Sie den Text zwischen Anfang und Ende des Tags. o Rufen Sie die HTML-Kodierungsfunktion auf. o Geben Sie das Ergebnis an die JSP-Seite zurück.
⑷ Beim Erstellen eines Tag-Deskriptors muss das benutzerdefinierte Tag beschrieben werden, damit das System weiß, wie es verarbeitet wird. Das Suffix dieser Beschreibungsdatei ist .tld, normalerweise ist ihr Name mit dem des Tag-Prozessors identisch und sie wird im Verzeichnis „/WEB-INF/“ gespeichert.
HTML-Codierungs-Tag-Deskriptor
ÖFFENTLICH „-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//DE“
" http://Java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd ">
⑸ Aktualisieren Sie die Web-XML-Datei, um dem JSP-Container nun mitzuteilen, dass er die Tag-Bibliothek verwenden soll. Dazu müssen Sie die Datei web.xml ändern. Insbesondere müssen Sie ein Taglib-Projekt hinzufügen, um die Tag-Bibliothek zu registrieren. Am wichtigsten ist es, dem Tag einen URI zuzuweisen. Ein URI ist eine eindeutige Referenz, die nur für dieses bestimmte Tag auf der Website gilt. Es empfiehlt sich, die vollständige URL oder den Paketnamen zu verwenden, um die Eindeutigkeit sicherzustellen, da das Tag auf verschiedenen Websites verwendet werden kann. Dieses Beispiel ist vereinfacht.
Ändern Sie die Datei web.xml
ÖFFENTLICH „-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN“
" http://Java.sun.com/j2ee/dtds/web-app_2.2.dtd ">
HTMLEncode
/WEB-INF/HTML_FormatTag.tld
⑹ Das benutzerdefinierte Tag mit neuen Tags wurde eingerichtet und kann auf einer JSP-Seite verwendet werden. Deklarieren Sie dazu einfach das Tag auf der Seite mit der taglib-Direktive. Das Tag wird durch seinen eindeutigen URI referenziert und erhält ein Namespace-Präfix. Das Präfix kann beliebig sein, solange es nicht mit anderen Namespaces in Konflikt steht.
Verwenden Sie HTML-Codierungs-Tags auf einer JSP-Seite:
<%@ taglib uri="HTMLEncode" prefix="Examples" %>
Beispielcode-Ausgabe
was wie folgt angezeigt wird:
Mit diesem Tag habe ich den gesamten Code der Seite codiert. Das Interessante ist, dass alle benutzerdefinierten Tags auf dem Server verarbeitet werden. Das bedeutet, dass auf der Ausgabeseite keine benutzerdefinierten Tags angezeigt werden.
Es ist nicht schwer, ein Etikett zu erstellen. Der schwierigste Teil besteht darin, alle Einzelheiten der Etikettenverarbeitung zu erlernen. Dies ist eine sehr leistungsstarke Funktion und wir haben nur die Grundlagen gestreift. Da dieser Prozess mehrere Schritte erfordert, werden neue JSP-Programmierer beim Erstellen von Tags verwirrt sein.
Wie verwende ich JSP zum Entwickeln von DOM-Anwendungen?
DOM ist die Abkürzung für Document Object Model, also das Dokumentobjektmodell. XML organisiert Daten in einem Baum, daher ist DOM eine Objektbeschreibung dieses Baums. Laienhaft ausgedrückt geht es darum, durch Parsen des XML-Dokuments logisch ein Baummodell für das XML-Dokument zu erstellen, und die Knoten des Baums sind Objekte. Durch den Zugriff auf diese Objekte können wir auf den Inhalt von XML-Dokumenten zugreifen.
Schauen wir uns unten ein einfaches Beispiel an, um zu sehen, wie wir ein XML-Dokument im DOM bearbeiten. Dies ist ein XML-Dokument und das Objekt, das wir bearbeiten möchten:
Als nächstes müssen wir den Inhalt dieses Dokuments zur Verwendung durch das Programm in Java-Objekte analysieren. Mit JAXP können wir dies mit nur wenigen Codezeilen tun. Zuerst müssen wir eine Parser-Factory erstellen, um mit dieser Factory ein bestimmtes Parser-Objekt abzurufen:
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
Der Zweck der Verwendung von DocumentBuilderFacotry besteht darin, ein Programm zu erstellen, das vom spezifischen Parser unabhängig ist. Wenn die statische Methode newInstance() der DocumentBuilderFactory-Klasse aufgerufen wird, bestimmt sie anhand einer Systemvariablen, welcher Parser verwendet werden soll. Und da alle Parser der von JAXP definierten Schnittstelle folgen, ist der Code unabhängig vom verwendeten Parser derselbe. Wenn Sie also zwischen verschiedenen Parsern wechseln, müssen Sie nur die Werte der Systemvariablen ändern, ohne Code zu ändern. Das ist der Vorteil der Fabrik.
DocumentBuilder db = dbf.newDocumentBuilder();
Nachdem Sie ein Factory-Objekt erhalten haben, verwenden Sie dessen statische Methode newDocumentBuilder(), um ein DocumentBuilder-Objekt abzurufen, das einen bestimmten DOM-Parser darstellt. Welcher Parser es ist, Microsoft oder IBM, ist für das Programm jedoch nicht wichtig.
Dann können wir diesen Parser verwenden, um das XML-Dokument zu analysieren:
Document doc = db.parse("c:/xml/message.xml");
Die parse()-Methode von DocumentBuilder akzeptiert einen XML-Dokumentnamen als Eingabeparameter und gibt ein Document-Objekt zurück. Dieses Document-Objekt stellt ein Baummodell eines XML-Dokuments dar. Alle zukünftigen Vorgänge an XML-Dokumenten haben nichts mit dem Parser zu tun und können direkt an diesem Dokumentobjekt ausgeführt werden. Die spezifische Methode zum Betreiben von Document wird durch das DOM definiert.
Ausgehend vom erhaltenen Document-Objekt können wir unsere DOM-Reise beginnen. Mit der Methode getElementsByTagName() des Document-Objekts können wir ein NodeList-Objekt abrufen, das ein Tag-Element in einem XML-Dokument darstellt, und das NodeList-Objekt stellt, wie Sie an seinem Namen erkennen können, ein Node-Objekt dar:
NodeList nl = doc.getElementsByTagName("message");
Durch eine solche Anweisung erhalten wir eine Liste von Node-Objekten, die allen
Knoten my_node = nl.item(0);
Wenn ein Node-Objekt erstellt wird, werden die im XML-Dokument gespeicherten Daten extrahiert und im Node gekapselt. In diesem Beispiel verwenden wir zum Extrahieren des Inhalts innerhalb des Message-Tags normalerweise die Methode getNodeValue() des Node-Objekts:
String message = my_node.getFirstChild().getNodeValue();
Bitte beachten Sie, dass hier auch eine getFirstChild()-Methode verwendet wird, um das erste untergeordnete Node-Objekt unter der Nachricht abzurufen. Obwohl es außer Text keine weiteren Unter-Tags oder Attribute unter dem Nachrichten-Tag gibt, bestehen wir darauf, hier die Methode getFirseChild () zu verwenden, die hauptsächlich mit der DOM-Definition des W3C zusammenhängt. W3C definiert auch den Textteil innerhalb des Tags als Node, daher müssen wir zuerst den Node abrufen, der den Text darstellt, bevor wir getNodeValue() verwenden können, um den Inhalt des Textes abzurufen. Da wir nun die Daten aus der XML-Datei extrahieren konnten, können wir diese Daten an der entsprechenden Stelle zum Erstellen der Anwendung verwenden.
DOM-Beispiel
Lassen Sie uns zunächst darüber sprechen, was dieses Beispiel bewirken soll. Wir haben einige URL-Adressen in einer Datei namens „link“ gespeichert. Die hinzugefügte URL-Adresse wird in diese XML-Datei geschrieben. Es ist sehr einfach, aber sehr praktisch und reicht aus, um die meisten Verwendungszwecke von DOM zu veranschaulichen.
Das erste Programm heißt xmldisplay.Java. Seine Hauptfunktion besteht darin, den Inhalt jedes Knotens in dieser XML-Datei zu lesen und dann die Ausgabe auf System.out zu formatieren:
import Javax.xml.parsers. *;
import org.w3c.dom.*;
Dies dient der Einführung der erforderlichen Klassen, da hier der von Sun bereitgestellte XML-Parser verwendet wird. Daher muss das Paket Java.xml.parsers eingeführt werden, das den DOM-Parser und die SAX-Analyse enthält. Die spezifische Implementierung des Geräts. Das Paket org.w3c.dom definiert die von w3c entwickelte DOM-Schnittstelle.
DocumentBuilderFactory Factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Dokument doc=builder.parse("links.xml");
doc.normalize();
Darüber hinaus gibt es einen kleinen Trick, der unnötige Textknotenobjekte entfernt, die im XML-Dokument als Leerzeichen abgebildet sind. Andernfalls entspricht der DOM-Baum, den Sie erhalten, möglicherweise nicht Ihren Vorstellungen. Besonders bei der Ausgabe ist dieses normalize() nützlicher.
NodeList links =doc.getElementsByTagName("link");
Wie gerade erwähnt, werden Leerzeichen in XML-Dokumenten auch als Objekte im DOM-Baum abgebildet. Daher treten beim direkten Aufrufen der getChildNodes-Methode der Node-Methode manchmal Probleme auf, und manchmal kann das erwartete NodeList-Objekt nicht zurückgegeben werden. Die Lösung besteht darin, getElementByTagName(String) von Element zu verwenden, und die zurückgegebene NodeLise ist das erwartete Objekt. Anschließend können Sie die Methode item() verwenden, um das gewünschte Element zu extrahieren.
for (int i=0;i
System.out.print("Inhalt: ");
System.out.println(link.getElementsByTagName("text").item(0).getFirstChild();
.getNodeValue());
...
Der obige Codeausschnitt vervollständigt die formatierte Ausgabe des XML-Dokumentinhalts. Solange Sie auf einige Details achten, wie z. B. die Verwendung der Methoden getFirstChile() und getElementsByTagName(), sind diese relativ einfach.
Im folgenden Inhalt geht es darum, den DOM-Baum nach der Änderung in das XML-Dokument umzuschreiben. Dieses Programm heißt xmlwrite.Java. In der JAXP 1.0-Version gibt es keine direkten Klassen und Methoden, die das Schreiben von XML-Dokumenten bewältigen können, und Sie müssen einige Hilfsklassen in anderen Paketen verwenden. In der JAXP 1.1-Version wurde die Unterstützung für XSLT eingeführt. Das sogenannte XSLT soll nach der Transformation des XML-Dokuments (Übersetzung) eine neue Dokumentstruktur erhalten. Mit dieser neu hinzugefügten Funktion können wir den neu generierten oder geänderten DOM-Baum einfach zurück in die XML-Datei schreiben. Schauen wir uns die Implementierung des Codes an. Die Hauptfunktion dieses Codes besteht darin, einen neuen Linkknoten hinzuzufügen .xml-Datei:
import Javax.xml.parsers.*;
import Javax.xml.transform.*;
import Javax.xml.transform.dom.DOMSource;
import Javax.xml.transform.stream.StreamResult;
import org.w3c.dom.*;
Mehrere Klassen im neu eingeführten Java.xml.transform-Paket werden zur Verarbeitung von XSLT-Transformationen verwendet.
Wir hoffen, der obigen XML-Datei einen neuen Linkknoten hinzufügen zu können. Daher müssen wir zuerst die Datei links.xml lesen, einen DOM-Baum erstellen, dann den DOM-Baum ändern (Knoten hinzufügen) und schließlich das geänderte DOM wieder hinzufügen links.xml-Datei:
DocumentBuilderFactory Factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Dokument doc=builder.parse("links.xml");
doc.normalize();
//---Variablen abrufen----
String text="Hanzhongs Homepage";
String-URL=" www.hzliu.com ";
String-Autor="Hzliu Liu";
String description="Eine Seite von Hanzhong Liu, gönnen Sie sich eine Menge Überraschungen!!!";
Um die wichtigsten Punkte klar zu erkennen und den Vorgang zu vereinfachen, codieren wir den Inhalt, der dem Speicher-String-Objekt hinzugefügt werden soll, fest Bei der Operation verwenden wir häufig eine Schnittstelle, um Benutzereingaben zu extrahieren oder den gewünschten Inhalt über JDBC aus der Datenbank zu extrahieren.
Texttextseg;
Element link=doc.createElement("link");
Zunächst sollte klar sein, dass alle Knotentypen, unabhängig davon, ob es sich um Texttyp, Attr-Typ oder Elementtyp handelt, über das Dokumentobjekt CreateXXX( erstellt werden. )-Methode in (XXX stellt den spezifischen Typ dar, der erstellt werden soll), daher müssen wir dem XML-Dokument ein Link-Element hinzufügen und zunächst ein Link-Objekt erstellen:
Element linktext=doc.createElement("text");
textseg=doc.createTextNode(text);
linktext.appendChild(textseg);
link.appendChild(linktext);
...
Der Prozess zum Erstellen von Knoten ist möglicherweise etwas einheitlich, es muss jedoch beachtet werden, dass der Text im Element enthalten ist (im DOM stellen diese Texte auch einen Knoten dar, sodass für sie auch entsprechende Knoten erstellt werden müssen). Verwenden Sie direkt die setNodeValue()-Methode des Element-Objekts, um den Inhalt dieser Texte festzulegen, und Sie müssen die setNodeValue()-Methode des erstellten Textobjekts verwenden, um den Text festzulegen, damit das erstellte Element und sein Textinhalt festgelegt werden können zum DOM-Baum hinzugefügt. Schauen Sie sich den vorherigen Code an und Sie werden das besser verstehen:
doc.getDocumentElement().appendChild(link);
Vergessen Sie abschließend nicht, den erstellten Knoten zum DOM-Baum hinzuzufügen. Die Methode getDocumentElement() der Document-Klasse gibt das Element-Objekt zurück, das den Stammknoten des Dokuments darstellt. In einem XML-Dokument muss der Wurzelknoten eindeutig sein.
TransformerFactory tFactory =TransformerFactory.newInstance();
Transformator transformator = tFactory.newTransformer();
DOMSource source = new DOMSource(doc);
StreamResult result = new StreamResult(new Java.io.File("links.xml"));
transformator.transform(source, result);
Verwenden Sie dann XSLT, um den DOM-Baum auszugeben. Die TransformerFactory wendet hier auch das Factory-Muster an, wodurch der spezifische Code vom spezifischen Transformator unabhängig wird. Die Implementierungsmethode ist dieselbe wie bei DocumentBuilderFactory, daher werde ich hier nicht auf Details eingehen. Die Transfrom-Methode der Transformer-Klasse akzeptiert zwei Parameter, eine Datenquellenquelle und ein Ausgabezielergebnis. Hier werden jeweils DOMSource und StreamResult verwendet, damit der Inhalt des DOM in einen Ausgabestream ausgegeben werden kann. Wenn der Ausgabestream eine Datei ist, wird der Inhalt des DOM in die Datei geschrieben.
Wie verwende ich JSP zum Entwickeln von SAX-Anwendungen?
SAX ist die Abkürzung für Simple API for XML. Es handelt sich nicht um einen offiziellen, vom W3C vorgeschlagenen Standard. Man kann ihn als „Volks“-De-facto-Standard bezeichnen. Tatsächlich ist es das Ergebnis einer Community-Diskussion. Dennoch wird SAX in XML nicht weniger verwendet als DOM und fast alle XML-Parser unterstützen es.
Im Vergleich zu DOM ist SAX eine leichte Methode. Wir wissen, dass wir bei der DOM-Verarbeitung das gesamte XML-Dokument lesen, dann einen DOM-Baum im Speicher erstellen und jedes Knotenobjekt im DOM-Baum generieren müssen. Wenn das Dokument klein ist, stellt dies keine Probleme dar, wird das Dokument jedoch größer, wird die Verarbeitung des DOM recht zeitaufwändig und mühsam. Insbesondere wird auch der Speicherbedarf exponentiell ansteigen, so dass der Einsatz von DOM in manchen Anwendungen (z. B. in Applets) nicht kosteneffektiv ist. Eine bessere Alternativlösung ist derzeit SAX.
SAX unterscheidet sich konzeptionell völlig von DOM. Erstens ist er im Gegensatz zum DOM-Dokumenttreiber ereignisgesteuert, dh er muss nicht das gesamte Dokument lesen, und der Dokumentleseprozess ist auch der SAX-Analyseprozess. Die sogenannte ereignisgesteuerte Methode bezieht sich auf eine Programmausführungsmethode, die auf dem Rückrufmechanismus basiert. (Wenn Sie sich über das neue Proxy-Ereignismodell von Java im Klaren sind, werden Sie diesen Mechanismus leicht verstehen.) Der XMLReader akzeptiert das XML-Dokument und analysiert es während des Lesevorgangs des XML-Dokuments, also des Lesevorgangs des Dokuments. Der Parsing-Prozess wird gleichzeitig ausgeführt, was sich stark von DOM unterscheidet. Bevor das Parsen beginnt, müssen Sie einen ContentHandler bei XMLReader registrieren, der einem Ereignis-Listener entspricht. In ContentHandler sind viele Methoden definiert, wie zum Beispiel startDocument(), das anpasst, was gehandhabt werden soll, wenn das Dokument während des Parsens gefunden wird Prozess. Wenn XMLReader den entsprechenden Inhalt liest, löst er das entsprechende Ereignis aus, delegiert die Verarbeitungsleistung dieses Ereignisses an ContentHandler und ruft die entsprechende Methode auf, um zu antworten.
Im Allgemeinen ist es vielleicht etwas schwierig zu verstehen, aber keine Sorge, die folgenden Beispiele werden Ihnen helfen, den SAX-Parsing-Prozess zu verstehen. Schauen Sie sich diese einfache XML-Datei an:
Wenn XMLReader das
Aufgetretener Projektmethoden-Callback
{document start} startDocument()
"n" Zeichen("
„Ogden Nash“-Zeichen („
"n" Zeichen("
"n" Zeichen("
„Adam“-Zeichen(“
"n" Zeichen("
{Ende des Dokuments} endDocument()
ContentHandler ist eigentlich eine Schnittstelle, die ContentHandler implementiert, um bestimmte Ereignisse zu verarbeiten. Man kann sagen, dass dies der Kern von SAX ist das Dokument. Werfen wir einen Blick auf einige der darin definierten Methoden:
Leere Zeichen (char[] ch, int start, int length): Diese Methode wird verwendet, um die in der XML-Datei gelesene Zeichenfolge zu verarbeiten. Ihr Parameter ist ein Zeichenarray und der Startpunkt der gelesenen Zeichenfolge in diesem Array Länge können wir einfach einen Konstruktor der String-Klasse verwenden, um die String-Klasse dieser Zeichenfolge zu erhalten: String charEncontered=new String(ch,start,length).
void startDocument(): Wenn Sie auf den Anfang des Dokuments stoßen, rufen Sie diese Methode auf, um einige Vorverarbeitungsarbeiten durchzuführen.
void endDocument(): Entsprechend der obigen Methode wird diese Methode aufgerufen, wenn das Dokument endet, um einige Nacharbeiten durchzuführen.
void startElement(String namespaceURI, String localName, String qName, Attributes atts): Diese Methode wird ausgelöst, wenn ein Start-Tag gelesen wird. Namespaces werden in der SAX1.0-Version nicht unterstützt, in der neuen Version 2.0 wird jedoch Unterstützung für Namespaces bereitgestellt. Der NamespaceURI im Parameter hier ist der Namespace, localName ist der Labelname und qName ist das geänderte Präfix des Labels Es gibt keinen. Bei der Verwendung von Namespaces ist keiner der Parameter null. Und atts ist die Liste der in diesem Tag enthaltenen Attribute. Über atts können Sie alle Attributnamen und entsprechenden Werte abrufen. Es ist zu beachten, dass eine wichtige Funktion von SAX die Streaming-Verarbeitung ist. Bei der Begegnung mit einem Tag werden die zuvor angetroffenen Tags nicht aufgezeichnet. Mit anderen Worten: In der startElement()-Methode sind alle Informationen, die Sie kennen, der Name und die Attribute Die verschachtelte Struktur des Tags, der Name des oberen Tags, ob Unterelementattribute vorhanden sind und andere strukturbezogene Informationen sind unbekannt und benötigen zur Vervollständigung Ihr Programm. Dadurch lässt sich SAX weniger gut programmieren als DOM.
void endElement(String namespaceURI, String localName, String qName): Diese Methode entspricht der oben genannten Methode. Diese Methode wird aufgerufen, wenn ein End-Tag auftritt.
Wir verwenden immer noch das Dokumentbeispiel, das wir verwendet haben, als wir über DOM gesprochen haben, aber schauen wir uns zunächst eine einfachere Anwendung an. Wir hoffen, zu zählen, wie oft jedes Tag in einer XML-Datei vorkommt. Dieses Beispiel ist sehr einfach, reicht aber aus, um die Grundideen der SAX-Programmierung zu veranschaulichen. Am Anfang wird natürlich weiterhin die Importanweisung verwendet:
import org.xml.sax.helpers.DefaultHandler;
import Javax.xml.parsers.*;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import Java.util.*;
import Java.io.*;
Dann erstellen wir eine Klasse, die von DefaultHandler erbt. Die spezifische Programmlogik kann vorerst beiseite gelegt werden. Auf die Struktur des Programms sollten wir achten:
öffentliche Klasse SAXCounter erweitert DefaultHandler.
private Hashtable-Tags; //Diese Hashtable wird verwendet, um die Häufigkeit des Erscheinens des Tags aufzuzeichnen
//Arbeiten Sie, bevor Sie das Dokument verarbeiten
public void startDocument() löst SAXException {
tags = new Hashtable();//Hashtable initialisieren
}
//Verarbeiten Sie jedes Startelementattribut
public void startElement(String namespaceURI, String localName,
String rawName, Attribute atts)
löst eine SAXException aus
{
String key = localName;
...
Mal sehen, was dieses Programm macht. In der main()-Methode erstellen Sie vor allem einen Parser und analysieren dann das Dokument. Tatsächlich wird beim Erstellen des SAXParser-Objekts hier die gleiche Entwurfstechnik wie im DOM verwendet, um den Programmcode unabhängig vom spezifischen Parser zu machen: Erstellen Sie ein bestimmtes SAXParser-Objekt über eine SAXParserFactory-Klasse, damit es beim Parsen unterschiedlich ist , muss lediglich der Wert einer Umgebungsvariablen geändert werden, während der Programmcode unverändert bleiben kann. Dies ist die Idee des FactoryMethod-Musters. Ich werde hier nicht auf Details eingehen. Wenn Sie es immer noch nicht verstehen, können Sie sich auf die Erklärung im obigen DOM beziehen. Das Prinzip ist dasselbe.
Hier ist jedoch eines zu beachten: die Beziehung zwischen der SAXParser-Klasse und der XMLReader-Klasse. Sie sind möglicherweise etwas verwirrt. Tatsächlich ist SAXParser eine Wrapper-Klasse für XMLReader in JAXP, und XMLReader ist eine in SAX2.0 definierte Schnittstelle zum Parsen von Dokumenten. Sie können auch die Methode parser() in SAXParser oder XMLReader aufrufen, um das Dokument zu analysieren, und der Effekt ist genau der gleiche. Allerdings akzeptiert die parser()-Methode in SAXParser mehr Parameter und kann verschiedene XML-Dokumentdatenquellen analysieren, sodass sie bequemer zu verwenden ist als XMLReader.
Dieses Beispiel berührt nur die Oberfläche von SAX, das folgende ist jedoch fortgeschrittener. Die Funktion, die wir unten implementieren möchten, besteht darin, den Inhalt aus dem XML-Dokument zu lesen und die Ausgabe zu formatieren. Obwohl die Programmlogik immer noch sehr einfach aussieht, ist SAX nicht besser als DOM.
Wie bereits erwähnt, können wir bei der Begegnung mit einem Start-Tag in der Methode startElement() die Position des Tags im XML-Dokument nicht ermitteln. Dies stellt bei der Verarbeitung von XML-Dokumenten ein großes Problem dar, da die Semantik von Tags in XML teilweise durch deren Position bestimmt wird. Und bei einigen Programmen, die die Struktur des Dokuments überprüfen müssen, ist dies sogar noch problematischer. Natürlich gibt es kein Problem, das nicht gelöst werden kann. Wir können einen Stapel verwenden, um die Dokumentstruktur aufzuzeichnen.
Das Merkmal des Stapels ist: Zuerst rein, zuerst raus. Unsere aktuelle Idee besteht darin, Push zu verwenden, um den Namen des Etiketts in der startElemnt()-Methode zum Stapel hinzuzufügen und ihn in der endElement()-Methode herauszuholen. Wir wissen, dass bei einem gut strukturierten XML die Verschachtelungsstruktur vollständig ist und dass jedem Start-Tag immer ein End-Tag entspricht und es keine Fehlausrichtung zwischen den Tag-Verschachtelungen gibt. Daher entspricht jeder Aufruf der StartElement () -Methode zwangsläufig einem Aufruf der Endelement () -Methode, so dass Push and Pop auch paarweise die Struktur des Stapels analysieren müssen, um leicht zu wissen, wo sich das aktuelle Etikett befindet, genau wissen, wo sich das aktuelle Etikett befindet. . Position in der Dokumentstruktur.
Die öffentliche Klasse Saxreader erweitert Defaulthandler {
Java.util.stack tags = new java.util.stack ();
...
Obwohl die Stapelanalyse hier nicht verwendet wird, sollte die Stack-Analyse eine sehr leichte Aufgabe ist ist von unten nach oben angeordnet. Attribute jedes Elements. Wenn wir die Elemente des Stapels nacheinander von unten nach oben arrangieren, erhalten wir mit den Informationen dieses Pfads einen einzigartigen Pfad vom XML -Stammknoten zum aktuellen Knoten. .
Bisher haben wir die beiden wichtigsten Tools für die XML -Programmierung gemeistert: DOM und SAX und wissen auch, wie man sie in einem Java -Programm verwendet. Die DOM -Programmierung ist relativ einfach, aber langsam und nimmt viel Speicher an, während die A -AX -Programmierung komplexer ist, aber schnell und weniger Speicher in Anspruch nimmt. Daher sollten wir uns dafür entscheiden, verschiedene Methoden gemäß verschiedenen Umgebungen anzuwenden. Die meisten XML -Anwendungen können im Grunde genommen mit ihnen gelöst werden. Es ist zu beachten, dass DOM und SAX tatsächlich sprachunabhängig sind und nicht nur für Java sind.