Ziemer's gesammelte
Tutorials
- UML-Projekt mit NetBeans
- Web-Projekt mit NetBeans
-
... Vorbereitung
-
... Implementierung
-
... Entity Classes annotieren
-
... Der erste Start
-
... Der Workaround
-
... Code-Tricks
-
... Hinweise
-
... Links
Entity Classes annotieren
Die Hauptarbeit besteht nun darin, sämtliche persistenz-relevanten Bestandteile der Entity Classes mit so genannten Annotationen (englisch: annotations) zu versehen. Dazu gehören diejenigen Attribute, durch die eine Beziehung zu anderen Klassen (also anderen Tabellen) hergestellt wird, aber auch zusätzliche Attribute, mit deren Hilfe der JPA-Provider die objekt-relationale Abbildung (OR-Mapping) vornehmen kann.
Die blau markierten Stellen sind unbedingt notwendig, während die grünen nur als Beispiele dienen.
Entity Class
Jede persistente Entitätklasse (englisch: entity class) erhält die Annotation @Entity vor ihrem Klassennamen, um sie als solche kenntlich zu machen. Stimmt der Klassenname nicht mit der korrespondierenden Datenbanktabelle überein, wird zusätzlich der Tabellenname angegeben:
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.Table;
@Entity
@Table(name = "DOZENT")
public class Dozent implements Serializable {
...
}
Attribute annotieren
Beim Entwurf einer JPA-Entität ist jedes Attribut persistent, und der Name des Attributs entspricht dem Namen der Tabellenspalte. Aufgrund dieser Annahme muss man lediglich die Abweichungen von der Regel mit Annotationen konfigurieren: Die Tabellen-Relationen werden einfach mit Referenzen auf andere Entitäten modelliert, und mit den Annotationen @OneToMany, @ManyToOne, @OneToOne und @ManyToMany markiert.
Annotationen können (konsistent!) vor den Member Attributes oder vor den Getter-Operationen stehen. Beides hat Vor- und Nachteile. Meist überwiegen die Vorteile, wenn die Attribute annotiert werden. Werden die Attribute annotiert, füllt der Persistenz-Mechanismus materialisierte Objekte direkt über diese Attribute, auch wenn sie als private deklariert wurden. Ein zu dematerialisierender Objektzustand wird über die Attribute ermittelt. Werden hingegen die Getters annotiert, nutzt der Persistenz-Mechanismus diese, um Objekte zu dematerialisieren, und die Setters, um sie zu materialisieren.
Many-To-Many-Assoziation
Das Attribut, welches einem Objekt des Typs A eine Beziehung zu mehreren Objekten des Typs B ermöglicht, während die Objekte des Typs B ebenfalls Beziehungen zu mehreren Objekten des Typs A pflegen, erhält eine Annotation @ManyToMany vor dem Attribut selbst oder vor der Getter-Operation. Dies ist im obigen Klassendiagramm zwischen den Klassen Lehrveranstaltung und Dozent der Fall:
import javax.persistence.ManyToMany;
...
@ManyToMany
private Set< Dozent> mDozent;
public Set< Dozent> getMDozent () {
return this.mDozent;
}
public void setMDozent (Set< Dozent> val) {
this.mDozent = val;
}
Bei der nicht-führenden Klasse ("non-owning side", datenbankseitig Fremdtabelle) wird zusätzlich zur oben angegebene Annotation @ManyToMany der Namen des korrespondierenden Attributs in der Stammtabelle-Klasse ergänzt. Die Klasse Dozent ist datenbankseitig die Fremdtabelle, während Lehrveranstaltung die Stammtabelle ist:
Default: if the relationship is unidirectional, TopLink JPA determines the field that owns the relationship. If the relationship is bidirectional, then set the mappedBy attribute on the inverse (non-owning) side of the association to the name of the field or property that owns the relationship.
@ManyToMany(mappedBy="mDozent")
private Set< Lehrveranstaltung> mLehrveranstaltung;
public Set< Lehrveranstaltung> getMLehrveranstaltung () {
return this.mLehrveranstaltung;
}
public void setMLehrveranstaltung (Set< Lehrveranstaltung> val) {
this.mLehrveranstaltung = val;
}
Many-To-One-Assoziation
Das Attribut, welches einem Objekt des Typs A eine Beziehung zu einem einzigen Objekt des Typs B ermöglicht, während das Objekt des Typs B Beziehungen zu mehreren Objekten des Typs A pflegt, erhält eine Annotation @ManyToOne vor dem Attribut selbst oder vor der Getter-Operation. Dies ist im obigen Klassendiagramm von der Klasse Klausur zur Klasse Lehrveranstaltung der Fall:
import javax.persistence.ManyToOne;
...
@ManyToOne
private Lehrveranstaltung mLehrveranstaltung;
public Lehrveranstaltung getMLehrveranstaltung() {
return this.mLehrveranstaltung;
}
public void setMLehrveranstaltung(Lehrveranstaltung val) {
this.mLehrveranstaltung = val;
}
One-To-Many-Assoziation
Das Attribut, welches einem Objekt des Typs A eine Beziehung zu mehreren Objekten des Typs B ermöglicht, während das Objekt des Typs B Beziehungen zu einem einzigen Objekt des Typs A pflegt, erhält eine Annotation @OneToMany vor dem Attribut selbst oder vor der Getter-Operation.
Als Beispiel nehmen wir einmal kurz an, dass die Assoziation zwischen den Klassen Lehrveranstaltung und Klausur nicht unidirektional sei, sondern bidirektional. Dann müsste man diese One-To-Many-Assoziation folgendermaßen annotieren. Achtung: Die Assoziation zwischen den genannten Klassen ist jedoch unidirektional. Bitte annotieren Sie die Klasse Lehrveranstaltung in diesem Zusammenhang nicht!
import javax.persistence.OneToMany;
...
@OneToMany(mappedBy="mLehrveranstaltung")
private Set< Klausur> mKlausur;
public Set< Klausur> getMKlausur() {
return this.mKlausur;
}
public void setMKlausur(Set< Klausur> val) {
this.mKlausur = val;
}
Die Seite mit dem @OneToMany ist stets die nicht-führende Seite, und trägt deshalb auch stets das mappedBy-Attribut.
Default: TopLink JPA assumes the relationship is unidirectional. If the relationship is bidirectional, then set the mappedBy element on the inverse (non-owning) side of the association to the name of the field or property that owns the relationship.
import javax.persistence.ManyToOne;
...
@ManyToOne
private Lehrveranstaltung mLehrveranstaltung;
public Lehrveranstaltung getMLehrveranstaltung () {
return this.mLehrveranstaltung;
}
public void setMLehrveranstaltung (Lehrveranstaltung val) {
this.mLehrveranstaltung = val;
}
One-To-One-Assoziation
Funktioniert analog zur Many-To-Many-Assoziation.
Primärschlüssel
Das Attribut id ermöglicht das eigentliche OR-Mapping. Es ist der Primärschlüssel der korrespondierenden Tabelle und wird deshalb mit einer speziellen Annotation versehen. Dieses veranlasst den JPA-Provider auch, den Wert des Attributs bei der Erzeugung jeder neuen Entität automatisch zu inkrementieren (Autosequenz):
import javax.persistence.Id;
import javax.persistence.GeneratedValue;
...
@Id
@GeneratedValue
private Long id;
public Long getId() {
return this.id;
}
public void setId(Long id) {
this.id = id;
}
Kommt beim ersten Starten der Anwendung folgender Fehler:
NetBeansProjects/Klausurplaner/nbproject/build-impl.xml:683: The module has not been deployed.
So sind vermutlich die Annotationen nicht korrekt gesetzt. Es könnte jedoch auch daran liegen, dass in der persistence.xml das Häkchen bei Use Java Transaction APIs nicht gesetzt ist. Bitte prüfen Sie auch das.