XML schreiben - lesen

[Andi_CH]

JA ich weiss - DOM, SAX ... aber der Unterschied ist mir nicht klar, aber die eigentliche Frage.

Gibt es irgendwo oder hat irgendwer ein KSKB in dem eine Datei geschrieben und wieder gelesen wird?
Ich habe bis jetzt nur Codeschnipsel gefundne, die ich nicht so richtig zusammenbauen kann.

Der Grund: (vielleicht haltet ihr XML nicht für den richtigen Ansatz, auch wenn ich das mal üben möchte)

Ich möchte userspezifische Einstellungen speichern und lesen.
Ein Eintrag besteht aus einen Keyword und 1 - mehreren Werten (abhängig vom Keyword)

z.B.
debug false
cam IP-Cam1 192.168.1.43 0 urlpat1
cam IP-Cam2 192.168.1.45 0 urlpat1

Wobei es (z.B. bei Windowspfadangaben) auch vorkommen kann, dass ' ' drin sind, aber genau das ist ja bei xml das kleinere Problem als bei Textdateien

Die Dateien sind klein (ich schätze mal ~10 Einträge)
Das zeitliche Verhalten ist unkritisch (wenns in <1 Sekunde fertig ist ... )

 

[bygones]

ganz ehrlich - deine Ambitionen in allen Ehren, aber XML ist einfach ein besch*** sache in Java. Es ist ein horrender Aufwand der im gegensatz zu kleinen files wie du sie hast meiner Ansicht nach in keiner Relation steht.

Die APIs, seien es DOM oder SAX sind meiner Ansicht nach unhandlich und voller boilerplate code.

daher find ich es irgendwie ironisch von einem KSKB zu sprechen...

naja - gibt bestimmt den einen oder anderen hier, der andere Meinung ist und dann auch etwas Code posten wird.

Mein Rat - such dir ein anderes Format - JSON, YAML oder was auch immer

 

[SlaterB]

was spricht denn z.B. gegen Suche 'xml schreiben beispiel java'
und dann etwa Ergebnis
Javakochbuch - Kapitel 21: XML
?

 

[Marcinek]

JA ich weiss - DOM, SAX ... aber der Unterschied ist mir nicht klar, aber die eigentliche Frage.

Gibt es irgendwo oder hat irgendwer ein KSKB in dem eine Datei geschrieben und wieder gelesen wird?
Ich habe bis jetzt nur Codeschnipsel gefundne, die ich nicht so richtig zusammenbauen kann.

Andy ich denke du hast genügend Erfahrung um so ein Codeschnipsel zu finden oder? - Jeder liest XML Dateien.

Zeig mal so ein Codeschnipsel und dann kann mir dir helfen das zu verstehen.

---

Der Unterschied SAX und DOM ist, dass du bei DOM die GANZE Datei in den Speicher liest und dann darauf arbeitest, und bei SAX beim lesen diese bearbeitest

---

Die Dateien sind klein (ich schätze mal ~10 Einträge)
Das zeitliche Verhalten ist unkritisch (wenns in <1 Sekunde fertig ist ... )

[

Schau dir mal XStram an aber das ist für deine Anforderung schon oversized.
Eventuell mal XML Propertie Reader suchen?

 

[Andi_CH]

6 Links habe ich schon angeschaut und bin am Ausprobieren - na ja

"XML Propertie Reader" versuche ich gleich mal, Danke.

 

[maki]

ganz ehrlich - deine Ambitionen in allen Ehren, aber XML ist einfach ein besch*** sache in Java. Es ist ein horrender Aufwand der im gegensatz zu kleinen files wie du sie hast meiner Ansicht nach in keiner Relation steht.

Hehehe... so schreibt nur jemand der XML Dateien in Groovy gelesen/geschrieben hat
Danach kommt einem die XML Verarbeitung in Java erst recht umständlich vor.

 

[bygones]

Hehehe... so schreibt nur jemand der XML Dateien in Groovy gelesen/geschrieben hat
Danach kommt einem die XML Verarbeitung in Java erst recht umständlich vor.

mhm richtig - vorher kaeme man nicht auf die Idee dass sowas

public class StaxWriter {
	private String configFile;

	public void setFile(String configFile) {
		this.configFile = configFile;
	}

	public void saveConfig() throws Exception {
		// Create a XMLOutputFactory
		XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
		// Create XMLEventWriter
		XMLEventWriter eventWriter = outputFactory
				.createXMLEventWriter(new FileOutputStream(configFile));
		// Create a EventFactory
		XMLEventFactory eventFactory = XMLEventFactory.newInstance();
		XMLEvent end = eventFactory.createDTD("\n");
		// Create and write Start Tag
		StartDocument startDocument = eventFactory.createStartDocument();
		eventWriter.add(startDocument);

		// Create config open tag
		StartElement configStartElement = eventFactory.createStartElement("",
				"", "config");
		eventWriter.add(configStartElement);
		eventWriter.add(end);
		// Write the different nodes
		createNode(eventWriter, "mode", "1");
		createNode(eventWriter, "unit", "901");
		createNode(eventWriter, "current", "0");
		createNode(eventWriter, "interactive", "0");

		eventWriter.add(eventFactory.createEndElement("", "", "config"));
		eventWriter.add(end);
		eventWriter.add(eventFactory.createEndDocument());
		eventWriter.close();
	}

	private void createNode(XMLEventWriter eventWriter, String name,
			String value) throws XMLStreamException {

		XMLEventFactory eventFactory = XMLEventFactory.newInstance();
		XMLEvent end = eventFactory.createDTD("\n");
		XMLEvent tab = eventFactory.createDTD("\t");
		// Create Start node
		StartElement sElement = eventFactory.createStartElement("", "", name);
		eventWriter.add(tab);
		eventWriter.add(sElement);
		// Create Content
		Characters characters = eventFactory.createCharacters(value);
		eventWriter.add(characters);
		// Create End node
		EndElement eElement = eventFactory.createEndElement("", "", name);
		eventWriter.add(eElement);
		eventWriter.add(end);

	}
}

intuitiv ist, um

<?xml version="1.0" encoding="UTF-8"?>
<config>
	<mode>1</mode>
	<unit>900</unit>
	<current>1</current>
	<interactive>1</interactive>
</config>

zu schreiben.... (geklaut von Java and XML - Tutorial).

Es mag besseren code geben bzw neue libs.

 

[SlaterB]

> bzw neue libs.
wie bei Checked Exceptions und anderen Dingen verstehe ich nicht die so fundamentalen Probleme mit Standard-Interfacen,
das kann man doch alles in Basisklassen verstecken und dann von

main {
  XML.write(zeile1,zeile2,zeile3); // Strings
}

bis zu

main {
  XMLBuilder.xmlStart("1.0").openTag("config").entry("mode","1"). ..
}

beliebiges selber bauen

----

der wesentliche Bestandteil des geposteten Codes,

        createNode(eventWriter, "mode", "1");
        createNode(eventWriter, "unit", "901");
        createNode(eventWriter, "current", "0");
        createNode(eventWriter, "interactive", "0");

kommt dem ja auch schon nahe, das meiste drumherum ist nur Blahblah, kann man verstecken,
aber man hat eben die Möglichkeit, Konfigurationen anzugeben

 

[maki]

@bygones
Fieser Trick hier StAX als Beispiel zu nehmen
IMHO ist JDom einfache als StAX, kommt aber trotzdem nicht an Groovy ran.

 

[Andi_CH]

Den geposteten Code werde ich jetzt mal anschauen - dank dem Keyword-Tipp gefunden:
(Also wenn das kein KSKB ist ;-) )

Wie handle ich das, dass es mehrere Cams geben kann? Anzahl nicht bekannt.

www.kodejava.org/examples/267.html und www.kodejava.org/examples/267.html

import java.io.File;
import java.io.FileOutputStream;
import java.util.Properties;

public class PropertiesToXml {

	private final static String filename = "configuration.xml";

	public static void main(String[] args) throws Exception {
		Properties properties = new Properties();
		properties.setProperty("database.type", "mysql");
		properties.setProperty("database.url", "jdbc:mysql://localhost/mydb");
		properties.setProperty("database.username", "root");
		properties.setProperty("database.password", "root");
		properties.setProperty("data.folder", "data/folder");
		properties.setProperty("jdbc.url", "jdbcUrl");
		properties.setProperty("oben", "test");
		FileOutputStream fos = new FileOutputStream(filename);
		properties.storeToXML(fos, "test_configuration", "UTF-8");
		File f = new File(filename);
		System.out.println(f.getAbsolutePath());
		System.out.println(f.getCanonicalPath());
	}
}

import java.io.FileInputStream;
import java.util.Properties;

public class LoadXmlProperties {
	
	private final static String filename = "configuration";

	public static void main(String[] args) {
		LoadXmlProperties lxp = new LoadXmlProperties();
		try {
			Properties properties = lxp.readProperties();
			/*
			 * Display all properties information
			 */
			properties.list(System.out);

			/*
			 * Read the value of data.folder and jdbc.url configuration
			 */
			System.out.println(properties.getProperty("database.type"));
			System.out.println("data.Folder = " + properties.getProperty("data.folder"));
			System.out.println("url.jdbcUrl = " + properties.getProperty("jdbc.url"));
			System.out.println("oben        = " + properties.getProperty("oben"));
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

 

[bygones]

@bygones
Fieser Trick hier StAX als Beispiel zu nehmen
IMHO ist JDom einfache als StAX, kommt aber trotzdem nicht an Groovy ran.

hehe - ertappt ;-)

@Slater
klar kann man selber aus den ganzen wirren libs da draussen seine eigene sauberer erstellen - aber warum muss ich mich auch noch darum kuemmern den Dreck von anderen aufzuraeumen. Mag jemand anders sein natuerlich. Aber ich bleibe dabei, was man unter dem Deckmantel von XML in Java so geschaffen hat, da grauts einem... API design mal komplett ignoriert etc.

 

[SlaterB]

vielleicht habe ich einfach nur noch keine guten APIs gesehen bzw. habe immer eigene abweichende Vorstellungen,
egal ob FileStreams, komplexe GUI-Layouts, JFreeChart, Calendar auf welches natürlich sowieso schon genug eingehauen wird,
alles gehört mit Hilfsklassen ausgestattet

 

[bygones]

ich werde jetzt nicht anfangen groovy bsp zu posten um zu zeigen, dass es freundliche apis gibt, das wuerde einfach zu einer unnuetzigen Diskussion fuehren.

Es spricht auch nix gegen kleine Hilfsklassen die eine API an seine Fragestellung adaptiert, aber die Frage ist wie simpel, einfach diese API zu nutzen und wie schwer sie miss zu verstehen.

Und XML apis sind nun mal das parate bsp (ua mit Calendar ;-) ) die furchtbar in die Hose gegangen sind. Wenn man mir nicht glaubt, so kann man sich einen Vortrag von J. Bloch anschauen (How To Design A Good API and Why it Matters - YouTube) anschauen - dort zeigt er u.a. diese Java Klassen bzw Apis (und andere weitere)

 

[Andi_CH]

Kann ich in Properties wirklich keine Struktur bauen?
"Cam" und darunter eine Aufzählung die ich dann als iterierbare Datenstruktur abrufen kann?

 

[SlaterB]

das ist der Preis für den einfachen Zugriff

 

[bygones]

Kann ich in Properties wirklich keine Struktur bauen?
"Cam" und darunter eine Aufzählung die ich dann als iterierbare Datenstruktur abrufen kann?

du kannst bei properties nur eine aufzaehlung anfuehren, die du selber dann ausliest - ala

key = value1,value2,value3

String values = property.getProperty("key");
String[] v = values.split(",");

aber die Ausdrucksfaehigkeit von Properties ist enorm eingeschraenkt - dafuer eben wie Slater sagt, enorm leichter Zugriff

 

[Andi_CH]

Das da finde ich gar nicht so schlecht.

Anstelle von Proberties selbst parsen - warum nicht. Die 3 "Dates" werden einfach meine Cams ;-)

Danke für euren Einsatz!

Das Schreiben eines entsprechenden XML-Files bin ich noch am üben ;-)

 

[Spacerat]

Ob's schon jemandem aufgefallen ist, dass XML eigentlich schon eine eigene Sprache ist? Ich denke mal ja. Zwar keine Programmiersprache aber zumindest eine, mit der man Dokument-Typen (ähnlich SGML, hätt' ich fast gesagt :lol beschreiben kann. Nun stellt sich eigentlich nur die Frage, will man XML-Dateien eines speziellen (z.B. ODF-Dateiformat oder ähnliches), eines eigenen oder gar eines unbestimmten Typs lesen bzw. schreiben? Trivial ist logischerweise nichts bzw. nur sehr wenig davon.

 

[maki]

@Sapcerat
XML ist nunmal eine Sprache um Sprachen zu definieren, u.a. auch "Programmiersprachen" bzw. DSLs, siehe Ant "Scripte".

 

[Spacerat]

[OT]@maki: Sicher nur Sprachen? Sicher nicht... Die Extensible Markuplanguage, welche aus der Standard Generalized Markup Language hervorgeht, kann definitiv mehr als nur Build-Abläufe für andere Sprachen strukturieren. Sieh' dir z.B. nur mal das Open Document Format an. XML findet man heute überall... HTML4+, C4DXML und was weis ich noch wo.[/OT]