Proxy hibernált terhelés () módszerrel

1. Áttekintés

Ebben az oktatóanyagban megnézzük, mi a proxy a Hibernate's kontextusában Betöltés() módszer.

A Hibernate számára új olvasók számára fontolja meg először az alapok megismerését.

2. Rövid bevezetés a meghatalmazottakhoz és Betöltés() Módszer

A meghatalmazás definíció szerint „olyan funkció, amely felhatalmazást kapott arra, hogy helyettesként vagy egy másik helyetteseként működjön”..

Ez a hibernált állapotra vonatkozik, amikor hívunk Session.load () hogy létrehozzák az úgynevezett an inicializálatlan proxy a kívánt entitásosztályunkból.

Egyszerűen fogalmazva, a Hibernate az alosztályba sorolja az entitásosztályunkat, a CGLib könyvtár. A @Id metódus esetén a proxy implementáció minden más tulajdonság metódust delegál a hibernált munkamenetbe a példány feltöltésére, némileg hasonlóan:

a HibernateProxy nyilvános osztály kiterjeszti a MyEntity {private MyEntity targetet; public String getFirstName () {if (target == null) {target = readFromDatabase (); } return target.getFirstName (); }}

Ezt az alosztályt kell visszaadni ahelyett, hogy közvetlenül lekérdezné az adatbázist.

Miután meghívta az entitás metódusainak egyikét, az entitás betöltődik, és ezen a ponton lesz an inicializált proxy.

3. Meghatalmazottak és Lusta Betöltés

3.1. Egyetlen entitás

Gondoljuk át Munkavállaló mint entitás. Először feltételezzük, hogy nincs kapcsolata más táblákkal.

Ha használjuk Session.load () hogy példányosítson egy Munkavállaló:

Alkalmazott albert = session.load (Employee.class, new Long (1));

Ezután a Hibernate létrehoz egy inicializálatlan proxyt a Munkavállaló. Tartalmazza azt az azonosítót, amelyet megadtunk neki, de különben nem lesz más értéke, mert még nem értük el az adatbázist.

Ha azonban egy módszert hívunk be albert:

Karakterlánc keresztnév = albert.getFirstName ();

Ezután Hibernate lekérdezi a munkavállaló adatbázistábla egy entitáshoz, amelynek elsődleges kulcsa 1, feltöltve albert a megfelelő sorból származó tulajdonságokkal.

Ha nem talál egy sort, akkor a Hibernate dob egy ObjectNotFoundException.

3.2. Egy a sokhoz viszony

Most hozzunk létre egy Vállalat entitás is, ahol a Vállalat sok van Alkalmazottak:

public class Company {private String name; magánszett alkalmazottak; }

Ha ezúttal használjuk Session.load () a vállalatnál:

Vállalati bizco = session.load (Vállalati osztály, új Hosszú (1)); Karakterlánc neve = bizco.getName ();

Ezután a vállalat tulajdonságai a korábbiakhoz hasonlóan kerülnek feltöltésre, azzal a különbséggel, hogy az alkalmazottak száma csak egy kicsit más.

Lám, csak a vállalati sorra kérdeztünk, de a meghatalmazott békén hagyja a munkavállalót, amíg felhívjuk getEmployees a beolvasási stratégiától függően.

3.3. Sok-egy kapcsolat

Az eset hasonló az ellenkező irányba:

public class Alkalmazott {private String keresztnév; magánvállalati munkahely; }

Ha használjuk Betöltés() újra:

Employee bob = session.load (Employee.class, new Long (2)); String firstName = bob.getFirstName ();

bob most inicializálásra kerül, és valójában munkahely most inicializálatlan proxy lesz, a letöltési stratégiától függően.

4. Lusta-ish betöltése

Most, Betöltés() nem mindig ad inicializálatlan proxyt. Valójában a Ülés java doc emlékeztet minket (kiemelés hozzáadva):

Ez a módszer esetleg egy nem azonosító módszer elérésekor igény szerint inicializált proxy példányt ad vissza.

Egyszerű példa arra, hogy ez mikor történhet meg, a kötegméret.

Tegyük fel, hogy használjuk @Csomó méret miénken Munkavállaló entitás:

@Entity @BatchSize (size = 5) osztály alkalmazott {// ...}

És ezúttal három alkalmazottunk van:

Catherine alkalmazott = session.load (Employee.class, új Long (3)); Alkalmazott darrell = session.load (Employee.class, új Long (4)); Employee emma = session.load (Employee.class, new Long (5));

Ha hívunk getFirstName tovább Katalin:

String cathy = catherine.getFirstName ();

Ezután a Hibernate úgy dönthet, hogy mindhárom alkalmazottat egyszerre terheli, mindhármat inicializált proxyként változtatja meg.

És akkor, amikor felhívjuk darrellKeresztneve:

Karakterlánc darrell = darrell.getFirstName ();

Azután A hibernálás egyáltalán nem éri el az adatbázist.

5. Lelkes betöltés

5.1. Használata kap()

Teljes mértékben megkerülhetjük a proxykat is, és megkérhetjük a Hibernate-et, hogy töltse be az igazi dolgot Session.get ():

Employee finnigan = session.get (Employee.class, new Long (6));

Ez a proxy visszaadása helyett azonnal meghívja az adatbázist.

És valójában egy helyett ObjectNotFoundException, akkor visszatér nulla ha finnigan nem létezik.

5.2. Teljesítményre gyakorolt ​​hatások

Míg kap() kényelmes, Betöltés() könnyebb lehet az adatbázisban.

Például mondjuk gerald új cégnél fog dolgozni:

Gerald alkalmazott = session.get (Employee.class, új Long (7)); Company worldco = (Vállalat) session.load (Vállalat.osztály, új Hosszú (2)); alkalmazott.setCompany (worldco); session.save (alkalmazott);

Mivel tudjuk, hogy csak változtatni fogunk a munkavállaló rekord ebben a helyzetben, hívás Betöltés() mert Vállalat értelmes.

Ha felhívnánk kap() tovább Vállalat, akkor minden adatát feleslegesen töltöttük volna be az adatbázisból.

6. Következtetés

Ebben a cikkben röviden megtudtuk, hogyan Hibernálás a proxyk működnek, és ez hogyan befolyásolja a Betöltés módszer entitásokkal és kapcsolataikkal.

Ezenkívül gyorsan megnéztük, hogyan Betöltés() különbözik kap().

Szokás szerint az oktatóanyaghoz tartozó teljes forráskód elérhető a GitHubon.