Start - Publikationen - Wissen - TOGAF - Impressum -

Mapping von Fremdschlüssel-Relationen


Bei der Arbeit mit Entitäten-Relationen wird der technologische Bruch zwischen der relationalen Welt der Datenbanken und der objektorientierten Welt moderner Programmiersprachen besonders deutlich. Will man die Arbeit eines Persistenzframeworks beherrschen, muss man diesen Bruch verstehen. Als Voraussetzung für das Mapping mit JPA werden Fremdschlüssel-Relationen angenommen, bei der eine Spalte einer Tabelle B Primärschlüssel einer anderen Tabelle A enthält. Die Existenz eines Primärschlüssels wiederum ist zugesichert, da JPA-Entitäten zwingend einen Primärschlüssel haben müssen:

           +-----+
+-----+    |  B  | 
|  A  |    +-----+
+-----+    |pk   |
|pk   |<---|fk_A |  
+-----+    +-----+

Zwischen beiden Tabellen exisitiert dann eine Relation, die bei Bedarf von der Datenbank konsistenz gehalten wird (relationale Integrität). Der Pfeil in der Abbildung impliziert eine Richtung der Relation, die aber in Wirklichkeit nicht existiert.

Eine solche Relation kann auf mehrfache Weise als die Assoziation zwischen Objektinstanzen A und B repräsentiert werden. Die plausibelste Variante zur Projektion dieser einfachen Fremdschlüssel-Relation auf eine Objekt-Assoziation geschieht über die @ManyToOne Beziehung. Hier besitzt ein Instanz B eine Referenz auf eine Instanz A:

           +------------+
+-----+    |B           | 
|A    |    +------------+
+-----+    |@ManyToOne  |
|     |<---|A a         |  
+-----+    +------------+

Die Assoziation kann auch bidirektional ausgelegt werden, in A wird dabei mit dem Attribut mappedBy die Information hinterlegt, wo die Relation dieser Assoziation gepflegt wird:

+------------+     +------------+
|A           |     |B           | 
+------------+     +------------+
|@OneToMany  |     |            |
|mappedBy="a"|     |@ManyToOne  |
|Col col_b|<--->|A a         |  
+------------+     +------------+

In solchen bidirektionalen Beziehungen liegt es immer in der Verantwortung des Entwicklers, beide Seiten aus Sicht der Relation konsistent zu halten. Eine @OneToOne Beziehung ist eine spezielle Ausprägung einer @ManyToOne Assoziation, bei der die Collection der einen Seite nur ein Element enthalten darf. Der Fremdschlüssel-Relation ist dabei ohne weiteres nicht anzusehen, ob sie eine @ManyToOne oder @OneToOne Semantik besitzt. Die Bidirektion braucht auch hier eine Angabe über den Halter ("owner") der Relation und muss programmatisch konsistent gehalten werden:

           +------------+
+-----+    |B           | 
|A    |    +------------+
+-----+    |@OneToOne   |
|     |<---|A a         |  
+-----+    +------------+
+------------+     +------------+
|A           |     |B           | 
+------------+     +------------+
|@OneToOne   |     |            |
|mappedBy="a"|     |@OneToOne   |
|B b         |<--->|A a         |  
+------------+     +------------+

Mapping von Beziehungs-Tabellen


Zwischen zwei Tabellen A und B ist eine Beziehungstabelle A_B definiert, in der zwei Fremdschlüssel auf die Primärschlüssel in A und B verweisen:

+-----+    +-----+
|  A  |    | A_B |    +-----+
+-----+    +-----+    |  B  |    
|pk   |<---|fk_A |    +-----+
+-----+    |fk_B |--->|pk   |
           +-----+    +-----+

Aus Datenbanksicht basiert dieses Konzept also wieder auf Fremdschlüssel-Relationen und ist nichts Neues. Jedoch lassen sich mit solchen Beziehungstabellen @ManyToMany Beziehungen zwischen Objektinstanzen abbilden. Beide Richtungen sind erlaubt, weder A noch B nehmen eine besondere Rolle als "owner" der Beziehung ein:

+------------+     +------------+      +------------+     +------------+
|A           |     |B           |      |A           |     |B           |
+------------+     +------------+      +------------+     +------------+
|@ManyToMany |     |            |      |            |     |@ManyToMany |
|Col col_b|---->|            |      |            |<----|Col col_a|
+------------+     +------------+      +------------+     +------------+

Bidirektion wird erreicht, indem (willkürlich) auf einer Seite der Assoziation auf einen Besitzer der Beziehung verwiesen wird:

+------------+     +------------+
|A           |     |B           |
+------------+     +------------+
|@ManyToMany |     |            |
|mappedBy="a"|     |@ManyToMany |
|Col col_b|<--->|Col col_a|
+------------+     +------------+

Außerdem sind Beziehungstabellen auch die Grundlage unidirektionaler @OneToMany Beziehungen:

+------------+     +------------+
|A           |     |B           |
+------------+     +------------+
|@OneToMany  |     |            |
|Col col_b|---->|            |
+------------+     +------------+

copyright © 2002-2018 | Dr. Christian Dürr | prozesse-und-systeme.de | all rights reserved