Eine Many-To-Many-Beziehung wird über die JPA-Annotation @ManyToMany realisiert.
Auf beiden Seiten liegt eine Collection vor mit einer solchen Annotation, wobei eine Seite dabei wieder den Eigentümer/Verwalter der Beziehung innehaben muss - mappedBy:
@Entity
public class A {
@Id
private Long id;
...
@ManyToMany
private List<B> colBs;
}
@Entity
public class B {
@Id
private Long id;
...
@ManyToMany(mappedBy="colBs")
List<A> colAs;
}
Somit ist Entity A Besitzer der n-m-Beziehung.
Eine n-m-Beziehung wird immer in einer separaten dedizierten Tabelle gespeichert:
Der Name ist zusammengesetzt: Entity-Name des Besitzers der Beziehung + _ + Entity-Name der anderen Seite.
In diesem Beispiel: A_B.
Die Foreignkeyspalten für die Herstellung der Beziehung im Default wird nach folgendem Muster erzeugt:
Attributname der referenzierten Seite + _ + PK-Name.
In diesem Beispiel: colbs_id bzw. colas_id
Montag, 12. März 2012
JPA Hibernate one-to-many orphanRemoval
Bei einer 1-n-Beziehung gibt es wieder die Möglichkeit dies uni- oder bidirektional auszudrücken:
Unidirektional:
Auf der 1-Seite liegt eine Collection vor, die nach JPA mit der Annotation @OneToMany versehen wird.
Die Collection besteht aus Entitäten der n-Seite, zwischen denen die Beziehung ja auch ausgedrückt werden soll.
Diverse Parameter können gesetzt werden:
- mappedBy
Der Besitzer der Beziehung. Wird dies bei der 1-Seite aufgeführt, dann ist die n-Seite der Besitzer der Beziehung bzw. Verwalter. Hier wird also die Instanzvariable der n-Seite angegeben. Dadurch wird auf der n-Seite das Fremschlüsselfeld(default) geführt, damit dbseitig die Beziehung hergestellt werden kann.
- cascade
- fetch
Soll die Beziehung bidirektional sein, dann wird auch auf der n-Seite eine Annotation bei der entsprechenden Instanzvariable gesetzt:
@ManyToOne
Hier gibt es interessantere Annotationen/Parameter, die gesetzt werden können.
Doch zunächst der Standard. Wird kein Name via @JoinColumn definiert, so erhält die Fremdschlüsselspalten folgenden Namen: Name der Instanzvariable + _ + Name des PK-Feldes
- @JoinColumn mit den Parametern:
Unidirektional:
Auf der 1-Seite liegt eine Collection vor, die nach JPA mit der Annotation @OneToMany versehen wird.
Die Collection besteht aus Entitäten der n-Seite, zwischen denen die Beziehung ja auch ausgedrückt werden soll.
Diverse Parameter können gesetzt werden:
- mappedBy
Der Besitzer der Beziehung. Wird dies bei der 1-Seite aufgeführt, dann ist die n-Seite der Besitzer der Beziehung bzw. Verwalter. Hier wird also die Instanzvariable der n-Seite angegeben. Dadurch wird auf der n-Seite das Fremschlüsselfeld(default) geführt, damit dbseitig die Beziehung hergestellt werden kann.
- cascade
- fetch
Soll die Beziehung bidirektional sein, dann wird auch auf der n-Seite eine Annotation bei der entsprechenden Instanzvariable gesetzt:
@ManyToOne
Hier gibt es interessantere Annotationen/Parameter, die gesetzt werden können.
Doch zunächst der Standard. Wird kein Name via @JoinColumn definiert, so erhält die Fremdschlüsselspalten folgenden Namen: Name der Instanzvariable + _ + Name des PK-Feldes
- @JoinColumn mit den Parametern:
- referencedColumnName - Name des Fremdschlüsselfeldes
- nullable - Muss die Beziehung gesetzt sein?
- orphanRemoval - bei true wird beim Löschen der Entität auf der 1-Seite alle referenzierten Entitäten der n-Seite gelöscht. Dies macht bspw. bei einer Komposition Sinn. In einigen Fällen kann auch über die Alternative @Embeddable bzw. @Embedded nachgedacht werden. Zur Realisierung der Komposition, d.h. Einzelbestandteile der Komposition werden über die Komposition gemanaged und Einzelteile alleine dürfen designtechnisch nie vorkommen, sollte man dann bei mappedBy die 1-Seite als Besitzer eintragen. Somit wird beim Löschen der Entität auf der 1-Seite vom JPA-Provider bspw. Hibernate auch die n-Seite gelöscht.
- cascade - bspw. kann hier über cascade = CascadeType.PERSIST festgelegt, dass bei einem persist-Aufruf alle referenzierten Entitäten der n-Seite ebenfalls persistiert werden.
- fetch - bzgl. Performance / Ladeverhalten sollte hier genau überlegt werden
Samstag, 10. März 2012
Grails2
Neue Grails Version2.0
Während bereits an der Grails-Version 3 gearbeitet wird: Grails Upcoming Version,
hier die ausgelieferten Features von Grails2:
String name
...
static constrains = {
name blank:false
}
}
Auf der View wird nun name als Pflichtfeld dargestellt
Während bereits an der Grails-Version 3 gearbeitet wird: Grails Upcoming Version,
hier die ausgelieferten Features von Grails2:
- Alle Views werden über den Generator in HTML5 mit JQuery erstellt
- Vorteil: clientseitige Validierung bzgl. Syntax möglich,
- bessere Usability: Feedback bei der Eingabe etc.
- Pflichtfelder wie in der Domänenklasse definiert, werden entsprechend gerendert:
- im dynamic Scaffolding wird in der Domain-Klasse die statischen constraints definiert und die dynamisch erzeugte View dazu stellt diese Felder als Pflichtfelder dar(mit einem * und validiert diese entsprechend):
String name
...
static constrains = {
name blank:false
}
}
Auf der View wird nun name als Pflichtfeld dargestellt
- Serverfehler(HTTP Statuscode 500) werden nun sauber dargestellt: mit Stacktrace, Message und betreffende Groovy-Klasse
- bessere Performance: statische Ressourcen wie Bilder, CSS, *.js werden nun clientseitg gepackt und gecacht
- Neue Unterstützung für nosql-Datenbanken:
- Diese können mit GORM-Mittel angegangen werden.
- Persistenz Features:
- Detached Queries (wiederverwendbare Queries jenseites einer Persistenz-Session)
- Typsichere, compile-time secure Where-Queries!
- neue bequeme Persistenzmethoden: findOrCreate() etc.
- Abstrakte Domänenklassen
- Grails-Konsole hat sich eine TAB-Vervollständigung, so wie man es von einer Linux - Konsole gewöhnt ist
- Fehler werden auf der Grails-Konsole formatiert und farblich dargestellt
- Controller-Features
- Actions können jetzt auch Methoden sein und müssen nicht mehr Closures sein
- Für einen Controller könnten automatisch die Unit-Tests angelegt werden:
- Sogenannte @TestFor-Annotation mit der Klasse als Parameter:
- @TestFor(XYController)
binäre Assoziation JPA
1-zu-1-Beziehung mit JPA
Hierfür dient die JPA-Annotation @OneToOne.Im Standard wird dies über einen ForeignKey datenbankseitig abgebildet.
Unidirektional
Bei einer unidirektionalen @OneToOne-Beziehung enthält die Entität von der aus auf die andere Entität navigiert werden kann, die @OneToOne-Annotation.
mappedBy
Soll die 1-zu-1-Beziehung zwischen zweier Entitäten bidirektional sein,dann muss in beiden Entity die @OneToOne-Annotation gesetzt sein und über das mappedBy-Attribut
wird gesagt, welche Seite die Beziehung verwaltet. Die Beziehung mit der Entität mit dem mappedBy wird von der anderen Entität verwaltet und es wird dabei auf die referenzierte Property verwiesen.
Letztendlich wird gesagt, auf welcher Seite das foreignkey-Spalte vorliegen soll.
Die Entität ohne dem mappedBy-Attribut bekommt dabei in der entsprechenden Tabelle eine ForeignKey-Spalte, um die Beziehung darstellen zu können - der Name leitet sich ab:
Tabellenname der referenzierten Tabelle + _ + Spaltenname des PKs
@Entity
public class A {
@OneToOne
B b;
...
}
@Entity
public class B {
@OneToOne(mappedBy="b")
A a;
Persistieren @OneToOne per JPA
Beim Persistieren einer @OneToOne-Beziehung muss man die Beziehung programmatisch setzen undbeide mittels persist() abspeichern.
cascade=CascadeType.PERSIST
Um zu vermeiden, dass beide Entitäten einer @OneToOne-Beziehung einzeln gespeichert werden müssen, kann man sich das cascade-Attribut bei der @OneToOne-Beziehung zu Nutze machen:@OneToOne(cascade=CascadeType.PERSIST).
Dadurch werden die Beziehung einer Entität mitgespeichert.
Bei einer OneToOne-Beziehung "besitzt" die Entität ohne das mappedBy-Attribut, die Assoziation
und verfügt daher über die ForeignKey-Spalte und die wird gleichermaßen gespeichert, also auch die damti verknüfte Entität. Somit müssen nicht mehr auf beide Entitäten ein persist() aufgerufen werden,
ein persist() auf Entität A genügt, B wird ebenfalls gespeichert.
optional
Bei der Angabe von einer @OneToOne - Beziehung kann über den Parameter optional festgelegt werden, ob die Beziehung gesetzt sein muss oder vorliegen kann:@OneToOne(optional=true)
Donnerstag, 8. März 2012
Caching via Hibernate JPA
JPA Caching
Um eine bestehende Applikation zu optimieren, bietet es sich an, dass man Katalogdaten bzw. Stammdaten cacht. In Abgrenzung zu Bewegungsdaten, die sich auf bestimmte Vorgänge beziehen und nur punktuell benötigt werden, werden Stammdaten in jedem Prozess/Vorgang benötigt unabhängig vom konkreten Geschäftsvorfall.Somit bietet es sich an solche Daten als Kandidaten fürs Cachen vorzusehen.
Sogenannte Schlüsseldaten oder Katalogdaten kennzeichnen sich dadurch aus, dass sie ständig gelesen werden, aber ganz selten verändert werden.
Wie können nun Caching-Strategien mit JPA bzw. Hibernate durchgeführt werden?
- Aktivieren des Hibernate Second Level Caches
- Konfigurieren des Cache-Providers
- Herausfiltern der Caching-Kandidaten und Kennzeichnen der Entities/Assoziationen
1. Aktivieren des Hibernate Second Level Caches
In der persistence.xml bzw. hibernate.cfg.xml wird die Property hibernate.cache.use_second_level_cache auf true gesetzt. Damit wird neben den First-Level-Cache, der alle gemanagten Entitäten der jeweiligen Hibernate Session beinhaltet, ein zweiter Cache in Hibernate aktiviert, der transaktionsübergreifend arbeitet.
Der First-Level-Cache ist an die aktuelle Transaktion gebunden und wird somit geleert, sobald die Transaktion abgeschlossen wurde.
Der Second-Level-Cache ist nicht an der Hibernate-Session gebunden, sondern ist gebunden an dem EntityManager bzw. an der HibernateSessionFactory. Dadurch können Entities zurückgegeben werden, ohne das hierzu eine Rückfrage an die Datenbank erfolgen muss, wenn diese Entities nicht in der aktuellen Transaktion ermittelt wurden, sondern in Transaktionen zuvor gelesen/geschrieben worden sind.
2.Konfigurieren des Cache-Providers
Hibernate kommt mit einer eigenen Implementierung für den Second-Level-Cache.
Dies ist aber nur eine Testimplementierung und ist keinesweges für den produktiven Einsatz gedacht.
Somit muss man den jeweiligen Cacheprovider auswählen und in der Konfiguration setzen:
hibernate.cache.region.factory_class
Es gibt einige Cacheprovider: JBoss Cache, Infinispan, ...
Infinispan wird der zukünftige Cacheprovider im JBoss sein und ist sehr praxiserprobt.
Die Einführung der Regions(Interface region.factory_class) ist neu.
Es gibt die Möglichkeit auch Query-Ergebnisse zu cachen. Die Regeln und Vorgehensweisen für einen solchen Cache unterscheiden sich für einen applikationsweiten Second-Level-Cache, der Entitäten transaktionsübergreifend cacht.
Somit kann der Second-Level-Cache in unterschiedliche Regionen unterteilt werden, damit die unterschiedlichen Cachemechanismen, Eviction-Policys etc. greifen können.
3.Herausfiltern der Caching-Kandidaten und Kennzeichnen der Entities/Assoziationen
Damit eine Entität von Hibernate gecacht wird, muss sie mit einer Annotation versehen werden:
@org.hibernate.annotations.Cache bzw. JPA @javax.persistence.Cacheable
Eine Assoziation muss in der jeweiligen Getter-Methode der betreffenden Entität mit der hibernate-Annotation @org.hibernate.annotations.Cache gekennzeichnet werden.
Folgendes Buch befasst sich im Kapitel 9 bzgl. Caching und auch Query Cache:
Mittwoch, 7. März 2012
Behandlung von IDs / Performance und Optimierung
Wird ein Object/Relation Mapper wie bspw. Hibernate verwendet, so muss jede gemanagte Entity, die bspw. in einer Tabelle persistiert wird, eine ID besitzen.Es muss also etwas geben, dass eine solche Entity eindeutig identifiziert.
In JPA dient die Annotation @Id dazu.
Die Attribute zur Identifizierung können nach folgenden Aspekten ausgewählt werden:
- Nutzung eines fachlichen Schlüssels
- Nutzung/Generierung eines technischen Schlüssels
Für Variante 2 müssen für neue Objekte neue IDs generiert werden.
JPA Generatoren
Unter JPA kommen hier Generatoren zum Einsatz:
@GeneratedValue
Es gibt 3 Generatoren, die über den Annotation-Parameter strategy ausgewählt wird:
- IDENTITY
- SEQUENCE
- TABLE
- AUTO
IDENTITY
Bei IDENTITY kommt eine Autoincrement-Spalte zum Einsatz, wenn die darunterliegende DB dies unterstützt.SEQUENCE
Bei SEQUENCE wird ein eigener DB-seitiger Generator verwendet, der sich um das Hochzählen des Wertes kümmert.TABLE
Bei TABLE wird eine Tabelle hibernate_sequences angelegt, die die Werte des Generators hält.AUTO
Bei AUTO entscheidet hibernate anhand des eingestellten db-Dialekts, welcher Generator am Besten zu verwenden ist.
JPA PERFORMANCE
Performance
Grundsätzlich bedeuten technische Schlüssel eine schlechtere Performance, da beim persist der EntityManager/HibernateSessionFactory die von der DB vergebene ID auslesen muss.
Wehe den Datenbanken, die diese wichtige Operation per API nicht speziell anbieten.
Gibt es vom Treiber keine spezielle Operation bzw. Möglichkeit dies effizient einzulesen,
dann sind schlechtere Insert-Operation vorprogrammiert wie auf anderen Datenbanken.
Die AUTO-strategy kann auf bestimmten Datenbanken Performance kaputtmachen.
So kommt bei der Oracle-Datenbank eine Sequenz zum Einsatz, aber mit leider einer vorkonfigurierten allocationSize von 1.
Dies kann bei AUTO-strategy nicht eingestellt werden und bedeutet somit,
dass die Insert-Performance sehr schlecht ist, da nach jedem Insert über den Treiber die nächste verfügbare ID von der Sequenz ausgelesen werden muss.
So wird im Standard bei manueller Anlage oder bei Nutzung von Datenbanktools auf der DB2 und Oracle Sequences angelegt, die die nächsten 20 IDs cachen, so dass nicht nach jeder Einfügeoperation das Sequenzobjekt hierzu befragt werden muss.
CREATE SEQUENCE XY
START WITH 1
INCREMENT BY 1
NO MAXVALUE
NO CYCLE
CACHE 20;
INSERT INTO ORDERS (ORDERNO, CUSTNO)
VALUES (NEXT VALUE FOR XY, 123456);
Performance @GeneratedValue
Ist besondere Performance gefragt, kann man die Annotation @GeneratedVaule rausnehmen, so dass der JPA-Provider nicht mehr in der Verantwortung ist, eine ID zu ermitteln und bei persist zu setzen.
Dann muss man selber für eine ID-Generierung sorgen, dies kann hinsichtlich schwacher Treiber, deutlich schneller sein.
UUID-Klasse
Im java.util-Package gibt es seit Java 1.5 eine UUID-Klasse mit der man UUIDs generieren kann.
Eventuell sichert man dies noch mit eindeutigen Informationen aus dem jeweiligen Kontext ab, so dass die UUID wirklich eindeutig ist und nie per Zufall doppelt vergeben werden kann.
Dies hätte den Vorteil, dass nach der persist()-Methode ein Nachschlagen des vergeben Wertes für den DB-Treiber wegfiele.
Eine gute weiterführende Lektüre zum Thema ID Behandlung bietet folgendes Buch
(Kapitel 4 Abschnitt Mapping the Primary Key):
Eine gute weiterführende Lektüre zum Thema ID Behandlung bietet folgendes Buch
(Kapitel 4 Abschnitt Mapping the Primary Key):
Abonnieren
Posts (Atom)