NIO File Tree in XML umwandeln

Vince42

Mitglied
Moin,

ich möchte gerne mit NIO Files.walk() und JAXB einen Verzeichnisbaum rekursiv in eine XML-Datei umwandeln. Mein aktueller Stand sieht wie folgt aus:
Java:
package org.nodez.reader;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/*
* Convert file structure into tree datatype
* Version: 0.1
* Date: 2017-11-26
*/
public class Filesystem {
 
  // Constants
  private static final String OUTPUT_FILE = "q:\\project\\nodez\\output\\FilesystemTree.xml";
 
  // Variables
  private static Document doc;
 
  public static void main(String[] args) {
    createOutputFile();
    Path root = Paths.get(args[0]);
    try (Stream<Path> stream = Files.walk(root)) {
      Element node = doc.createElement("node");
      Attr name = doc.createAttribute("name");
      name.setValue("..."); // <-- how do I get the name of the folder or file?
      // node.setAttribute("name", "...");
      doc.appendChild(node);
    } catch (IOException e) {
      e.printStackTrace();
    }
    writeOutputFile();
  }
 
  private static void createOutputFile() {
    try {
      DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
      DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
      Document doc = docBuilder.newDocument();
      Element rootElement = doc.createElement("tree");
      doc.appendChild(rootElement);
    } catch (ParserConfigurationException e) {
      e.printStackTrace();
    }
  }
 
  private static void writeOutputFile() {
    try {
      TransformerFactory transformerFactory = TransformerFactory.newInstance();
      Transformer transformer = transformerFactory.newTransformer();
      DOMSource source = new DOMSource(doc);
      StreamResult result = new StreamResult(new File(OUTPUT_FILE));
      transformer.transform(source, result);
      System.out.println("File saved!");
    } catch (TransformerException e) {
      e.printStackTrace();
    }
  }

}

Es ist leider ewig her, daß ich mal mit Java programmiert habe, daher bin ich für jeden Verbesserungsvorschlag dankbar. Ich habe leider nicht verstanden, wie ich dem Attribut "name" den Namen des aktuellen Ordners oder der Datei zuweise. Vermutlich ist es trivial, aber ich konnte in den Codeschnipseln und Dokumentationen nichts passendes finden - oder ich habe es gelesen und nicht verstanden.

Vielen Dank im voraus!
 
Hallo.

Also einem Attribute den Namen zu geben ist weniger Sinnvoll. Weil die unerlaubte Zeichen wie z. B \ eine Fehlermeldung aller Voraussicht erzeugen würden.

Denke das ein Knoten so aussehen könnte:

Code:
<directory>
    <name>C:\\</name>
    <files>
        <file>
            <name>Test</name>
            <extension>exe</extension>
        </file>   
        <file>
            <name>Test</name>
            <extension>exe</extension>
        </file>
    <files>
    <directories>
        <directory>.....</directory>
    </directories>
<directory>

Ein Beispiel wie das gehen könnte: https://www.mkyong.com/java/how-to-create-xml-file-in-java-dom/

Aber ehrlich gesagt kann so eine XML echt bescheiden aussehen, wenn du z. B von Laufwerk C aus startest.
Die Rechte musst du auch noch beachten. Nicht in allen Ordner darfst du rein ....

Grüße
 
Danke für den Beitrag! Die Web Site von mkyong hatte ich auch als Ausgangsbasis für den Code genommen. Jetzt stellt sich mir die Frage, wie in der Code-Zeile "name.setValue("...");" der Name der Datei aus dem Objekt stream über eine Methode oder ein Property ausgelesen werden kann.
Ich habe auch etwas über Marshalling im Zusammenhang mit JAXB gelesen, was tendentiell interessant klang, um Objekte in XML und XML in Objekte umzuwandeln - wäre das eher der Weg, der hier zu verfolgen wäre?
 
Ein Beispiel wie man z.B alle Ordner in einer XML speichert.

Java:
        // root elements
        Document doc = docBuilder.newDocument();
        Element rootElement = doc.createElement("hierarchy");
        doc.appendChild(rootElement);

        Element dirsElement = doc.createElement("directories");
        rootElement.appendChild(dirsElement);

        Files.walk(Paths.get("D:\\example")).filter(new Predicate<Path>() {

            @Override
            public boolean test(Path t) {
                return Files.isDirectory(t) && Files.isReadable(t) && Files.isWritable(t);
            }
        }).forEach(new Consumer<Path>() {

            @Override
            public void accept(Path t) {
                Element dirElement = doc.createElement("directory");
                dirElement.appendChild(doc.createTextNode(t.toAbsolutePath().toString()));
                dirsElement.appendChild(dirElement);

                // Hier ein Aufruf um alle Dateien im Ordner in dirElement zu hängen
                try {
                    Files.walk(t).filter(Files::isRegularFile).forEach(System.out::println);
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });

Es fehlt natürlich noch die Dateien dem Knoten <Files></Files> hinzufügen. Für dein anliegen brauchst du kein Marshalling.

Grüße
 
Das hat schon mal sehr gut funktioniert - danke nochmal. Ich mußte erstmal noch ein paar Java-Docs lesen, aber ich glaube, daß ich größtenteils verstanden habe, was der Code macht. Jetzt habe ich noch ein paar Anschlußfragen:
  • Wie schaffe ich es, daß der Output "pretty" ist, dh alles mit Zeilenumbrüchen und Einrückungen versehen ist?
  • Wie ermittle ich am besten die Hierarchietiefe, um die Elemente ordnungsgemäß zu verschachteln?
  • Wie kann ich das Erzeugungsdatum, das Datum der letzten Änderung und die Dateigröße ermitteln? Läuft das über BasicFileAttributes?
  • Da ich mit Attributen arbeiten muß: der Funktionsaufruf 'node.setAttribute("size", 1024);' liefert einen Fehler, da setAttribute nur Strings als zweiten Parameter akzeptiert. Ich habe leider keine Funktionsvariante gefunden, die numerische Werte erlaubt, nur boolesche - es kann aber auch gut sein, daß ich zu blind war. 🙂
  • Und noch eine Mini-Frage: Das erste Element sollte nicht das Root-Element sein - soll ich das einfach per "wenn es das erste Element ist, erzeuge kein Element" machen oder gibt es einen eleganteren Weg?
Cheers
Vince
 
Zu 1.
Java:
Transformer transformer = transformerFactory.newTransformer();
transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
transformer.setOutputProperty(OutputKeys.INDENT, "yes");

Zu 2.
Du erhälst ein Path Objekt, damit hast du auch die Möglichkeit den Ausgangsverzeichnis zu bekommen.
Jetzt musst du dir nur eine Logik ausdenken, wie du zu jedem Path ein Element abspeicherst.
Das heißt du erstellst ein Knoten für C:\\Ordner 1\\ und dazu ein Element und speicherst beide Informationen und dann gehst du bei jedem Ordner und Prüfst ob das Ausgangsverzeichnis schon vorhanden ist, und fügst dem Directory->Directoeries->Neues Element hinzu.

Zu 3.
https://docs.oracle.com/javase/tutorial/essential/io/fileAttr.html

Zu 4.
Vergiss setAttribute() und erzeuge für jede Information ein Element.
Java:
<file>
<name></name>
<extenstion></extension>
<last_modified></last_modified>
usw...
</file>

Zu 5.
Meinst du z. B das Element "hierarchy"? Wenn ja, dann lass es weg und fange direkt mit "directories" an.

Grüße
 
Musst du Files.walk() nutzen?
Wesentlich leichter ist es vermutlich, rekursiv selbst durch den Baum zu laufen.
 
@truesoul Vielen Dank für Deine Tips! Ich bin leider jetzt erst dazu gekommen sie umzusetzen, aber es funktioniert alles bestens.

Zu 4.
Vergiss setAttribute() und erzeuge für jede Information ein Element.
Die Defnition des XSD liegt leider nicht in meiner Hand - ich muß mich an die Vorgaben halten. 😉

Musst du Files.walk() nutzen?
Wesentlich leichter ist es vermutlich, rekursiv selbst durch den Baum zu laufen.
Muß ich nicht. Ich hatte irgendwo gelesen, daß Files.walk() schneller und aktuell "state of the art" sei - aber ich erkenne die Probleme, welche die "Nicht-Rekursion" mit sich bringt - es ist definitv eine Überlegung wert und eine weitere schöne Übung.

Vielen Dank für Eure Hilfe - sie hilft mir wirklich sehr beim Einstieg!

Cheers
Vince
 
Ich habe jetzt die iterierende Version hinbekommen - so weit so gut:
Java:
package org.nodez.fetch;

import java.io.File;
import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.regex.Pattern;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Element;

public class Filesystem3 {

  // Constants
  private static final String ROOT_FOLDER = "q:\\project\\nodez\\java";
  private static final String OUTPUT_FILE = "q:\\project\\nodez\\output\\FilesystemTree.xml";
 
  // Variables
  private static Document doc;
  // private static Element parent;
 
  public static void main(String[] args) {
   
    try {
      DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
      DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
      doc = docBuilder.newDocument();
      Element tree = doc.createElement("tree");
      tree.setAttribute("name", ROOT_FOLDER);
      doc.appendChild(tree);
      Path root = Paths.get(ROOT_FOLDER);
      processChildren(tree, root);
      try {
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        Transformer transformer = transformerFactory.newTransformer();
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        DOMSource source = new DOMSource(doc);
        StreamResult result = new StreamResult(new File(OUTPUT_FILE));
        transformer.transform(source, result);
        System.out.println("File saved!");
      } catch (TransformerException e) {
        e.printStackTrace();
      }

    } catch (ParserConfigurationException e) {
      e.printStackTrace();
    }
  }

  private static void processChildren(Element parentElement, Path parentPath) {
    File[] list = parentPath.toFile().listFiles();
    if (list != null) {
      for (File item : list) {
        Element node = doc.createElement("node");
        node.setAttribute("name", item.getName());
        try {
          BasicFileAttributes attributes = Files.readAttributes(parentPath, BasicFileAttributes.class);
          node.setAttribute("created", String.valueOf(attributes.creationTime()));
          node.setAttribute("modified", String.valueOf(attributes.lastModifiedTime()));
          if (item.isDirectory()) {
            parentElement.appendChild(node);
            processChildren(node, Paths.get(item.getAbsolutePath()));
          } else {
            node.setAttribute("size", Long.toString(attributes.size()));
            parentElement.appendChild(node);
          }
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }   
  }

}

Es gibt sicherlich noch gute Ideen, was man hier refactoren könnte - immer her mit den Vorschlägen!
 

Neue Themen


Zurück
Oben