Spring Data JPA @Modifying Annotation

1. Inleiding

In deze korte tutorial, we zullen leren hoe u update-query's kunt maken met de Spring Data JPA @Query annotatie. We zullen dit bereiken door de @Wijzigen annotatie.

Eerst zullen we ons geheugen opfrissen en zien hoe we queries kunnen maken met Spring Data JPA. Daarna gaan we diep in op het gebruik van @Query en @Wijzigen annotaties. Ten slotte zullen we zien hoe we de status van onze persistentiecontext kunnen beheren wanneer we query's aanpassen.

2. Query's in Spring Data JPA

Laten we eerst de 3 mechanismen die Spring Data JPA biedt voor het opvragen van gegevens in een database:

  • Query-methoden
  • @Query annotatie
  • Aangepaste repository-implementatie

Laten we een Gebruiker class en een bijpassende Spring Data JPA-repository om deze mechanismen te illustreren:

@Entity @Table (naam = "gebruikers", schema = "gebruikers") openbare klasse Gebruiker {@Id @GeneratedValue (strategie = GenerationType.IDENTITY) privé int id; private String naam; privé LocalDate creationDate; privé LocalDate lastLoginDate; private boolean actief; privé String-e-mail; }
openbare interface UserRepository breidt JpaRepository {} uit

Het mechanisme voor zoekmethoden stelt ons in staat om de gegevens te manipuleren door de query's af te leiden van de methodenamen:

List findAllByName (String naam); ongeldig deleteAllByCreationDateAfter (LocalDate-datum);

In dit voorbeeld kunnen we een zoekopdracht vinden die gebruikers op basis van hun naam ophaalt, of toch een zoekopdracht die gebruikers verwijdert met een aanmaakdatum na een bepaalde datum.

Wat betreft de @Query annotatie, het geeft ons de mogelijkheid om een ‚Äč‚Äčspecifieke JPQL- of SQL-query te schrijven in het @Query annotatie:

@Query ("selecteer u uit gebruiker u waar u.email zoals '%@gmail.com'") Lijst findUsersWithGmailAddress ();

In dit codefragment kunnen we een zoekopdracht zien waarbij gebruikers worden opgehaald met een @ gmail.com e-mailadres.

Het eerste mechanisme stelt ons in staat om gegevens op te halen of te verwijderen. Wat betreft de tweede, het stelt ons in staat vrijwel elke query uit te voeren. Echter, voor het bijwerken van vragen moeten we de @Wijzigen annotatie. Dit is het onderwerp van deze tutorial.

3. Gebruik de @Wijzigen Annotatie

De @Wijzigen annotatie wordt gebruikt om de @Query annotatie om niet alleen uit te voeren SELECTEER queries maar ook INVOEGEN, BIJWERKEN, VERWIJDEREN, en zelfs DDL vragen.

Laten we een beetje met deze annotatie spelen en kijken waar het van gemaakt is.

Laten we eerst een voorbeeld bekijken van een @Wijzigen UPDATE vraag:

@Modifying @Query ("update gebruiker u ingesteld u.active = false waar u.lastLoginDate <: date") void deactivateUsersNotLoggedInSince (@Param ("date") LocalDate datum);

Hier deactiveren we de gebruikers die zich sinds een bepaalde datum niet hebben aangemeld.

Laten we een andere proberen, waarbij we gedeactiveerde gebruikers zullen verwijderen:

@Modifying @Query ("verwijder gebruiker u waar u.active = false") int deleteDeactivatedUsers ();

Zoals we kunnen zien, retourneert deze methode een geheel getal. Het is een kenmerk van Spring Data JPA @Wijzigen queries die ons het aantal bijgewerkte entiteiten geven.

We moeten er rekening mee houden dat het uitvoeren van een verwijderopdracht met @Query werkt anders dan Spring Data JPA's deleteBy naam-afgeleide zoekmethoden. Deze laatste haalt eerst de entiteiten uit de database en verwijdert ze vervolgens een voor een. Dit betekent dus dat de levenscyclusmethode @PreRemove zal op die entiteiten worden opgeroepen. Bij de eerste wordt echter een enkele query uitgevoerd op de database.

Laten we tot slot een verwijderd kolom naar onze GEBRUIKERS tafel met een DDL vraag:

@Modifying @Query (waarde = "verander tabel USERS.USERS voeg kolom verwijderd int (1) niet nul standaard 0", nativeQuery = true) void addDeletedColumn ();

Helaas zorgt het gebruik van wijzigende query's ervoor dat de onderliggende persistentiecontext achterhaald is. Het is echter mogelijk om deze situatie te beheersen. Dat is het onderwerp van de volgende sectie.

4. De persistentiecontext beheren

Als onze wijzigende query entiteiten wijzigt die zijn opgenomen in de persistentiecontext, wordt deze context achterhaald. Een manier om met deze situatie om te gaan, is door de persistentiecontext te verwijderen. Door dat te doen, zorgen we ervoor dat de persistentiecontext de volgende keer de entiteiten uit de database haalt.

We hoeven de Doorzichtig() methode op de EntityManager. We kunnen gewoon de clearAutomatisch eigendom van de @Wijzigen annotatie:

@Modifying (clearAutomatically = true)

Op die manier zorgen we ervoor dat de persistentiecontext wordt gewist na het uitvoeren van onze query.

Maar wat als onze persistentiecontext niet-doorgespoelde veranderingen bevatte? Daarom zou het wissen ervan betekenen dat niet-opgeslagen wijzigingen worden verwijderd. Gelukkig is er nog een andere eigenschap van de annotatie die we kunnen gebruiken - flushAutomatisch:

@Modifying (flushAutomatically = true)

Nu de EntityManager wordt leeggemaakt voordat onze zoekopdracht wordt uitgevoerd.

5. Conclusie

Dat concludeert dit korte artikel over de @Wijzigen annotatie. We hebben gezien hoe u deze annotatie kunt gebruiken om bijwerkquery's uit te voeren, zoals INVOEGEN, BIJWERKEN, VERWIJDEREN, en zelfs DDL. Daarna hebben we geleerd hoe we de toestand van de persistentiecontext kunnen beheren met de clearAutomatisch en flushAutomatisch eigendommen.

Zoals gewoonlijk is de volledige code voor dit artikel beschikbaar op GitHub.


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