Metode Kueri Berasal di Repositori JPA Data Musim Semi

1. Perkenalan

Untuk kueri sederhana, mudah untuk mendapatkan apa kueri seharusnya hanya dengan melihat nama metode yang sesuai di kode kita.

Dalam tutorial ini, kita akan menjelajahi bagaimana Spring Data JPA memanfaatkan ide ini dalam bentuk konvensi penamaan metode.

2. Struktur Metode Query Derived di Spring

Nama metode yang diturunkan memiliki dua bagian utama yang dipisahkan oleh kata kunci By pertama :

List findByName(String name)

Bagian pertama - seperti menemukan - adalah pengantar dan sisanya - seperti ByName - adalah kriterianya.

Spring Data JPA mendukung temukan, baca, kueri, hitung, dan dapatkan . Jadi, misalnya, kita bisa melakukan queryByName dan Spring Data akan berperilaku sama.

Kami juga dapat menggunakan Distinct, First, atau Top untuk menghapus duplikat atau membatasi kumpulan hasil kami:

List findTop3ByAge()

Bagian kriteria berisi ekspresi kondisi spesifik entitas dari kueri. Kita dapat menggunakan kata kunci kondisi bersama dengan nama properti entitas. Kita juga dapat menggabungkan ekspresi dengan And dan Or, serta melihatnya sebentar lagi.

3. Contoh Penerapan

Pertama, tentunya kita membutuhkan aplikasi yang menggunakan Spring Data JPA.

Dalam aplikasi itu, mari kita definisikan kelas entitas:

@Table(name = "users") @Entity class User { @Id @GeneratedValue private Integer id; private String name; private Integer age; private ZonedDateTime birthDate; private Boolean active; // standard getters and setters }

Dan, mari kita juga mendefinisikan repositori. Ini akan memperluas JpaRepository, salah satu jenis Spring Data Repository:

interface UserRepository extends JpaRepository {}

Di sinilah kita akan menempatkan semua metode kueri turunan kita.

4. Kata Kunci Kondisi Kesetaraan

Persamaan yang tepat adalah salah satu kondisi yang paling sering digunakan dalam kueri. Kami memiliki beberapa opsi untuk mengekspresikan operator = atau IS dalam kueri.

Kami hanya dapat menambahkan nama properti tanpa kata kunci untuk kondisi pencocokan persis:

List findByName(String name);

Dan kita bisa menambahkan Is atau Equals untuk keterbacaan:

List findByNameIs(String name); List findByNameEquals(String name);

Keterbacaan ekstra ini berguna saat kita perlu mengekspresikan ketidaksetaraan sebagai gantinya:

List findByNameIsNot(String name);

Ini sedikit lebih mudah dibaca daripada findByNameNot (String) !

Karena persamaan nol adalah kasus khusus, kita tidak boleh menggunakan operator =. Spring Data JPA menangani parameter null secara default. Jadi, ketika kita mengirimkan nilai null untuk kondisi kesetaraan, Spring menafsirkan kueri sebagai IS NULL dalam SQL yang dihasilkan.

Kami juga dapat menggunakan kata kunci IsNull untuk menambahkan kriteria IS NULL ke kueri:

List findByNameIsNull(); List findByNameIsNotNull();

Perhatikan bahwa, baik IsNull maupun IsNotNull tidak memerlukan argumen metode.

Ada juga dua kata kunci lagi yang tidak memerlukan argumen apa pun. Kita dapat menggunakan kata kunci True dan False untuk menambahkan kondisi persamaan untuk tipe boolean :

List findByActiveTrue(); List findByActiveFalse();

Tentu saja, terkadang kita menginginkan sesuatu yang lebih lunak daripada persamaan yang tepat, mari kita lihat apa lagi yang bisa kita lakukan.

5. Kata Kunci Kondisi Kesamaan

Saat kami perlu menanyakan hasil dengan pola properti, kami memiliki beberapa opsi.

Kita dapat menemukan nama yang dimulai dengan nilai menggunakan StartingWith :

List findByNameStartingWith(String prefix);

Secara kasar, ini diterjemahkan menjadi "WHERE name LIKE 'value%' ".

Jika kita menginginkan nama yang diakhiri dengan nilai, maka EndingWith adalah yang kita inginkan:

List findByNameEndingWith(String suffix);

Atau, kita dapat menemukan nama mana yang mengandung nilai dengan Mengandung :

List findByNameContaining(String infix);

Perhatikan bahwa semua kondisi di atas disebut ekspresi pola yang telah ditentukan sebelumnya. Jadi, kita tidak perlu menambahkan operator % di dalam argumen saat metode ini dipanggil.

Tetapi, anggaplah kita sedang melakukan sesuatu yang lebih kompleks. Katakanlah kita perlu mengambil pengguna yang namanya dimulai dengan a , berisi b, dan diakhiri dengan c.

Untuk itu, kita bisa menambahkan LIKE kita sendiri dengan kata kunci Like :

List findByNameLike(String likePattern);

Dan kita kemudian dapat menyerahkan pola LIKE kita saat memanggil metode ini:

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

Cukup tentang nama untuk saat ini. Mari coba beberapa nilai lain di User.

6. Perbandingan Kondisi Kata Kunci

Selain itu, kita dapat menggunakan waktu kurang dan LessThanEqual kata kunci untuk membandingkan catatan dengan nilai yang diberikan menggunakan < dan <= operator:

List findByAgeLessThan(Integer age); List findByAgeLessThanEqual(Integer age);

On the other hand, in the opposite situation, we can use GreaterThan and GreaterThanEqual keywords:

List findByAgeGreaterThan(Integer age); List findByAgeGreaterThanEqual(Integer age);

Or, we can find users who are between two ages with Between:

List findByAgeBetween(Integer startAge, Integer endAge);

We can also supply a collection of ages to match against using In:

List findByAgeIn(Collection ages);

Since we know the users' birthdates, we might want to query for users who were born before or after a given date. We'd use Before and After for that:

List findByBirthDateAfter(ZonedDateTime birthDate); List findByBirthDateBefore(ZonedDateTime birthDate);

7. Multiple Condition Expressions

We can combine as many expressions as we need by using And and Or keywords:

List findByNameOrBirthDate(String name, ZonedDateTime birthDate); List findByNameOrBirthDateAndActive(String name, ZonedDateTime birthDate, Boolean active);

The precedence order is And then Or, just like Java.

While Spring Data JPA imposes no limit to how many expressions we can add, we shouldn't go crazy here. Long names are unreadable and hard to maintain. For complex queries, take a look at the @Query annotation instead.

8. Sorting the Results

Next up is sorting. We could ask that the users be sorted alphabetically by their name using OrderBy:

List findByNameOrderByName(String name); List findByNameOrderByNameAsc(String name);

Ascending order is the default sorting option, but we can use Desc instead to sort them in reverse:

List findByNameOrderByNameDesc(String name);

9. findOne vs findById in a CrudRepository

The Spring team made some major changes in CrudRepository with Spring Boot 2.x. One of them is renaming findOne to findById.

Previously with Spring Boot 1.x, we'd call findOne when we wanted to retrieve an entity by its primary key:

User user = userRepository.findOne(1);

Since Spring Boot 2.x we can do the same with findById:

User user = userRepository.findById(1);

Note that the findById() method is already defined in CrudRepository for us. So we don't have to define it explicitly in custom repositories that extend CrudRepository.

10. Conclusion

Pada artikel ini, kami menjelaskan mekanisme derivasi kueri di Spring Data JPA. Kami menggunakan kata kunci kondisi properti untuk menulis metode kueri turunan di repositori JPA Spring Data.

Kode sumber tutorial ini tersedia di proyek Github.