# JTreedaten in eine XML Datei speichern



## Elmishelmi (4. Dez 2015)

Hi,

ich habe mir einen JTree erstellt und möchte die Daten von diesem in eine XML Datei schreiben. Die Daten des JTree's kommen aus einer XML Datei die ich zuvor geladen und dann geparsed habe. Ich habe einiges versucht, um die Daten wieder in ein XML Dokument zu schreiben. Doch es gelingt mir nicht die Daten nach dem ändern des JTree's wieder in eine XML zu schreiben.

Kann ich die geparsten Daten nicht einfach in eine Datei schreiben, in dem ich das Dokument oder das Rootelement mit den Kindelementen übergebe, inklusive der bearbeiteten Elemente?
Oder muss ich das TreeModel übergeben? Falls ja, an welcher Stelle müsste ich das tun, dort wo ich das TreeModel erstelle?

Die Daten müssen in der XML Datei, wie in der Ursprungsdatei dargestellt werden, deshalb fällt XStream raus.

Kann mir jemand sagen wie ich die Daten von dem JTree wieder in ein Dokument bekomme?

Was ich bereits versucht habe und nicht wie gewünscht funktioniert hat, habe ich auskommentiert. XStream habe gelöscht, weil die Lösung nicht wie gewünscht war.

Danke schon mal im voraus für alle Infos, komme an der Stelle nicht weiter.

Hier mein Code:

```
package Model;

import java.io.File;

import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

//Das TreeModel liest das Dokument ein und überführt die Daten anschließend in einen Baum
public class MyTreeModel {
   
    Document doc;
   
    // Datei werden aus dem Dokument geladen und die Baumwurzel wird erstellt
    public void synchronizeXmlWithModel(File file, DefaultMutableTreeNode root) {

        try {
           
            Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(file);
            root.setUserObject(file.getName());
            buildTreeModelByTreeWalk(doc, root);
           
            //Funktioniert nur beim Laden der Datei.
            /*
            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            Transformer transformer = transformerFactory.newTransformer();
            DOMSource source = new DOMSource(doc);
            StreamResult result = new StreamResult(new File("abc.xml"));
            transformer.transform(source, result);
            */   
           
        } catch (Exception e) {
           
            e.printStackTrace();
       
        }
    }

    // Der Parser durchsucht die geladene Datei und prüft um welchen
    // Knotentyp(NodeType) es sich handelt und
    // fügt die einzelnen Knoten(node) dem Baumknoten(treeNode) hinzu.
    public void buildTreeModelByTreeWalk(Node node, DefaultMutableTreeNode parentTreeNode) {
       
        DefaultMutableTreeNode treeNode = new DefaultMutableTreeNode();
        switch (node.getNodeType()) {

        case Node.COMMENT_NODE: {
            treeNode.setUserObject(node.getTextContent());

            // TestAusgabe der Baumwurzel, dient der Parserüberprüfung
            // System.out.println(treeNode);

        }
            break;

        case Node.ELEMENT_NODE: {
            if (treeNode.isLeaf() == true) {

                treeNode.setUserObject(node.getNodeName());
                NamedNodeMap attributes = node.getAttributes();
                int numAttrs = attributes.getLength();

                for (int i = 0; i < numAttrs; i++) {

                    Attr attr = (Attr) attributes.item(i);
                    String attrName = attr.getNodeName();
                    String attrValue = attr.getNodeValue();

                    // Ausgabe der Attributnamen und Werte, dient der
                    // Parserüberprüfung
                    treeNode.setUserObject(node.getNodeName());
                    treeNode.add(new DefaultMutableTreeNode(attrName));
                    treeNode.add(new DefaultMutableTreeNode(attrValue));
                                       
                }
            }

        }
            break;

        case Node.TEXT_NODE: {

            String textContent = node.getTextContent().trim();
            if (textContent.equals("")) {

                return;
            }

            treeNode.setUserObject(textContent);

            // Testausgabe des Knoteninhalts, dient der Parserüberprüfung
            // System.out.println(treeNode);
        }
            break;
        }

        parentTreeNode.add(treeNode);

        if (node.hasChildNodes()) {

            NodeList list = node.getChildNodes();

            for (int i = 0, len = list.getLength(); i < len; i++) {

                buildTreeModelByTreeWalk(list.item(i), treeNode);
               
            }
        }
    }
   
    public void writeFile(File file, DefaultMutableTreeNode root, DefaultTreeModel model) throws TransformerException, ParserConfigurationException {
       
        //Bekommt die Dokumentdaten und
        //schreibt die Daten in einen neuen XML File,
        //Doc bleibt leer.
        /*
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        DOMSource source = new DOMSource(doc);
        StreamResult result = new StreamResult(new File("abx.xml"));
        transformer.transform(source, result);
       
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        Document doc = factory.newDocumentBuilder().newDocument();

        // Get tree root...
        root = (DefaultMutableTreeNode) model.getRoot();

        buildTreeModelByTreeWalk(doc, root);
         // Save the document to disk...
        Transformer tf = TransformerFactory.newInstance().newTransformer();
        tf.setOutputProperty(OutputKeys.INDENT, "yes");
        tf.setOutputProperty(OutputKeys.METHOD, "xml");
        tf.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");

        DOMSource domSource = new DOMSource(doc);
        StreamResult sr = new StreamResult(new File("TreeModel.xml"));
        tf.transform(domSource, sr);
         */

    }
}
```


----------



## Harry Kane (4. Dez 2015)

Die Instanzvariable doc in deiner MyTreeModel-Klasse wird in deiner synchronizeXmlWithModel-Methode nicht verwendet bzw. initialisiert, sondern du baust deinen Baum aus einer neuen Instanz von Document auf, die in der Methode erzeugt wird. je nachdem was sonst noch in der Klasse passiert, kann es sein, das doc null ist, wenn du die writeFile Methode aufrufst.
Mir erschliesst sich übrigens nicht, warum du in deiner writeFile-Methode, nachdem du mit transformer.transform(source, result) die XML Datei geschrieben hast, eine neue doc-variable anlegst, die ebenfalls nur in der Methode existiert, und damit nochmal die buildTreeModelByTreeWalk methode aufrufst. Da doc ein "frisches" Document ohne Kindelemente ist, sollte danach eigentlich der JTree leer sein. Ist das beabsichtigt?


----------



## Elmishelmi (7. Dez 2015)

Zu spät vor dem Posten gesehen, sorry. Die Instanzvariable habe ich für einen Test benutzt. Ich wollte die Daten des Doc der Methode synchronizeXmlWithModel-Method an die Methode WriteFile übergeben. Das hat allerdings nicht geklappt. Wie du schon sagtest ist Doc null.

Ich bin noch neu in Java und wenn etwas nicht funktioniert probiere ich ein bisschen was aus, auch wenns wie in diesem Fall keinen Sinn ergibt. Nach mehreren Versuchen probiere ich einfach alles aus. Ist übrigens auch auskommentiert. 

Wie muss ich denn vorgehen, um die Daten, die ich aus dem Dokument lade, wieder in eine XML Datei zu schreiben?


----------



## Elmishelmi (7. Dez 2015)

Edit: Habe den Fehler gefunden. Hab den Wald vor lauter Bäumen nicht mehr gesehen und das Problem an der falschen Stelle gesucht. Habe in meiner Maindatei eine neue Instanz des TreeModels erstellt, anstatt das aktuelle TreeModel zu benutzen.

Danke für den Tipp, hat mich zur Lösung gebracht, die Datei wird nun genau so geschrieben wie ich es möchte!


----------

