Wann sollte ich SAX über StAX wählen?

Überblick
XML-Dokumente sind hierarchisch Dokumente, in denen die gleichen element-Namen und namespaces auftreten, an mehreren stellen mit unterschiedlicher Bedeutung, und im Infinitiv Tiefe (rekursive). Als normal wird die Lösung der großen Probleme ist, teilen Sie Sie in kleinere Probleme. Im Rahmen der XML-Analyse verwendet, das heißt der Analyse bestimmter Teile von XML-Methoden spezifisch für die XML. Zum Beispiel, ein Stück von der Logik würde der parse-Adresse:

<Address>
    <Street>Odins vei</Street>    
    <Building>4</Building>
    <Door>b</Door>
</Address>

d.h. Sie hätten eine Methode

AddressType parseAddress(...); //A

oder

void parseAddress(...); //B

irgendwo in Ihrer Logik, wobei XML-Eingänge Argumente und zurückgeben eines Objekts (Ergebnis von B kann der Wert aus einem Feld später).

SAX

SAX 'schiebt' XML Veranstaltungenes bleibt Ihnen überlassen, zu bestimmen, wo die XML-Ereignisse gehören, die in Ihrem Programm /Daten.

//method in stock SAX handler
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException
    //.. your logic here for start element
}

Im Falle eines 'Gebäudes' start-element, würden Sie brauchen, um festzustellen, dass Sie eigentlich in der Analyse einer Adresse und dann auf der route der XML-Ereignis die Methode, deren Aufgabe es ist, zu interpretieren Adresse.

StAX

StAX 'zieht' XML Veranstaltungenes bleibt Ihnen überlassen, zu bestimmen, wo in Ihrem Programm /Daten zu erhalten, die XML-Ereignisse.

//method in standard StAX reader
int event = reader.next();
if(event == XMLStreamConstants.START_ELEMENT) {
    //.. your logic here for start element
}

Natürlich, Sie würden immer wollen, um zu erhalten eine "Aufbau" - event in der Methode, deren Aufgabe es ist, zu interpretieren-Adresse.

Diskussion

Der Unterschied zwischen SAX und StAX ist, dass der push-und pull. In beiden Fällen wird der parse-Staat behandelt werden müssen, irgendwie.

Bedeutet dies eine Methode B, die als typisch für SAX, und Eine Methode für StAX. Darüber hinaus SAX geben müssen, B einzelne XML-Ereignisse, während der StAX kann Eine mehrere Ereignisse (durch ein XMLStreamReader Instanz).

Damit B prüfen Sie zunächst den vorherigen Zustand des Parsen und dann mit jedem einzelnen XML-Ereignis und speichert dann den Zustand (in einem Feld). Methode A kann nur verarbeiten der XML-Ereignisse, die alle auf einmal durch den Zugriff auf die XMLStreamReader mehrere Male, bis zufrieden.

Fazit

StAX können Sie Ihre Struktur analysieren (data-binding) - code entsprechend der XML-Struktur; so in Bezug auf SAX, der 'Staat' ist implizit aus den Programm-Ablauf für StAX, in der Erwägung, dass im SAX, der Sie immer schützen zu müssen, eine Art state-variable + route dem Fluss nach, der Staat, für die meisten-event ruft.

Empfehle ich StAX für alle aber die einfachsten Dokumente. Vielmehr bewegen SAX als eine Optimierung später (aber Sie werden wahrscheinlich wollen zu gehen, Binär).

Folgen diesem Muster, wenn das Parsen mit StAX:

public MyDataBindingObject parse(..) { //provide input stream, reader, etc

        //set up parser
        //read the root tag to get to level 1
        XMLStreamReader reader = ....;

        do {
            int event = reader.next();
            if(event == XMLStreamConstants.START_ELEMENT) {
              //check if correct root tag
              break;
            }

            //add check for document end if you want to

        } while(reader.hasNext());

        MyDataBindingObject object = new MyDataBindingObject();
        //read root attributes if any

        int level = 1; //we are at level 1, since we have read the document header

        do {
            int event = reader.next();
            if(event == XMLStreamConstants.START_ELEMENT) {
                level++;
                //do stateful stuff here

                //for child logic:
                if(reader.getLocalName().equals("Whatever1")) {
                    WhateverObject child = parseSubTreeForWhatever(reader);
                    level --; //read from level 1 to 0 in submethod.

                    //do something with the result of subtree
                    object.setWhatever(child);
                }

                //alternatively, faster
                if(level == 2) {
                    parseSubTreeForWhateverAtRelativeLevel2(reader);
                    level --; //read from level 1 to 0 in submethod.

                    //do something with the result of subtree
                    object.setWhatever(child);
                }


            } else if(event == XMLStreamConstants.END_ELEMENT) {
                level--;
                //do stateful stuff here, too
            }

        } while(level > 0);

        return object;
}

Also die submethod verwendet, etwa der gleiche Ansatz, D. H. das zählen level:

private MySubTreeObject parseSubTree(XMLStreamReader reader) throws XMLStreamException {

    MySubTreeObject object = new MySubTreeObject();
    //read element attributes if any

    int level = 1;
    do {
        int event = reader.next();
        if(event == XMLStreamConstants.START_ELEMENT) {
            level++;
            //do stateful stuff here

            //for child logic:
            if(reader.getLocalName().equals("Whatever2")) {
                MyWhateverObject child = parseMySubelementTree(reader);
                level --; //read from level 1 to 0 in submethod.

                //use subtree object somehow
                object.setWhatever(child);
            }

            //alternatively, faster, but less strict
            if(level == 2) {
              MyWhateverObject child = parseMySubelementTree(reader);
                level --; //read from level 1 to 0 in submethod.

                //use subtree object somehow
                object.setWhatever(child);
            }


        } else if(event == XMLStreamConstants.END_ELEMENT) {
            level--;
            //do stateful stuff here, too
        }

    } while(level > 0);

    return object;
}

Und dann schließlich werden Sie eine Stufe erreichen, in dem Sie Lesen werden, die Basis-Typen.

private MySetterGetterObject parseSubTree(XMLStreamReader reader) throws XMLStreamException {

    MySetterGetterObject myObject = new MySetterGetterObject();
    //read element attributes if any

    int level = 1;
    do {
        int event = reader.next();
        if(event == XMLStreamConstants.START_ELEMENT) {
            level++;

            //assume <FirstName>Thomas</FirstName>:
            if(reader.getLocalName().equals("FirstName")) {
               //read tag contents
               String text = reader.getElementText()
               if(text.length() > 0) {
                    myObject.setName(text)
               }
               level--;

            } else if(reader.getLocalName().equals("LastName")) {
               //etc ..
            } 


        } else if(event == XMLStreamConstants.END_ELEMENT) {
            level--;
            //do stateful stuff here, too
        }

    } while(level > 0);

    //verify that all required fields in myObject are present

    return myObject;
}

Dies ist Recht einfach und es gibt keinen Raum für Missverständnisse. Denken Sie daran, zu verringern Lautstärke korrekt:

A. nachdem Sie erwarteten Zeichen bekam aber eine END_ELEMENT in einigen tag enthalten chars (in dem obigen Muster):

<Name>Thomas</Name>

wurde statt

<Name></Name>

Gleiches gilt für eine fehlende Teilstruktur zu, Sie bekommen die Idee.

B. nach dem Aufruf subparsing Methoden, die aufgerufen werden, auf start-Elemente, und kehrt NACH dem entsprechenden end-element, D. H. der parser ist auf einem Niveau niedriger als vor dem Aufruf der Methode (dem obigen Muster).

Hinweis, wie dieser Ansatz völlig ignoriert 'ignorable' whitespace zu, für mehr und robuste Implementierung.

Parser

Gehen Sie mit Woodstox für die meisten Funktionen oder Aaalto-xml für die Geschwindigkeit.

InformationsquelleAutor der Antwort

Es ist alles ein Gleichgewicht.

Können Sie wiederum einen SAX-parser in ein pull-parser mit Hilfe einer Warteschlange blockiert und einige Tricks thread so, für mich gibt es viel weniger Unterschied ist, als es zunächst scheint.

Glaube ich derzeit StAX muss gepackt werden, die durch einen Drittanbieter-jar-während SAX kommt frei in javax.

Ich vor kurzem beschlossen SAX und baute ein pull-parser um ihn herum, damit ich nicht angewiesen auf Drittanbieter-jar.

Zukünftigen Java-Versionen werden mit ziemlicher Sicherheit enthalten ein StAX-Implementierung, so dass das problem verschwindet.

InformationsquelleAutor der Antwort OldCurmudgeon

Meisten der zur Verfügung gestellten Informationen diese Antworten sind etwas veraltet... es wurde eine umfassende Studie aller XML-parsing-libraries in das Jahr 2013 research paper... Lesen Sie es und Sie werden leicht sehen, der klare Sieger (Tipp: es gibt nur einen wahren Gewinner)...

http://recipp.ipp.pt/bitstream/10400.22/1847/1/ART_BrunoOliveira_2013.pdf

InformationsquelleAutor der Antwort vtd-xml-author