Les repositories (personnage, inventaire et objet)

 

Explication du code : IPersonnageRepository

Introduction

L'interface IPersonnageRepository est une interface de repository qui permet d'effectuer des opérations CRUD (Create, Read, Update, Delete) sur l'entité Personnage. Elle étend CrudRepository de Spring Data JPA, ce qui lui donne accès à des méthodes prédéfinies pour interagir avec la base de données.

Détails du code

1. Définition du package:

Ceci définit le package dans lequel se trouve l'interface. Les packages aident à organiser le code en groupes logiques.

2. Importations:

Ces lignes importent les classes et interfaces nécessaires pour le fonctionnement de IPersonnageRepository.

3. Déclaration de l'interface:

L'interface IPersonnageRepository étend CrudRepository, ce qui signifie qu'elle hérite des méthodes CRUD de base. Les paramètres génériques <Personnage, Integer> indiquent que cette interface opère sur l'entité Personnage avec une clé primaire de type Integer.

4. Méthodes déclarées:

• Optional<Personnage> findById(Long id);: Cette méthode renvoie un Personnage basé sur son identifiant. Le type de retour Optional signifie que le résultat peut être présent ou non (c'est-à-dire que le Personnage peut ne pas exister dans la base de données).

• void deleteById(Long id);: Cette méthode supprime un Personnage basé sur son identifiant.

• Optional<Personnage> findByNom(String nom);: Cette méthode renvoie un Personnage basé sur son nom. Encore une fois, le type de retour Optional est utilisé pour gérer les cas où le Personnage peut ne pas exister.

5. Méthode avec une requête personnalisée:

Cette méthode utilise une annotation @Query pour définir une requête JPA personnalisée. La requête récupère un Personnage basé sur son identifiant tout en préchargeant (FETCH) ses relations avec Inventaire et Objet. Cela peut améliorer les performances en évitant les requêtes supplémentaires pour charger ces relations. L'annotation @Param("id") est utilisée pour lier le paramètre de la méthode à la variable :id dans la requête.

Conclusion

L'interface IPersonnageRepository est un exemple d'utilisation de Spring Data JPA pour simplifier l'accès aux données. Grâce à l'extension de CrudRepository et à l'utilisation d'annotations comme @Query, il est possible de définir des opérations de base de données complexes avec peu de code.

 

package com.example.rest.Service;

import com.example.rest.Model.Personnage.Personnage;
import com.example.rest.Repository.Personnage.IPersonnageRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class PersonnageService {

    private final IPersonnageRepository personnageRepository;

    @Autowired
    public PersonnageService(IPersonnageRepository personnageRepository) {
        this.personnageRepository = personnageRepository;
    }

    public Optional<Personnage> findPersonnageById(Long id) {
        return personnageRepository.findById(id);
    }

    public Optional<Personnage> findPersonnageByNom(String nom) {
        return personnageRepository.findByNom(nom);
    }

    public void deletePersonnageById(Long id) {
        personnageRepository.deleteById(id);
    }

    public Personnage savePersonnage(Personnage personnage) {
        return personnageRepository.save(personnage);
    }

    public Optional<Personnage> findPersonnageWithInventairesAndObjet(Long id) {
        return personnageRepository.findByIdWithInventairesAndObjet(id);
    }
}

package com.example.rest.Controller;

import com.example.rest.Model.Personnage.Personnage;
import com.example.rest.Service.PersonnageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.Optional;

@RestController
@RequestMapping("/api/personnages")
public class PersonnageController {

    private final PersonnageService personnageService;

    @Autowired
    public PersonnageController(PersonnageService personnageService) {
        this.personnageService = personnageService;
    }

    @GetMapping("/{id}")
    public ResponseEntity<Personnage> getPersonnageById(@PathVariable Long id) {
        Optional<Personnage> personnage = personnageService.findPersonnageById(id);
        return personnage.map(ResponseEntity::ok).orElseGet(() -> ResponseEntity.notFound().build());
    }

    // Vous pouvez ajouter d'autres méthodes pour gérer les opérations CRUD et les endpoints API.
}

package com.example.rest.Repository.Personnage; // Définition du package

import java.util.List;
import java.util.Optional; // Importation de la classe Optional pour gérer les résultats qui peuvent être nuls

import org.springframework.data.repository.CrudRepository; // Importation de l'interface CrudRepository pour les opérations CRUD de base

import com.example.rest.Model.Personnage.Inventaire; // Importation de la classe Inventaire
import com.example.rest.Model.Personnage.Objet;
import com.example.rest.Model.Personnage.Personnage; // Importation de la classe Personnage

// Déclaration de l'interface IInventaireRepository qui étend CrudRepository pour fournir des opérations CRUD sur l'entité Inventaire
public interface IInventaireRepository extends CrudRepository<Inventaire, Integer>{

    // Déclaration de la méthode pour trouver un Inventaire par son ID
    Optional<Inventaire> findById(Long id);

    // Déclaration de la méthode pour supprimer un Inventaire par son ID
    void deleteById(Long id);

    // Déclaration de la méthode pour trouver un Inventaire par son objet Personnage associé
    Optional<Personnage> findByPersonnage(Personnage personnage);

    // Déclaration de la méthode pour trouver un Inventaire par son objet Personnage associé, qui peut être nul
    Optional<Personnage> findByPersonnage(Optional<Personnage> personnage);

    Optional<Inventaire> findByPersonnageAndObjet(Personnage personnage, Objet objet);

    List<Inventaire> findAllByPersonnageId(Long personnageId);
}

IObjetRepository

package com.example.rest.Repository.Personnage; // Définition du package

import java.util.Optional; // Importation de la classe Optional pour gérer les résultats qui peuvent être nuls

import org.springframework.data.repository.CrudRepository; // Importation de l'interface CrudRepository pour les opérations CRUD de base

import com.example.rest.Model.Personnage.Objet; // Importation de la classe Objet

// Déclaration de l'interface IObjetRepository qui étend CrudRepository pour fournir des opérations CRUD sur l'entité Objet
public interface IObjetRepository extends CrudRepository<Objet, Long> {

    // Déclaration de la méthode pour trouver un Objet par son nom
    Optional<Objet> findByNom(String nom);
    
    // Espace réservé pour l'ajout de méthodes personnalisées si nécessaire
}

 

L'interface IObjetRepository est une interface de répository qui permet d'effectuer des opérations CRUD sur l'entité Objet. Voici une explication détaillée de chaque partie de ce code.

1. Déclaration du Package et Importations

• Le code appartient au package com.example.rest.Repository.Personnage.
• Il importe la classe Optional pour gérer les résultats qui peuvent être nuls, CrudRepository pour les opérations CRUD de base, et la classe du modèle Objet.

2. Déclaration de l'Interface

• IObjetRepository est déclaré comme une interface publique.
• Elle étend CrudRepository, ce qui signifie qu'elle hérite de méthodes pour effectuer des opérations CRUD de base sur l'entité Objet.
• Le type de l'ID de l'entité Objet est spécifié comme Long.

3. Déclaration des Méthodes

• Une méthode est déclarée pour effectuer une opération spécifique sur l'entité Objet.
• findByNom(String nom): Retourne un Objet basé sur son nom. Si un objet avec le nom spécifié existe, il est retourné enveloppé dans un Optional, sinon un Optional vide est retourné.

4. Espace pour Méthodes Personnalisées

• Un commentaire indique qu'il y a un espace réservé pour l'ajout de méthodes personnalisées si nécessaire. Cela signifie que d'autres méthodes peuvent être ajoutées à l'avenir pour répondre à des besoins spécifiques non couverts par les méthodes CRUD de base.

Conclusion

L'interface IObjetRepository est un composant clé pour interagir avec la base de données, spécifiquement avec l'entité Objet. Elle déclare une méthode qui peut être utilisée pour récupérer un Objet basé sur son nom. En utilisant cette interface dans d'autres composants de l'application, tels que les services et les contrôleurs, vous pouvez facilement gérer les données de Objet et exposer des fonctionnalités liées à Objet à travers votre API.

 

IAcountRepository 

// Définir le package où se trouve l'interface
package com.example.rest.Repository;


// Importation de l'interface CrudRepository qui fournit des méthodes CRUD génériques pour la persistance des données
import org.springframework.data.repository.CrudRepository;

// Importation des modèles nécessaires pour définir les types d'entités et leurs relations
import com.example.rest.Model.Account;

// Définition d'une interface qui représente le repository pour les entités Account
public interface IAcountRepository extends CrudRepository<Account, Integer> {
    
    // Méthode pour trouver un compte par son email
    Account findByEmail(String email);
    

}
/*
 La méthode findByEmail  ne nécessitent pas d'implémentation. 
 Spring Data JPA génère automatiquement l'implémentation de ces méthodes à l'exécution.
  Les noms des méthodes sont construits en suivant une convention qui détermine la requête à effectuer. 
  Par exemple, findByEmail traduit en SQL une requête qui recherche un enregistrement par sa colonne email.
 */

 

L'interface IAccountRepository est un composant crucial pour effectuer des opérations CRUD sur l'entité Account. Voici une explication détaillée de chaque partie de ce code.

1. Déclaration du Package et Importations

• Le code appartient au package com.example.rest.Repository.
• Il importe CrudRepository pour les opérations CRUD de base et la classe du modèle Account.

2. Déclaration de l'Interface

• IAccountRepository est déclaré comme une interface publique.
• Elle étend CrudRepository, héritant ainsi de méthodes pour effectuer des opérations CRUD de base sur l'entité Account.
• Le type de l'ID de l'entité Account est spécifié comme Integer.

3. Déclaration des Méthodes

• Une méthode est déclarée pour effectuer une opération spécifique sur l'entité Account.
• findByEmail(String email): Retourne un Account basé sur son email. Si un compte avec l'email spécifié existe, il est retourné, sinon null est retourné.

Conclusion

L'interface IAccountRepository est essentielle pour interagir avec la base de données, spécifiquement avec l'entité Account. Elle déclare une méthode qui peut être utilisée pour récupérer un Account basé sur son email. En utilisant cette interface dans d'autres composants de l'application, tels que les services et les contrôleurs, vous pouvez facilement gérer les données de Account et exposer des fonctionnalités liées à Account à travers votre API.

 

 

package com.example.rest.Repository;

import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;

import com.example.rest.Model.Profil;

import jakarta.transaction.Transactional;

public interface IProfilRepository extends CrudRepository<Profil, Integer> {

    Profil findByName(String string);
    // Vous pouvez ajouter des méthodes personnalisées ici si nécessaire
    @Modifying
    @Transactional
    @Query(value = "DELETE FROM profil_game WHERE game_id = :gameId", nativeQuery = true)
    void deleteByGameId(@Param("gameId") Integer gameId);
    


}

 

La méthode deleteByGameId est une méthode personnalisée définie dans un repository pour effectuer une opération de suppression spécifique dans la base de données. Voici une explication détaillée de chaque annotation et paramètre de cette méthode :

1. Annotations

• Cette annotation est utilisée pour indiquer que la requête associée à la méthode va modifier les données dans la base de données, c'est-à-dire qu'il s'agit d'une opération de suppression, d'insertion ou de mise à jour.

• Cette annotation indique que la méthode doit être exécutée dans le cadre d'une transaction. Cela signifie que si une erreur se produit pendant l'exécution de la méthode, toutes les modifications apportées à la base de données seront annulées (rollback).

• Cette annotation est utilisée pour exécuter une requête SQL personnalisée.
• value spécifie la requête SQL à exécuter, ici, une requête de suppression.
• nativeQuery = true indique que la requête est écrite en SQL natif, et non en JPQL (Java Persistence Query Language).

2. Signature de la Méthode

• La méthode ne retourne rien (void).
• Elle prend un paramètre gameId de type Integer.
• @Param("gameId") est utilisé pour lier la valeur du paramètre gameId à la variable :gameId dans la requête SQL.

3. Requête SQL

• Cette requête SQL supprime tous les enregistrements de la table profil_game où la colonne game_id correspond à la valeur du paramètre gameId passé à la méthode.

Conclusion

La méthode deleteByGameId est une méthode transactionnelle qui modifie la base de données en supprimant des enregistrements de la table profil_game basés sur l'ID du jeu passé en paramètre. Elle utilise une requête SQL native pour effectuer cette opération de suppression.

 

package com.example.rest.Repository;

import org.springframework.data.repository.CrudRepository;

import com.example.rest.Model.Game;

public interface IGameRepository extends CrudRepository<Game, Integer> {

    Game findByName(String gameName);
    // Vous pouvez ajouter des méthodes personnalisées ici si nécessaire
}

 

 

Résumé

Un repository est un patron de conception qui permet d’abstraire l’accès aux données d’une application.

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.