ALS Queries in Spring JPA Repositories

1. Inleiding

In deze korte tutorial behandelen we verschillende manieren om LIKE-query's te maken in Spring JPA Repositories.

We beginnen met het bekijken van de verschillende trefwoorden die we kunnen gebruiken bij het maken van zoekmethoden. Vervolgens behandelen we de @Query annotatie met benoemde en geordende parameters.

2. Installatie

Voor ons voorbeeld zullen we een film tafel.

Laten we onze definiëren Film entiteit:

@Entity public class Movie {@Id @GeneratedValue (strategy = GenerationType.SEQUENCE) privé Lange id; private String-titel; privé String-regisseur; private String-beoordeling; privé int duur; // standaard getters en setters}

Met onze Film entiteit gedefinieerd, laten we enkele voorbeeldinvoeginstructies maken:

INVOEGEN IN film (id, titel, regisseur, waardering, duur) WAARDEN (1, 'Godzilla: King of the Monsters', 'Michael Dougherty', 'PG-13', 132); INVOEGEN IN film (id, titel, regisseur, beoordeling, duur) WAARDEN (2, 'Avengers: Endgame', 'Anthony Russo', 'PG-13', 181); INVOEGEN IN film (id, titel, regisseur, beoordeling, duur) WAARDEN (3, 'Captain Marvel', 'Anna Boden', 'PG-13', 123); INVOEGEN IN film (id, titel, regisseur, waardering, duur) WAARDEN (4, 'Dumbo', 'Tim Burton', 'PG', 112); INVOEGEN IN film (id, titel, regisseur, beoordeling, duur) WAARDEN (5, 'Booksmart', 'Olivia Wilde', 'R', 102); INVOEGEN IN film (id, titel, regisseur, waardering, duur) WAARDEN (6, 'Aladdin', 'Guy Ritchie', 'PG', 128); INVOEGEN IN film (id, titel, regisseur, waardering, duur) WAARDEN (7, 'The Sun Is Also a Star', 'Ry Russo-Young', 'PG-13', 100);

3. ALS Zoekmethoden

Voor veel eenvoudige LIKE-queryscenario's kunnen we profiteren van een verscheidenheid aan trefwoorden om querymethoden in onze opslagplaatsen te creëren.

Laten we ze nu verkennen.

3.1. Bevat, Bevat, Bevat en Leuk vinden

Laten we eens kijken hoe we de volgende LIKE-query kunnen uitvoeren met een query-methode:

SELECTEER * UIT film WAAR titel ZOALS '% in%';

Laten we eerst de zoekmethoden definiëren met Bevat, Bevat, en Bevat:

Lijst findByTitleContaining (String-titel); Lijst findByTitleContains (String-titel); Lijst findByTitleIsContaining (String-titel);

Laten we onze zoekmethoden noemen met de gedeeltelijke titel in:

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

We kunnen verwachten dat elk van de drie methoden dezelfde resultaten oplevert.

Spring geeft ons ook een Leuk vinden trefwoord, maar het gedraagt ​​zich iets anders in die zin dat we het jokerteken moeten opgeven bij onze zoekparameter.

Laten we een LIKE-querymethode definiëren:

List findByTitleLike (String-titel);

Laten we nu onze bellen findByTitleLike methode met dezelfde waarde die we eerder gebruikten, maar inclusief de jokertekens:

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

3.2. Begint met

Laten we nu eens kijken naar de volgende vraag:

SELECTEER * UIT Film WAAR Beoordeling ZOALS 'PG%';

Laten we de Begint met trefwoord om een ​​zoekmethode te maken:

Lijst findByRatingStartsWith (String-beoordeling);

Met onze gedefinieerde methode, laten we het noemen met de waarde PG:

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

3.3. Eindigt met

De lente biedt ons de tegenovergestelde functionaliteit met de Eindigt met trefwoord.

Laten we deze vraag eens bekijken:

SELECTEER * UIT Film WAAR regisseur ZOALS '% Burton';

Laten we nu een Eindigt met zoekmethode:

Lijst findByDirectorEndsWith (String director);

Zodra we onze methode hebben gedefinieerd, noemen we deze met de Burton parameter:

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

3.4. Case ongevoeligheid

We willen vaak alle records vinden die een bepaalde tekenreeks bevatten, ongeacht het hoofdlettergebruik. In SQL kunnen we dit bereiken door de kolom volledig in hoofdletters of kleine letters te forceren en dezelfde waarden op te geven die we opvragen.

Met Spring JPA kunnen we de Negeer zaak trefwoord gecombineerd met een van onze andere trefwoorden:

Lijst findByTitleContainingIgnoreCase (String-titel);

Nu kunnen we de methode aanroepen met de en verwacht resultaten te krijgen die zowel resultaten in kleine letters als in hoofdletters bevatten:

Lijstresultaten = movieRepository.findByTitleContainingIgnoreCase ("de"); assertEquals (2, results.size ());

3.5. Niet

Soms willen we alle records vinden die geen bepaalde tekenreeks bevatten. We kunnen de NotContains, Bevat niet, en Niet zoals trefwoorden om dat te doen.

Laten we een zoekopdracht definiëren met Bevat niet om films te vinden met beoordelingen die geen PG:

Lijst findByRatingNotContaining (String-beoordeling);

Laten we nu onze nieuw gedefinieerde methode noemen:

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

Om functionaliteit te verkrijgen waarmee records worden gevonden waar de director niet met een bepaalde tekenreeks begint, gebruiken we de Niet zoals trefwoord om de controle over onze jokertekens te behouden:

Lijst findByDirectorNotLike (String director);

Laten we tot slot de methode aanroepen om alle films te vinden waarvan de naam van de regisseur begint met iets anders dan Een:

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

We kunnen gebruiken Niet zoals op een vergelijkbare manier om een Niet gecombineerd met de Eindigt met soort functionaliteit.

4. Met behulp van @Query

Soms moeten we queries maken die te gecompliceerd zijn voor Query Methods of die resulteren in absurd lange methodenamen. In die gevallen we kunnen de @Query annotatie om onze database te doorzoeken.

4.1. Benoemde parameters

Laten we voor vergelijkingsdoeleinden een query maken die gelijk is aan de findByTitleContaining methode die we eerder hebben gedefinieerd:

@Query ("SELECTEER m UIT Film m WAAR m.title LIKE%: title%") Lijst searchByTitleLike (@Param ("title") String-titel);

We nemen onze jokertekens op in de zoekopdracht die we leveren. De @Param annotatie is hier belangrijk omdat we een benoemde parameter gebruiken.

4.2. Bestelde parameters

Naast benoemde parameters kunnen we geordende parameters gebruiken in onze zoekopdrachten:

@Query ("SELECTEER m UIT Film m WAAR m.rating LIKE? 1%") Lijst searchByRatingStartsWith (String rating);

We hebben controle over onze jokertekens, dus deze vraag is het equivalent van de findByRatingStartsWith query-methode.

Laten we alle films zoeken met een beoordeling die begint met PG:

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

Als we geordende parameters gebruiken in LIKE-zoekopdrachten met niet-vertrouwde gegevens, moeten we inkomende zoekwaarden ontsnappen.

Als we Spring Boot 2.4.1 of hoger gebruiken, kunnen we de SpEL gebruiken ontsnappen methode:

@Query ("SELECTEER m UIT Film m WAAR m.director LIKE%? # {Escape ([0])} escape? # {EscapeCharacter ()}") Lijst searchByDirectorEndsWith (String director);

Laten we nu onze methode noemen met de waarde Burton:

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

5. Conclusie

In deze korte tutorial hebben we geleerd hoe we LIKE-query's kunnen maken in Spring JPA Repositories.

Ten eerste hebben we geleerd hoe we de opgegeven trefwoorden kunnen gebruiken om zoekmethoden te maken. Vervolgens hebben we geleerd hoe we dezelfde taken kunnen uitvoeren met de @Query parameter met zowel benoemde als geordende parameters.

De volledige voorbeeldcode is beschikbaar op GitHub.