[JAVA] XML

[Dunedain]

Hallo Leute.

Stehe gerade vor einem XML Problem. Ich habe ein String Array mit einer unbekannten Anzahl von Elementen, und möchte diese nun unter dem RootNode dynamisch erzeugen.

Code:

String[] elements = { "eine" , "unbekannte" , "element" , "anzahl" };

aus diesem Array soll nun folgendes erstellt werden:

XML-Code:

<root>
  <eine>
    <unbekannte>
      <element>
        <anzahl/>
      </element>
    </unbekannte>
  </eine>
</root>

Des weiteren ist es möglich, dass ein Knoten mehrmals benutzt wird.
Also muss ein möglicherweise schon bestehender Knoten "gefunden" werden...

Code:

Strings[] elements2 = { "eine" , "andere" , "element" , "anzahl" };

Wofür das ganze?
Ich schreibe mir gerade eine eigene Properties Klasse, damit ich Daten strukturierter speichern kann. Soll später so ähnlich aussehen wie die JvXmlAppStorage der JEDIs (hofffe, hab den Namen richtig in Erinnerung...)

Hab schon ein bischen rumprobiert, aber ich hab auf DOM Ebene noch nicht mit XML gearbeitet.
Also bitte nicht schlagen, wenn die Lösung allzu simpel ist^^

[yankee]

Also wenn du grundätzlich nur eine Datei in den ram in arrays laden willst um sie später wieder zu speichern solltest du darüber nachdenken, ob xml die richtige Entscheidung ist ^^.
JSON wäre da viel schneller, hat deutlich weniger overhead undlibs für Java gib' it auch genug: www.json.org

Wenn du trotzdem unbedingt xml verwenden willst, dann könntest du einfach in deinen strings mit string replace alle < durch &lt; alle > durch &gt; und alle & durch &amp; ersetzen und dann noch die xml-tags drumrumhauen und du hast deine xml-datei sehr schnell generiert.

So... jetzt werde ich leider gerade zum Frühstück gerufen^^.

EDIT: so, da bin ich wieder.
Zum auslesen kannst du dann SAX (http://www.saxproject.org/) nehmen. Das dürfte die performanteste Lösung sein...

[Dunedain]

Nein, ich will nicht nur ein paar Arrays abspeichern^^

Was ich möchte, ist eine strukturierte Möglichkeit, Daten abzuspeichern, zum Beispiel Fensterpositionen und andere Sachen.
Geht natürlich auch mit den Standard Properties, aber leider bieten diese mir nicht die Möglichkeit, eine Struktur in die Ausgabe zu bringen.


Prototyp: writeInteger( String Key, Integer Value );
Beispiel: writeInteger( "window.position.left", 100 );
Beispiel: writeInteger( "window.position.top", 100 );

Die oben getätigten Eingaben sollten nun beim speichern der Einstellungen einen solchen output erzeugen:

XML-Code:

<root>
  <window>
    <position>
      <left type="integer">100</left>
      <top type="integer">100</top>
    </position>
  </window>
</root>

--> Der Key wird durch "." geteilt, (das im ersten Post angesprochene String Array), welches wiederum die Unterknoten definiert.
--> Das Type Attribut ist nur ne Hilfestellung für menschliche Leser, um den erwarteten Datentyp anzuzeigen

Dazu sollte vielleicht noch gesagt werden, dass nicht jeder Aufruf der write Funktionen etwas in die Ausgabedatei schreibt, sondern diese Werte werden zuerst in eine Liste (Hashtable like) geschrieben und beim Aufruf der Speicherfunktion dann in die Datei ausgelagert. (und genau da liegt mein Problem...)

Ob XML dafür die optimale Lösung ist, weiß ich nicht, aber möglich ist es auf jeden Fall^^

[yankee]

Zitat von Dunedain:

Dazu sollte vielleicht noch gesagt werden, dass nicht jeder Aufruf der write Funktionen etwas in die Ausgabedatei schreibt, sondern diese Werte werden zuerst in eine Liste (Hashtable like) geschrieben und beim Aufruf der Speicherfunktion dann in die Datei ausgelagert. (und genau da liegt mein Problem...)

Das musst du mir genauer erklären?
Heisst das, du hast eine Liste, die dann so aussieht:
[
["window.position.left",100],
["window.position.top",100],
...
]


Nun... Das musst du auseinander nehmen. Oder eine API finden, die das für dich machen, aber irgendwer muss es auseinander nehmen...

[Dunedain]

Genau!

Die ArrayList enthält StorageItem Objekte, die durch die write... Funktionen erzeugt werden.
Das StorageItem Objekt enthält 3 Eigenschaften:

Code:

String Key
String Type
Object Value

Das StorageItem Objekt, welches bei dem oben genannten Beispiel erzeugt würde, würde dann so aussehen:

Code:

Key=window.position.left
Type=integer
Value=100

Beim speichern der ArrayList werden dann die einzelnen Elemente durchlaufen.

Code:

 public void saveToFile (
        String FileName )
{
    
    try
    {
        
        /* Dokument erstellen */
        Document doc = domBuilder.newDocument ();
        
        /* Root Knoten erstellen */
        Element rootNode = doc.createElement ( RootNode );
        doc.appendChild ( rootNode );


        String[] elements;
        // Data ist die ArrayList...
        for( int i = 0 ; i < Data.size() ; i++ )
        {

            elements = Data.get(i).getKey.split("\\.");

            // Hier liegt das Problem. Das elements Array enthält jetzt die
            // zu erstellenden Knoten.
            // Aber wie erstelle ich jetzt die einzelnen Knoten und deren Unterknoten,
            // Bzw. prüfe auf die Existenz eines Knotens???

        }

        
        /* Speichern */
        TransformerFactory tranFactory = TransformerFactory.newInstance ();
        Transformer aTransformer = tranFactory.newTransformer ();
        
        Source src = new DOMSource ( doc );
        Result dest = new StreamResult ( new File ( FileName ) );
        aTransformer.transform ( src, dest );
        
    }
    catch(Exception e)
    {
        System.err.println (e.toString ());
    }
    
}

Das Problem ist nicht technischer, sondern geistiger Natur. Ich weiß zwar, wie ich einen einzelnen Knoten erstelle (-->RootNode), aber nicht, wie ich in möglichst wenig Schritten neue Knoten und deren Unterknoten erstellen kann.

[yankee]

Also unmöglich ist das sicherlich nicht, aber performancetechnisch keine gute Idee und ich frage mich grundsätzlich wieso du das so machst und überhaupt.

Es wäre viel leichter, du würdest deine Liste so organisieren:

Code:

[
  {
    "name":"window",
    "wert":
    [
      {
        "name":"position",
        "wert":
        [
          {
            "name":"left",
            "wert":100
          },
          {
            "name":"top",
            "wert":100
          }
        ]
      }
    ]
  }
]

durch die Struktur kannst da dann nämlich rekursiv durchgehen und alles in xml speichern.
Es würde auch schon helfen, wenn du deine Liste zumindest nach den Keys sortierst...

[Dunedain]

Die von dir beschriebene Listenstruktur ist ja identisch mit der, die ich für der XML Datei skizziert habe. Dazu müsste ich ja noch nicht mal viel geändert werden. Könnte dann so oder so ähnlich aussehen?

Code:

key=window
type=container
value=ArrayList<StorageItem> { position }

key=position
type=container
value=ArrayList<StorageItem> { left }

key=left
type=integer
value=100

Oder müsste ich an den entsprechenden Stellen ne neue Liste anstelle eines StorageItems einhängen?

Hab jetzt die Liste so wie von dir beschrieben implementiert, zusätzlich noch um Beschreibungs- und Datentypfelder erweitert. Lesen und schreiben der Werte funzt, nur mit Export (bzw. dann auch später Import) über XML tue ich mich irgendwie sehr schwer.

Vielleicht darf ich nochmal um Hilfe bitten?

[Dunedain]

Ne Woche vorbei, und keiner weiß Rat?

Ich versuche nach wie vor, die vorgestellte Listenstruktur in ein JDOM XML Dokument zu packen, wobei jeder Eintrag in der Liste ein eigenes XML Element sein soll.
Wie schon weiter oben erwähnt, ginge das, zumindest theoretisch, durch eine Funktion die die Liste durchläuft, und die Elemente in das Root Element einhängt.
Hab zwar durch das ausprobieren momentan keine funktionierende Version mehr, aber das einzigeste, was ich zu Stande bekommen habe, ist, dass die einzelnen Elemente direkt in das Root Element eingehängt wurden, und nicht wie beabsichtigt, als Unterknoten.

Vielleicht kann mir jemand mit ein "bischen" (je nach dem wie viel das ist -_-) Code aushelfen?
Danke

[yankee]

Das sah doch eigentlich schon ganz gut aus, was du da geschrieben hast...

Jede StorageItem hat einen key, ein typ und ein value.
Du solltest vielleicht subnodes von value trennen.
Mal schnell Quick&Dirty zusammengehauen:

Code:

class StorageItem
{
  public String key;
  public String value;
  public String type;
  public ArrayListe<StorageItem> subnodes;
  public String xmlFormat(String s)
  {
    return s.replaceAll('&','&amp;').replaceAll('<','&lt;').replaceAll('>','&gt;');
  }
  public String toString()
  {
    String result ="<"+this.xmlFormat(key)+">";
    for(int i=0; i<subnodes.length; i++) result +=subnodes.get(i).toString();
    result +=this.xmlFormat(value) + "</"+ this.xmlFormat(key) + ">";
  }
}

Du nimmst wahrscheinlich eher einen StringBuilder als einen String in toString, um die Performance zu verbessern und musst noch was einbauen, damit der qt schön formatiert wird und nicht in einer Zeile hintereinander weg ausgegeben wird.
Aber so rein von der Theorie müsste das so klappen...
Oder gibt es damit noch ein Problem?

[Dunedain]

Danke für die schnelle Antwort.

Hab die Idee, SubNodes von Value zu trennen einfach mal übernommen.
Deine Ausgabemethode funktioniert (nach einigen Änderungen^^) auch, ist jedoch nicht ganz das, was ich wollte. Ich wollte (muss?) das ganze über nen DOM|JDOM regeln, da ich die Daten ja auch wieder einlesen können muss. Und genau da liegt mein Problem.

Dabei spielt die Form der Ausgabe, ob über eine XML Schnittstelle oder so wie du es vorgeschlagen hast, über einen String ja keine Rolle, sofern gültiges XML produziert wird.

Ich werd einfach nochmal ein bischen rum tüfteln, vielleicht krieg ich das ja irgendwie mit deinem Funktionsansatz hin...