TOC

Annotations de données de printemps

Annotations de données de printemps

1. introduction

Spring Data fournit une abstraction sur les 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. Spring simplifie également le traitement des détails du stockage de données dépendant de la mise en œuvre.

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 de printemps communes

2.1. @Transactional

Quand on veutconfigure the transactional behavior of a method, on peut le faire avec: 

@Transactional
void pay() {}

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

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

2.2. @NoRepositoryBean

Sometimes we want to create repository interfaces with the only goal of providing common methods for the child repositories.

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

Par exemple, si nous voulons une méthodeOptional<T> 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 la version 2 de Spring Data qui inclut cette méthode remplaçant les anciensT 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 visiterthis article.

2.4. @Id

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

class Person {

    @Id
    Long id;

    // ...

}

Étant donné qu'il est indépendant de l'implémentation, il facilite l'utilisation d'une classe de modèle avec plusieurs moteurs de stockage de données.

2.5. @Transient

Nous pouvons utiliser cette annotation pour marquer un champ de la classe de modèle comme étant transitoire. Par conséquent, le moteur du magasin de données ne lit ni n'écrit 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 visiterthis article.

3. Spring Data JPA Annotations

3.1. @Query

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

De plus, nous pouvons utiliser des requêtes SQL natives, si nous définissons l'argumentnativeQuery urtrue: 

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

Pour plus d'informations, veuillez visiterthis article.

3.2. @Procedure

Avec Spring Data JPA, nous pouvons facilement appeler des procédures stockées à partir de référentiels.

Tout d'abord, nous devons déclarer le référentiel sur la classe d'entité à l'aide des annotations JPA standard: 

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

Après cela, nous pouvons y faire référence dans le référentiel avec le nom que nous avons déclaré dans le sargumentname : 

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

3.3. @Lock

Nous pouvons configurer le mode de verrouillage lorsque nous exécutons une méthode de requête de référentiel: 

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

Les modes de verrouillage disponibles:

  • READ

  • ÉCRIRE

  • OPTIMISTE

  • OPTIMISTIC_FORCE_INCREMENT

  • PESSIMISTIC_READ

  • PESSIMISTIC_WRITE

  • PESSIMISTIC_FORCE_INCREMENT

  • NONE

3.4. @Modifying

Nous pouvons modifier les données avec une méthode de référentiel si nous l'annotons avec@Modifying: 

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

Pour plus d'informations, veuillez visiterthis article.

3.5. @EnableJpaRepositories

Pour utiliser les référentiels JPA, nous devons l'indiquer à Spring. On peut faire ça avec@EnableJpaRepositories.

Notez que nous devons utiliser cette annotation avec@Configuration: 

@Configuration
@EnableJpaRepositories
class PersistenceJPAConfig {}

Spring cherchera des référentiels dans les sous-packages de cette@Configuration class.

Nous pouvons modifier ce comportement avec le sargumentbasePackages : 

@Configuration
@EnableJpaRepositories(basePackages = "org.example.persistence.dao")
class PersistenceJPAConfig {}

Notez également que Spring Boot le fait automatiquement s'il trouve Spring Data JPA sur le classpath.

4. Spring Data Mongo Annotations

Spring Data facilite beaucoup le travail avec MongoDB. Dans les sections suivantes, nous explorerons les fonctionnalités les plus élémentaires de Spring Data MongoDB.

Pour plus d'informations, veuillez visiter nosarticle about Spring Data MongoDB.

4.1. @Document

Cette annotation marque une classe comme étant un objet de domaine que nous voulons conserver dans la base de données: 

@Document
class User {}

Cela nous permet également de choisir le nom de la collection que nous voulons utiliser: 

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

Notez que cette annotation est l'équivalent Mongo de@Entity in JPA.

4.2. @Field

Avec@Field, nous pouvons configurer le nom d'un champ que nous voulons utiliser lorsque MongoDB persiste le document: 

@Document
class User {

    // ...

    @Field("email")
    String emailAddress;

    // ...

}

Notez que cette annotation est l'équivalent Mongo de@Column in JPA.

4.3. @Query

Avec@Query, nous pouvons fournir une requête de recherche sur une méthode de référentiel MongoDB: 

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

4.4. @EnableMongoRepositories

Pour utiliser les référentiels MongoDB, nous devons l'indiquer à Spring. On peut faire ça avec@EnableMongoRepositories.

Notez que nous devons utiliser cette annotation avec@Configuration: 

@Configuration
@EnableMongoRepositories
class MongoConfig {}

Spring cherchera des référentiels dans les sous-packages de cette@Configuration class. Nous pouvons modifier ce comportement avec le sargumentbasePackages : 

@Configuration
@EnableMongoRepositories(basePackages = "org.example.repository")
class MongoConfig {}

Notez également que Spring Boot le fait automatiquement s'il trouve Spring Data MongoDB sur le chemin d'accès aux classes.

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, en utilisant Spring. De plus, nous avons examiné les annotations les plus courantes dans les projets JPA et MongoDB.

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

Related