streamalism.org

1. Oversikt

Persistensleverandører som dvalemodus bruker persistens-kontekst for å administrere enhetens livssyklus i et program.

I denne veiledningen begynner vi med introduksjonen av utholdenhetskonteksten, så får vi se hvorfor det er viktig. Til slutt ser vi forskjellen mellom transaksjonsomfanget utholdenhetskontekst og utvidet omfanget utholdenhetssammenheng med eksempler.

2. Persistens Kontekst

La oss ta en titt på den offisielle definisjonen av Persistence Context:

En EntityManager-forekomst er knyttet til en utholdenhetskontekst. En utholdenhetskontekst er et sett av entitetsforekomster der det for en vedvarende enhetsidentitet er en unik entitetsforekomst. Innen utholdenhetskonteksten styres forekomsten av enheter og deres livssyklus. EntityManager API brukes til å opprette og fjerne vedvarende enhetsforekomster, for å finne enheter etter deres primære nøkkel og for å spørre etter enheter.

Ovennevnte uttalelse kan virke litt kompleks akkurat nå, men det vil være fullstendig fornuftig når vi fortsetter. Persistens-konteksten er hurtigbufferen på første nivå der alle enhetene blir hentet fra databasen eller lagret i databasen. Det sitter mellom applikasjonen vår og vedvarende lagring.

Persistens-kontekst holder rede på eventuelle endringer som er gjort i en administrert enhet. Hvis noe endres under en transaksjon, blir enheten merket som skitten. Når transaksjonen er fullført, blir disse endringene spylt til vedvarende lagring.

De EntityManager er grensesnittet som lar oss samhandle med utholdenhetskonteksten. Hver gang vi bruker EntityManager, vi samhandler faktisk med utholdenhetskonteksten.

Hvis hver endring som foretas i enheten, ringer til vedvarende lagring, kan vi forestille oss hvor mange samtaler som vil bli gjort. Dette vil føre til ytelseseffekt fordi vedvarende lagringsanrop er dyre.

3. Persistens Kontekst Type

Persistens-sammenhenger er tilgjengelige i to typer:

• Transaksjon-omfanget utholdenhetskontekst
• Langvarig utholdenhetskontekst

La oss ta en titt på hver.

3.1 Transaksjon-Omfattet Persistens Kontekst

Transaksjonens vedvarende kontekst er bundet til transaksjonen. Så snart transaksjonen er fullført, vil enhetene som er tilstede i utholdenhetskonteksten skylles til vedvarende lagring.

Når vi utfører noen operasjoner i transaksjonen, blir EntityManager sjekker for en utholdenhetskontekst. Hvis en eksisterer, vil den bli brukt. Ellers vil det skape en utholdenhetskontekst.

Standard konteksttype for utholdenhet erPersistenceContextType.TRANSACTION. Å fortelle EntityManager for å bruke transaksjonens vedvarende kontekst, kommenterer vi den bare med @PersistenceContext:

@PersistenceContext private EntityManager entityManager;

3.2 Persistens-kontekst med utvidet omfang

En utvidet utholdenhetskontekst kan strekke seg over flere transaksjoner. Vi kan vedvare enheten uten transaksjonen, men kan ikke skylle den uten en transaksjon.

Å fortelle EntityManager for å bruke langvarig utholdenhetskontekst, må vi bruke type attributt av @PersistenceContext:

@PersistenceContext (type = PersistenceContextType.EXTENDED) private EntityManager entityManager;

I den statsløse øktbønnen, ble utvidet utholdenhetskontekst i en komponent er helt uvitende om noen utholdenhetskontekst for en annen komponent. Dette gjelder selv om begge er i samme transaksjon.

La oss si at vi vedvarer en eller annen enhet i en metode for komponent EN, som kjører i en transaksjon. Vi kaller deretter en eller annen metode for komponent B. I komponent B-er Metode persistens kontekst, vil vi ikke finne enheten vi fortsatte tidligere i metoden for Component EN.

4. Eksempel på utholdenhetskontekst

Nå som vi vet nok om utholdenhetskontekst, er det på tide å dykke inn i et eksempel. Vi lager forskjellige bruksområder med transaksjons persistens kontekst og utvidet persistens kontekst.

Først, la oss lage tjenesteklassen vår, TransctionPersistenceContextUserService:

@Komponent offentlig klasse TransctionPersistenceContextUserService {@PersistenceContext private EntityManager entityManager; @Transactional public User insertWithTransaction (User user) {entityManager.persist (user); retur bruker; } offentlig bruker insertWithoutTransaction (brukerbruker) {entityManager.persist (bruker); retur bruker; } offentlig brukerfunn (lang id) {return entityManager.find (User.class, id); }}

Neste klasse, ExtendedPersistenceContextUserService, er veldig lik ovenstående, bortsett fra @PersistenceContext kommentar. Denne gangen passerer vi PersistenceContextType.EXTENDED inn i det type parameter for dens @PersistenceContext kommentar:

@Komponent offentlig klasse ExtendedPersistenceContextUserService {@PersistenceContext (type = PersistenceContextType.EXTENDED) private EntityManager entityManager; // Gjenværende kode samme som ovenfor}

5. Test tilfeller

Nå som vi har satt opp tjenesteklassene, er det på tide å lage forskjellige brukstilfeller med transaksjonens utholdenhetskontekst og utvidet utholdenhetssammenheng.

5.1 Testing Transaction Persistence Context

La oss fortsette a Bruker enhet som bruker transaksjonsavgrenset utholdenhetskontext. Enheten lagres i vedvarende lagring. Vi verifiserer deretter ved å ringe et funn ved hjelp av vår utvidede utholdenhetskontekst EntityManager:

Brukerbruker = ny bruker (121L, "Devender", "admin"); transctionPersistenceContext.insertWithTransaction (bruker); User userFromTransctionPersistenceContext = transctionPersistenceContext .find (user.getId ()); assertNotNull (userFromTransctionPersistenceContext); BrukerbrukerFromExtendedPersistenceContext = utvidetPersistenceContext .find (user.getId ()); assertNotNull (userFromExtendedPersistenceContext);

Når vi prøver å sette inn en Bruker enhet uten en transaksjon, da TransactionRequiredException vil bli kastet:

@Test (forventet = TransactionRequiredException.class) offentlig ugyldig testThatUserSaveWithoutTransactionThrowException () {Brukerbruker = ny bruker (122L, "Devender", "admin"); transctionPersistenceContext.insertWithoutTransaction (bruker); }

5.2 Testing av utvidet utholdenhetskontekst

Deretter la oss vedvare brukeren med en utvidet utholdenhetskontekst og uten en transaksjon. De Bruker enheten blir lagret i vedvarende kontekst (cache), men ikke i vedvarende lagring:

Brukerbruker = ny bruker (123L, "Devender", "admin"); extendedPersistenceContext.insertWithoutTransaction (bruker); BrukerbrukerFromExtendedPersistenceContext = utvidetPersistenceContext .find (user.getId ()); assertNotNull (userFromExtendedPersistenceContext); User userFromTransctionPersistenceContext = transctionPersistenceContext .find (user.getId ()); assertNull (userFromTransctionPersistenceContext);

I utholdenhetskonteksten for enhver vedvarende enhetsidentitet vil det være en unik entitetsforekomst. Hvis vi prøver å fortsette en annen enhet med samme identifikator:

@Test (forventet = EntityExistsException.class) public void testThatPersistUserWithSameIdentifierThrowException () {User user1 = new User (126L, "Devender", "admin"); User user2 = new User (126L, "Devender", "admin"); utvidetPersistenceContext.insertWithoutTransaction (bruker1); utvidetPersistenceContext.insertWithoutTransaction (bruker2); }

Vi får se EntityExistsException:

javax.persistence.EntityExistsException: Et annet objekt med samme identifikasjonsverdi var allerede knyttet til økten

Utvidet utholdenhetskontekst i en transaksjon lagrer enheten i vedvarende lagring på slutten av transaksjonen:

Brukerbruker = ny bruker (127L, "Devender", "admin"); extendedPersistenceContext.insertWithTransaction (bruker); BrukerbrukerFromDB = transctionPersistenceContext.find (user.getId ()); assertNotNull (userFromDB);

Den utvidede utholdenhetskonteksten skyller hurtigbufrede enheter til vedvarende lagring når de brukes i transaksjonen. Først vedvarer vi enheten uten en transaksjon. Deretter fortsetter vi en annen enhet i transaksjonen:

Bruker bruker1 = ny bruker (124L, "Devender", "admin"); utvidetPersistenceContext.insertWithoutTransaction (bruker1); Brukerbruker2 = ny bruker (125L, "Devender", "admin"); ExtendedPersistenceContext.insertWithTransaction (user2); Brukerbruker1FromTransctionPersistenceContext = transctionPersistenceContext .find (user1.getId ()); assertNotNull (user1FromTransctionPersistenceContext); Bruker bruker2FromTransctionPersistenceContext = transctionPersistenceContext .find (user2.getId ()); assertNotNull (user2FromTransctionPersistenceContext);

6. Konklusjon

I denne opplæringen fikk vi god forståelse av utholdenhetskonteksten.

Først så vi på transaksjonens vedvarende kontekst, som eksisterer gjennom hele transaksjonens levetid. Deretter så vi på den utvidede utholdenhetskonteksten, som kan strekke seg over flere transaksjoner.

Som alltid er eksempelkoden tilgjengelig på GitHub.