streamalism.org

1. Introduktion

I denne hurtige vejledning skal vi dække forskellige måder at oprette LIKE-forespørgsler på i JPA Repositories.

Vi starter med at se på de forskellige nøgleord, vi kan bruge, når vi opretter forespørgselsmetoder. Derefter dækker vi @Forespørgsel kommentar med navngivne og ordnede parametre.

2. Opsætning

For vores eksempel spørger vi en film bord.

Lad os definere vores Film enhed:

@Entity public class Film {@Id @GeneratedValue (strategi = GenerationType.SEQUENCE) privat Lang id; privat streng titel; privat streng direktør; privat streng rating; privat int varighed; // standard getters og setter}

Med vores Film enhed defineret, lad os oprette nogle eksempler indsætte udsagn:

INSERT INTO movie (id, title, director, rating, duration) VALUES (1, 'Godzilla: King of the Monsters', 'Michael Dougherty', 'PG-13', 132); INDSÆT I film (id, titel, instruktør, vurdering, varighed) VÆRDIER (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 film (id, titel, instruktør, rating, varighed) VÆRDIER (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); INDSÆT I film (id, titel, instruktør, vurdering, varighed) VÆRDIER (7, 'Solen er også en stjerne', 'Ry Russo-Young', 'PG-13', 100);

3. Ligesom forespørgselsmetoder

For mange enkle LIKE-forespørgselsscenarier kan vi drage fordel af en række nøgleord til at oprette forespørgselsmetoder i vores opbevaringssteder.

Lad os udforske dem nu.

3.1. Indeholder, Indeholder, Indeholder og Synes godt om

Lad os se på, hvordan vi kan udføre følgende LIKE-forespørgsel med en forespørgselsmetode:

VÆLG * FRA film HVOR titel LIKE '% i%';

Lad os først definere forespørgselsmetoder ved hjælp af Indeholder, Indeholder, og Indeholder:

Liste findByTitleContaining (streng titel); Liste findByTitleContains (streng titel); Liste findByTitleIsContaining (streng titel);

Lad os kalde vores forespørgselsmetoder med den delvise titel i:

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

Vi kan forvente, at hver af de tre metoder giver de samme resultater.

Foråret giver os også en Synes godt om nøgleord, men det opfører sig lidt anderledes, da vi skal give jokertegnet vores søgeparameter.

Lad os definere en LIKE-forespørgselsmetode:

Liste findByTitleLike (String title);

Lad os nu kalde vores findByTitleLike metode med den samme værdi, som vi brugte før, men med jokertegntegn:

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

3.2. Starter med

Lad os nu se på følgende forespørgsel:

VÆLG * FRA film HVOR Rating LIGE 'PG%';

Lad os bruge Starter med nøgleord for at oprette en forespørgselsmetode:

Liste findByRatingStartsWith (String rating);

Med vores metode defineret, lad os kalde det med værdien PG:

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

3.3. Slutter med

Spring giver os den modsatte funktionalitet med Slutter med nøgleord.

Lad os overveje denne forespørgsel:

VÆLG * FRA film HVOR instruktør LIKE '% Burton';

Lad os nu definere en Slutter med forespørgselsmetode:

Liste findByDirectorEndsWith (strengdirektør);

Når vi har defineret vores metode, lad os kalde den med Burton parameter:

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

3.4. Sagsfølsomhed

Vi vil ofte finde alle poster, der indeholder en bestemt streng, uanset tilfældet. I SQL kan vi muligvis opnå dette ved at tvinge kolonnen til alle store og små bogstaver og give det samme de værdier, vi spørger om.

Med Spring JPA kan vi bruge IgnoreCase nøgleord kombineret med et af vores andre nøgleord:

Liste findByTitleContainingIgnoreCase (streng titel);

Nu kan vi kalde metoden med det og forvent at få resultater, der indeholder både, lavere og store bogstaver:

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

3.5. Ikke

Nogle gange vil vi finde alle de poster, der ikke indeholder en bestemt streng. Vi kan bruge Indeholder ikke, Ikke indeholdende, og Ikke som nøgleord for at gøre det.

Lad os definere en forespørgsel ved hjælp af Ikke indeholdende for at finde film med ratings, der ikke indeholder PG:

Liste findByRatingNotContaining (strengrangering);

Lad os nu kalde vores nyligt definerede metode:

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

For at opnå funktionalitet, der finder poster, hvor instruktøren ikke starter med en bestemt streng, lad os bruge Ikke som nøgleord for at bevare kontrollen over vores wildcard-placering:

Liste findByDirectorNotLike (strengdirektør);

Lad os endelig kalde metoden for at finde alle de film, hvor instruktørens navn starter med noget andet end En:

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

Vi kan bruge Ikke som på en lignende måde for at opnå en Ikke kombineret med Slutter med slags funktionalitet.

4. Brug @Forespørgsel

Nogle gange er vi nødt til at oprette forespørgsler, der er for komplicerede til forespørgselsmetoder eller ville resultere i absurd lange metodenavne. I disse tilfælde vi kan bruge @Forespørgsel kommentar til forespørgsel til vores database.

4.1. Navngivne parametre

Til sammenligningsformål skal vi oprette en forespørgsel, der svarer til findByTitleContaining metode, vi definerede tidligere:

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

Vi inkluderer vores jokertegn i den forespørgsel, vi leverer. Det @Param kommentar er vigtig her, fordi vi bruger en navngivet parameter.

4.2. Bestilte parametre

Ud over navngivne parametre kan vi bruge ordnede parametre i vores forespørgsler:

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

Vi har kontrol over vores jokertegn, så denne forespørgsel svarer til findByRatingStartsWith forespørgselsmetode.

Lad os finde alle filmene med en vurdering, der starter med PG:

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

Når vi bruger ordnede parametre i LIKE-forespørgsler med ikke-tillid til data, skal vi undslippe indkommende søgningsværdier.

Hvis vi bruger Spring Boot 2.4.1 eller nyere, kan vi bruge SpEL flugt metode:

@Query ("VÆLG m FRA Film m HVOR m.director LIKE%? # {Escape ([0])} escape? # {EscapeCharacter ()}") ListesøgningByDirectorEndsWith (String director);

Lad os nu kalde vores metode med værdien Burton:

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

5. Konklusion

I denne korte vejledning lærte vi, hvordan man opretter LIKE-forespørgsler i JPA Repositories i foråret.

Først lærte vi, hvordan man bruger de medfølgende søgeord til at oprette forespørgselsmetoder. Derefter lærte vi, hvordan man udfører de samme opgaver ved hjælp af @Forespørgsel parameter med både navngivne og ordnede parametre.

Den fulde eksempelkode er tilgængelig på GitHub.