Deriverte spørringsmetoder i JPA-repositorier for vårdata

1. Introduksjon

For enkle spørsmål er det lett å utlede hva spørringen skal være bare ved å se på det tilsvarende metodenavnet i koden vår.

I denne opplæringen vil vi undersøke hvordan Spring Data JPA utnytter denne ideen i form av en metodekonvensjon.

2. Struktur av avledede spørringsmetoder om våren

Avledede metodenavn har to hoveddeler atskilt med den første Av nøkkelord:

Liste findByName (strengnavn)

Den første delen - som finne - er den introdusent og resten - som Ved navn - er den kriterier.

Spring Data JPA støtter finne, lese, spørre, telle og . Så for eksempel kunne vi ha gjort det queryByName og Spring Data ville oppføre seg likt.

Vi kan også bruke Distinkt, først, eller Topp for å fjerne duplikater eller begrense resultatsettet:

Liste findTop3ByAge ()

Kriteriedelen inneholder enhetsspesifikke tilstandsuttrykk for spørringen. Vi kan bruke betingelsesnøkkelordene sammen med enhetens eiendomsnavn. Vi kan også sammenkoble uttrykkene med Og og Eller, også se på bare et øyeblikk.

3. Eksempel på søknad

Først trenger vi selvfølgelig en applikasjon som bruker Spring Data JPA.

I den applikasjonen, la oss definere en enhetsklasse:

@Table (name = "users") @Entity class User {@Id @GeneratedValue private Integer id; privat strengnavn; privat Hele alder; privat ZonedDateTime fødselsdato; private boolske aktive; // standard getters og setters}

Og la oss også definere et depot. Det vil utvide seg JpaRepository, en av Spring Data Repository-typene:

grensesnitt UserRepository utvider JpaRepository {}

Dette er hvor vi vil plassere alle våre avledede spørringsmetoder.

4. Likhetstilstand Nøkkelord

Nøyaktig likhet er en av de mest brukte forholdene i spørsmålene. Vi har flere muligheter for å uttrykke = eller IS-operatører i spørringen.

Vi kan bare legge til eiendomsnavnet uten nøkkelord for en eksakt samsvarsvilkår:

Liste findByName (strengnavn);

Og vi kan legge til Er eller Er lik for lesbarhet:

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

Denne ekstra lesbarheten er nyttig når vi i stedet trenger å uttrykke ulikhet:

Liste findByNameIsNot (strengnavn);

Dette er ganske mye mer leselig enn findByNameNot (streng)!

Som null likhet er et spesielt tilfelle, vi skal ikke bruke = operatoren. Spring Data JPA håndterer null parametere som standard. Så når vi passerer en null verdi for en likestillingsbetingelse, tolker Spring spørringen som NULL i den genererte SQL.

Vi kan også bruke IsNull nøkkelord for å legge til IS NULL-kriterier i spørringen:

Liste findByNameIsNull (); Liste findByNameIsNotNull ();

Legg merke til at heller ikke IsNull heller ikke Er ikke null krever et metodeargument.

Det er også to søkeord til som ikke krever noen argumenter. Vi kan bruke ekte og Falsk nøkkelord for å legge til likestillingsbetingelser for boolsk typer:

Liste findByActiveTrue (); Liste findByActiveFalse ();

Selvfølgelig, noen ganger ønsker vi noe mildere enn nøyaktig likhet, la oss se hva mer vi kan gjøre.

5. Likhetstilstand Nøkkelord

Når vi trenger å spørre resultatene med et mønster av en eiendom, har vi noen alternativer.

Vi kan finne navn som starter med en verdi ved hjelp av Starter med:

Liste findByNameStartingWith (String prefiks);

Grovt sett oversettes dette til “HVOR Navn SOM 'verdi%'“.

Hvis vi vil ha navn som ender med en verdi, da Avslutter med er det vi ønsker:

Liste findByNameEndingWith (String suffiks);

Eller vi kan finne hvilke navn som inneholder en verdi med Inneholder:

Liste findByNameContaining (strenginfiks);

Merk at alle forhold ovenfor kalles forhåndsdefinerte mønsteruttrykk. Så, vi trenger ikke legge til % operatør inne i argumentet når disse metodene kalles.

Men la oss anta at vi gjør noe mer komplekst. Si at vi må hente brukerne hvis navn begynner med et en, inneholder b, og avslutt med c.

For det kan vi legge til vår egen LIKE med Som nøkkelord:

Liste findByNameLike (streng som mønster);

Og vi kan da levere inn LIKE-mønsteret vårt når vi kaller metoden:

String likePattern = "a% b% c"; userRepository.findByNameLike (likePattern);

Det er nok med navn for nå. La oss prøve noen andre verdier i Bruker.

6. Sammenligningstilstand Nøkkelord

Videre kan vi bruke Mindre enn og LessThanEqual nøkkelord for å sammenligne postene med den gitte verdien ved hjelp av < og <= operatører:

Liste findByAgeLessThan (hel alder); Liste finneByAgeLessThanEqual (hel alder);

På den annen side, i motsatt situasjon, kan vi bruke Større enn og GreaterThanEqual nøkkelord:

Liste findByAgeGreaterThan (hel alder); Liste finneByAgeGreaterThanEqual (hel alder);

Eller vi kan finne brukere som er mellom to aldre med Mellom:

Liste findByAgeBetween (Integer startAge, Integer endAge);

Vi kan også levere en samling aldre å matche mot bruk I:

Liste findByAgeIn (samlingens aldre);

Siden vi kjenner brukernes fødselsdatoer, vil vi kanskje spørre etter brukere som ble født før eller etter en gitt dato. Vi bruker Før og Etter for det:

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

7. Flere tilstandsuttrykk

Vi kan kombinere så mange uttrykk som vi trenger ved å bruke Og og Eller nøkkelord:

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

Prioritetsrekkefølgen er Og deretter Eller, akkurat som Java.

Mens Spring Data JPA pålegger ingen grenser for hvor mange uttrykk vi kan legge til, bør vi ikke bli gal her. Lange navn er uleselige og vanskelige å vedlikeholde. For kompliserte spørsmål, ta en titt på de @Spørsmål kommentar i stedet.

8. Sortering av resultatene

Neste gang er sortering. Vi kan be om at brukerne blir sortert alfabetisk etter navn ved hjelp av Rekkefølge etter:

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

Stigende rekkefølge er standard sorteringsalternativ, men vi kan bruke Beskrivelse i stedet for å sortere dem i omvendt retning:

Liste findByNameOrderByNameDesc (strengnavn);

9. Finn én vs. findById i en CrudRepository

Vårt team gjorde noen store endringer i CrudRepository med Spring Boot 2.x. En av dem gir nytt navn Finn én til findById.

Tidligere med Spring Boot 1.x, ville vi ringe Finn én da vi ønsket å hente en enhet med hovednøkkelen:

Brukerbruker = userRepository.findOne (1);

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

Brukerbruker = userRepository.findById (1);

Merk at findById () metoden er allerede definert i CrudRepository for oss. Så vi trenger ikke å definere det eksplisitt i egendefinerte arkiver som strekker seg CrudRepository.

10. Konklusjon

I denne artikkelen forklarte vi spørringsderivasjonsmekanismen i Spring Data JPA. Vi brukte egenskapens søkeord for å skrive avledede spørringsmetoder i Spring Data JPA-lagre.

Kildekoden til denne veiledningen er tilgjengelig på Github-prosjektet.


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