Schema --> GUI (User) --> XML

[Thomas82]

Hallo,
ich habe folgendes Problem / Wunsch: Ich möchte verschiedene Schema Dateien einlesen, aus diesen Informationen eine Oberfläche mit Textfeldern, Comboxen etc. zur Eingabe basteln und die Eingaben in eine zu dem Schema passende xml-Datei schreiben.
Bisher habe ich mit JAXB und einem Schema für Schemas, meine Schema Dateien eingelesen, jedoch weiß ich nicht, wie ich nach dem Unmarshelling an alle Elemente+Attribute, die in meinen Schema Dateien angegeben sind, komme?
Im Klartext wie komme ich am geschicktesten an die Informationen aus meinen Schema Dateien zur Erstellung der GUI? Langsam denke ich, dass ich statt JAXB besser JDOM verwenden sollte, oder?
Hat jemand eine gute Idee?

Vielen Dank
Thomas

 

[pinhead84]

Hallo Thomas,

zwei Lösungsansätze sehe ich spontan für dein Problem:

(a) Eine XSD-Datei ist auch nichts anderes als ein XML-Dokument. Warum nimmst nicht einfach einen XML-Parser deiner Wahl und liest dein XSD-Schema dynamisch aus? - Bei dieser Lösung wäre es ratsam, nicht alle XSD-Spielereien des Standards zu verwenden, sondern sich auf Grundlegendes zu beschränken. (z.B. keine Vererbungen)

(b) Du verwendest die Reflections-API von Java auf den dynamisch erzeugten JAXB-Klassen. Auf diesem Wege kannst du dir alle Attribute, die zugehörigen getter- und setter-Methoden dynamisch ermitteln & Instanzen erzeugen.

Beide Lösungsansätze haben ihre Vor- & Nachteile. Variante (a) kenne ich von OpenCms, Variante (b) findet man in Netbeans/Eclipse zu Hauf.

Vielleicht gibt es noch andere Lösungen, die direkt von JAXB2 geliefert werden. Damit kenne ich mich aber nicht gut genug aus.

Langsam denke ich, dass ich statt JAXB besser JDOM verwenden sollte, oder?

Wenn du am Ende der Kette ein XML-Dokument haben willst, ist JAXB meiner Meinung nach schon ein guter Lösungsansatz. Wie sagte der dicke Kanzler: 'Wichtig ist was hinten rauskommt'.

 

[Wildcard]

Ich würde zu EMF greifen. Du kannst dir entweder mit EMF ein laufzeit Modell aus deiner XSD erstellen lassen, oder du nimmst das XSD Modell (ein fertiges, mit EMF erstelltes Datenmodell) um den Inhalt der XSD zu verarbeiten.

 

[Thomas82]

Erstmal vielen Dank für die Antworten.
Ich würde schon gern JAXB verwenden, jedoch würde ich gern wissen, wie ich durch den kompletten XML Baum "wandern" kann. Ähnlich wie es in JDOM der Fall ist.
Oder ist es sinnvoll eine Kombination aus (J)DOM und JAXB zu verwenden? Also mit JDOM den Baum durchgehen und mit JAXB die jeweiligen Elemente unmarshalln?

 

[pinhead84]

Ich würde schon gern JAXB verwenden, jedoch würde ich gern wissen, wie ich durch den kompletten XML Baum "wandern" kann. Ähnlich wie es in JDOM der Fall ist.

Durch welchen Baum willst du denn gehen?

(a) Durch den XML-Baum deines Schemas (sollte mit JDOM funktionieren, ist aber aufwändig)
oder
(b) durch den XML-Baum des zu erzeugenden JAXB-Objektes (sollte mit JDOM/JAXB wohl nicht funktionieren)

Meines Erachtens ist es einfacher die Reflections-API zu verwenden. Dann musst du nicht mittels JDOM selbst dein Schema interpretieren, sondern kannst direkt mit dem JAXB-Objekten arbeiten, die du ja letztendlich auch instanziieren und exportieren willst.

Das von 'Wildcard' empfohlene EMF kenne ich selbst nicht, schaut aber auch vielversprechend aus, siehe z.B. hier.

 

[CoderJohannes]

Hi Thomas!
Ich mache gerade genau das - generiere Flex-UIs aus Schemata mit JAXB. Konkret habe ich ein Plugin für XJC geschrieben. Wie das geht, steht hier: http://weblogs.java.net/blog/kohsuke/archive/2005/06/writing_a_plugi.html
Innerhalb der run-Methode des Plugins bekommt man dann das geparste Schema inkl. evtl. importierter Schemata über model.getModel().schemaComponent. Die JAXB/XJC-Javadoc findet sich hier: https://jaxb-architecture-document.dev.java.net/nonav/doc/?jaxb/package-summary.html
Die so ausgelesenen Schemata liegen dann in XSOM vor. Mit etwas Lesen in der Javadoc (https://xsom.dev.java.net/nonav/javadoc/index.html) und dem Architektur-Diagramm (http://www.w3.org/TR/xmlschema-1/components.gif) findet man sich hierin ganz gut zurecht.
Das so vorliegende Schema kann man dann mittels Visitor-Pattern durchlaufen. Ich habe eine XSOMWalker-Klasse geschrieben, die für alle für mich interessanten Schemakomponenten eine Visitor-, eine ProcessPre- und eine ProcessPost-Methode enthält (diese "Visitor"-Klassen sind nicht wirklich Visitors im Sinne des GOF-Patterns, aber mir ist kein besserer Name eingefallen). Meine ElementDeclaration-Visitor-Methode sieht z.B. so aus:

public final void elementDecl(XSElementDecl decl, XSComponent parent)
	{
		processElementDeclPre(decl, parent);
		if (decl.getType().isSimpleType())
		// value
		{
			processElementDeclSimpleTypePre(decl, parent);
			simpleType(decl.getType().asSimpleType(), decl);
			processElementDeclSimpleTypePost(decl, parent);
		}
		else
		// group of values
		{
			processElementDeclComplexTypePre(decl, parent);
			complexType(decl.getType().asComplexType());
			processElementDeclComplexTypePost(decl, parent);
		}
	}

Die process...-Methoden dieser Klasse sind leer:

protected void processElementDeclComplexTypePre(XSElementDecl decl, XSComponent parent)
{
}

Wenn man nun eine Unterklasse dieser Walker-Klasse schreibt, muss man nur noch die process-Methoden überschreiben und hier den Generierungscode für die bearbeiteten Schemakomponenten einfügen. Wie das praktisch für Flex-UIs machbar ist, habe ich übrigens hier beschrieben: http://blog.ubigrate.com/2008/11/25/creating-flex-uis-in-java-a-short-tutorial/
Eine kleine EInführung in XJC gibt es hier: http://blog.ubigrate.com/2008/05/12/neues-von-jaxb/
Hilft das soweit weiter?
Grüße, Johannes