<  X  M  L  / >  Extensible Markup Language

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.