Ibernazione: differenza tra session.get e session.load

Dall'API, ho potuto vedere che ha qualcosa a che fare con il proxy. Ma non sono riuscito a trovare molte informazioni su proxy e non capisco la differenza tra chiamata session.gete session.load. Qualcuno potrebbe spiegarmi o indirizzarmi a una pagina di riferimento?

Grazie!!

Dal forum di Hibernate :

Questo dal libro Hibernate in Action. Bravo leggere questo ..

Recupero di oggetti in base all'identificatore Il seguente frammento di codice Hibernate recupera un oggetto Utente dal database:

User user = (User) session.get(User.class, userID);

Il metodo get () è speciale perché l'identificatore identifica in modo univoco una singola istanza di una classe. Quindi è comune per le applicazioni utilizzare l'identificatore come una comoda maniglia per un oggetto persistente. Il recupero per identificatore può utilizzare la cache durante il recupero di un oggetto, evitando un accesso al database se l'oggetto è già memorizzato nella cache. Hibernate fornisce anche un metodo load ():

User user = (User) session.load(User.class, userID);

Il metodo load () è più vecchio; get () è stato aggiunto all'API di Hibernate a causa della richiesta dell'utente. La differenza è banale:

Se load () non riesce a trovare l'oggetto nella cache o nel database, viene generata un'eccezione. Il metodo load () non restituisce mai null. Il metodo get () restituisce null se l'oggetto non può essere trovato.

Il metodo load () può restituire un proxy invece di una vera istanza persistente. Un proxy è un segnaposto che attiva il caricamento dell'oggetto reale quando vi si accede per la prima volta; D'altra parte, get () non restituisce mai un proxy. Scegliere tra get () e load () è facile: se sei certo che l'oggetto persistente esista e che la non esistenza sarebbe considerata eccezionale, load () è una buona opzione. Se non sei sicuro che esista un'istanza persistente con l'identificatore fornito, usa get () e verifica il valore restituito per vedere se è nullo. L'uso di load () ha un'ulteriore implicazione: l'applicazione può recuperare un riferimento valido (un proxy) a un'istanza persistente senza premere il database per recuperare il suo stato persistente. Quindi load () potrebbe non generare un'eccezione quando non trova l'oggetto persistente nella cache o nel database; l'eccezione verrebbe lanciata in seguito, quando si accede al proxy. Ovviamente, il recupero di un oggetto tramite identificatore non è flessibile quanto l'utilizzo di query arbitrarie.

Bene, almeno in nhibernate, session.Get (id) caricherà l'oggetto dal database, mentre session.Load (id) crea solo un oggetto proxy senza lasciare il tuo server. Funziona proprio come ogni altra proprietà con caricamento lento nei tuoi POCO (o POJO :). È quindi possibile utilizzare questo proxy come riferimento all'oggetto stesso per creare relazioni, ecc.

Pensa come avere un oggetto che conserva solo l'Id e che caricherà il resto se ne avrai bisogno. Se lo passi solo per creare relazioni (come FK), l'id è tutto ciò di cui avrai bisogno.

session.load () restituirà sempre un "proxy" (termine Hibernate) senza colpire il database. In Hibernate, il proxy è un oggetto con il valore identificativo specificato, le sue proprietà non sono ancora inizializzate, sembra solo un oggetto falso temporaneo. Se non viene trovata alcuna riga, verrà generata un'eccezione ObjectNotFoundException.

session.get () colpisce sempre il database e restituisce l'oggetto reale, un oggetto che rappresenta la riga del database, non il proxy. Se non viene trovata alcuna riga, restituisce null.

Anche le prestazioni con questi metodi rendono diff. tra due...

Un punto extra in più:

get metodo della classe Hibernate Session restituisce null se l'oggetto non viene trovato nella cache così come nel database. mentre il metodo load () genera ObjectNotFoundException se l'oggetto non viene trovato nella cache e nel database ma non restituisce mai null.

Una conseguenza indiretta dell'utilizzo di "load" invece di "get" è che il blocco ottimistico utilizzando un attributo di versione potrebbe non funzionare come ci si aspetterebbe. Se un caricamento crea semplicemente un proxy e non legge dal database, la proprietà version non viene caricata. La versione verrà caricata solo quando / se successivamente si fa riferimento a una proprietà sull'oggetto, attivando una selezione. Nel frattempo, un'altra sessione può aggiornare l'oggetto e la tua sessione non avrà la versione originale necessaria per eseguire il controllo ottimistico del blocco, quindi l'aggiornamento della tua sessione sovrascriverà l'aggiornamento dell'altra sessione senza alcun avviso.

Ecco un tentativo di abbozzare questo scenario con due sessioni che lavorano con un oggetto con lo stesso identificatore. La versione iniziale per l'oggetto in DB è 10.

Session 1                  Session 2
---------                  ---------
Load object
Wait a while..   
                           Load object
                           Modify object property
                           [triggers db 'select' -
                            version read as 10]
                           Commit
                           [triggers db update,
                            version modified to 11]
Modify object property
  [triggers db 'select' -
  version read as 11]
Commit
  [triggers db update,
  version modified to 12]

Vogliamo effettivamente che il commit della sessione 1 fallisca con un'eccezione di blocco ottimistica, ma qui avrà successo.

Usare "get" invece di "load" aggira il problema, perché get emetterà immediatamente una selezione ei numeri di versione verranno caricati al momento giusto per il controllo ottimistico del blocco.

Inoltre dobbiamo stare attenti durante l'utilizzo di load poiché genererà un'eccezione se l'oggetto non è presente. Dobbiamo usarlo solo quando siamo sicuri che l'oggetto esiste.

Un'eccellente spiegazione si trova su http://www.mkyong.com/hibernate/different-between-session-get-and-session-load
session.load ():
restituirà sempre un "proxy" (termine Hibernate) senza colpire il database.
In Hibernate, il proxy è un oggetto con il valore identificativo specificato, le sue proprietà non sono ancora inizializzate, sembra solo un oggetto falso temporaneo.
Restituirà sempre un oggetto proxy con il valore di identità specificato, anche se il valore di identità non esiste nel database. Tuttavia, quando si tenta di inizializzare un proxy recuperando le sue proprietà dal database, verrà raggiunto il database con l'istruzione select. Se non viene trovata alcuna riga, verrà generata un'eccezione ObjectNotFoundException.
session.get ():
Colpisce sempre il database (se non viene trovato nella cache) e restituisce l'oggetto reale, un oggetto che rappresenta la riga del database, non il proxy.
Se non viene trovata alcuna riga, restituisce null.

load () non riesce a trovare l'oggetto dalla cache o dal database, viene generata un'eccezione e il metodo load () non restituisce mai null.

Il metodo get () restituisce null se l'oggetto non può essere trovato. Il metodo load () può restituire un proxy invece di una vera istanza persistente get () non restituisce mai un proxy.