streamalism.org

1. Introduktion

EntityManager er en del af Java Persistence API. Hovedsageligt implementerer den programmeringsgrænsefladerne og livscyklusreglerne defineret af JPA 2.0-specifikationen.

Desuden kan vi få adgang til Persistence Context ved at bruge API'erne i EntityManager.

I denne vejledning ser vi på konfiguration, typer og forskellige API'er til EntityManager.

2. Maven-afhængigheder

Først skal vi inkludere afhængighederne i dvale:

 org. dvale-dvale-core 5.4.0.Final 

Vi bliver også nødt til at medtage driverafhængigheder afhængigt af den database, vi bruger:

 mysql mysql-connector-java 8.0.13 

Afhængighederne i dvale-kerne og mysql-stik-java er tilgængelige på Maven Central.

3. Konfiguration

Lad os nu demonstrere EntityManager, ved hjælp af en Film enhed, der svarer til en MOVIE-tabel i databasen.

I løbet af denne artikel vil vi gøre brug af EntityManager API til at arbejde med Film objekter i databasen.

3.1. Definition af enheden

Lad os starte med at oprette den enhed, der svarer til MOVIE-tabellen, ved hjælp af @Enhed kommentar:

@Entity @Table (name = "MOVIE") offentlig klasse film {@Id privat Lang id; privat streng filmnavn; privat heltal frigivelse år; private String sprog; // standard konstruktør, getters, setters}

3.2. Det persistence.xml Fil

Når EntityManagerFactory er oprettet, persistensimplementeringen søger efter META-INF / persistence.xml fil i klassestien.

Denne fil indeholder konfigurationen til EntityManager:

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

For at forklare definerer vi persistens-enheden, der specificerer den underliggende datalager, der administreres af EntityManager.

Desuden definerer vi dialekten og de andre JDBC-egenskaber i den underliggende datalager. Dvaletilstand er database-agnostisk. Baseret på disse egenskaber forbinder dvale med den underliggende database.

4. Container og applikationsadministreret EntityManager

I bund og grund, der er to typer EntityManager: Container-Managed og Application-Managed.

Lad os se nærmere på hver type.

4.1. Container-administreret EntityManager

Her injicerer beholderen beholderen EntityManager i vores virksomhedskomponenter.

Med andre ord opretter containeren EntityManager fra EntityManagerFactory for os:

@PersistenceContext EntityManager entityManager; 

Dette betyder også containeren er ansvarlig for påbegyndelse af transaktionen samt forpligte eller rulle den tilbage.

Tilsvarende er containeren ansvarlig for at lukke EntityManager, så det er sikkert at brugeuden manuel oprydning. Selv hvis vi prøver luk en containeradministreret EntityManager, det skal kaste en IllegalStateException.

4.2. Applikationsstyret EntityManager

Omvendt er livscyklussen for EntityManager styres af applikationen her.

Faktisk opretter vi manuelt EntityManager. Desuden styrer vi også livscyklussen for EntityManager vi har oprettet.

Lad os først oprette EntityManagerFactory:

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

For at skabe en EntityManager, skal vi udtrykkeligt ringe createEntityManager () i EntityManagerFactory:

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

Da vi er ansvarlige for at skabe EntityManager tilfælde er det også vores ansvar at lukke dem. Derfor skal vi tæt hver EntityManager når vi er færdige med at bruge dem.

4.3. Trådsikkerhed

Det EntityManagerFactory tilfælde og følgelig dvale SessionFactory tilfælde er trådsikre. Så det er helt sikkert i samtidige sammenhænge at skrive:

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

På den anden side, det EntityManager tilfælde er ikke trådsikre og er beregnet til at blive brugt i trådbegrænsede miljøer. Dette betyder, at hver tråd skal få sin forekomst, arbejde med den og lukke den i slutningen.

Når du bruger applikationsstyret EntityManagers, det er let at oprette trådbegrænsede forekomster:

EntityManagerFactory emf = // hentet et sted EntityManager em = emf.createEntityManager (); // brug det i den aktuelle tråd

Ting bliver dog kontraintuitive, når du bruger containeradministreret EntityManagers. For eksempel:

@Service offentlig klasse MovieService {@PersistenceContext // eller endda @Autowired privat EntityManager entityManager; // udeladt}

Det ser ud til, at en EntityManager instans skal deles for alle operationer. Imidlertid injicerer containeren (JakartaEE eller Spring) en særlig proxy i stedet for en simpel EntityManager her. Forår injicerer for eksempel en proxy af typen SharedEntityManagerCreator.

Hver gang vi bruger den injicerede EntityManager, denne proxy genbruger enten den eksisterende EntityManager eller opret en ny. Genbrug sker normalt, når vi aktiverer noget lignende Åbn Session / EntityManager i visning.

På den ene eller anden måde, containeren sikrer, at hver EntityManager er begrænset til en tråd.

5. Dvaletilstandsoperationer

Det EntityManager API giver en samling af metoder. Vi kan interagere med databasen ved at bruge disse metoder.

5.1. Vedvarende enheder

For at have et objekt tilknyttet EntityManager kan vi gøre brug af vedvarer () metode:

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

Når objektet er gemt i databasen, er det i vedholdende stat.

5.2. Indlæser enheder

Med henblik på at hente et objekt fra databasen kan vi bruge finde() metode.

Her søger metoden efter den primære nøgle. Faktisk forventer metoden enhedsklassetypen og den primære nøgle:

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

Men hvis vi bare har brug for henvisningen til enheden, kan vi bruge getReference () metode i stedet. I virkeligheden returnerer den en proxy til enheden:

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

5.3. Afmontering af enheder

I tilfælde af at vi har brug for at frigøre en enhed fra persistens-sammenhængen, vi kan bruge løsrive() metode. Vi sender objektet, der skal løsnes, som parameter til metoden:

em.detach (film);

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

5.4. Fusionerende enheder

I praksis kræver mange applikationer enhedsændring på tværs af flere transaktioner. For eksempel vil vi muligvis hente en enhed i en transaktion til gengivelse til brugergrænsefladen. Derefter vil en anden transaktion medføre de ændringer, der er foretaget i brugergrænsefladen.

Vi kan gøre brug af fusionere() metode til sådanne situationer. Fletningsmetoden hjælper med at bringe de ændringer, der er foretaget i den løsrevne enhed, i den administrerede enhed, hvis nogen:

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

5.5. Forespørgsel efter enheder

Desuden kan vi gøre brug af JPQL til at forespørge efter enheder. Vi påberåber os getResultList () at henrette dem.

Selvfølgelig kan vi bruge getSingleResult (), hvis forespørgslen kun returnerer et enkelt objekt:

offentlig liste queryForMovies () {EntityManager em = getEntityManager (); Liste over film = em.createQuery ("VÆLG film fra filmfilm hvor movie.language =? 1") .setParameter (1, "engelsk") .getResultList (); returnere film; }

5.6. Fjernelse af enheder

Derudover vi kan fjerne en enhed fra databasen ved hjælp af fjerne() metode. Det er vigtigt at bemærke, at objektet ikke er løsrevet, men fjernet.

Her ændres enhedens tilstand fra vedholdende til ny:

offentlig tomrum removeMovie () {EntityManager em = HibernateOperations.getEntityManager (); em.getTransaction (). begynder (); Filmfilm = em.find (Film.klasse, ny Lang (1L)); em.remove (film); em.getTransaction (). begå (); }

6. Konklusion

I denne artikel har vi udforsket EntityManager i Dvale. Vi har set på typerne og konfigurationen, og vi har lært om de forskellige metoder, der er tilgængelige i API'en til at arbejde med vedholdenhedskontekst.

Som altid er koden, der bruges i artiklen, tilgængelig på Github.