WIE Abfragen in Spring JPA-Repositorys

1. Einleitung

In diesem kurzen Tutorial werden verschiedene Möglichkeiten zum Erstellen von LIKE-Abfragen in Spring JPA-Repositorys behandelt.

Zunächst betrachten wir die verschiedenen Schlüsselwörter, die wir beim Erstellen von Abfragemethoden verwenden können. Anschließend behandeln wir die Annotation @Query mit benannten und geordneten Parametern.

2. Setup

Für unser Beispiel werden wir einen werden abfragt Film Tabelle.

Lassen Sie uns unsere definieren Film Einheit:

@Entity public class Movie { @Id @GeneratedValue(strategy = GenerationType.SEQUENCE) private Long id; private String title; private String director; private String rating; private int duration; // standard getters and setters }

Nachdem unsere Movie- Entität definiert ist, erstellen wir einige Beispiel-Einfügeanweisungen:

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. WIE Abfragemethoden

Für viele einfache LIKE-Abfrageszenarien können wir eine Vielzahl von Schlüsselwörtern verwenden, um Abfragemethoden in unseren Repositorys zu erstellen.

Lassen Sie uns sie jetzt erkunden.

3.1. Enthaltend , enthält , IsContaining und Wie

Schauen wir uns an, wie wir die folgende LIKE-Abfrage mit einer Abfragemethode ausführen können:

SELECT * FROM movie WHERE title LIKE '%in%';

Definieren wir zunächst Abfragemethoden mit Containing , Contains und IsContaining :

List findByTitleContaining(String title); List findByTitleContains(String title); List findByTitleIsContaining(String title);

Nennen wir unsere Abfragemethoden mit dem Teiltitel in :

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

Wir können erwarten, dass jede der drei Methoden die gleichen Ergebnisse liefert.

Spring stellt uns auch ein Like- Schlüsselwort zur Verfügung, das sich jedoch etwas anders verhält, da wir das Platzhalterzeichen mit unserem Suchparameter versehen müssen.

Definieren wir eine LIKE-Abfragemethode:

List findByTitleLike(String title);

Rufen wir nun unsere findByTitleLike- Methode mit demselben Wert auf, den wir zuvor verwendet haben, jedoch einschließlich der Platzhalterzeichen:

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

3.2. Beginnt mit

Schauen wir uns nun die folgende Abfrage an:

SELECT * FROM Movie WHERE Rating LIKE 'PG%';

Verwenden Sie das Schlüsselwort StartsWith , um eine Abfragemethode zu erstellen:

List findByRatingStartsWith(String rating);

Nennen wir unsere definierte Methode mit dem Wert PG :

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

3.3. Endet mit

Spring bietet uns mit dem Schlüsselwort EndsWith die entgegengesetzte Funktionalität .

Betrachten wir diese Abfrage:

SELECT * FROM Movie WHERE director LIKE '%Burton';

Definieren wir nun eine EndsWith- Abfragemethode:

List findByDirectorEndsWith(String director);

Nachdem wir unsere Methode definiert haben, rufen wir sie mit dem Burton- Parameter auf:

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

3.4. Groß- und Kleinschreibung beachten

Wir möchten oft alle Datensätze finden, die eine bestimmte Zeichenfolge enthalten, unabhängig vom Fall. In SQL können wir dies erreichen, indem wir die Spalte auf alle Groß- oder Kleinbuchstaben setzen und diese mit den von uns abgefragten Werten versehen.

Mit Spring JPA können wir das Schlüsselwort IgnoreCase in Kombination mit einem unserer anderen Schlüsselwörter verwenden:

List findByTitleContainingIgnoreCase(String title);

Jetzt können wir die Methode mit dem aufrufen und erwarten, dass Ergebnisse sowohl in Klein- als auch in Großbuchstaben angezeigt werden:

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

3.5. Nicht

Manchmal möchten wir alle Datensätze finden, die keine bestimmte Zeichenfolge enthalten. Wir können die Verwendung NotContains , NotContaining, und NOTLIKE Schlüsselwörter , das zu tun.

Definieren wir eine Abfrage mit NotContaining , um Filme mit Bewertungen zu finden, die kein PG enthalten :

List findByRatingNotContaining(String rating);

Rufen wir nun unsere neu definierte Methode auf:

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

Um Funktionen zu erhalten, mit denen Datensätze gefunden werden, bei denen der Director nicht mit einer bestimmten Zeichenfolge beginnt, verwenden wir das Schlüsselwort NotLike , um die Kontrolle über unsere Platzhalterplatzierung zu behalten:

List findByDirectorNotLike(String director);

Rufen wir abschließend die Methode auf, um alle Filme zu finden, in denen der Name des Regisseurs mit etwas anderem als An beginnt :

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

Wir können NotLike auf ähnliche Weise verwenden, um eine Nicht- Kombination mit der EndsWith- Funktionalität zu erreichen.

4. Verwenden von @Query

Manchmal müssen wir Abfragen erstellen, die für Abfragemethoden zu kompliziert sind oder zu absurd langen Methodennamen führen. In diesen Fällen können wir die Annotation @Query verwenden , um unsere Datenbank abzufragen.

4.1. Benannte Parameter

Erstellen wir zu Vergleichszwecken eine Abfrage, die der zuvor definierten findByTitleContaining- Methode entspricht :

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

Wir nehmen unsere Platzhalter in die von uns bereitgestellte Abfrage auf. Die Annotation @Param ist hier wichtig, da wir einen benannten Parameter verwenden.

4.2. Geordnete Parameter

Zusätzlich zu den benannten Parametern können wir in unseren Abfragen geordnete Parameter verwenden:

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

Wir haben die Kontrolle über unsere Platzhalter, daher entspricht diese Abfrage der Abfragemethode findByRatingStartsWith .

Lassen Sie uns alle Filme mit einer Bewertung finden, die mit PG beginnt :

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

Wenn wir geordnete Parameter in LIKE-Abfragen mit nicht vertrauenswürdigen Daten verwenden, sollten wir eingehende Suchwerte umgehen.

Wenn wir Spring Boot 2.4.1 oder höher verwenden, können wir die SpEL- Escape- Methode verwenden:

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

Rufen wir nun unsere Methode mit dem Wert Burton auf :

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

5. Schlussfolgerung

In diesem kurzen Tutorial haben wir gelernt, wie Sie LIKE-Abfragen in Spring JPA-Repositorys erstellen.

Zunächst haben wir gelernt, wie Sie mit den angegebenen Schlüsselwörtern Abfragemethoden erstellen. Anschließend haben wir gelernt, wie dieselben Aufgaben mithilfe des Parameters @Query mit benannten und geordneten Parametern ausgeführt werden.

Der vollständige Beispielcode ist auf GitHub verfügbar.