MySQL Many to Many Tabellen in Java abbilden?

[DefconDev]

Hallo zusammen,

Ich habe ungefähr eine solche Struktur.

Tabellen:
Hauptverzweigung

X one to many --> Y

Y many to many --> Z

Z one to many --> A

A many to many --> B

Nebenverzweigung

Y one to one --> S

Z one to one --> P

A one to one --> D

Wenn ich das 1:1 in Java als Klassen abbilde, wird es spätestens ab der dritten Dimension(Z), wenn man bei X anfängt extrem unübersichtlich.

Abhelfen soll da ORM bzw. Frameworks wie Hibernate/Spring auf Basis von JPA. Sollte ich das alles richtig verstanden habe, das Thema ist absolutes Neuland. Hatte bisher nur simple Datenbanken programmiert, da war so etwas überdimensioniert. Die ersten Tutorials die ich mir ansah waren auch sehr interessant, nur stelle ich mir auch hier die Frage ob Hibernate/Spring überhaupt nötig ist? Bzw. übersehe ich etwas oder gehe ich das Problem komplett falsch an.

 

[kneitzel]

Also generell nötig ist Hibernate/Spring nicht. Eine einfache Ebene um Daten zu laden und zu speichern (halt ein Data Layer) muss nicht komplex sein. Was für ein Problem mit der Abbildung hast Du denn?
Bei der Abbildung von "to many" hast Du dann unter dem Strich einfach ein Array mit den Elementen.

Was hier aber natürlich Sinn machen kann ist ein "lazy load". Du lädst Dinge also nur, wenn Du diese wirklich brauchst und ggf. auch nur das, was Du wirklich benötigst.

Also wenn Du eine Instanz von A lädst, dann lädst Du nicht die ganzen B, auf die Du verweist. Das wird dann erst nachgeladen, wenn Du es wirklich benötigst. Wenn Du nun eine typische Gui hast, dann hast Du evtl. ein Fenster, dass ein A Element anzeigt mit einer Liste von allen B Objekten. Aber da interessieren dich (hoffentlich) nicht bei jedem B Element die Liste von allen A Elementen, zu denen das verlinkt ist.

So ein Data Layer ist im übrigen extrem einfach und schnell geschrieben. Wir haben auf Arbeit auch erst Frameworks benutzt, aber der Overhead war dann unter dem Strich höher als das schnelle "eintippen" eines Data Layer. Und die Komplexität der ganzen Lösung wurde dadurch deutlich reduziert.

 

[stg]

Wenn ich das 1:1 in Java als Klassen abbilde, wird es spätestens ab der dritten Dimension(Z), wenn man bei X anfängt extrem unübersichtlich.
Abhelfen soll da ORM bzw. Frameworks wie Hibernate/Spring auf Basis von JPA.

Die Java-Klassen für die Datenhaltung in der Anwendung brauchst du trotz, oder gerade mit ORM Frameworks sowieso. In der Regel erzeugst du durch die Verwendung also eher overhead, wie kneitzel schon schreibt, denn damit deine Anwendung später nicht von der Struktur der Datenbank abhängig ist, wird hier oft noch ein zusätzliches DTO Layer zwischengeschoben.
JPA untersützt dich beim Mapping, beim Datenzugriff usw. aber um die anschließende Verwaltung der Beziehungen der einzelnen Entity-Klassen musst du dich z.B. hinterher trotzdem selbst kümmern. Dein Data Layer wird jeenfalls dadurch nicht weniger komplex, falls du dir das erhoffst?

Also schildere doch biite zunächstmal, was dir da unübersichtlich erscheint!

 

[AndiE]

Ich finde, ein gutes Beispiel zum Verständnis ist Kunde-Rechnung-Artikel. Dabei ist Kunde zu Rechnung 1:n und Rechnung zu Artikel m:n. Wenn du das nun serialisieren müsstest, dann enthält jede Klasse "Kunde" eine Liste " Rechnungen". Für die Anwendung ist es in diesem Falle schlau, in der Klasse "Rechnung" eine Sammlung "Artikel anzulegen. Die Datenablage ist dann zwar redundant. Aber es ist ja eher von der Anfrage auszugehen "Welche Artikel stehen auf der Rechnung", als die Anfrage "Auf welchen Rechnungen steht ein Artikel?". Alternativ kann man aber auch das abbilden, indem man in die Klasse Artikel eine Sammlung "Rechnungen" einfügt.

 

[DefconDev]

Was hier aber natürlich Sinn machen kann ist ein "lazy load". Du lädst Dinge also nur, wenn Du diese wirklich brauchst und ggf. auch nur das, was Du wirklich benötigst.

Leider müssen alle Informationen abgebildet werden, zumin. gut 2/3.

Ich habe jetzt für jeden Knotenpunkt der eine "one to many" oder "n:m" Beziehung hat eine eigene Klasse erstellt und lasse die miteinander kommunizieren anhand der id's.

Das erscheint mir jedenfalls übersichtlicher als wenn ich etliche Arrays(Listen) aufrufe und permanent alles durchlaufen muss über mehrere Dimensionen.