Detaillierte Erläuterung der XML-SAX-Analyse-XML/RSS-Tutorial-php.cn

Die letzte Funktion von DOM und SAX besteht darin, uns die Verwendung von Sprachen wie Java JavaScript zu ermöglichen, um Knoten, Text, Attribute und andere Informationen in XML-Dateien abzurufen.

Dieser Artikel ist aus anderen Blogs zitiert. Der Inhalt ist leicht verständlich. Um Zeit zu sparen, habe ich ihn direkt kopiert. Normalerweise gibt es zwei Möglichkeiten, XML in JAVA zu analysieren: DOM und SAX. Obwohl DOM ein W3C-Standard ist und eine Standardanalysemethode bereitstellt, war seine Analyseeffizienz immer unbefriedigend, da der Parser bei Verwendung von DOM zum Parsen von XML das gesamte Dokument liest und eine speicherresidente Baumstruktur (Knotenbaum) erstellt. ), und dann kann Ihr Code die Standardschnittstelle des DOM verwenden, um die Baumstruktur zu manipulieren. In den meisten Fällen sind wir jedoch nur an einem Teil des Dokuments interessiert, ohne zuerst das gesamte Dokument zu analysieren. Außerdem ist es sehr zeitaufwändig, einige der benötigten Daten vom Wurzelknoten des Knotenbaums aus zu indizieren.

SAX ist eine Alternative zum XML-Parsing. Im Vergleich zum Document Object Model DOM ist SAX eine schnellere und einfachere Möglichkeit, XML-Daten zu lesen und zu bearbeiten. Mit SAX können Sie ein Dokument beim Lesen verarbeiten, sodass Sie nicht warten müssen, bis das gesamte Dokument gespeichert ist, bevor Sie Maßnahmen ergreifen. Es sind nicht der Aufwand und die konzeptionellen Sprünge erforderlich, die für das DOM erforderlich sind. Die SAX-API ist eine ereignisbasierte API, die sich für die Verarbeitung von Datenströmen eignet, d. h. für die sequenzielle Verarbeitung von Daten während des Datenflusses. Die SAX-API

benachrichtigt Sie, wenn beim Parsen Ihres Dokuments bestimmte Ereignisse auftreten. Daten, die Sie nicht speichern, werden verworfen, wenn Sie darauf antworten.

Das Folgende ist ein Beispiel für die SAX-Analyse von XML (etwas lang, da alle Methoden der SAX-Ereignisverarbeitung detailliert mit Anmerkungen versehen sind). Es gibt vier Hauptschnittstellen für die Verarbeitung Ereignisse in der SAX-API sind ContentHandler, DTDHandler, EntityResolver bzw. ErrorHandler. Das folgende Beispiel ist möglicherweise etwas langwierig. Solange Sie die DefaultHandler-Klasse erben und einige der Ereignisverarbeitungsmethoden überschreiben, können Sie den Effekt dieses Beispiels auch erzielen Schauen Sie sich alle wichtigen Methoden zum Parsen von Ereignissen in der SAX-API an. (Tatsächlich implementiert DefaultHandler die vier oben genannten Event-Handler-Schnittstellen und stellt dann die Standardimplementierung jeder abstrakten Methode bereit.)

1, ContentHandler-Schnittstelle: Empfangen von Dokumenten-Handler-Schnittstelle für Benachrichtigungen über logische Inhalte.

Java Code Collection Code

'import org.xml.sax.Attributes;

import org.xml.sax.ContentHandler;

import org. xml.sax.Locator;

import org.xml.sax.SAXException;

class MyContentHandler implementiert ContentHandler{

StringBuffer jsonStringBuffer;

int frontBlankCount = 0;

public MyContentHandler(){

jsonStringBuffer = new StringBuffer();

}

* Benachrichtigung über Charakterdaten erhalten.

* Im DOM entspricht ch[begin:end] dem Knotenwert des Textknotens (nodeValue)

@Override

public void Characters(char[] ch, int begin, int length) throws SAXException {

StringBuffer buffer = new StringBuffer();

for(int i = begin ; i < begin+length ; i++){

switch(ch[i]){

case '\\\\\\\\\\\\\\\\\\ \\\ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\':buffer.append("\\\\ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \\\\ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \\\\\\\\ \\\\\\\\\\\\\\\");break;

case '\\\\\\\\\\\\\ \\\\\\\\\ \\\\\\\\\r':buffer.append("\\\\\\\\\\\\\\\\\\\\ \\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\\\r");break;

case '\\\\\\\\\\ \\\\\\\\\\\\\\\\\n':buffer.append("\\\\\ \\\\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\\\\ \\\\\\\\\n");break;

case ' \\\\\\\\\\\\\\\\\\\\\\\\ \\\\\t':buffer.append("\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\\\\\T ");break;

case '\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\"':buffer. append("\\\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\\\"");break;

Standard: buffer.append(ch[i]) ;

}

System.out.println(this.toBlankString(this.frontBlankCount )+

">>> Zeichen ("+length+"): "+buffer.toString());

}

* Benachrichtigung über das Ende eines Dokuments erhalten.

@Override

public void endDocument() throws SAXException {

System.out.println(this.toBlankString(--this. frontBlankCount)+

">>> Enddokument");

}

* Erhalten Sie eine Benachrichtigung über das Ende eines Dokuments.

* Die Parameterbedeutungen sind wie folgt:

* uri: der Namespace des Elements

* localName: der lokale Name des Elements (ohne Präfix)

* qName : Qualifizierter Name des Elements (mit Präfix)

@Override

public void endElement(String uri ,String localName,String qName )

wirft SAXException {

System.out.println(this.toBlankString(--this.frontBlankCount)+

">> > Endelement: " +qName+"("+uri+")");

}

* Ende die Zuordnung des Präfix-URI-Bereichs.

@Override

public void endPrefixMapping(String prefix) throws SAXException {

System.out.println(this.toBlankString(-- this.frontBlankCount)+

">>> end prefix_mapping : "+prefix);

}

* Erhalten Sie Benachrichtigungen über ignorierbare Leerzeichen im Elementinhalt.

* Die Bedeutung der Parameter ist wie folgt:

* ch: Zeichen aus dem XML-Dokument

* start: die Startposition im Array

* Länge: aus dem Array Die Anzahl der eingelesenen Zeichen

@Override

public void ignorableWhitespace(char[] ch, int begin, int length)

wirft SAXException {

StringBuffer buffer = new StringBuffer();

for(int i = begin ; i < begin+length ; i++){

switch(ch [i]){

case '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \\ \\\\\\\\\\\\\\\\\\\\\\\':buffer.append("\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \\\\ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \\\\\\\\ \\\\");break;

case '\\\\\\\\\\\\\\\\\\\\\\\ \\\\\\\r' :buffer.append("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \\\\\\\\\\\ \\\\\\\\\\\\\\\\\r");break;

case '\\\\\\\ \\\\\\\\\\\\ \\\\\\\\\\\n':buffer.append("\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\\\\\\\\n") ;break;

case '\\\\\ \\\\\\\\\\\\\\\\\\\\\\\\\t':buffer.append( "\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\t");break;

case '\\\\\\\\\\\\\\\\\\\ \\\\\\\\\\\"':buffer.append("\\\ \\\\\\\\\\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\\ \\\\\\\\\\\\\\\\\\\\\ \\\\\\\\\\\\\"");break;

Standard: buffer.append(ch[i]);

}

System.out.println(this.toBlankString(this.frontBlankCount)+">> > ignorierbares Leerzeichen("+length+"): "+buffer.toString());

}

* Erhalten Sie eine Benachrichtigung über Verarbeitungsanweisungen.

* Parameterbedeutungen sind wie folgt:

* Ziel: Verarbeitungsanweisungsziel

* Daten: Verarbeitungsanweisungsdaten, wenn nicht angegeben, sind sie null.

@Override

public void processingInstruction(String target,String data)

wirft SAXException {

System.out .println(this.toBlankString(this.frontBlankCount)+">>> Prozessanweisung: (target = \\\\\\\\\\\\\\\\\\\\\\\ \\\\\\""

+target+"\\\\\\\\\\\\\\\\\\\\\\\\\\\\ ",data = \\\\\\\\\\\\\\\\\\\\\\\\\\\\""+data+"\\\\\\\\\ \\\\\ \\\\\\\\\\\\\\\\\\")");

}

* Empfängt ein Objekt, mit dem der Ursprung von SAX-Dokumentereignissen ermittelt wird.

* Parameterbedeutungen sind wie folgt:

* Locator: Ein Objekt, das den Ort eines beliebigen SAX-Dokumentereignisses zurückgeben kann

@Override

public void setDocumentLocator(Locator locator) {

System.out.println(this.toBlankString(this.frontBlankCount)+

">>> set document_locator : (lineNumber = " +locator.getLineNumber()

+", ColumnNumber = "+locator.getColumnNumber()

+", systemId = "+locator.getSystemId()

+" ,publicId = "+locator.getPublicId()+")");

}

* Erhalten Sie Benachrichtigungen für übersprungene Entitäten.

* Die Bedeutung der Parameter ist wie folgt:

* Name: Der Name der zu überspringenden Entität. Wenn es sich um eine Parameterentität handelt, beginnt der Name mit „%“,

* Wenn es sich um eine externe DTD-Teilmenge handelt, handelt es sich um die Zeichenfolge „[dtd]“

@Override

public void skippedEntity(String name ) wirft SAXException {

System.out.println(this.toBlankString(this.frontBlankCount)+

">>> skipped_entity : "+name);

}

* Benachrichtigung über den Beginn eines Dokuments erhalten.

@Override

public void startDocument() throws SAXException {

System.out.println(this.toBlankString(this.frontBlankCount++) +

">>> Startdokument ");

}

* Erhalten Sie eine Benachrichtigung über den Beginn eines Elements.

* Die Parameterbedeutungen sind wie folgt:

* uri: der Namespace des Elements

* localName: der lokale Name des Elements (ohne Präfix)

* qName : Qualifizierter Name des Elements (mit Präfix)

* atts : Attributsammlung des Elements

@Override

public void startElement(String uri , String localName, String qName,

Attributes atts) löst die SAXException {

System.out.println(this.toBlankString(this.frontBlankCount++)+

aus

">> ;> start element : "+qName+"("+uri+")");

}

* Präfix-URI-Namespace-Bereichszuordnung starten.

* Die Informationen für dieses Ereignis sind für die reguläre Namespace-Verarbeitung nicht erforderlich:

* Wenn die Funktion http://xml.org/sax/features/namespaces wahr ist (Standard),

* Der SAX-XML-Reader ersetzt automatisch Präfixe in Element- und Attributnamen.

* Parameterbedeutungen sind wie folgt:

* Präfix: Präfix

* uri: Namespace

@Override

public void startPrefixMapping(String prefix,String uri)

wirft SAXException {

System.out.println(this.toBlankString(this.frontBlankCount++)+

">>> start prefix_mapping : xmlns:"+prefix+" = "

+"\\\\\\\\\\\\\\\\\\\\\\ \\\\\\\\\""+uri+"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\"");

}

private String toBlankString(int count){

StringBuffer buffer = neuer StringBuffer ( );

for(int i = 0;i

buffer.append(" " ");

return buffer.toString();

}

2, DTDHandler-Schnittstelle: Empfangen und DTD-Benachrichtigungshandlerschnittstelle für verwandte Ereignisse

Java-Code-Sammlungscode

'import org.xml.sax.DTDHandler;

import org.xml.sax.SAXException ;

öffentliche Klasse MyDTDHandler implementiert DTDHandler {

* Benachrichtigung über Annotationsdeklarationsereignisse erhalten .

* Die Bedeutung der Parameter ist wie folgt:

* Name – der Name der Anmerkung, oder null, wenn nicht angegeben 🎜>* systemId – Die Systemkennung der Anmerkung oder null, wenn nicht angegeben

@Override

public void notationDecl(String name. , String publicId, String systemId)

wirft SAXException {

System.out.println(">>> Notation declare : (name = "+name

+",systemId = "+publicId

+",publicId = "+systemId+")");

}

/ *

* Erhalten Sie Benachrichtigungen über ungelöste Entitätsdeklarationsereignisse.

* Die Bedeutung der Parameter ist wie folgt:

* Name – der Name der ungelösten Entität.

* publicId – Die öffentliche Kennung der Entität oder null, wenn nicht angegeben.

* systemId – Die Systemkennung der Entität.

* notationName – der Name der zugehörigen Anmerkung.

@Override

public void unparsedEntityDecl(String name,

String publicId,

String systemId,

String notationName) wirft SAXException {

System.out.println(">>> unparsed entity declare : (name = "+name

+",systemId = " +publicId

+",publicId = "+systemId

+",notationName = "+notationName+")");

}

3. Es handelt sich um die grundlegende Schnittstelle zum Parsen von Entitäten.

Java Code Collection Code

'import java.io.IOException;

import org.xml.sax.EntityResolver;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

public class MyEntityResolver implementiert EntityResolver {

* Ermöglicht der Anwendung, externe Entitäten aufzulösen.

* Der Parser ruft diese Methode auf, bevor er eine externe Entität öffnet (außer Dokumententitäten der obersten Ebene).

* Die Bedeutung der Parameter ist wie folgt:

* publicId : die referenzierte externe Entität. Der öffentliche Bezeichner oder null, wenn nicht angegeben.

* systemId: Die Systemkennung der referenzierten externen Entität.

* Gibt zurück:

* Ein InputSource-Objekt, das die neue Eingabequelle beschreibt, oder null,

*, um den Parser aufzufordern, eine reguläre URI-Verbindung zur Systemkennung zu öffnen.

@Override

public InputSource discoverEntity(String publicId, String systemId)

wirft SAXException, IOException {

return null;

}

4, ErrorHandler-Schnittstelle: ist der Fehlerhandler Basic Schnittstelle.

Java Code Collection Code

import org.xml.sax.ErrorHandler;

import org.xml.sax.SAXException;

import org.xml .sax.SAXParseException;

public class MyErrorHandler implementiert ErrorHandler {

* Benachrichtigung über behebbare Fehler erhalten

@Override

public void error(SAXParseException e) throws SAXException {

System.err.println (" Fehler ("+e.getLineNumber()+","

+e.getColumnNumber()+") : "+e.getMessage());

}

* Erhalten Sie Benachrichtigungen über nicht behebbare Fehler.

@Override

public void fatalError(SAXParseException e) throws SAXException {

System.err.println("FatalError ("+e .getLineNumber()+","

+e.getColumnNumber()+") : "+e.getMessage());

}

* Erhalten Sie Benachrichtigungen über nicht behebbare Fehler.

@Override

public void warning(SAXParseException e) löst SAXException {

System.err.println("Warning ("+e .getLineNumber()+","

+e.getColumnNumber()+") : "+e.getMessage());

}

Die Hauptmethode der Testklasse druckt Ereignisinformationen beim Parsen von Books.xml.

Java Code Collection Code

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import org.xml.sax.ContentHandler;

import org.xml.sax.DTDHandler;

import org.xml.sax .EntityResolver;

import org.xml.sax.ErrorHandler;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

import org.xml.sax.XMLReader;

import org.xml.sax.helpers.XMLReaderFactory;

public class Test {

public static void main(String[] args) throws SAXException,

FileNotFoundException, IOException {

//Erstellen Sie einen Handler für die Behandlung von dokumentinhaltsbezogenen Ereignissen

ContentHandler contentHandler = new MyContentHandler();

//Erstellen Sie einen Handler für die Behandlung von Fehlerereignissen

ErrorHandler errorHandler = new MyErrorHandler();

//Erstellen Sie einen Handler zur Verarbeitung von DTD-bezogenen Ereignissen

DTDHandler dtdHandler = new MyDTDHandler();

//Erstellen Sie einen Entitätsparser

EntityResolver entityResolver = new MyEntityResolver();

//Erstellen Sie einen XML-Parser (lesen und analysieren Sie XML über SAX)

XMLReader-Reader = XMLReaderFactory.createXMLReader();

* Parserbezogene Funktionen festlegen

* http://xml.org/sax/features/validation = true Zeigt das an die Verifizierungsfunktion ist aktiviert

* http://xml.org/sax/features/namespaces = true zeigt an, dass die Namespace-Funktion aktiviert ist

Reader. setFeature(" http://xml.org/sax/features/validation",true);

reader.setFeature("http://xml.org/sax/features/namespaces",true);

//Legen Sie den Handler des XML-Parsers für die Behandlung dokumentinhaltsbezogener Ereignisse fest.

reader.setContentHandler(contentHandler);

//Legen Sie den Handler des XML-Parsers für die Behandlung von Fehlerereignissen fest

reader.setErrorHandler(errorHandler);

//Legen Sie den Handler des XML-Parsers fest, um DTD-bezogene Ereignisse zu verarbeiten

reader.setDTDHandler(dtdHandler);

//Legen Sie den Entitätsparser des XML-Parsers fest

reader.setEntityResolver(entityResolver);

//Parsen Sie das Books.xml-Dokument

reader.parse(new InputSource( new FileReader("books.xml")));

}

Der Inhalt der Datei „books.xml“ lautet wie folgt:

Xml-Code-Sammlungscode

Denken in JAVA

Core JAVA2

C++-Grundierung

Die Konsolenausgabe lautet wie folgt:

>>> systemId = null, publicId = null)

>>> Startdokument

Fehler (2,7): Dokument ist ungültig: Keine Grammatik gefunden.

Fehler (2,7): Dokumentstammelement „books“, muss mit DOCTYPE root „null“ übereinstimmen.

>>>

> >> Startelement: Bücher(http://test.org/books)

>>> \\\\\\\\ \\\\\\\\\\\\\\\\\N\\\\\\\\\\\\\\\\\\\\\\\\ \\\\\ \t