streamalism.org

1. Introduktion

For enkle forespørgsler er det let at udlede, hvad forespørgslen skal være bare ved at se på det tilsvarende metodenavn i vores kode.

I denne vejledning undersøger vi, hvordan Spring Data JPA udnytter denne idé i form af en metode til navngivning af metoder.

2. Struktur af afledte forespørgselsmetoder i foråret

Afledte metode navne har to hoveddele adskilt af den første Ved nøgleord:

Liste findByName (strengnavn)

Den første del - ligesom finde - er introducer og resten - ligesom Ved navn - er kriterier.

Spring Data JPA understøtter find, læs, forespørgsel, tæl og få. Så for eksempel kunne vi have gjort det queryByName og Spring Data ville opføre sig det samme.

Vi kan også bruge Distinct, først, eller Top for at fjerne dubletter eller begrænse vores resultatsæt:

Liste findTop3ByAge ()

Kriteriedelen indeholder forespørgselsens enheds-specifikke tilstandsudtryk. Vi kan bruge betingelsesnøgleordene sammen med enhedens ejendomsnavne. Vi kan også sammenkæde udtrykkene med Og og Eller, også se på bare et øjeblik.

3. Eksempel på anvendelse

For det første har vi selvfølgelig brug for en applikation ved hjælp af Spring Data JPA.

Lad os i den applikation definere en enhedsklasse:

@Table (name = "brugere") @Entity-klasse Bruger {@Id @GeneratedValue privat heltal-id; privat strengnavn; privat heltalealder privat ZonedDateTime fødselsdato; privat Boolean aktiv; // standard getters og setter}

Og lad os også definere et lager. Det strækker sig JpaRepository, en af ​​Spring Data Repository-typerne:

interface UserRepository udvider JpaRepository {}

Det er her, vi placerer alle vores afledte forespørgselsmetoder.

4. Ligestillingsnøgleord

Præcis ligestilling er en af ​​de mest anvendte betingelser i forespørgsler. Vi har flere muligheder for at udtrykke = eller IS-operatører i forespørgslen.

Vi kan bare tilføje ejendomsnavnet uden nøgleord for at få en eksakt matchtilstand:

Liste findByName (strengnavn);

Og vi kan tilføje Er eller Lige med for læsbarhed:

Liste findByNameIs (strengnavn); Liste findByNameEquals (strengnavn);

Denne ekstra læsbarhed er praktisk, når vi i stedet skal udtrykke ulighed:

Liste findByNameIsNot (strengnavn);

Dette er en hel del mere læselig end findByNameNot (streng)!

Som nul lighed er et specielt tilfælde, vi skal ikke bruge = operatoren. Spring Data JPA håndtag nul parametre som standard. Så når vi passerer en nul værdi for en ligestillingsbetingelse, Spring fortolker forespørgslen som IS NULL i den genererede SQL.

Vi kan også bruge IsNull nøgleord for at tilføje IS NULL-kriterier til forespørgslen:

Liste findByNameIsNull (); Liste findByNameIsNotNull ();

Bemærk, at heller ikke IsNull heller ikke Er ikke nul kræver et metodeargument.

Der er også to nye nøgleord, der ikke kræver nogen argumenter. Vi kan bruge Rigtigt og Falsk nøgleord for at tilføje ligestillingsbetingelser for boolsk typer:

Liste findByActiveTrue (); Liste findByActiveFalse ();

Selvfølgelig ønsker vi nogle gange noget mere lempelig end nøjagtig lighed, lad os se hvad vi ellers kan gøre.

5. Lighed Nøgleord

Når vi har brug for at forespørge resultaterne med et mønster af en ejendom, har vi et par muligheder.

Vi kan finde navne, der starter med en værdi ved hjælp af Starter med:

Liste findByNameStartingWith (strengpræfiks);

Groft oversættes dette til ”HVOR navn SYNES GODT OM 'værdi%'“.

Hvis vi vil have navne, der slutter med en værdi, så Slutter med er, hvad vi ønsker:

Liste findByNameEndingWith (streng-suffiks);

Eller vi kan finde hvilke navne der indeholder en værdi med Indeholder:

Liste findByNameContaining (strenginfix);

Bemærk, at alle betingelser ovenfor kaldes foruddefinerede mønsterudtryk. Så, vi behøver ikke tilføje % operatør inde i argumentet når disse metoder kaldes.

Men lad os antage, at vi gør noget mere komplekst. Sig, at vi skal hente de brugere, hvis navne starter med en -en, indeholder b, og slut med c.

Til det kan vi tilføje vores egen LIKE med Synes godt om nøgleord:

Liste findByNameLike (streng som mønster);

Og vi kan derefter aflevere vores LIKE-mønster, når vi kalder metoden:

Streng som mønster = "a% b% c"; userRepository.findByNameLike (som mønster);

Det er nok med navne indtil videre. Lad os prøve nogle andre værdier i Bruger.

6. Sammenligningstilstand Nøgleord

Desuden kan vi bruge Mindre end og LessThanEqual nøgleord for at sammenligne poster med den givne værdi ved hjælp af < og <= operatører:

Liste findByAgeLessThan (helårsalder); Liste findByAgeLessThanEqual (heltal);

På den anden side kan vi i den modsatte situation bruge Bedre end og GreaterThanEqual nøgleord:

Liste findByAgeGreaterThan (hel alder); Liste findByAgeGreaterThanEqual (hel alder);

Eller vi kan finde brugere, der er mellem to aldre med Mellem:

Liste findByAgeBetween (Integer startAge, Integer endAge);

Vi kan også levere en samling aldre, der passer til brugen I:

Liste findByAgeIn (samlingens aldre);

Da vi kender brugernes fødselsdatoer, vil vi muligvis spørge efter brugere, der blev født før eller efter en given dato. Vi bruger Før og Efter for det:

Liste findByBirthDateAfter (ZonedDateTime birthDate); Liste findByBirthDateBefore (ZonedDateTime birthDate);

7. Flere udtryksbetingelser

Vi kan kombinere så mange udtryk, som vi har brug for, ved hjælp af Og og Eller nøgleord:

Liste findByNameOrBirthDate (strengnavn, ZonedDateTime fødselsdato); Liste findByNameOrBirthDateAndActive (strengnavn, ZonedDateTime fødselsdato, Boolsk aktiv);

Forrangsrækkefølgen er Og derefter Eller, ligesom Java.

Mens Spring Data JPA pålægger ingen grænse for, hvor mange udtryk vi kan tilføje, bør vi ikke blive skøre her. Lange navne er ulæselige og svære at vedligeholde. For komplekse forespørgsler, se på det @Forespørgsel kommentar i stedet.

8. Sortering af resultaterne

Næste er sortering. Vi kan bede om, at brugerne sorteres alfabetisk efter deres navn ved hjælp af Bestil af:

Liste findByNameOrderByName (strengnavn); Liste findByNameOrderByNameAsc (strengnavn);

Stigende rækkefølge er standardsorteringsindstillingen, men vi kan bruge Beskrivelse i stedet for at sortere dem omvendt:

Liste findByNameOrderByNameDesc (strengnavn);

9. findOne vs. findById i en CrudRepository

Forårsteamet foretog nogle store ændringer i CrudRepository med Spring Boot 2.x. En af dem omdøber findOne til findById.

Tidligere med Spring Boot 1.x, ville vi ringe findOne da vi ønskede at hente en enhed med dens primære nøgle:

Brugerbruger = userRepository.findOne (1);

Siden Spring Boot 2.x kan vi gøre det samme med findById:

Brugerbruger = userRepository.findById (1);

Bemærk, at findById () metoden er allerede defineret i CrudRepository for os. Så vi behøver ikke at definere det eksplicit i brugerdefinerede arkiver, der udvides CrudRepository.

10. Konklusion

I denne artikel forklarede vi forespørgselsafledningsmekanismen i Spring Data JPA. Vi brugte egenskabsnøgleordene til at skrive afledte forespørgselsmetoder i Spring Data JPA-arkiver.

Kildekoden til denne vejledning er tilgængelig på Github-projektet.