LIKE Queries di Spring JPA Repositories

1. Perkenalan

Dalam tutorial singkat ini, kami akan membahas berbagai cara membuat kueri LIKE di Spring JPA Repositories.

Kami akan mulai dengan melihat berbagai kata kunci yang dapat kami gunakan saat membuat metode kueri. Kemudian, kita akan membahas anotasi @Query dengan parameter bernama dan terurut.

2. Penyiapan

Untuk contoh kita, kita akan menanyakan tabel film .

Mari tentukan entitas Film kita :

@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 }

Dengan entitas Film kita ditentukan, mari buat beberapa contoh pernyataan penyisipan:

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. SEPERTI Metode Query

Untuk banyak skenario kueri LIKE sederhana, kami dapat memanfaatkan berbagai kata kunci untuk membuat metode kueri di repositori kami.

Mari kita jelajahi sekarang.

3.1. Berisi , Berisi , IsContaining dan Suka

Mari kita lihat bagaimana kita dapat melakukan query LIKE dengan metode query:

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

Pertama, mari kita tentukan metode kueri menggunakan Containing , Contains, dan IsContaining :

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

Mari kita panggil metode kueri kita dengan judul parsial di :

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());

Kita bisa mengharapkan masing-masing dari tiga metode untuk mengembalikan hasil yang sama.

Spring juga memberi kami kata kunci Suka , tetapi perilakunya sedikit berbeda karena kami harus memberikan karakter wildcard dengan parameter penelusuran kami.

Mari tentukan metode kueri LIKE:

List findByTitleLike(String title);

Sekarang, mari kita panggil metode findByTitleLike kita dengan nilai yang sama yang kita gunakan sebelumnya tetapi menyertakan karakter wildcard:

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

3.2. Dimulai dengan

Sekarang, mari kita lihat kueri berikut:

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

Mari gunakan kata kunci StartsWith untuk membuat metode kueri:

List findByRatingStartsWith(String rating);

Dengan mendefinisikan metode kami, sebut saja dengan nilai PG :

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

3.3. Berakhir dengan

Spring memberi kita fungsi yang berlawanan dengan kata kunci EndsWith .

Mari pertimbangkan kueri ini:

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

Sekarang, mari kita tentukan metode kueri EndsWith :

List findByDirectorEndsWith(String director);

Setelah kita mendefinisikan metode kita, sebut saja dengan parameter Burton :

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

3.4. Ketidakpekaan Kasus

Kami sering ingin menemukan semua record yang berisi string tertentu apa pun masalahnya. Dalam SQL, kita dapat melakukannya dengan memaksa kolom ke semua huruf besar atau kecil dan memberikan nilai yang sama dengan yang kita kueri.

Dengan Spring JPA, kita dapat menggunakan kata kunci IgnoreCase yang digabungkan dengan salah satu kata kunci kita yang lain:

List findByTitleContainingIgnoreCase(String title);

Sekarang kita dapat memanggil metode dengan yang dan berharap untuk mendapatkan hasil yang mengandung kedua, hasil lebih rendah untuk dan huruf besar:

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

3.5. Tidak

Terkadang kami ingin menemukan semua rekaman yang tidak berisi string tertentu. Kita dapat menggunakan kata kunci NotContains , NotContaining, dan NotLike untuk melakukan itu.

Mari tentukan kueri menggunakan NotContaining untuk menemukan film dengan peringkat yang tidak mengandung PG :

List findByRatingNotContaining(String rating);

Sekarang, mari kita panggil metode yang baru kita tentukan:

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

Untuk mencapai fungsionalitas yang menemukan record di mana sutradaranya tidak dimulai dengan string tertentu, mari gunakan kata kunci NotLike untuk mempertahankan kendali atas penempatan wild card kita:

List findByDirectorNotLike(String director);

Terakhir, mari panggil metode untuk menemukan semua film yang nama sutradaranya dimulai dengan sesuatu selain An :

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

Kita dapat menggunakan NotLike dengan cara yang mirip untuk mencapai fungsi Tidak digabungkan dengan jenis fungsi EndsWith .

4. Menggunakan @Query

Terkadang kita perlu membuat kueri yang terlalu rumit untuk Metode Kueri atau akan menghasilkan nama metode yang sangat panjang. Dalam kasus tersebut, kita dapat menggunakan anotasi @Query untuk menanyakan database kita.

4.1. Parameter Bernama

Untuk tujuan perbandingan, mari buat kueri yang setara dengan metode findByTitleContaining yang kami tentukan sebelumnya:

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

Kami menyertakan wildcard kami dalam kueri yang kami berikan. The @param penjelasan penting di sini karena kita menggunakan parameter bernama.

4.2. Parameter yang Dipesan

Selain parameter bernama, kita dapat menggunakan parameter terurut dalam kueri kita:

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

Kami memiliki kontrol atas karakter pengganti kami, jadi kueri ini setara dengan metode kueri findByRatingStartsWith .

Mari temukan semua film dengan rating yang dimulai dengan PG :

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

Saat kita menggunakan parameter terurut dalam kueri LIKE dengan data tidak tepercaya, kita harus menghindari nilai pencarian yang masuk.

Jika kita menggunakan Spring Boot 2.4.1 atau yang lebih baru, kita dapat menggunakan metode escape SpEL :

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

Sekarang, mari panggil metode kita dengan nilai Burton :

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

5. Kesimpulan

Dalam tutorial singkat ini, kita belajar bagaimana membuat query LIKE di Spring JPA Repositories.

Pertama, kami mempelajari cara menggunakan kata kunci yang disediakan untuk membuat metode kueri. Kemudian, kami mempelajari cara menyelesaikan tugas yang sama menggunakan parameter @Query dengan parameter bernama dan terurut.

Kode contoh lengkap tersedia di GitHub.