Modificare gli oggetti efficientemente. Dott. Doria Mauro

Transcript

1 Hibernate Modificare gli oggetti efficientemente Dott. Doria Mauro

2 Transitive persistence La persistenza transitiva è una tecnica che consente di propagare automaticamente la persistenza ad un sottografico di oggetti transienti e/o detached. Ad esempio, nell associazione tra Item e Bid, è possibile legare il ciclo di vita di un oggetto bid a quello dell item in cui si trova: Un bid viene automaticamente reso persistente al momento in cui rendiamo persistente l item Un bid viene cancellato al momento che cancelliamo un item. 2 Esistono diversi modi per realiazzare la transitive persistence, anche se si basano tutti sugli stessi principi

3 Persistence by reachability Uno strato di persistenza si dice che implementa la persistence by reachability se una istanza diventa persistente ogni volta che l applicazione crea un reference a questa istanza da un altra istanza che è già persistente. 3

4 Persistence by reachability Nell esempio precedente: Quando l oggetto Computer diventa persistente, lo diventano pure Desktop PCs e Monitor Quando Computer diventa detached lo diventano anche Desktop PCs e Monitor Se uno di questi due oggetti perde il reference da Computer, diventa automaticamente transient (e quindi rimosso). Si presume una navigazione nel grafo degli oggetti unidirezionale da padre a figlio. 4 Navigando nel grafo degli oggetti, si incontrano soltanto oggetti persistenti; non sono mai possibili violazioni di integrità referenziale.

5 Persistence by reachability Per quanto possa sembrare una strategia affascinante, questa tecnica non è applicabile così com è (ne da Hibernate, ne da altri ORM framework) Sarebbe necessario una sorta di garbage collector per la persistenza con un comportamento simile a quello della JVM Il problema più grosso sta nel fatto che: Gli oggetti sono condivisi (quindi ad un oggetto possono essere collegati references da diversi altri oggetti) Gli oggetti presenti nel persistent context non rappresentano tutti i legami presenti nel DB 5 Per fare questo G.C. sarebbe necessario fare una costante scansione del DB alla ricerca dei legami tra le righe

6 Persistenza a cascata Hibernate applica un tipo più semplice di persistence by reachability: la persistenza a cascata. Hibernate propaga lo stato di un oggetto verso un altro referenziato in base a quanto descritto nella proprietà cascade. La persistenza a cascata è più flessibile e assegna maggiore controllo allo sviluppatore. Solo così è possibile sapere facilmente quando un oggetto diventa detached. 6 Non si attiva di default ed è disponibile in tutti i tipi di associazione: (uno-a-uno, uno-a-molti, molti-a-molti) e per tutte le collections (<set>, <bag>, <list> e <map>).

7 Persistenza a cascata Tutti i valori per l attributo cascade: 7 (Come save-update)

8 Persistenza a cascata 8

9 Persistenza a cascata 9 Il valore delete-orphan si può applicare soltanto alle collections

10 Persistenza a cascata E possibile combinare tra loro diverse opzioni. Ecco alcuni esempi: <many-to-one name="parent" column="parent_category_id" class="category" cascade="save-update, persist, merge"/> NOTA: il valore delete-orphan non è incluso quando si sceglie il valore all <set name="bids" cascade="all, delete-orphan" inverse="true"> <key column ="ITEM_ID"/> <one-to-many class="bid"/> </set> 10 NOTA: non vi è nessuna relazione tra l attributo cascade e quello inverse

11 Esempi di cascade Un amministratore deve poter aggiungere, eliminare e modificare tutte le categorie dei prodotti che vende. Il mapping della classe Category: 11 <class name="category" table="category"> <property name="name" column="category_name"/> <many-to-one name="parentcategory" class="category" column="parent_category_id" cascade="none"/> <set name="childcategories" table="category" cascade="save-update" inverse="true"> <key column="parent_category_id"/> <one-to-many class="category"/> </set>... NOTA: si tratta di una associazione autoreferenziata di tipo molti-a-uno

12 Esempi di cascade aggiungere una nuova categoria E possibile aggiungere una categoria in diversi modi: Session session = sessionfactory.opensession(); L oggetto computer Transaction tx = session.begintransaction(); diventa persistent Category computer = (Category) session.load(category.class, computerid); Category laptops = new Category("Laptops"); computer.getchildcategories().add(laptops); laptops.setparentcategory(computer); 12 tx.commit(); session.close(); Completa la bidirezionalità dell associazione L oggetto laptop diventa persistente sotto l effetto del cascade

13 Esempi di cascade aggiungere una nuova categoria: modalità detached La stessa operazione si può fare quando la categoria padre è detached: Queste operazioni in nessuna sessione: Category computer = (Category) session.get( ) // Caricato in una precedente sessione Category laptops = new Category("Laptops"); computer.getchildcategories().add(laptops); laptops.setparentcategory(computer); 13 Queste operazioni in una seconda sessione: Session session = sessionfactory.opensession(); Transaction tx = session.begintransaction(); // Rendere persistente la nuova categoria già linkata a suo padre session.save(laptops); tx.commit(); session.close(); NO CASCADE QUI!!! Cosa succederebbe se il cascade fosse attivato per l associazione <many-to-one>? Hibernate valuta il link verso il padre e aggiunge il riferimento alla riga padre anche nel DB indipendentemente da cascade e inverse

14 Esempi di cascade aggiungere una nuova categoria: modalità detached Vediamo un altro esempio per valutare la convenienza di questo stile detached: Queste operazioni in nessuna sessione: 14 Category computer = (Category) session.get( ) // Caricato in una precedente sessione Category laptops = new Category("Laptops"); Category laptopultraportable = new Category("Ultra-Portable"); Metodi che creano Category laptoptabletpcs = new Category("Tablet PCs"); l associazione in tutte laptops.addchildcategory(laptopultraportable); e due i sensi laptops.addchildcategory(laptoptabletpcs); computer.addchildcategory(laptops); Queste operazioni in una seconda sessione: Session session = sessionfactory.opensession(); Transaction tx = session.begintransaction(); // Rendere persistente tutte le categorie session.save(laptops); tx.commit(); session.close(); Hibernate valuta il link verso il padre e aggiunge il riferimento alla riga padre anche nel DB e poi salva laptop e,a cascata, tutte le sue sottocategorie

15 Esempi di cascade aggiungere una nuova categoria: modalità detached Vediamo ancora un altro esempio per valutare la capacità di updatare (oltre che salvare) a cascata: Queste, dopo aver chiuso la sessione dell esempio precedente:.. //continua dall esempio precedente laptops.setname("laptop Computers"); // Modifica laptopultraportable.setname("ultra-portable Notebooks"); // Mdifica laptoptabletpcs.setname("tablet Computers"); // Modifica Category laptopbags = new Category("Laptop Bags"); laptops.addchildcategory(laptopbags); // Aggiunge Metodo che crea l associazione in tutte e due i sensi Queste operazioni in una seconda sessione: 15 Session session = sessionfactory.opensession(); Transaction tx = session.begintransaction(); // Modifica 3 categorie e ne inserisce una nuova session.saveorupdate(laptops); tx.commit(); session.close(); Hibernate valuta in autonomia cosa deve essere updatato e cosa invece inserito

16 SaveOrUpdate saveorupdate() ha il seguente effetto: Tutto questo deve essere reso persistente non importa se nuovo o vecchio E una buona idea utilizzare sempre il metodo saveorupdate() anche al posto dei singoli save() o update(). Con saveorupdate(), Hibernate determina lo stato dell oggetto (per decidere quale operazione fare delle due) in maniera molto più semplice rispetto ai metodi save() e update() e comunque senza accedere al DB. Vi è solo un caso (raro) in cui Hibernate effettua una select per determinare questo: quando l oggetto utilizza un identificatore composito con campi normali e non si conosce la sua versione (versioning). 16

17 Delete Normalmente la responsabilità della cancellazione degli oggetti ricade sullo sviluppatore che deve controllare se vi sono references all oggetto prima di cancellarlo. Non è possibile cancellare oggetti a cui sono associati altri oggetti. Abilitando il delete-orphan, quando si rimuove un oggetto dalla collection in cui si trova e questi non ha altri references associati, Hibernate provvedere alla sua rimozione automatica. E una proprietà molto interessante che evita allo sviluppatore di compiere la doppia azione di eliminare l oggetto dalla collezione e dallo stato di persistenza 17 E configurabile soltanto all interno dei tag ti tipo collections

18 Delete-orphan 18 Con delete-orphan disattivato: Item anitem =... // Caricato in una sessione precedente anitem.getbids().remove(abid); anitem.getbids().remove(anotherbid); Session session = sessionfactory.opensession(); Transaction tx = session.begintransaction(); session.delete(abid); session.delete(anotherbid); session.saveorupdate(anitem); tx.commit(); session.close(); Con delete-orphan attivato: Update dell oggetto prima di chiudere la sessione perché anitem è detached; se fosse persistent, l update sarebbe inutile Necessarie in quanto la semplice rimozione dalla collection non è una operazione di persistenza. Item anitem =... // Caricata in una precedente sessione anitem.getbids().remove(abid); anitem.getbids().remove(anotherbid); Session session = sessionfactory.opensession(); Transaction tx = session.begintransaction(); session.saveorupdate(anitem); tx.commit(); session.close();

19 bulk and batch operations Quando si manipola una grande mole di dati, il mondo dei DB mette a disposizione la possibilità di scrivere delle funzioni direttamente dulla basedati dette stored procedure Vedremo come Hibernate mette a disposizione degli strumenti per gestire le stored procedure e in generale il problema della massa dei dati. Hibernate consente di modificare gli oggetti direttamente nel DB attraverso il liguaggio HQL 19

20 Updatare oggetti nel DB In Hibernate è possibile updatare gli oggetti direttamente nel DB Queste operazioni sono speciali perché baipassano completamente il persistence context, quindi non hanno nessun effetto sugli oggetti in memoria! Vi sono due modi possibili per procedere: Operare in un nuovo contesto di persistenza Utilizzare il metodo refresh() 20

21 Updatare oggetti nel DB Grazie al linguaggio HQL di Hibernate è possibile lanciare le query che operano direttamente nel DB Ecco un esempio: Query q = session.createquery("update Item i set i.isactive = :isactive"); q.setboolean("isactive", true); int updateditems = q.executeupdate(); Numero di oggetti modificati dall istruzione update La modifica avviene direttamente nel DB. Le query HQL sono molto simili alle istruzioni SQL ma vanno specificate le classi al posto delle tabelle e le proprietà al posto delle colonne. 21

22 Updatare oggetti nel DB Con HQL le update possono essere anche polimorfiche o modificare la versione degli oggetti (versioning). Query q = session.createquery( "update CreditCard set stolenon <= :now where type = 'Visa " ); q.settimestamp("now", new Date() ); int updatedcreditcards = q.executeupdate(); Hibernate conosce la ripartizione dei dati tra le tabelle che mappano la generalizzazione Query q = session.createquery("update versioned Item i set i.isactive = :isactive"); q.setboolean("isactive", true); int updateditems = q.executeupdate(); 22 NOTA: le query HQL non si possono fare join, si può coinvolgere una sola classe alla volta, gli alias sono opzionale e nella were e possibile scrivere delle sottoquery

23 Inserire oggetti nel DB Sempre nell ottica di voler manipolare una grande mole di dati direttamente nel DB, vediamo un esempio di inserimento. Si vuole scrivere una procedura che marchi le carte di credito come rubate e che sposti le informazioni (dati carta, proprietario) in un altra tabella) L idea è quella di usa una istruzione HQL di insert senza passare dal persistent context. 23 Il primo passo è quello di creare una classe apposita da mappare con il DB e il secondo di scrivere l istruzione HQL.

24 Inserire oggetti nel DB Query q = session.createquery ("insert into StolenCreditCard (type, number, expmonth, expyear, ownerfirstname, onwerlastname, ownerlogin, owner address, ownerhomeaddress) select c.type, c.number, c.expmonth, c.expyear, u.firstname, u.lastname, u.username, u. , u.homeaddress from CreditCard c join c.user u where c.stolenon is not null ); int createdobjects = q.executeupdate(); 24

25 Batch query E possibile eseguire una query riportando i dati in memoria in gruppi e non tutti insieme. Ecco un esempio: Session session = sessionfactory.opensession(); Transaction tx = session.begintransaction(); ScrollableResults itemcursor = session.createquery("from Item").scroll(); int count=0; while ( itemcursor.next() ) { Item item = (Item) itemcursor.get(0); modifyitem(item); if ( ++count % 100 == 0 ) { session.flush(); session.clear(); } } tx.commit(); session.close(); Creazione del cursore Spostamento del cursore Elemento a partire dalla posizione corrente Ogni 100 elementi si ripulisce il persistence context 25 Per avere le migliori prestazioni: hibernate.jdbc.batch_size = numero

26 Batch insert E possibile anche inserire e modificare i modalità betch; lo scopo è quello di fare il flushing dei dati e svuotare il persistent context durante l operazione 26 Session session = sessionfactory.opensession(); Transaction tx = session.begintransaction(); for ( int i=0; i<100000; i++ ) { Item item = new Item(...); session.save(item); if ( i % 100 == 0 ) { session.flush(); session.clear(); } } tx.commit(); session.close(); NOTA: sia per le query che per l insert, è opportuno disabilitare la cache di secondo livello per le classi persistenti. Se si utilizza il generatore di identificativo identity, la batch insert potrebbe non essere supportata

27 Data filtering In alcuni casi, per motivi di sicurezza, si vuole mettere a disposizione soltanto una parte dei dati presenti sul DB. Non sempre è possibile scrivere delle query appropriate che dinamicamente selezionano i dati; cosa succede se scrivo unacategoria.getitems()? Ottengo tutti gli item di quella categoria senza possibilità di evitarne alcuni Una soluzione potrebbero essere le viste (view) sul DB, ma queste non sono nello standard di SQL e molti DB non le supportanto 27 Hibernate consente di filtrare i dati dinamicamente attraverso il meccanismo dei filter

28 Dynamic data filter Prima di tutto il filtro va dichiarato nel file XML di configurazione e si assegna un nome univoco (la dichiarazione è globale): <filter-def name="limititemsbyuserrank"> <filter-param name="currentuserrank" type="int"/> </filter-def> A questo punto è possibile aggiungere il filtro ad una classe: Nome del filtro <class name="item" table="item"> Una condizione SQL di... filtraggio degli oggetti Item <filter name="limititemsbyuserrank condition=":currentuserrank >= (select u.rank from USER u where u.user_id = SELLER_ID)"/> </class> 28 Infine, si abilita il filtro per una sessione e si passano gli eventuali parametri Filter filter = session.enablefilter("limititemsbyuserrank"); filter.setparameter("currentuserrank", loggedinuser.getranking());

29 Dynamic data filter E consentito un passaggio di parameri per la condizione del filtro. Il metodo enablefilter() abilita il filtro e torna un oggeto Filter su cui è possibile invorare diversi metodi. I più utili sono: setparameter(): setta un parametro nella condizione del filtro getfilterdefinition(): lista dei parametri del filtro validate(): Hibernate torna una exception se il parametro non è settato. setparameterlist(): setta una lista di argomenti 29

30 Dynamic data filter A questo punto, tutte le query effettuate sulla sessione filtrata otterranno dei dati soggetti all azione del filtro. List<Item> filtereditems = session.createquery("from Item").list(); List<Item> filtereditems = session.createcriteria(item.class).list(); Solo due metodi non sono soggetti al filtro: Recupero attraverso l identificatore Navigazione tramite il metodo set (es: unacategoria().getitem()) Per evitare questo ultimo aspetto, si può filtrare una collection 30

31 Dynamic data filter I campi di applicazione dei filtri sono molti; per citarne alcuni: Sicurezza: per motivi di sicurezza molto spesso è utile limitare l accesso ad una parte dei dati e non a tutto il DB Dati spaziali: si potrebbe limitare l accesso soltanto a quei dati che sono relativi ad una certa regione spaziale Dati temporali: si potrebbe mettere a disposizione dati in un certo intervallo di tempo (ad esempio l ultima settimana) 31

32 Lazy strategy La lazy strategy è la capacità di Hibernate di gestire efficientemente gli oggetti in memoria rimandando (o ritardando) le operazioni a quando sono strettamente necessario, in modo del tutto trasparente all applicazione. Hibernate applica di default, la lazy strategy per tutti i suoi oggetti identity e le collections. La lazy strategy si basa uno dei pattern fondamentali della GoF: proxy. Il comportamento di base attuato da Hibernate per il lazy è: 32 caricare in memoria soltanto gli oggetti che sono stati richiesti

33 Lazy loading Vediamo la logica lazy alla base del recupero di un oggetto dal DB. Consideriamo il caricamento in base all identificatore: Item item = (Item) session.load(item.class, new Long(123)); Per l applicazione, il risultato sarà il caricamento in memoria dell item 123, e l oggetto è nello stato persistent. In realtà, Hibernate proxa l oggetto l oggetto proxato reale e passa all applicazione NO 33 SI Persistence Context item 123 xxx yyy zzz Proxy 123

34 Lazy loading Ogni volta che viene richiesto ad Hibernate il caricamento di un oggetto, esso controlla se può generare un oggetto proxy a runtime per evitare di accedere al DB. 34 Il proxy ritarda (lazy) il momento dell accesso ai dati fino a quando non viene richiesto l accesso alle proprietà dell oggetto. Item item = (Item) session.load(item.class, new Long(123)); item.getid(); item.getdescription(); // Inizializzazione the proxy Ecco un altro esempio: Item item = (Item) session.load(item.class, new Long(123)); User user = (User) session.load(user.class, new Long(1234)); Bid newbid = new Bid("99.99"); newbid.setitem(item); newbid.setbidder(user); session.save(newbid); L identificatore è già presente nel proxy e quindi non scatta l accesso al DB La descrizione no e quindi scatta l accesso al DB C è solo uno spostamento di puntatori e non è necessarie select sul DB

35 Lazy loading 35 IL lazy loading è estremamento ottimizzato. Al momento del caricamento dell oggetto, si ottiene il proxy quando è possibile! Vediamo un esempio: L oggetto notebook è costruito e salvato in una sessione Category notebook = new Category(..); session2.save(notebook); tx.commit(); session2.close(); //creazione di una nuova sessione con persistence context vuoto. Session session3 = sessionfactory.opensession(); Transaction tx3 = session3.begintransaction(); session3.update(notebook); //senza questa istruzione si ha il proxy //recupero l oggetto notebook salvato in precedenza Category altronotebook= (Category)session3.load(Category.class, new Long(3)); System.out.println("CLASS: " + altronotebook.getclass()); //Category System.out.println("CLASS: " + notebook.getclass()); //Category System.out.println (" IDENTICI: " + altronotebook == notebook); //true L oggetto notebook diventa persistent nella nuova sessione Il persistent context già possiede l oggetto ma di tipo Category; viene restituito questo e non un proxy

36 Lazy loading Il metodo get(), al contrario di load() non torna mai un proxy. Se si vuole la classe reale dell oggetto proxato si può utilizzare un metodo statico di Hibernate: HibernateProxyHelper.getClassWithoutInitializingProxy(obj); Una volta che il proxy è costretto ad accedere al DB, questo si dice inizializzato. In questo caso vengono caricati i dati dal DB ma sempre in una ottica lazy. Hibernate, quando carica un oggetto, cercherà di minimizzare l accesso al DB e di minimizzare l occupazione di spazio di memoria per quell oggetto 36

37 Lazy loading Quando un oggetto Item, ad esempio, è inizializzato, si presenta così: Hibernate costruirà una serie di proxy, uno per ogni associazione *-a-uno presenti nella classe Item Hibernate costruirà una sorta di segnaposto per tutte le collezioni presenti nella classe Item (si parla di segnaposto perché Hibernate wrappa le collection originali con sue collections interne). 37 Le proprietà value e i componenti vengono caricati subito (no lazy)

38 Lazy loading Le collections vengono inizializzate quando si comincia a navigare all interno o quando si chiamano metodi di supporto come size() o contains(). Per le collections, Hibernate adotta un extra lazy: <class name="item" table="item">... <set name="bids" lazy="extra". Con lazy=extra, quando vengono effettuate chiamate ai metodi di supporto, Hibernate non inizializza la collection ma, per ottenere le informazioni, effettua query diretta al DB 38

39 Eager strategy Cosa succede se si tenta di navigare un oggetto proxato non inizializzato o con elementi non inizializzati fuori da una sessione (l oggetto detached)? Si ottiene una LazyInitializationException! Hibernate non è più in grado di recuperare gli oggetti associati perché il persistence context è ormai chiuso. Naturalmente, non sempre il proxy è desiderabile soprattutto per le collections. Hibernate ha una seconda strategia di caricamento dei dati: eager strategy. 39 La eager strategy carica subito l oggetto in ogni sua parte!

40 Eager strategy Non si vuole disabilitare la gestione proxy per tutte le classi; questo sarebbe disastroso per le performance dell applicazioni; Con lazy=false, si disabilita la lazy strategy per una certa classe. Ecco un esempio tra Item e User: 40 <class name="item" table="item">... <many-to-one name="seller lazy="false".../> <set name="bids" lazy="false" inverse="true"> <key column="item_id"/> <one-to-many class="bid"/> </set>... </class>

41 Domande? Eager strategy Lazy load Batch insert reachability Data filter cascade 41 Batch query proxy