Auszug Seminarunterlagen "Hibernate 3.x"

Themenüberblick "Hibernate-Sessions"

Allgemeines über Sessions
Session-Caches & Flushing
Objektzustände in Hibernate
Objektzustand-Modell
Transitive Persistenzoperationen
Hibernate-Session-Methoden
Unterschied zwischen save() und persist()

Präsentation "Hibernate 3.x" © Oliver P. Schell 2011 www.schellsoft.de 71

Allgemeines über Sessions

Die Hibernate-Session verwaltet alle JDBC-Ressourcen:
• JDBC-Connections
• Zustände aller persistenten Objekte
• DB-Transaktionen
• Session-Cache
(1st-Level-Cache)
• VM- oder Cluster-Cache
(2cnd-Level-Cache)

Hierzu stehen verschiedenste Methoden bereit:
• Methoden zur allgemeinen Verwaltung der Session
• Methoden zum Umgang mit Connections
• Methoden zur Persistierung einzelner Objekte
• Methoden zur Durchführung von Abfragen
• Methoden zur Verwaltung des Cache
Bitte allgemein beachten:
• Niemals Werteobjekte explizit über die Session abspeichern!


Session-Caches & Flushing

Der Session-Cache (1st-Level-Cache) optimiert die Schreibzugriffe:
• Er observiert alle persistierten Beans
• SQL-Statements werden erst beim "Flushing" in die DB geschrieben
Wege in den Session-Cache:
• Duch Übergabe an die Session:
• s.save( event );
• Durch Laden aus der Datenbank:
• event = (Event) s.load( Event.class, 17 );

Flushing = Übertragen von "dirty"-Anweisungen an die Datenbank:
• Nach einem INSERT, dass einen nativen PK liefert (automatisch)
• Vor Queries (automatisch)
• Vor einem COMMIT (automatisch)
• Bei s.flush() (programmgesteuert)

Garantierte Operationssequenz beim Flushing:
• 1) INSERTs in der Reihenfolge der s.save()-Aufrufe
• 2) UPDATEs
• 3) Collection DELETEs
• 4) Collection-Element DELETEs, UPDATEs, INSERTs
• 5) Alle Entity DELETEs in der Reihenfolge der s.delete()-Aufrufe

Objektzustände in Hibernate

Transient = Bean wurde neu erzeugt oder in DB gelöscht:
• Objekt besitzt keine Datenbank-Repräsentation
• Objekt besitzt keinen gültigen Primärschlüssel
• Objekt ist nicht mit Session-Cache assoziiert
• Event event = new Event();

Persistent = Bean wird von Hibernate überwacht:
• Objekt besitzt evtl. eine Datenbank-Repräsentation
• Objekt besitzt einen (vielleicht temporären) gültigen Primärschlüssel
• Objekt ist mit Session-Cache assoziiert

Detached = Bean wird von Hibernate nicht überwacht:
• Objekt besitzt eine Datenbank-Repräsentation
• Objekt besitzt einen gültigen Primärschlüssel
• Objekt ist nicht mit Session-Cache assoziiert
• s.evict( event );


Objektzustand-Modell


Konsequenzen der Objektzustände

Bitte beachten Sie:
• Änderungen an persistenten Objekten werden erkannt und gespeichert:
event.setCity( "Berlin" ); // OBJEKT IST DIRTY!
s.getTransaction().commit();
• Änderungen an detachten Objekten sind für Hibernate nicht erkennbar:
event.setCity( "Berlin" ); // OBJEKT IST DETACHT!
• Referenziert ein persistentes Objekt ein transientes, so wird dieses persistent!
• person = (Person) s.load( Person.class, 17 );
person.getEvents().add( event ); // OBJEKT IST PERSISTENT!
" allerdings ist die Cascade-Einstellung für das Persistieren entscheidend!
• Detachte Objekte können unvollständig sein:
(lazy-loading liefert Proxy, der nur bei persistenten Beans funktioniert!)
• person = (Person) s.load( Person.class, 17 );
s.close();
Hibernate.isInitialized( person.getTermine() ); // FALSE!
Hibernate.initialize( person.getTermine() ); // EXCEPTION!


Transitive Persistenzoperationen

Transitive Persistenzoperationen =
rekursive Anwendung von Session-Operationen:
• Persistenz-Operationen übertragen sich üblicherweise auf relationale Beans:
• s.save( person ); // SPEICHERT EVTL. ALLE RELATIONALEN OBJEKTE

Im Falle von Geschäftsbeziehungen:
• cascade-Attribut im Mapping entscheidet!
• Flags entsprechen den Session-Methoden-Namen:
• <one-to-many name="personen" cascade="persist, delete, lock">
• Vorhandene Keys zur Kaskadierung der Operation (none = default!):
• create, merge, save-update, delete, lock, refresh, evict, replicate, none,
all
• Löscht Geschäftsobjekte, wenn sie aus einer Collection entfernt wurden:
(nur für one-to-many-Relationen möglich)
• cascade="delete-orphan" // IST NICHT IN "ALL" ENTHALTEN!

Im Falle von Wertebeziehungen:
• "transitive persistence by reachability"
• Änderung am Geschäftsobjekt / Werteobjekt = Neuspeichern aller Werteobjekte!
• cascade-Attribut im Mapping ist wirkungslos!



Allgemeine Session-Verwaltung:
• Liefert Entity-Mode der Session:
(z.B. RDB, Maps von Maps oder XML-Dateien)
• EntityMode getEntityMode()
• Öffnet eine neue Session:
• Session getSession( EntityMode entityMode )
• Liefert die Session-Factory, die diese Session erzeugt hat:
• SessionFactory getSessionFactory()
• Löscht den Inhalt der Session:
(alle geladenen Objekte werden detached)
• void clear()



Umgang mit Connections:
• Ist die Session offen?
(z.B. false nach COMMIT oder close() )
• boolean isOpen()
• Ist die Session mit einer Datenbank verbunden?
• boolean isConnected()
• Enthält die Session Änderungen?
• boolean isDirty()
• Liefert die Connection der Session:
• Connection connection()
• Entkoppelt die Session von der Connection:
• Connection disconnect()
• Verbindet die Session mit einer Connection:
• void reconnect()
• Verbindet die Session mit der angegebenen Connection:
• void reconnect( Connection connection )
• Schließt die Session und gibt die Connection wieder:
• Connection close()



Umgang mit einzelnen Objekten:
• Liefert die ID des angegebenen Objektes:
• Serializable getIdentifier( Object object )
• Enthält die Session das angegebene Objekt?
• boolean contains( Object object )
• Entkoppelt das angegebene Objekt von der Session:
(wird in "detached" überführt)
• void evict( Object object )
• Lädt das Objekt mit der angegebenen ID:
(liefert Exception im Fehlerfalle)
• Object load( Class c, Serializable id, LockMode mode )
• Object load( String entityName, Serializable id, LockMode mode )
• Object load( Class theClass, Serializable id )
• Object load( String entityName, Serializable id )
• void load( Object object, Serializable id )



• Speichert das Objekt erneut:
(sendet INSERT, PK-Zustand ist gleichgültig!)
• Serializable save( Object object )
• void save( Object object, Serializable id )
• Serializable save( String entityName, Object object )
• void save( String entityName, Object object, Serializable id )
• Speichert das angegebene Objekt:
(je nach PK-Zustand wird save() oder update() gerufen)
• void saveOrUpdate( Object object )
• void saveOrUpdate( String entityName, Object object )
• Persistiert den Zustand des angegebenen detachten Objektes:
(flexibleres und konfigurierbares saveOrUpdate())
• void replicate( Object object, ReplicationMode rMode )
• void replicate( String entName, Object o, ReplicationMode m )
verfügbare Replication-Modi:
• EXCEPTION, IGNORE, OVERWRITE, LATEST_VERSION



• Aktualisiert ein detachtes Objekt
(sendet statisches UPDATE, vollständiger Abgleich aller Attribute,
PK muss gültig sein, sonst wird Exception geworfen!)
• void update( Object object )
• void update( Object object, Serializable id )
• void update( String entityName, Object object )
• void update( String entityName, Object object, Serializable id )
• Kopiert Inhalte eines detachten Objekts in eine persistente Instanz:
(falls in der Session keine passende Instanz liegt, wird sie aus DB geladen)
• Object merge( Object object )
• Object merge( String entityName, Object object )
teilweiser & dynamischer Abgleich detacht geänderter Attribute möglich:
• <class dynamic-update="true">
• Persistiert ein Objekt:
(der Unterschied zu save() wird im Folgenden geklärt)
• void persist( Object object )
• void persist( String entityName, Object object )



• Löscht das übergebene Objekt aus der DB:
(Objekt muss lediglich eine gültige ID haben, der Zustand ist egal)
• void delete( Object object )
• void delete( String entityName, Object object )
• Sperrt ein detachtes oder persistentes Objekt:
(detachte Instanzen müssen unverändert sein)
• void lock( Object object, LockMode lockMode )
• void lock( String entityName, Object object, LockMode mode )
• Aktualisiert den Objektzustand aus der Datenbank:
(ohne auf den Cache zuzugreifen)
• void refresh( Object object )
• void refresh( Object object, LockMode lockMode )
• Liefert den Sperrmodus für das angegebene Objekt:
• LockMode getCurrentLockMode( Object object )
• Startet eine Transaktion:
• Transaction beginTransaction()



• Liefert das Transaction-Objekt, das mit dieser Session assoziiert ist:
• Transaction getTransaction()
• Liefert das Objekt mit der angegebenen ID
(oder NULL im Fehlerfalle):
• Object get( Class clazz, Serializable id )
• Object get( Class clazz, Serializable id, LockMode lockMode )
• Object get( String entityName, Serializable id )
• Object get( String entityName, Serializable id, LockMode mode )
• Liefert den Entity-Namen für das angegebene persistente Objekt:
(Entity-Name muss in der Mapping-Datei definiert sein)
• String getEntityName( Object object )
• Definiert das angegebene Objekt als Readonly-Objekt:
(es findet kein Dirty-Checking statt)
• void setReadOnly( Object entity, boolean readonly )



Umgang mit Abfragen:
• Erzeugt eine Abfrage, die alle Objekte vom angegebenen Typ liefert:
• Criteria createCriteria( Class persistentClass )
• Criteria createCriteria( Class persistentClass, String alias )
• Erzeugt eine Abfrage für alle Objekte mit angegebenem Entity-Namen:
• Criteria createCriteria( String entityName )
Criteria createCriteria( String entityName, String alias )
• Erzeugt eine Abfrage mit der angegebenen HQL-Abfrage:
• Query createQuery( String queryString )
• Erzeugt eine Abfrage mit der angegebenen SQL-Abfrage:
• SQLQuery createSQLQuery( String queryString )
• Erzeugt eine Abfrage für die angegebene persistente Collection und den angegebenen Filter
(HQL):
• Filter createFilter( Object collection, String queryString )



Umgang mit Abfragen:
• Liefert die benannte Abfrage mit dem angegebenen Namen:
• Query getNamedQuery( String queryName )
• Bricht die aktuelle Abfrage (z.B. aus parallelem Thread) ab:
• void cancelQuery()
• Aktiviert den angegebenen Filter für diese Session:
• Filter enableFilter( String filterName )
• Liefert den aktiven Filter mit dem angegebenen Namen:
• Filter getEnabledFilter( String filterName )
• Deaktiviert den angegebenen Filter für diese Session:
• void disableFilter( String filterName )



Umgang mit dem Cache:
• Schreibt die Änderungen im Cache in die Datenbank:
• void flush()
• Setzt den Flush-Modus:
(Default-Wert ist auto = flushing vor SQL-Queries und vor Transaktionen)
• void setFlushMode( FlushMode flushMode )
• Liefert den Flush-Modus:
• FlushMode getFlushMode()
• Setzt den Second-Level-Cache-Modus:
• void setCacheMode( CacheMode cacheMode )
• Liefert den Cache-Modus:
• CacheMode getCacheMode()


Unterschied zw. save() und persist()

Die Unterschiede zw. save() und persist() sind eher akademisch!
Es geht um 2 Fragen:
• In welchem Zustand muss die Bean sein, um eingefügt zu werden?
• Wann genau wird der PK eines eingefügten Objekts ermittelt?
save():
• Speichert sowohl transiente als auch detachte Objekte
• Der PK wird sofort ermittelt,
evtl. auch durch ein INSERT außerhalb der Transaktionsgrenzen!

persist():
• Speichert nur transiente, aber keine detachten Objekte
• Hibernate garantiert:
persist() erzeugt kein INSERT außerhalb der Transaktionsgrenzen


Auszug Seminarunterlagen "Hibernate 3.x"

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (20)

Ähnlich wie Auszug Seminarunterlagen "Hibernate 3.x"

Ähnlich wie Auszug Seminarunterlagen "Hibernate 3.x" (20)

Auszug Seminarunterlagen "Hibernate 3.x"