Les repository en Java Spring sont des interfaces qui permettent de communiquer avec une source de données, comme une base de données. Ils sont utilisés avec Spring Data JPA, un framework ORM qui met en pratique le design pattern DAO (Data Access Object) pour implémenter la communication avec la source de données.

L’annotation @Repository est utilisée pour indiquer que la classe a pour rôle de communiquer avec une source de données. En réalité, @Repository est une spécialisation de l’annotation @Component, qui permet de déclarer auprès de Spring qu’une classe est un bean à exploiter.

Cette façon de faire de Spring Data JPA est également un design pattern nommé Repository. Le concept est le suivant: une donnée est modélisée via une classe, les opérations sur la base de données concernant cette donnée sont spécifiées via une interface, et les opérations sont implémentées dans une classe. Ainsi, pour interagir avec la base de données, on doit avoir une instance de l’implémentation du Repository, et à travers ses méthodes, on peut exécuter des opérations comme obtenir une donnée ou en créer une en BDD

Les repositories en Spring Data JPA sont des interfaces qui permettent d’accéder aux données stockées dans une base de données relationnelle. Ils fournissent des méthodes prédéfinies pour effectuer des opérations CRUD (création, lecture, mise à jour et suppression) sur les entités, ainsi que des méthodes pour effectuer des requêtes personnalisées.

Pour utiliser les repositories en Spring Data JPA, vous devez d’abord définir une interface qui étend l’une des interfaces de repository fournies par Spring Data JPA, telles que CrudRepository, PagingAndSortingRepository ou JpaRepository. Cette interface doit être paramétrée avec le type de l’entité et le type de sa clé primaire. Par exemple, pour définir un repository pour une entité Personne avec une clé primaire de type Long, vous pouvez définir une interface PersonneRepository comme suit :

 
public interface PersonneRepository extends CrudRepository<Personne, Long> {
    // ...
}

Une fois que vous avez défini votre interface de repository, vous pouvez l’utiliser dans votre code en l’injectant dans vos beans à l’aide de l’annotation @Autowired. Par exemple, pour utiliser le repository PersonneRepository dans un bean PersonneService, vous pouvez faire comme suit :

 
@Service
public class PersonneService {
    @Autowired
    private PersonneRepository personneRepository;

    // ...
}

Lorsque vous utilisez un repository, vous pouvez appeler ses méthodes pour effectuer des opérations sur les données. Par exemple, pour enregistrer une nouvelle personne dans la base de données, vous pouvez appeler la méthode save du repository :

 
Personne personne = new Personne();
personne.setNom("Dupont");
personne.setPrenom("Jean");
personneRepository.save(personne);

En plus des méthodes prédéfinies fournies par les interfaces de repository de Spring Data JPA, vous pouvez également définir vos propres méthodes pour effectuer des requêtes personnalisées. Pour ce faire, vous pouvez ajouter des méthodes à votre interface de repository et utiliser les conventions de nommage de Spring Data JPA pour définir la requête à exécuter. Par exemple, pour définir une méthode qui recherche les personnes par nom, vous pouvez ajouter une méthode findByNom à votre interface PersonneRepository :

Java
public interface PersonneRepository extends CrudRepository<Personne, Long> {
    List<Personne> findByNom(String nom);
}

Spring Data JPA générera automatiquement une implémentation pour cette méthode qui exécute une requête SQL pour rechercher les personnes par nom.

En résumé, les repositories en Spring Data JPA sont des interfaces qui permettent d’accéder aux données stockées dans une base de données relationnelle. Ils fournissent des méthodes prédéfinies pour effectuer des opérations CRUD et des requêtes personnalisées sur les entités. Pour utiliser les repositories en Spring Data JPA, vous devez définir une interface qui étend l’une des interfaces de repository fournies par Spring Data JPA et l’utiliser dans votre code en l’injectant dans vos beans.

 

CrudRepository

CrudRepository est une interface de Spring Data JPA qui fournit des méthodes génériques pour effectuer des opérations CRUD (création, lecture, mise à jour et suppression) sur une entité. Elle étend l’interface Repository et ajoute des méthodes pour effectuer des opérations telles que la sauvegarde d’une entité, la recherche d’une entité par son identifiant, la suppression d’une entité, la vérification de l’existence d’une entité, et la récupération de toutes les entités.

Pour utiliser CrudRepository, vous devez créer une interface qui étend CrudRepository et spécifie le type de l’entité et le type de sa clé primaire. Par exemple, pour créer un repository pour une entité Personne avec une clé primaire de type Long, vous pouvez créer une interface PersonneRepository comme suit :

 
public interface PersonneRepository extends CrudRepository<Personne, Long> {
    // ...
}

Une fois que vous avez créé votre interface de repository, vous pouvez l’utiliser dans votre code en l’injectant dans vos beans à l’aide de l’annotation @Autowired. Par exemple, pour utiliser le repository PersonneRepository dans un bean PersonneService, vous pouvez faire comme suit :

 
@Service
public class PersonneService {
    @Autowired
    private PersonneRepository personneRepository;

    // ...
}

Lorsque vous utilisez un repository, vous pouvez appeler ses méthodes pour effectuer des opérations sur les données. Par exemple, pour enregistrer une nouvelle personne dans la base de données, vous pouvez appeler la méthode save du repository :

 
Personne personne = new Personne();
personne.setNom("Dupont");
personne.setPrenom("Jean");
personneRepository.save(personne);

En plus des méthodes prédéfinies fournies par CrudRepository, vous pouvez également définir vos propres méthodes pour effectuer des requêtes personnalisées. Pour ce faire, vous pouvez ajouter des méthodes à votre interface de repository et utiliser les conventions de nommage de Spring Data JPA pour définir la requête à exécuter. Par exemple, pour définir une méthode qui recherche les personnes par nom, vous pouvez ajouter une méthode findByNom à votre interface PersonneRepository :

 
public interface PersonneRepository extends CrudRepository<Personne, Long> {
    List<Personne> findByNom(String nom);
}

Spring Data JPA générera automatiquement une implémentation pour cette méthode qui exécute une requête SQL pour rechercher les personnes par nom.

En résumé, CrudRepository est une interface pratique qui fournit des méthodes génériques pour effectuer des opérations CRUD sur une entité. Elle peut être étendue pour créer des repositories personnalisés pour vos entités et peut être utilisée dans votre code en injectant des instances de vos interfaces de repository dans vos beans.

 

Voici une liste des méthodes fournies par l’interface CrudRepository de Spring Data JPA :

  • save(S entity) : Sauvegarde une entité donnée dans la base de données.
  • saveAll(Iterable<S> entities) : Sauvegarde plusieurs entités dans la base de données.
  • findById(ID id) : Récupère une entité par son identifiant.
  • existsById(ID id) : Vérifie si une entité avec l’identifiant donné existe dans la base de données.
  • findAll() : Récupère toutes les entités de la base de données.
  • findAllById(Iterable<ID> ids) : Récupère toutes les entités avec les identifiants donnés.
  • count() : Compte le nombre d’entités dans la base de données.
  • deleteById(ID id) : Supprime une entité par son identifiant.
  • delete(T entity) : Supprime une entité donnée de la base de données.
  • deleteAll(Iterable<? extends T> entities) : Supprime plusieurs entités de la base de données.
  • deleteAll() : Supprime toutes les entités de la base de données.

 

En plus des méthodes prédéfinies fournies par CrudRepository, vous pouvez également définir vos propres méthodes pour effectuer des requêtes personnalisées en utilisant les conventions de nommage de Spring Data JPA. Par exemple, pour définir une méthode qui recherche les personnes par nom, vous pouvez ajouter une méthode findByNom à votre interface PersonneRepository :

Java
Ce code est généré par IA. Examinez et utilisez attentivement. Consultez notre FAQ pour plus d’informations.
 
public interface PersonneRepository extends CrudRepository<Personne, Long> {
    List<Personne> findByNom(String nom);
}

Spring Data JPA générera automatiquement une implémentation pour cette méthode qui exécute une requête SQL pour rechercher les personnes par nom.

Vous pouvez également utiliser d’autres conventions de nommage pour définir des méthodes de requête personnalisées, telles que findByNomAndPrenom, findByNomOrPrenom, findByNomOrderByPrenomAsc, etc. Vous pouvez trouver plus d’informations sur les conventions de nommage de Spring Data JPA dans la documentation officielle.

 

Résumé

Un repository est un patron de conception qui permet d’abstraire l’accès aux données d’une application. Il fournit une interface pour effectuer des opérations CRUD (Create, Read, Update, Delete) sur les données d’une entité, sans exposer les détails de la source de données sous-jacente.

Dans le cadre de Spring Data, un repository est une interface qui étend l’une des interfaces de base fournies par Spring Data, telles que CrudRepository ou PagingAndSortingRepository. Ces interfaces fournissent des méthodes prédéfinies pour effectuer des opérations CRUD sur les données d’une entité. Vous pouvez également définir des méthodes personnalisées dans votre interface de repository pour effectuer des opérations spécifiques sur les données.

Spring Data prend en charge plusieurs types de sources de données, y compris les bases de données relationnelles, les bases de données NoSQL et les services Web. Vous pouvez utiliser la même interface de repository pour travailler avec différents types de sources de données en configurant simplement la source de données appropriée dans votre application.

En résumé, un repository est un moyen pratique et flexible de travailler avec les données d’une application en utilisant Spring Data. Il fournit une abstraction pour l’accès aux données et permet de travailler avec différents types de sources de données en utilisant une interface commune.

Modifié le: mercredi 6 septembre 2023, 10:30