Annotations de données Spring

Cet article fait partie d'une série: • Annotations Spring Core

• Annotations Web de printemps

• Annotations Spring Boot

• Annotations de planification du printemps

• Annotations Spring Data (article actuel) • Annotations Spring Bean

1. Introduction

Spring Data fournit une abstraction des technologies de stockage de données. Par conséquent, notre code de logique métier peut être beaucoup plus indépendant de l'implémentation de persistance sous-jacente. En outre, Spring simplifie la gestion des détails du stockage de données dépendant de l'implémentation.

Dans ce didacticiel, nous verrons les annotations les plus courantes des projets Spring Data, Spring Data JPA et Spring Data MongoDB.

2. Annotations de données Spring courantes

2.1. @Transactionnel

Lorsque nous voulons configurer le comportement transactionnel d'une méthode , nous pouvons le faire avec:

@Transactional void pay() {}

Si nous appliquons cette annotation au niveau de la classe, cela fonctionne sur toutes les méthodes de la classe. Cependant, nous pouvons remplacer ses effets en l'appliquant à une méthode spécifique.

Il a de nombreuses options de configuration, qui peuvent être trouvées dans cet article.

2.2. @NoRepositoryBean

Parfois, nous voulons créer des interfaces de référentiel dans le seul but de fournir des méthodes communes pour les référentiels enfants .

Bien sûr, nous ne voulons pas que Spring crée un bean de ces référentiels car nous ne les injecterons nulle part. @NoRepositoryBean fait exactement ceci: lorsque nous marquons une interface enfant de org.springframework.data.repository.Repository , Spring n'en crée pas un bean.

Par exemple, si nous voulons une méthode optionnelle findById (ID id) dans tous nos référentiels, nous pouvons créer un référentiel de base:

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

Cette annotation n'affecte pas les interfaces enfants; Par conséquent, Spring créera un bean pour l'interface de référentiel suivante:

@Repository interface PersonRepository extends MyUtilityRepository {}

Notez que l'exemple ci-dessus n'est pas nécessaire depuis Spring Data version 2 qui inclut cette méthode remplaçant l'ancien T findOne (ID id) .

2.3. @Param

Nous pouvons passer des paramètres nommés à nos requêtes en utilisant @Param :

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

Notez que nous nous référons au paramètre avec la syntaxe : name .

Pour plus d'exemples, veuillez consulter cet article.

2.4. @Id

@Id marque un champ dans une classe de modèle comme clé primaire:

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

Comme il est indépendant de l'implémentation, il rend une classe de modèle facile à utiliser avec plusieurs moteurs de stockage de données.

2.5. @Transitoire

Nous pouvons utiliser cette annotation pour marquer un champ dans une classe de modèle comme transitoire. Par conséquent, le moteur de stockage de données ne lira ni n'écrira la valeur de ce champ:

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

Comme @Id , @Transient est également indépendant de l'implémentation, ce qui le rend pratique à utiliser avec plusieurs implémentations de magasin de données.

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

Avec ces annotations, nous pouvons auditer nos classes de modèle: Spring remplit automatiquement les champs annotés avec le principal qui a créé l'objet, l'a modifié en dernier lieu, ainsi que la date de création et la dernière modification:

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

Notez que si nous voulons que Spring remplisse les principaux, nous devons également utiliser Spring Security.

Pour une description plus détaillée, veuillez consulter cet article.

3. Annotations JPA Spring Data

3.1. @Requete

Avec @Query , nous pouvons fournir une implémentation JPQL pour une méthode de référentiel:

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

De plus, nous pouvons utiliser des paramètres nommés:

@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

Dans cet article, nous avons vu quelles sont les annotations les plus importantes dont nous avons besoin pour traiter les données en général, à l'aide de Spring. En outre, nous avons examiné les annotations JPA et MongoDB les plus courantes.

Comme d'habitude, des exemples sont disponibles sur GitHub ici pour les annotations courantes et JPA, et ici pour les annotations MongoDB.

Suivant » Annotations Spring Bean « Précédent Annotations Spring Scheduling