streamalism.org

1. Introduksjon

I denne raske opplæringen skal vi dekke forskjellige måter å lage LIKE-spørsmål i JPA Spring Repositories på.

Vi begynner med å se på de forskjellige nøkkelordene vi kan bruke mens vi lager spørringsmetoder. Så dekker vi @Spørsmål kommentar med navngitte og ordnede parametere.

2. Oppsett

For eksempel vil vi spørre om a film bord.

La oss definere vår Film enhet:

@Entity offentlig klasse Film {@Id @GeneratedValue (strategi = GenerationType.SEQUENCE) privat Lang id; privat strengetittel; privat String direktør; privat streng vurdering; privat int varighet; // standard getters og setters}

Med vår Film definert enhet, la oss lage noen eksempler på utsagn:

INSERT INTO movie (id, title, director, rating, duration) VALUES (1, 'Godzilla: King of the Monsters', 'Michael Dougherty', 'PG-13', 132); INSERT INTO movie (id, title, director, rating, duration) VALUES (2, 'Avengers: Endgame', 'Anthony Russo', 'PG-13', 181); INSERT INTO movie (id, title, director, rating, duration) VALUES (3, 'Captain Marvel', 'Anna Boden', 'PG-13', 123); INSERT INTO movie (id, title, director, rating, duration) VALUES (4, 'Dumbo', 'Tim Burton', 'PG', 112); INSERT INTO movie (id, title, director, rating, duration) VALUES (5, 'Booksmart', 'Olivia Wilde', 'R', 102); INSERT INTO movie (id, title, director, rating, duration) VALUES (6, 'Aladdin', 'Guy Ritchie', 'PG', 128); INSERT INTO movie (id, title, director, rating, duration) VALUES (7, 'The Sun Is Also a Star', 'Ry Russo-Young', 'PG-13', 100);

3. LIKE spørringsmetoder

For mange enkle LIKE spørringsscenarier kan vi dra nytte av en rekke nøkkelord for å lage spørringsmetoder i våre arkiver.

La oss utforske dem nå.

3.1. Inneholder, Inneholder, Inneholder og Som

La oss se på hvordan vi kan utføre følgende LIKE-spørring med en spørringsmetode:

VELG * FRA film HVOR tittel LIKE '% in%';

La oss først definere spørringsmetoder ved hjelp av Inneholder, Inneholder, og Inneholder:

Liste findByTitleContaining (strengetittel); Liste findByTitleContains (strengetittel); Liste findByTitleIsContaining (streng tittel);

La oss kalle våre søkemetoder med delvis tittel i:

Listeresultater = movieRepository.findByTitleContaining ("in"); assertEquals (3, results.size ()); results = movieRepository.findByTitleIsContaining ("in"); assertEquals (3, results.size ()); resultater = movieRepository.findByTitleContains ("in"); assertEquals (3, results.size ());

Vi kan forvente at hver av de tre metodene gir de samme resultatene.

Våren gir oss også en Som nøkkelord, men det oppfører seg litt annerledes ved at vi må oppgi jokertegnet med søkeparameteren.

La oss definere en LIKE spørringsmetode:

Liste findByTitleLike (strengtittel);

La oss kalle vår findByTitleLike metoden med samme verdi som vi brukte før, men inkludert jokertegnene:

resultater = movieRepository.findByTitleLike ("% i%"); assertEquals (3, results.size ());

3.2. Begynner med

La oss nå se på følgende spørsmål:

VELG * FRA film HVOR RANGERING SOM 'PG%';

La oss bruke Begynner med nøkkelord for å lage en spørringsmetode:

Liste findByRatingStartsWith (Stringvurdering);

Med vår metode definert, la oss kalle det med verdien PG:

Listeresultater = movieRepository.findByRatingStartsWith ("PG"); assertEquals (6, results.size ());

3.3. Slutter med

Våren gir oss den motsatte funksjonaliteten med Slutter med nøkkelord.

La oss vurdere dette spørsmålet:

VELG * FRA filmen HVOR regissør LIKE '% Burton';

La oss nå definere en Slutter med spørringsmetode:

Liste findByDirectorEndsWith (strengdirektør);

Når vi har definert metoden vår, la oss kalle den med Burton parameter:

Listeresultater = movieRepository.findByDirectorEndsWith ("Burton"); assertEquals (1, results.size ());

3.4. Tilfelle ufølsomhet

Vi vil ofte finne alle postene som inneholder en bestemt streng, uansett tilfelle. I SQL kan vi oppnå dette ved å tvinge kolonnen til alle store og små bokstaver og gi det samme med verdier vi spør etter.

Med vår JPA kan vi bruke Ignorer tilfelle søkeord kombinert med et av de andre søkeordene våre:

Liste findByTitleContainingIgnoreCase (streng tittel);

Nå kan vi kalle metoden med de og forvent å få resultater som inneholder både, lavere og store resultater:

Listeresultater = movieRepository.findByTitleContainingIgnoreCase ("the"); assertEquals (2, results.size ());

3.5. Ikke

Noen ganger vil vi finne alle postene som ikke inneholder en bestemt streng. Vi kan bruke Inneholder ikke, Ikke inneholder, og Ikke like nøkkelord for å gjøre det.

La oss definere et spørsmål ved hjelp av Ikke inneholder for å finne filmer med rangeringer som ikke inneholder PG:

Liste findByRatingNotContaining (strengvurdering);

La oss kalle den nylig definerte metoden vår:

Listeresultater = movieRepository.findByRatingNotContaining ("PG"); assertEquals (1, results.size ());

For å oppnå funksjonalitet som finner poster der regissøren ikke starter med en bestemt streng, la oss bruke Ikke like nøkkelord for å beholde kontrollen over plasseringen av jokertegn:

Liste findByDirectorNotLike (strengdirektør);

Til slutt, la oss kalle metoden for å finne alle filmene der regissørens navn begynner med noe annet enn An:

Listeresultater = movieRepository.findByDirectorNotLike ("An%"); assertEquals (5, results.size ());

Vi kan bruke Ikke like på en lignende måte for å oppnå en Ikke kombinert med Slutter med slags funksjonalitet.

4. Bruke @Spørsmål

Noen ganger må vi lage spørsmål som er for kompliserte for spørringsmetoder eller som vil føre til absurd lange metodenavn. I slike tilfeller vi kan bruke @Spørsmål kommentar for å spørre databasen vår.

4.1. Navngitte parametere

For sammenligningsformål, la oss lage et spørsmål som tilsvarer findByTitleContaining metoden vi definerte tidligere:

@Query ("SELECT m FROM Movie m WHERE m.title LIKE%: title%") List searchByTitleLike (@Param ("title") String title);

Vi inkluderer jokertegnene våre i spørringen vi leverer. De @Param kommentar er viktig her fordi vi bruker en navngitt parameter.

4.2. Bestilte parametere

I tillegg til navngitte parametere kan vi bruke ordnede parametere i spørsmålene våre:

@Query ("SELECT m FROM Movie m WHERE m.rating LIKE? 1%") List searchByRatingStartsWith (String rating);

Vi har kontroll over jokertegnene våre, så dette spørsmålet tilsvarer findByRatingStartsWith spørringsmetode.

La oss finne alle filmene med en vurdering som starter med PG:

Listeresultater = movieRepository.searchByRatingStartsWith ("PG"); assertEquals (6, results.size ());

Når vi bruker bestilte parametere i LIKE-spørsmål med upålitelige data, bør vi unnslippe innkommende søkeverdier.

Hvis vi bruker Spring Boot 2.4.1 eller nyere, kan vi bruke SpEL flukt metode:

@Query ("SELECT m FROM Movie m WHERE m.director LIKE%? # {Escape ([0])} escape? # {EscapeCharacter ()}") List searchByDirectorEndsWith (String director);

La oss nå kalle metoden vår med verdien Burton:

Listeresultater = movieRepository.searchByDirectorEndsWith ("Burton"); assertEquals (1, results.size ());

5. Konklusjon

I denne korte opplæringen lærte vi hvordan du oppretter LIKE-spørsmål i JPA Spring Repositories.

Først lærte vi hvordan du bruker de angitte nøkkelordene til å lage søkemetoder. Deretter lærte vi hvordan vi kan utføre de samme oppgavene ved hjelp av @Spørsmål parameter med både navngitte og bestilte parametere.

Hele eksempelkoden er tilgjengelig på GitHub.