Dynamische Objekte / DB

[najjannaj]

Erstmal Hallo an alle,

ich habe folgendes vor:
Ich möchte dem Benutzer die Möglichkeit bieten sich ein "Klasse" selbst gestalten zu können. Dabei geht es nur darum zum Beispiel zu sagen, ich brauche eine Klasse namens "A" und die hat 3 Variablen, 2 sind mit Text und in eins sollen nur Zahlen reinkommen. Um die Validierung etc. möchte ich mir im ersten Schritt mal noch keine Gedanken machen. Instanzen dieser Klasse sollen später natürlich auch gespeichert werden können, am besten in einer Datenbank.

Zur Frage:
Wie würdet Ihr sowas anpacken? Speziell habe ich noch Probleme mir vorzustellen wie ich aus den Informationen zur Laufzeit eine Klasse erzeuge und mit dieser dann weiterarbeiten kann.

Bin für jeden Tipp sehr Dankbar!
Viele Grüße

 

[Gastredner]

Prinzipiell ließe sich ein solches Verhalten annähernd über eine Map realisieren:

import java.util.Map;
import java.util.HashMap;

/*
 *  Vielleicht sollte man Generics einsetzen, um bei Bedarf nur bestimmte Arten
 *  von Attributen zuzulassen.
 */
public class DynamicClass {

	private Map<String, Object> attributes;

	public DynamicClass() {
		this(new HashMap<String, Object>());
	}

	public DynamicClass(Map<String, Object> attributes) {
		this.attributes = attributes;
	}

	/*
	 * Allround-Methode zum Abfragen.
	 */
	public Object get(String attr) {
		Object value = attributes.get(attr);
		if (value != null) {
		
		} else {
			// Irgendwie behandeln, z. B. mit einer Exception:
			throw new RuntimeException("This class contains no attribute \'" + attr + "\'");
		}
	}

	/*
	 * Eine spezialisierte Methode - eine solche müsste für jeden primitiven Typ geschrieben werden.
	 * Es könnte auch eine Methode konsturiert werden, die Attribute von nicht-primitiven Typen
	 * durch Übergabe des gewünschten Class-Objects direkt zu casten versucht.
	 */
	public int getInt(String attr) {
		Object value = attributes.get(attr);
		if (value != null) {
			try {
				return Integer.parseInt(value);
			} catch (NumberFormatException e) {
				throw new RuntimeException("The attribute \'" + attr + "\' is no integer-type attribute!");
			}
		} else {
			throw new RuntimeException("This class contains no attribute \'" + attr + "\'");
		}
	}

	public void set(String attr, Object value) {
		if (attributes.keySet().contains(attr)) {
			attributes.put(attr, value);
		} else {
			// Irgendwie behandeln.
			throw new RuntimeException("This class contains no attribute \'" + attr + "\'");
		}
	}

	public void createAttribute(String name, Object initialValue) {
		if (!attributes.keySet().contains(attr)) {
			attributes.put(attr, value);
		} else {
			// Irgendwie behandeln.
			throw new RuntimeException("This class contains already contains an attribute \'" + attr + "\'");
		}
	}
}

Ungetestet und sehr primitiv, aber es sollte halbwegs laufen.
Allerdings frage ich mich, ob dieses Vorgehen sinnvoll ist. Zumindest unter Java wage ich es zu bezweifeln. Python bzw. Jython könnte dir helfen, wenn du Klassen unbedingt zur Laufzeit definieren musst:

>>> class Empty(object):
...         def __init__(self):
...                 pass
... 
>>> def func(x, y):
...         return x + y
... 
>>> a = 5
>>> no_more_empty = Empty()
>>> setattr(no_more_empty, "a", a)
>>> setattr(no_more_empty, "func", func)
>>> print no_more_empty.a
5
>>> print no_more_empty.func(no_more_empty.a, 10)
15

Das Beispiel stammt aus der interaktiven Jython-Konsole. Alles, was mit >>> oder ... beginnt, sind Benutzereingaben. Zeilen ohne führende Zeichen sind Ausgaben des Codes.

 

[najjannaj]

Im Prinzip ist die Idee glaub ich besser als mein Klassenerzeugen zur Laufzeit...

Um einen genauern Überblick zu geben was ich ungefähr damit vorhab, habe ich mir ein passendes Beispiel ausgedacht:

Man möchte zum Beispiel sich eine private Datenbank anlegen für Vokabeln. Ohne Abfrage oder Lernmodus oder sowas.. einfach das anlegen.. Nun kann man hingehen und zum Beispiel in Excel eine Tabelle wie folgt aufbaun:

| Deutsch | English | Spanisch |
| Hallo | Hello | Hola |

oder man hat mehr Ahnung von Computern und legt sich eine solche Datenbank in Access an und bastelt eine Oberfläche dazu um die Eingabe sehr leicht zu gestalten. Dieses Verhalten soll nun automatisch durch das Java-Programm generiert werden. Dazu sagt man am Anfang das man für dieses Beispiel folgende drei Felder benötigt:

1. Feld
Name = Deutsch
Eigenschaft = Text mit maximal 255 Zeichen

2. Feld
Name = English
Eigenschaft = Text mit maximal 255 Zeichen

3. Feld
Name = Spanisch
Eigenschaft = Text mit maximal 255 Zeichen

in diesem Beispiel natürlich recht Simpel. Aus dieser eingegebenen Definition soll Java anschließend ein "Model" erzeugen und dieses Model in einer Datenbank speichern. Aus dem Model erzeugt sich Java dann eine Benutzereingabemaske um die Daten einzugeben. So ungefähr kann man sich das Ziel vorstellen.

Aber ich denke das liese sich mit der Map ganz gut abbilden. Gibts dennoch weitere Vorschläge?

 

[najjannaj]

Hat niemand mehr eine Idee?
Wäre echt sehr dankbar!
Viele Grüße
Najjannaj

 

[Der Müde Joe]

Nimm doch einfach ein
ResourceBundle (Java Platform SE 6)

Ein Deutsch Bundle eines für Spanisch, und und. Oder hab ich jetzt was komplett falsch verstanden?
Je nach dem was man brauch lädt man das entsprechende Language File.

 

[SlaterB]

die Frage ist ziemlich allgemein, falls man überhaupt eine identifizieren kann,

zur DynamicClass würde ich noch ein DynamicAttribut mit Name, Datentyp, Wert vorschlagen,
dann tut es auch eine Liste der DynamicAttribut statt Map,

in der Datenbank entweder genauso allgemein eine Tabelle für Einträge + eine für Attribute, die einem Eintrag zugeordnet sind,
oder, falls es nur wenige der dynamischen Klassen in Java gibt, dann diese benennen und dynamisch eine zugehörige typechte DB-Tabelle anlegen,
sofern zur Laufzeit CREATE-SQL usw. möglich ist

wirklich neues ist das nicht dabei, aber du hast es ja auch schon weitgehend, so einfach bearbeiten und bei echten Problemen konkrete Fragen stellen