streamalism.org

1. Introduksjon

EntityManager er en del av Java Persistence API. Hovedsakelig implementerer den programmeringsgrensesnittene og livssyklusreglene definert av JPA 2.0-spesifikasjonen.

Videre kan vi få tilgang til Persistence Context, ved å bruke APIene i EntityManager.

I denne opplæringen tar vi en titt på konfigurasjonen, typene og forskjellige API-er for EntityManager.

2. Maven-avhengigheter

Først må vi inkludere avhengighetene til dvalemodus:

 org. dvalemodus dvalekjerne 5.4.0.Final 

Vi må også inkludere driveravhengighet, avhengig av databasen vi bruker:

 mysql mysql-connector-java 8.0.13 

Avhengighetene dvalemodus og mysql-connector-java er tilgjengelig på Maven Central.

3. Konfigurasjon

La oss demonstrere EntityManager, ved å bruke en Film enhet som tilsvarer en MOVIE-tabell i databasen.

I løpet av denne artikkelen vil vi bruke EntityManager API for å jobbe med Film objekter i databasen.

3.1. Definere enheten

La oss starte med å opprette enheten som tilsvarer MOVIE-tabellen, ved hjelp av @Enhet kommentar:

@Entity @Table (name = "MOVIE") offentlig klasse film {@Id privat Lang id; private String movieName; privat Heltallutgivelse År; private String språk; // standard konstruktør, getters, setters}

3.2. De persistence.xml Fil

Når EntityManagerFactory er skapt, vedvarende implementering søker etter META-INF / persistence.xml filen i klassestien.

Denne filen inneholder konfigurasjonen for EntityManager:

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

For å forklare definerer vi utholdenhetsenheten som spesifiserer den underliggende datalageret som administreres av EntityManager.

Videre definerer vi dialekten og de andre JDBC-egenskapene til den underliggende datalageret. Dvalemodus er database-agnostisk. Basert på disse egenskapene kobles dvalemodus med den underliggende databasen.

4. Beholder og applikasjon administrert EntityManager

I utgangspunktet, det er to typer EntityManager: Container-Managed og Application-Managed.

La oss se nærmere på hver type.

4.1. Container-Managed EntityManager

Her injiserer beholderen EntityManager i bedriftens komponenter.

Med andre ord oppretter containeren EntityManager fra EntityManagerFactory for oss:

@PersistenceContext EntityManager entityManager; 

Dette betyr også containeren har ansvaret for å starte transaksjonen, samt å begå eller rulle den tilbake.

På samme måte er containeren ansvarlig for å lukke EntityManager, så det er trygt å brukeuten manuell opprydding. Selv om vi prøver å lukk a containerstyrt EntityManager, det skal kaste en IllegalStateException.

4.2. Programstyrt EntityManager

Motsatt, livssyklusen til EntityManager administreres av applikasjonen her.

Faktisk oppretter vi manuelt EntityManager. Videre vil vi også administrere livssyklusen til EntityManager vi har skapt.

La oss først lage EntityManagerFactory:

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

For å skape en EntityManager, må vi eksplisitt ringe createEntityManager () i EntityManagerFactory:

offentlig statisk EntityManager getEntityManager () {return emf.createEntityManager (); }

Siden vi er ansvarlige for å skape EntityManager tilfeller er det også vårt ansvar å lukke dem. Derfor burde vi Lukk Hver EntityManager når vi er ferdig med å bruke dem.

4.3. Trådsikkerhet

De EntityManagerFactory tilfeller og følgelig dvalemodus SessionFactory tilfeller, er trådsikre. Så det er helt trygt i samtidige sammenhenger å skrive:

EntityManagerFactory emf = // hentet fra et sted EntityManager em = emf.createEntityManager ();

På den andre siden, de EntityManager tilfeller er ikke trådsikre og er ment å brukes i trådbegrensede miljøer. Dette betyr at hver tråd skal få sin forekomst, jobbe med den og lukke den på slutten.

Når du bruker applikasjonsstyrt EntityManagers, det er enkelt å lage trådbegrensede forekomster:

EntityManagerFactory emf = // hentet fra et sted EntityManager em = emf.createEntityManager (); // bruk den i gjeldende tråd

Ting blir imidlertid kontraintuitive når du bruker containeradministrert EntityManagers. For eksempel:

@Service offentlig klasse MovieService {@PersistenceContext // eller til og med @Autowired privat EntityManager entityManager; // utelatt}

Det ser ut til at en EntityManager forekomst skal deles for alle operasjoner. Imidlertid injiserer containeren (JakartaEE eller Spring) en spesiell proxy i stedet for en enkel EntityManager her. Våren injiserer for eksempel en proxy av typen SharedEntityManagerCreator.

Hver gang vi bruker den injiserte EntityManager, denne fullmakten vil enten bruke den eksisterende EntityManager eller opprett en ny. Gjenbruk skjer vanligvis når vi aktiverer noe sånt Åpne Session / EntityManager i View.

Uansett, containeren sørger for at hver EntityManager er begrenset til en tråd.

5. Dvalemodusenhetsoperasjoner

De EntityManager API gir en samling metoder. Vi kan samhandle med databasen ved å bruke disse metodene.

5.1. Vedvarende enheter

For å ha et objekt tilknyttet EntityManager, kan vi benytte oss av fortsette() metode:

offentlig ugyldig saveMovie () {EntityManager em = getEntityManager (); em.getTransaction (). begynner (); Filmfilm = ny film (); movie.setId (1L); movie.setMovieName ("Gudfaren"); movie.setReleaseYear (1972); movie.setLanguage ("engelsk"); em.persist (film); em.getTransaction (). commit (); }

Når objektet er lagret i databasen, er det i vedvarende stat.

5.2. Laster inn enheter

For å hente et objekt fra databasen, kan vi bruke finne() metode.

Her søker metoden etter primærnøkkelen. Faktisk forventer metoden enhetsklassen og primærnøkkelen:

offentlig film getMovie (lang filmId) {EntityManager em = getEntityManager (); Filmfilm = em.find (Movie.class, new Long (movieId)); em.detach (film); returfilm; }

Men hvis vi bare trenger referansen til enheten, kan vi bruke getReference () metode i stedet. I virkeligheten returnerer den en proxy til enheten:

Movie movieRef = em.getReference (Movie.class, new Long (movieId));

5.3. Koble enheter

I tilfelle vi trenger å løsrive en enhet fra utholdenhetskonteksten, vi kan bruke løsne() metode. Vi sender objektet som skal løsnes som parameter til metoden:

em.detach (film);

Når enheten er løsrevet fra utholdenhetskonteksten, vil den være i løsrevet tilstand.

5.4. Sammenslåing av enheter

I praksis krever mange applikasjoner enhetsendring på tvers av flere transaksjoner. For eksempel kan det være lurt å hente en enhet i en transaksjon for gjengivelse til brukergrensesnittet. Deretter vil en annen transaksjon bringe inn endringene som er gjort i brukergrensesnittet.

Vi kan benytte oss av slå sammen() metode, for slike situasjoner. Sammenslåingsmetoden hjelper til med å bringe inn endringene som er gjort til den frittliggende enheten, i den administrerte enheten, hvis noen:

offentlig ugyldig mergeMovie () {EntityManager em = getEntityManager (); Filmfilm = getMovie (1L); em.detach (film); movie.setLanguage ("italiensk"); em.getTransaction (). begynn (); em.merge (film); em.getTransaction (). commit (); }

5.5. Spørring etter enheter

Videre kan vi bruke JPQL til å spørre etter enheter. Vi påberoper oss getResultList () å henrette dem.

Selvfølgelig kan vi bruke getSingleResult (), hvis spørringen returnerer bare et enkelt objekt:

public List queryForMovies () {EntityManager em = getEntityManager (); Liste filmer = em.createQuery ("VELG film fra filmfilm der movie.language =? 1") .setParameter (1, "engelsk") .getResultList (); returnere filmer; }

5.6. Fjerner enheter

I tillegg vi kan fjerne en enhet fra databasen ved hjelp av fjerne() metode. Det er viktig å merke seg at objektet ikke er løsrevet, men fjernet.

Her endres enhetens tilstand fra vedvarende til ny:

offentlig ugyldig removeMovie () {EntityManager em = HibernateOperations.getEntityManager (); em.getTransaction (). begynn (); Filmfilm = em.find (Movie.class, new Long (1L)); em.remove (film); em.getTransaction (). commit (); }

6. Konklusjon

I denne artikkelen har vi utforsket EntityManager i Dvalemodus. Vi har sett på typene og konfigurasjonen, og vi har lært om de forskjellige metodene som er tilgjengelige i API for å jobbe med utholdenhetskontekst.

Som alltid er koden som brukes i artikkelen tilgjengelig på Github.