Beispiel: XML lesen/schreiben

Erzeugen

Parsen

1. Initialisierung
   
   1. DocumentBuilderFactory
      Wie im letzten Beispiel wird eine DocumentBuilderFactory initialisiert, allerdings sind unsere Ansprüche jetzt höher:

      import javax.xml.parsers.DocumentBuilder;
      import javax.xml.parsers.DocumentBuilderFactory;
      ...
      
          DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
      
          documentBuilderFactory.setNamespaceAware(true);
          documentBuilderFactory.setValidating(false);
          

      Beim Parsen sollen Namespaces beachtet werden (setNamespaceAware(true)). Wichtig ist außerdem, dass wir setValidating(false) aufrufen. Grund für diese scheinbar unlogische Aktion: hiermit schalten wir die DTD-Validierung ab! Da unsere XML-Datei morderner ist und keine DTD verwendet, würde eine solche Prüfung nur zu einem Validierungsfehler führen.
      

          URL urlSchema = new URL("http://www.informatik.fh-wiesbaden.de/~knauf/SWTProjekt2009/sherd.xsd");
          Schema schemaSherd = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI).newSchema(urlSchema);
          documentBuilderFactory.setSchema(schemaSherd);

      Hier wird definiert, dass die Validierung gegen das "sherd"-Schema auf meiner Webseite erfolgen soll. Die "schemaLocation"-Deklaration im XML-Dokument selbst wird vom Validator ignoriert, wir müssen von außen sagen, welches Schema wir verwenden. Vorteil dieser Aktion: wir könnten auch eine Datei-URL angeben, und dann würde diese lokale XSD für die Validierung verwendet, statt ins Internet zu gehen.
      
      
   2. DocumentBuilder
      

      import javax.xml.parsers.DocumentBuilder;
      ...
      
          DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
          
          documentBuilder.setErrorHandler(new SherdErrorHandler() );

      Aus der DocumentBuilderFactory wird ein DocumentBuilder gezaubert. Diesem wird eine Implementation des Interfaces org.xml.sax.ErrorHandler übergeben. Grund hierfür: der Standard-Errorhandler spuckt nur Konsolenausgaben aus, läßt aber das Parsen weiterlaufen. Wir wollen allerdings bei jedem XML-Fehler sofort abbrechen.
      Deshalb wurde die Klasse de.fhw.knauf.swtprojekt.xml.SherdErrorHandler gebaut, die in ihren Callbacks jeden Parse-Fehler (als Exception-Parameter übergeben) als echte Exception weiterwirft. Eine Instanz hiervon wird als ErrorHandler an den DocumentBuilder übergeben.
      

      package de.knauf.fhw.swprojekt.xml;
      
      import org.xml.sax.ErrorHandler;
      import org.xml.sax.SAXException;
      import org.xml.sax.SAXParseException;
      
      public class SherdErrorHandler implements ErrorHandler
      {
        @Override
        public void error(SAXParseException arg0) throws SAXException
        {
          throw arg0;
        }
      
        @Override
        public void fatalError(SAXParseException arg0) throws SAXException
        {
          throw arg0;
        }
      
        @Override
        public void warning(SAXParseException arg0) throws SAXException
        {
          throw arg0;
        }
      
      }

      
      .
   3. Parsen
      Es wird die Datei "sherd.xml" im Programmverzeichnis geladen und dem DocumentBuilder übergeben:

      import java.io.File;
      import org.w3c.dom.Document;
      ...
      
          File fileSherd = new File("sherd.xml");
        
          Document docSherd = documentBuilder.parse(fileSherd);

      Jeder auftretende Fehler resultiert hier in einer org.xml.sax.SAXParseException, da diese von unserem SherdErrorHandler weitergeworfen werden.
      
      
   4. Elemente auslesen
      Folgender Codeblock holt sich das erste Element "tabellen" im Dokument, läuft über alle seine Subelemente "tabelle" und gibt deren Attribute aus.
      

      import org.w3c.dom.Element;
      import org.w3c.dom.NodeList;
      ...
      
          NodeList listTabellen = docSherd.getElementsByTagName("tabellen");
          Element elementTabellen = (Element) listTabellen.item(0);
      	
          //Über alle Childs laufen:
          NodeList listTabelle = elementTabellen.getElementsByTagName("tabelle");
          for (int intIndex = 0; intIndex < listTabelle.getLength(); intIndex++)
          {
            Element elementTabelle = (Element) listTabelle.item(intIndex);
            
            System.out.println ("Tabelle " + intIndex + ": Name = " + elementTabelle.getAttribute("tabellenname") +
                ", ID= " + elementTabelle.getAttribute("id") +
                ", x=" + elementTabelle.getAttribute("x") + ", y=" + elementTabelle.getAttribute("y") +
                ", width=" + elementTabelle.getAttribute("width") + ", height=" + elementTabelle.getAttribute("height") );

      Bei diesem Code ist zu beachten: da das Dokument gegen das Schema validiert wurde, wissen wir, dass es genau ein Element "tabellen" gibt. Wir können also in der Liste der Elemente namens "tabellen" direkt auf das Element an Index 0 zugreifen ohne weitere Prüfungen. Ohne Schema-Validierung wäre solcher Code ein No-Go!
      
      Des weiteren ist zu beachten, dass z.B. das Abrufen eines Attributs anhand des Namens keine Fehler wirft, wenn es kein Attribut dieses Namens gibt, sondern dann kommt NULL zurück! Hier ist die Gefahr von unentdeckten Tippfehler also groß!
      
      
   5. Textinhalt auslesen
      Folgender Codeschnipsel holt den Textinhalt eines Elements (wobei es egal ist, ob es einen String-Inhalt oder eine CDATA-Sektion enthält):
      

      String sComment = elementComment.getTextContent();