Afgeleide zoekmethoden in Spring Data JPA-opslagplaatsen

1. Inleiding

Voor eenvoudige zoekopdrachten is het gemakkelijk om af te leiden wat de zoekopdracht zou moeten zijn gewoon door naar de corresponderende methode naam in onze code te kijken.

In deze tutorial zullen we onderzoeken hoe Spring Data JPA dit idee gebruikt in de vorm van een methode voor naamgeving.

2. Structuur van afgeleide zoekmethoden in het voorjaar

Namen van afgeleide methoden hebben twee hoofdonderdelen, gescheiden door de eerste Door trefwoord:

List findByName (String naam)

Het eerste deel - zoals vind - is de introducer en de rest - zoals Bij naam - is de criteria.

Spring Data JPA ondersteunt vind, lees, vraag, tel en krijgen. Dus we hadden het bijvoorbeeld kunnen doen queryByName en Spring Data zou hetzelfde gedragen.

We kunnen ook gebruik maken van Onderscheidend, ten eerste, of Top om duplicaten te verwijderen of onze resultatenset te beperken:

Lijst findTop3ByAge ()

Het criteriagedeelte bevat de entiteitspecifieke voorwaarde-uitdrukkingen van de query. We kunnen de voorwaarde-sleutelwoorden gebruiken in combinatie met de eigenschapsnamen van de entiteit. We kunnen de uitdrukkingen ook samenvoegen met En en Of, zo goed zien in een ogenblik.

3. Voorbeeldtoepassing

Ten eerste hebben we natuurlijk een applicatie nodig die Spring Data JPA gebruikt.

Laten we in die toepassing een entiteitsklasse definiëren:

@Table (name = "gebruikers") @ Entiteitsklasse Gebruiker {@Id @GeneratedValue privé Geheel getal-id; private String naam; privé Integer leeftijd; privé ZonedDateTime birthDate; private Boolean actief; // standaard getters en setters}

En laten we ook een repository definiëren. Het zal zich uitstrekken JpaRepository, een van de typen Spring Data Repository:

interface UserRepository breidt JpaRepository {} uit

Dit is waar we al onze afgeleide zoekmethoden zullen plaatsen.

4. Gelijkheidsvoorwaarde Sleutelwoorden

Exacte gelijkheid is een van de meest gebruikte voorwaarden bij zoekopdrachten. We hebben verschillende opties om uit te drukken = of IS-operators in de query.

We kunnen de eigenschapnaam gewoon toevoegen zonder een trefwoord voor een exacte overeenkomstvoorwaarde:

List findByName (String naam);

En we kunnen toevoegen Is of Is gelijk aan voor leesbaarheid:

List findByNameIs (String naam); List findByNameEquals (String naam);

Deze extra leesbaarheid is handig wanneer we in plaats daarvan ongelijkheid moeten uitdrukken:

List findByNameIsNot (String naam);

Dit is een stuk beter leesbaar dan findByNameNot (tekenreeks)!

Net zo nul gelijkheid is een speciaal geval, we zouden de = operator niet moeten gebruiken. Spring Data JPA handgrepen nul parameters standaard. Dus als we een nul waarde voor een gelijkheidsvoorwaarde, interpreteert Spring de query als IS NULL in de gegenereerde SQL.

We kunnen ook de Is niets trefwoord om IS NULL-criteria aan de zoekopdracht toe te voegen:

Lijst findByNameIsNull (); Lijst findByNameIsNotNull ();

Merk op dat geen van beide Is niets noch Is niet nul vereist een methode-argument.

Er zijn ook nog twee trefwoorden waarvoor geen argumenten nodig zijn. We kunnen gebruiken Klopt en Vals trefwoorden om voorwaarden voor gelijkheid toe te voegen boolean types:

Lijst findByActiveTrue (); Lijst findByActiveFalse ();

Natuurlijk willen we soms iets milder dan exacte gelijkheid, laten we eens kijken wat we nog meer kunnen doen.

5. Trefwoorden van gelijkheidsvoorwaarde

Als we de resultaten moeten opvragen met een patroon van een eigenschap, hebben we een paar opties.

We kunnen namen vinden die beginnen met een waarde met Beginnend met:

Lijst findByNameStartingWith (String prefix);

Dit vertaalt zich ruwweg naar "WAAR naam LEUK VINDEN 'waarde%'“.

Als we namen willen die eindigen op een waarde, dan Eindigend met is wat we willen:

Lijst findByNameEndingWith (String-achtervoegsel);

Of we kunnen zoeken welke namen een waarde bevatten met Bevat:

Lijst findByNameContaining (String-tussenvoegsel);

Merk op dat alle bovenstaande voorwaarden vooraf gedefinieerde patroonuitdrukkingen worden genoemd. Zo, we hoeven niet toe te voegen % operator binnen het argument wanneer deze methoden worden aangeroepen.

Maar laten we veronderstellen dat we iets ingewikkelder doen. Stel dat we de gebruikers moeten ophalen wiens naam begint met een een, bevatten b, en eindigen met c.

Daarvoor kunnen we onze eigen LIKE toevoegen met de Leuk vinden trefwoord:

Lijst findByNameLike (String likePattern);

En we kunnen dan ons LIKE-patroon inleveren als we de methode aanroepen:

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

Dat is voorlopig genoeg over namen. Laten we een paar andere waarden proberen Gebruiker.

6. Trefwoorden voor vergelijkingsvoorwaarde

Verder kunnen we gebruik maken van Minder dan en Minder dan gelijk trefwoorden om de records met de opgegeven waarde te vergelijken met de < en <= operators:

List findByAgeLessThan (Integer leeftijd); List findByAgeLessThanEqual (Integer leeftijd);

Aan de andere kant kunnen we in de tegenovergestelde situatie gebruiken Groter dan en GreaterThanEqual trefwoorden:

List findByAgeGreaterThan (Integer leeftijd); List findByAgeGreaterThanEqual (Integer leeftijd);

Of we kunnen gebruikers vinden die tussen twee leeftijden zijn Tussen:

Lijst findByAgeBetween (Integer startAge, Integer endAge);

We kunnen ook een verzameling leeftijden leveren om tegen gebruik te matchen In:

List findByAgeIn (Verzameling leeftijden);

Omdat we de geboortedata van de gebruikers kennen, willen we misschien vragen naar gebruikers die voor of na een bepaalde datum zijn geboren. We zouden gebruiken Voordat en Na daarom:

Lijst findByBirthDateAfter (ZonedDateTime birthDate); Lijst findByBirthDateBefore (ZonedDateTime birthDate);

7. Meerdere voorwaarde-uitdrukkingen

We kunnen zoveel uitdrukkingen combineren als we nodig hebben door En en Of trefwoorden:

Lijst findByNameOrBirthDate (String naam, ZonedDateTime birthDate); List findByNameOrBirthDateAndActive (String naam, ZonedDateTime birthDate, Boolean actief);

De prioriteitsvolgorde is En dan Of, net als Java.

Hoewel Spring Data JPA geen limiet oplegt aan het aantal uitdrukkingen dat we kunnen toevoegen, moeten we hier niet gek worden. Lange namen zijn onleesbaar en moeilijk te onderhouden. Kijk voor complexe vragen bij de @Query annotatie in plaats daarvan.

8. Sorteren van de resultaten

De volgende is sorteren. We zouden kunnen vragen dat de gebruikers alfabetisch op hun naam worden gesorteerd met OrderBy:

Lijst findByNameOrderByName (String naam); Lijst findByNameOrderByNameAsc (String naam);

Oplopende volgorde is de standaard sorteeroptie, maar we kunnen deze gebruiken Desc in plaats daarvan om ze in omgekeerde volgorde te sorteren:

Lijst findByNameOrderByNameDesc (tekenreeksnaam);

9. vind een vs findById in een CrudRepository

Het Spring-team heeft een aantal grote wijzigingen aangebracht in CrudRepository met Spring Boot 2.x. Een daarvan is hernoemen vind een naar findById.

Voorheen met Spring Boot 1.x, zouden we bellen vind een wanneer we een entiteit wilden ophalen met zijn primaire sleutel:

Gebruiker user = userRepository.findOne (1);

Sinds Spring Boot 2.x kunnen we hetzelfde doen met findById:

Gebruiker user = userRepository.findById (1);

Merk op dat de findById () methode is al gedefinieerd in CrudRepository voor ons. We hoeven het dus niet expliciet te definiëren in aangepaste opslagplaatsen die zich uitbreiden CrudRepository.

10. Conclusie

In dit artikel hebben we het mechanisme voor het afleiden van query's in Spring Data JPA uitgelegd. We hebben de trefwoorden voor eigenschapcondities gebruikt om afgeleide querymethoden te schrijven in Spring Data JPA-opslagplaatsen.

De broncode van deze tutorial is beschikbaar op het Github-project.


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