Anotasi Data Musim Semi

Artikel ini bagian dari serial: • Spring Core Annotations

• Anotasi Web Musim Semi

• Anotasi Spring Boot

• Penjadwalan Penjadwalan Musim Semi

• Anotasi Data Musim Semi (artikel saat ini) • Anotasi Spring Bean

1. Perkenalan

Spring Data menyediakan abstraksi atas teknologi penyimpanan data. Oleh karena itu, kode logika bisnis kita bisa jauh lebih independen dari penerapan ketekunan yang mendasarinya. Selain itu, Spring menyederhanakan penanganan detail penyimpanan data yang bergantung pada implementasi.

Dalam tutorial ini, kita akan melihat anotasi paling umum dari proyek Spring Data, Spring Data JPA, dan Spring Data MongoDB.

2. Anotasi Data Musim Semi Umum

2.1. @Transaksi

Saat kita ingin mengonfigurasi perilaku transaksional suatu metode , kita dapat melakukannya dengan:

@Transactional void pay() {}

Jika kita menerapkan anotasi ini pada tingkat kelas, maka itu bekerja pada semua metode di dalam kelas. Namun, kita dapat mengganti efeknya dengan menerapkannya ke metode tertentu.

Ini memiliki banyak opsi konfigurasi, yang dapat ditemukan di artikel ini.

2.2. @NoRository

Terkadang kita ingin membuat antarmuka repositori dengan satu-satunya tujuan menyediakan metode umum untuk repositori anak .

Tentu saja, kami tidak ingin Spring membuat kacang dari repositori ini karena kami tidak akan memasukkannya ke mana pun. @NoRepositoryBean melakukan persis seperti ini: ketika kita menandai antarmuka anak org.springframework.data.repository.Repository , Spring tidak akan membuat kacang darinya.

Misalnya, jika kita menginginkan metode findById (ID id) opsional di semua repositori kita, kita dapat membuat repositori dasar:

@NoRepositoryBean interface MyUtilityRepository extends CrudRepository { Optional findById(ID id); }

Anotasi ini tidak memengaruhi antarmuka anak; maka Spring akan membuat kacang untuk antarmuka repositori berikut:

@Repository interface PersonRepository extends MyUtilityRepository {}

Perhatikan, bahwa contoh di atas tidak diperlukan karena Spring Data versi 2 yang menyertakan metode ini menggantikan T findOne (ID id) yang lebih lama .

2.3. @Tokopedia

Kita bisa mengirimkan parameter bernama ke kueri kita menggunakan @Param :

@Query("FROM Person p WHERE p.name = :name") Person findByName(@Param("name") String name);

Perhatikan, bahwa kami merujuk ke parameter dengan sintaks : name .

Untuk contoh lebih lanjut, silakan kunjungi artikel ini.

2.4. @Indo

@Id menandai bidang di kelas model sebagai kunci utama:

class Person { @Id Long id; // ... }

Karena tidak bergantung pada penerapan, ini membuat kelas model mudah digunakan dengan beberapa mesin penyimpanan data.

2.5. @Sementara

Kita dapat menggunakan anotasi ini untuk menandai bidang di kelas model sebagai sementara. Karenanya mesin penyimpanan data tidak akan membaca atau menulis nilai bidang ini:

class Person { // ... @Transient int age; // ... }

Seperti @Id , @Transient juga tidak bergantung pada implementasi, yang membuatnya nyaman digunakan dengan beberapa implementasi penyimpanan data.

2.6. @CreatedBy , @LastModifiedBy , @CreatedDate , @LastModifiedDate

Dengan anotasi ini, kita dapat mengaudit kelas model kita: Spring secara otomatis mengisi field beranotasi dengan kepala sekolah yang membuat objek, terakhir mengubahnya, dan tanggal pembuatan, dan modifikasi terakhir:

public class Person { // ... @CreatedBy User creator; @LastModifiedBy User modifier; @CreatedDate Date createdAt; @LastModifiedDate Date modifiedAt; // ... }

Perhatikan, jika kita ingin Spring untuk mengisi principal, kita perlu menggunakan Spring Security juga.

Untuk penjelasan yang lebih lengkap, silakan kunjungi artikel ini.

3. Anotasi JPA Spring Data

3.1. @Pertanyaan

Dengan @Query , kami dapat menyediakan implementasi JPQL untuk metode repositori:

@Query("SELECT COUNT(*) FROM Person p") long getPersonCount();

Juga, kita bisa menggunakan parameter bernama:

@Query("FROM Person p WHERE p.name = :name") Person findByName(@Param("name") String name);

Besides, we can use native SQL queries, if we set the nativeQuery argument to true:

@Query(value = "SELECT AVG(p.age) FROM person p", nativeQuery = true) int getAverageAge();

For more information, please visit this article.

3.2. @Procedure

With Spring Data JPA we can easily call stored procedures from repositories.

First, we need to declare the repository on the entity class using standard JPA annotations:

@NamedStoredProcedureQueries({ @NamedStoredProcedureQuery( name = "count_by_name", procedureName = "person.count_by_name", parameters = { @StoredProcedureParameter( mode = ParameterMode.IN, name = "name", type = String.class), @StoredProcedureParameter( mode = ParameterMode.OUT, name = "count", type = Long.class) } ) }) class Person {}

After this, we can refer to it in the repository with the name we declared in the name argument:

@Procedure(name = "count_by_name") long getCountByName(@Param("name") String name);

3.3. @Lock

We can configure the lock mode when we execute a repository query method:

@Lock(LockModeType.NONE) @Query("SELECT COUNT(*) FROM Person p") long getPersonCount();

The available lock modes:

  • READ
  • WRITE
  • OPTIMISTIC
  • OPTIMISTIC_FORCE_INCREMENT
  • PESSIMISTIC_READ
  • PESSIMISTIC_WRITE
  • PESSIMISTIC_FORCE_INCREMENT
  • NONE

3.4. @Modifying

We can modify data with a repository method if we annotate it with @Modifying:

@Modifying @Query("UPDATE Person p SET p.name = :name WHERE p.id = :id") void changeName(@Param("id") long id, @Param("name") String name);

For more information, please visit this article.

3.5. @EnableJpaRepositories

To use JPA repositories, we have to indicate it to Spring. We can do this with @EnableJpaRepositories.

Note, that we have to use this annotation with @Configuration:

@Configuration @EnableJpaRepositories class PersistenceJPAConfig {}

Spring will look for repositories in the sub packages of this @Configuration class.

We can alter this behavior with the basePackages argument:

@Configuration @EnableJpaRepositories(basePackages = "com.baeldung.persistence.dao") class PersistenceJPAConfig {}

Also note, that Spring Boot does this automatically if it finds Spring Data JPA on the classpath.

4. Spring Data Mongo Annotations

Spring Data makes working with MongoDB much easier. In the next sections, we'll explore the most basic features of Spring Data MongoDB.

For more information, please visit our article about Spring Data MongoDB.

4.1. @Document

This annotation marks a class as being a domain object that we want to persist to the database:

@Document class User {}

It also allows us to choose the name of the collection we want to use:

@Document(collection = "user") class User {}

Note, that this annotation is the Mongo equivalent of @Entity in JPA.

4.2. @Field

With @Field, we can configure the name of a field we want to use when MongoDB persists the document:

@Document class User { // ... @Field("email") String emailAddress; // ... }

Note, that this annotation is the Mongo equivalent of @Column in JPA.

4.3. @Query

With @Query, we can provide a finder query on a MongoDB repository method:

@Query("{ 'name' : ?0 }") List findUsersByName(String name);

4.4. @EnableMongoRepositories

To use MongoDB repositories, we have to indicate it to Spring. We can do this with @EnableMongoRepositories.

Note, that we have to use this annotation with @Configuration:

@Configuration @EnableMongoRepositories class MongoConfig {}

Spring will look for repositories in the sub packages of this @Configuration class. We can alter this behavior with the basePackages argument:

@Configuration @EnableMongoRepositories(basePackages = "com.baeldung.repository") class MongoConfig {}

Also note, that Spring Boot does this automatically if it finds Spring Data MongoDB on the classpath.

5. Conclusion

Di artikel ini, kami melihat anotasi terpenting mana yang kami perlukan untuk menangani data secara umum, menggunakan Spring. Selain itu, kami melihat anotasi JPA dan MongoDB yang paling umum.

Seperti biasa, contoh tersedia di GitHub di sini untuk anotasi umum dan JPA, dan di sini untuk anotasi MongoDB.

Berikutnya » Anotasi Spring Bean « Anotasi Penjadwalan Musim Semi Sebelumnya