Útmutató a hibernált entitáskezelőhöz

1. Bemutatkozás

EntityManager a Java Persistence API része. Elsősorban a JPA 2.0 specifikáció által meghatározott programozási felületeket és életciklus-szabályokat hajtja végre.

Ezenkívül elérhetjük a perzisztencia-kontextust az API-k használatával EntityManager.

Ebben az oktatóanyagban megvizsgáljuk a konfigurációt, típusokat és a különböző API-kat EntityManager.

2. Maven-függőségek

Először bele kell foglalnunk a Hibernate függőségeit:

 org.hibernate hibernate-core 5.4.0.Végső 

Az illesztőprogram-függőségeket is fel kell vennünk, a használt adatbázistól függően:

 mysql mysql-connector-java 8.0.13 

A hibernate-core és a mysql-connector-java függőségek a Maven Centralon érhetők el.

3. Konfiguráció

Most mutassuk be a EntityManager, az a használatával Film entitás, amely megfelel az MOVIE táblának az adatbázisban.

A cikk folyamán felhasználjuk a EntityManager API a Film objektumok az adatbázisban.

3.1. Az entitás meghatározása

Kezdjük azzal, hogy létrehozzuk a MOVIE táblának megfelelő entitást, a @Entity kommentár:

@Entity @Table (name = "MOVIE") public class Movie {@Id private Long id; privát karakterlánc filmNév; magán egész szám kiadása év; privát String nyelv; // szabványos kivitelező, mérőeszközök, beállítók}

3.2. A kitartás.xml File

Amikor az EntityManagerFactory létrehozva, a kitartó megvalósítás a META-INF / persistence.xml fájlt az osztályútvonalon.

Ez a fájl tartalmazza a EntityManager:

 Hibernate EntityManager Demo com.baeldung.hibernate.pojo.Movie true 

Magyarázatként meghatározzuk azt a perzisztencia-egységet, amely meghatározza a. Által kezelt mögöttes adattárolót EntityManager.

Továbbá meghatározzuk a dialektust és az alapul szolgáló adattár többi JDBC tulajdonságát. A hibernálás adatbázis-agnosztikus. Ezen tulajdonságok alapján a Hibernate kapcsolatba lép az alapul szolgáló adatbázissal.

4. Konténer és alkalmazás kezelése EntityManager

Alapvetően, kétféle van EntityManager: Konténerkezelés és alkalmazáskezelés.

Nézzük meg közelebbről az egyes típusokat.

4.1. Konténer-kezelt EntityManager

Itt a konténer befecskendezi a EntityManager vállalati komponenseinkben.

Más szavakkal, a konténer létrehozza a EntityManager tól EntityManagerFactory nekünk:

@PersistenceContext EntityManager entitásManager; 

Ez azt is jelenti a konténer felelős a tranzakció megkezdéséért, valamint annak végrehajtásáért vagy visszagörgetéséért.

Hasonlóképpen a konténer feladata a csomag bezárása EntityManager, tehát biztonságos a használatakézi tisztítás nélkül. Még ha megpróbáljuk is bezár a konténerkezelt EntityManager, meg kell dobnia egy IllegalStateException.

4.2. Alkalmazás-kezelt EntityManager

Ezzel szemben a EntityManager itt található alkalmazás kezeli.

Valójában manuálisan fogjuk létrehozni a EntityManager. Ezenkívül kezelni fogjuk a EntityManager hoztunk létre.

Először hozzuk létre a EntityManagerFactory:

EntityManagerFactory emf = Persistence.createEntityManagerFactory ("com.baeldung.movie_catalog");

Annak létrehozása érdekében EntityManager, kifejezetten felhívnunk kell createEntityManager () ban,-ben EntityManagerFactory:

public static EntityManager getEntityManager () {return emf.createEntityManager (); }

Mivel mi vagyunk felelősek az alkotásért EntityManager esetekben az is felelősségünk, hogy bezárjuk őket. Ezért kellene Bezárás minden egyes EntityManager amikor befejeztük a használatukat.

4.3. Menetbiztonság

A EntityManagerFactory példák és következésképpen a Hibernate SessionFactory szálak biztonságosak. Tehát párhuzamos körülmények között teljesen biztonságos írni:

EntityManagerFactory emf = // valahonnan letöltött EntityManager em = emf.createEntityManager ();

Másrészről, a EntityManager a példányok nem biztonságosak a szálak számára, és szálakkal korlátozott környezetekben használhatók. Ez azt jelenti, hogy minden szálnak meg kell szereznie a példányát, együtt kell működnie vele, és a végén le kell zárnia.

Alkalmazás által kezelt használatakor EntityManagers, könnyű szálakkal korlátozott példányokat létrehozni:

EntityManagerFactory emf = // valahonnan beolvasva EntityManager em = emf.createEntityManager (); // használja az aktuális szálban

A konténerkezelés használatakor azonban a dolgok ellentmondásossá válnak EntityManagers. Például:

@Service public class MovieService {@PersistenceContext // vagy akár @Autowired private EntityManager entitásManager; // kihagyva}

Úgy tűnik, hogy az egyik EntityManager példányt meg kell osztani az összes műveletnél. A konténer (JakartaEE vagy Spring) azonban az egyszerű helyett speciális proxyt injektál EntityManager itt. Például Spring egy tipusú proxyt injektál SharedEntityManagerCreator.

Minden alkalommal, amikor az injekciót használjuk EntityManager, ez a proxy vagy újra felhasználja a meglévőt EntityManager vagy újat hozhat létre. Az újrafelhasználás általában akkor fordul elő, amikor ilyesmit engedélyezünk Nyissa meg a Session / EntityManager programot a Nézetben.

Másik út, a tartály biztosítja, hogy mindegyik EntityManager egy szálra korlátozódik.

5. Hibernált entitás műveletek

A EntityManager Az API módszerek gyűjteményét biztosítja. Ezekkel a módszerekkel kölcsönhatásba léphetünk az adatbázissal.

5.1. Megmaradó entitások

Annak érdekében, hogy egy objektum társuljon az EntityManagerhez, használhatjuk a kitartani () módszer:

public void saveMovie () {EntityManager em = getEntityManager (); em.getTransaction (). begin (); Filmfilm = új film (); film.setId (1L); film.setMovieName ("A keresztapa"); film.setReleaseYear (1972); movie.setLanguage ("angol"); em.ellenőr (film); em.getTransaction (). kötelezettség (); }

Miután az objektum mentésre került az adatbázisban, az az kitartó állapot.

5.2. Entitások betöltése

Egy objektum adatbázisból történő lekérése céljából használhatjuk a megtalálja() módszer.

Itt a módszer az elsődleges kulcs alapján keres. Valójában a módszer az entitásosztálytípust és az elsődleges kulcsot várja:

public Movie getMovie (Long movieId) {EntityManager em = getEntityManager (); Filmfilm = em.find (Film.osztály, új Hosszú (movieId)); em.detach (film); visszatérő film; }

Ha azonban csak az entitásra való hivatkozásra van szükségünk, használhatjuk a getReference () módszer helyett. Valójában egy proxyt ad vissza az entitásnak:

Movie movieRef = em.getReference (Film.osztály, új Hosszú (movieId));

5.3. Entitások leválasztása

Abban az esetben, ha le kell választanunk egy entitást a perzisztencia kontextusáról, használhatjuk a leválaszt () módszer. Paraméterként átadjuk a leválasztandó objektumot a metódusnak:

em.detach (film);

Amint az entitás leválik a perzisztencia-kontextusról, leválasztott állapotban lesz.

5.4. Egységek egyesítése

A gyakorlatban sok alkalmazás igényli az entitás módosítását több tranzakció során. Például előfordulhat, hogy egy tranzakcióban szeretnénk lekérni egy entitást, hogy megjelenjen a felhasználói felületen. Ezután egy újabb tranzakció behozza a felhasználói felületen végrehajtott módosításokat.

Használhatjuk a összeolvad() módszer, ilyen helyzetekre. Az egyesítési módszer segít a leválasztott entitásban, a kezelt entitásban végrehajtott módosítások behozatalában, ha vannak ilyenek:

public void mergeMovie () {EntityManager em = getEntityManager (); Filmfilm = getMovie (1L); em.detach (film); film.setLanguage ("olasz"); em.getTransaction (). begin (); em.merge (film); em.getTransaction (). kötelezettség (); }

5.5. Entitások lekérdezése

Ezenkívül felhasználhatjuk a JPQL-t az entitások lekérdezéséhez. Fel fogjuk hívni getResultList () hogy kivégezzék őket.

Természetesen használhatjuk a getSingleResult (), ha a lekérdezés csak egyetlen objektumot ad vissza:

public List queryForMovies () {EntityManager em = getEntityManager (); Sorolja fel a filmeket = em.createQuery ("Válasszon filmet a filmfilmből, ahol a film.nyelv =? 1") .setParameter (1, "angol") .getResultList (); visszatérő filmek; }

5.6. Entitások eltávolítása

Ezenkívül eltávolíthatunk egy entitást az adatbázisból a eltávolítás () módszer. Fontos megjegyezni, hogy az objektumot nem leválasztják, hanem eltávolítják.

Itt az entitás állapota tartósról újra változik:

public void removeMovie () {EntityManager em = HibernateOperations.getEntityManager (); em.getTransaction (). begin (); Filmfilm = em.find (Film.osztály, új Long (1L)); em.eltávolítás (film); em.getTransaction (). kötelezettség (); }

6. Következtetés

Ebben a cikkben feltártuk a EntityManager ban ben Hibernálás. Megnéztük a típusokat és a konfigurációt, és megismerkedtünk az API-val elérhető különféle módszerekkel a kitartás összefüggései.

Mint mindig, a cikkben használt kód elérhető a Github oldalon.


$config[zx-auto] not found$config[zx-overlay] not found