DOM-Parser – Der validierende DOM-Parser

Die letzte Parsergattung, die ich hier ansprechen möchte, ist der
validierende DOM-Parser. Im Prinzip funktioniert dieser natürlich
genauso, wie der nichtvalidierende DOM-Parser, das heißt, es wird
ein DOM-Tree aufgebaut.

Ich werde das Beispiel aus dem vorherigen Kapitel hier einfach nocheinmal
verwenden, möchte aber wieder darauf hinweisen, daß es eigentlich
unzweckmäßig ist, hier einen DOM-Parser einzusetzen, da das
Dokument ja nur einmal geparst wird, und danach auch nichtmehr verändert
wird.

Das Listing zum nichtvalidierenden DOM-Parser von IBM aus dem letzten
Kapitel, ändert sich eigentlich nur in einer Zeile, nämlich
bei der Instantiierung des Parsers:

DOMParser parser = new DOMParser();

Das vollständige Listing sieht folgendermaßen aus:

import org.w3c.dom.*;
import com.ibm.xml.parsers.*;

public class IBMDOMParser
{
    public static void main(String[] args)
    {
        IBMDOMParser MyParser = new IBMDOMParser();
        MyParser.parse(args[0]);
    }

    private void parse(String file)
    {
        DOMParser parser = new DOMParser();
        try
        {
            parser.parse(file);
            writeDoc(parser.getDocument().getDocumentElement());
        }
        catch (Exception e)
        {
            System.err.println("Fehler: " + e);
        }
    }

    private void writeDoc(Node node)
    {
        short type = node.getNodeType();
        switch (type)
        {
            case Node.ELEMENT_NODE:
            {
                String name = "<" + node.getNodeName();
                NamedNodeMap attrs = node.getAttributes();
                if (attrs != null)
                {
                    int length = attrs.getLength();
                    for (int i = 0; i < length; i++)
                    {
                        Node attr =  attrs.item(i);
                        name += " " + attr.getNodeName();
                        name += "="" + attr.getNodeValue() + """;
                    }
                }
                name += ">";
                System.out.println(name);

                NodeList children = node.getChildNodes();
                if (children != null)
                {
                    int length = children.getLength();
                    for (int i = 0; i < length; i++)
                        writeDoc(children.item(i));
                }
                break;
            }
            case Node.TEXT_NODE:
            {
                System.out.println(node.getNodeValue());
                break;
            }
        }
    }
}

Ziemlich einfach aus einem nichtvalidierenden einen validierenden Parser
zu machen, gelle? Und das ist beim Sun-Parser auch nicht anders. Auch
hier ändert sich nur die Zeile mit der Instantiierung des Parsers:

ValidatingParser parser = new ValidatingParser();

Auch hier nochmal das vollständige Listing:

import org.w3c.dom.*;
import com.sun.xml.parser.*;
import com.sun.xml.tree.XmlDocumentBuilder;
import java.io.File;

public class SunDOMParser
{
    public static void main(String[] args)
    {
        SunDOMParser MyParser = new SunDOMParser();
        MyParser.parse(args[0]);
    }

    private void parse(String file)
    {
        XmlDocumentBuilder builder = new XmlDocumentBuilder();
        ValidatingParser parser = new ValidatingParser();
        builder.setParser(parser);
        try
        {
            parser.parse(Resolver.createInputSource(new File(file)));
            writeDoc(builder.getDocument().getDocumentElement());
        }
        catch (Exception e)
        {
            System.err.println("Fehler: " + e);
        }
    }

    private void writeDoc(Node node)
    {
        short type = node.getNodeType();
        switch (type)
        {
            case Node.ELEMENT_NODE:
            {
                String name = "<" + node.getNodeName();
                NamedNodeMap attrs = node.getAttributes();
                if (attrs != null)
                {
                    int length = attrs.getLength();
                    for (int i = 0; i < length; i++)
                    {
                        Node attr =  attrs.item(i);
                        name += " " + attr.getNodeName();
                        name += "="" + attr.getNodeValue() + """;
                    }
                }
                name += ">";
                System.out.println(name);

                NodeList children = node.getChildNodes();
                if (children != null)
                {
                    int length = children.getLength();
                    for (int i = 0; i < length; i++)
                        writeDoc(children.item(i));
                }
                break;
            }
            case Node.TEXT_NODE:
            {
                System.out.println(node.getNodeValue());
                break;
            }
        }
    }
}

Da in diesem Kapitel nun wirklich wenig Neues zu erfahren war, möchte
ich zum Abschluß noch etwas anmerken, das vielleicht nicht allen
von euch klar war. Ihr könnt natürlich auch bei DOM-Parsern,
und zwar sowohl beim validierenden als auch beim nichtvalidierenden, einen
eigenen Errorhandler benutzen. Dieser wird wie gehabt mittels parser.setErrorHandler
beim Parser registriert.

Logischerweise kann man auch die HandlerBase im Zusammenhang
mit DOM-Parsern benutzen. Insofern ist meine Einordnung des Kapitels über
diese Klasse beim SAX-Parser vielleicht nicht ganz richtig.