@DynamicUpdate dengan Spring Data JPA

1. Gambaran keseluruhan

Apabila kita menggunakan Spring Data JPA dengan Hibernate, kita juga boleh menggunakan ciri tambahan Hibernate. @DynamicUpdate adalah salah satu ciri tersebut.

@DynamicUpdate adalah anotasi peringkat kelas yang boleh digunakan untuk entiti JPA. Ini memastikan bahawa Hibernate hanya menggunakan lajur yang diubah dalam pernyataan SQL yang dihasilkannya untuk kemas kini entiti .

Dalam artikel ini, kami akan melihat penjelasan @DynamicUpdate , dengan bantuan contoh Spring Data JPA .

2. JPA @Entity

Apabila aplikasi dimulakan, Hibernate menghasilkan penyataan SQL untuk operasi CRUD semua entiti. Pernyataan SQL ini dihasilkan sekali dan di-cache, dalam memori, untuk meningkatkan prestasi.

Pernyataan kemas kini SQL yang dihasilkan merangkumi semua lajur entiti. Sekiranya kita mengemas kini entiti, nilai lajur yang diubah suai diteruskan ke pernyataan kemas kini SQL. Untuk lajur yang tidak dikemas kini, Hibernate menggunakan nilai yang ada untuk kemas kini.

Mari cuba fahami ini dengan contoh. Pertama, mari kita pertimbangkan entiti JPA bernama Akaun :

@Entity public class Account { @Id private int id; @Column private String name; @Column private String type; @Column private boolean active; // Getters and Setters }

Seterusnya, mari kita tulis repositori JPA untuk entiti Akaun :

@Repository public interface AccountRepository extends JpaRepository { }

Sekarang, kami akan menggunakan AccountRepository untuk mengemas kini bidang nama objek Akaun :

Account account = accountRepository.findOne(ACCOUNT_ID); account.setName("Test Account"); accountRepository.save(account);

Setelah kami melaksanakan kemas kini ini, kami dapat mengesahkan pernyataan SQL yang dihasilkan. Penyataan SQL yang dihasilkan akan merangkumi semua lajur Akaun :

update Account set active=?, name=?, type=? where id=?

3. JPA @Entity dengan @DynamicUpdate

Kami telah melihat bahawa walaupun kami hanya mengubah suai bidang nama , Hibernate telah memasukkan semua lajur dalam pernyataan SQL.

Sekarang, mari tambahkan anotasi @DynamicUpdate ke entiti Akaun :

@Entity @DynamicUpdate public class Account { // Existing data and methods }

Seterusnya, mari kita jalankan kod kemas kini yang sama yang kita gunakan di bahagian sebelumnya. Kita dapat melihat bahawa SQL yang dihasilkan oleh Hibernate, dalam kes ini, hanya merangkumi lajur nama :

update Account set name=? where id=?

Jadi, apa yang berlaku apabila kita menggunakan @DynamicUpdate pada entiti ?

Sebenarnya, apabila kita menggunakan @DynamicUpdate pada entiti, Hibernate tidak menggunakan pernyataan SQL yang dicache untuk kemas kini. Sebaliknya, ia akan menghasilkan pernyataan SQL setiap kali kita mengemas kini entiti. Ini SQL dihasilkan termasuk hanya ruangan berubah .

Untuk mengetahui lajur yang diubah, Hibernate perlu mengesan keadaan entiti semasa. Oleh itu, apabila kita mengubah bidang entiti, ia membandingkan keadaan entiti semasa dan yang diubah.

Ini bermakna @ DynamicUpdate mempunyai overhead prestasi yang berkaitan dengannya . Oleh itu, kita hanya boleh menggunakannya ketika sebenarnya diperlukan.

Sudah tentu, terdapat beberapa senario di mana kita harus menggunakan anotasi ini - sebagai contoh, jika entiti mewakili jadual yang mempunyai sebilangan besar lajur dan hanya sebilangan lajur ini yang perlu dikemas kini dengan kerap. Juga, apabila kita menggunakan penguncian optimis tanpa versi, kita perlu menggunakan @DynamicUpdate .

4. Kesimpulan

Dalam tutorial ini, kami telah melihat anotasi Hibernate @DynamicUpdate . Kami telah menggunakan contoh Spring Data JPA untuk melihat @DynamicUpdate dalam tindakan. Juga, kita telah membincangkan kapan kita harus menggunakan ciri ini dan kapan tidak seharusnya.

Seperti biasa, contoh kod lengkap yang digunakan dalam tutorial ini terdapat di Github.