Les entités (tables Personnage Inventaire et Objet)

En suivant ce MCD nous allons ajouter 3 tables et créer les relations adéquates avec le framework Spring

MCD 

Posséder peut être remplacer par "autoriser_par"

Equiper = "equiper_avec"

On renomme equiper en inventaire

MCD

MPD

Personnage

package com.example.rest.Model.Personnage;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;

import java.util.Objects;
import java.util.Set;

import com.example.rest.Model.Profil;
import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.JsonIgnore;

import com.fasterxml.jackson.annotation.ObjectIdGenerators;

@Entity // Cette classe est une entité, elle peut être persistée dans la base de données
// Utilisé pour résoudre les problèmes de référence circulaire entre les objets lors de la sérialisation JSON.
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
@Table(name = "personnage") // Spécifie le nom de la table associée à l'entité dans la base de données.
public class Personnage {
    @Id // Cette variable est la clé primaire de l'entité
    @GeneratedValue(strategy = GenerationType.AUTO) // La valeur de cette variable est générée automatiquement

    private Long id; // Marque le champ comme une clé primaire.
    private String nom; // Nom du personnage
    private String classe; // Classe du personnage (ex: guerrier, mage, etc.)
    private Integer niveau; // Niveau du personnage
    // Les annotations @Column sont utilisées pour spécifier les noms des colonnes dans la base de données.
    @Column(name = "points_experience")
    private Integer pointsExperience; // Points d'expérience du personnage
    @Column(name = "points_vie")
    private Integer pointsVie; // Points de vie du personnage
    @Column(name = "points_mana")
    private Integer pointsMana; // Points de mana du personnage
    @Column(name = "points_force")
    private Integer pointsForce; // Points de force du personnage
    @Column(name = "points_score")
    private Integer pointsScore; // Score du personnage dans le jeu

    // Définit une relation OneToMany entre Personnage et Inventaire.
    @OneToMany(mappedBy = "personnage", fetch = FetchType.LAZY)
    private Set<Inventaire> inventaire; // Liste des objets dans l'inventaire du personnage.
    // Définit une relation ManyToOne entre Personnage et Profil.
    @ManyToOne
    @JoinColumn(name = "profil_id") // Spécifie la colonne de jointure.
    @JsonIgnore // Ignore ce champ lors de la sérialisation JSON.
    private Profil profil; // Profil associé au personnage.

}

Maintenant il faut écrire les constructeurs et les getters et les les setters pour ce code

Comment simplifier l'écriture des getters et setters ?

Code generator va générer les getters et setters et les constructeurs à votre place ...

Generate Everything est le bienvenue... Je suis d'accord avec vous cela sauve la vie

package com.example.rest.Model.Personnage;

import jakarta.persistence.CascadeType;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

import com.example.rest.Model.Profil;

@Entity // Cette classe est une entité, elle peut être persistée dans la base de données
@Table(name = "personnage")
public class Personnage {
    @Id // Cette variable est la clé primaire de l'entité
    @GeneratedValue(strategy = GenerationType.AUTO) // La valeur de cette variable est générée automatiquement
    private Long id;
    private String nom; // Nom du personnage
    private String classe; // Classe du personnage (ex: guerrier, mage, etc.)
    private Integer niveau; // Niveau du personnage
    private Integer pointsExperience; // Points d'expérience du personnage
    private Integer pointsVie; // Points de vie du personnage
    private Integer pointsMana; // Points de mana du personnage
    private Integer pointsforce; // Points de force du personnage
    private Integer pointsscore; // Score du personnage dans le jeu

    @OneToMany(cascade = CascadeType.ALL)
    @JoinColumn(name = "inventaire_id" )
    private Set<Inventaire> Inventaire= new HashSet<>(); 

    @ManyToOne
    @JoinColumn(name = "profil_id")
    private Profil profil;

    public Personnage() {
        // Constructeur par défaut
    }

    public Personnage(Long id, String nom, String classe, Integer niveau, Integer pointsExperience, Integer pointsVie,
            Integer pointsMana, Integer pointsforce, Integer pointsscore, Set<com.example.rest.Model.Personnage.Inventaire> inventaire) {
        this.id = id;
        this.nom = nom;
        this.classe = classe;
        this.niveau = niveau;
        this.pointsExperience = pointsExperience;
        this.pointsVie = pointsVie;
        this.pointsMana = pointsMana;
        this.pointsforce = pointsforce;
        this.pointsscore = pointsscore;
        this.Inventaire = inventaire;
    }

    public Long getId() {
        return this.id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNom() {
        return this.nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public String getClasse() {
        return this.classe;
    }

    public void setClasse(String classe) {
        this.classe = classe;
    }

    public Integer getNiveau() {
        return this.niveau;
    }

    public void setNiveau(Integer niveau) {
        this.niveau = niveau;
    }

    public Integer getPointsExperience() {
        return this.pointsExperience;
    }

    public void setPointsExperience(Integer pointsExperience) {
        this.pointsExperience = pointsExperience;
    }

    public Integer getPointsVie() {
        return this.pointsVie;
    }

    public void setPointsVie(Integer pointsVie) {
        this.pointsVie = pointsVie;
    }

    public Integer getPointsMana() {
        return this.pointsMana;
    }

    public void setPointsMana(Integer pointsMana) {
        this.pointsMana = pointsMana;
    }

    public Integer getPointsforce() {
        return this.pointsforce;
    }

    public void setPointsforce(Integer pointsforce) {
        this.pointsforce = pointsforce;
    }

    public Integer getPointsscore() {
        return this.pointsscore;
    }

    public void setPointsscore(Integer pointsscore) {
        this.pointsscore = pointsscore;
    }

    public Set<Inventaire> getInventaire() {
        return this.Inventaire;
    }
    

    public void setInventaires(Set<Inventaire> inventaires) {
        this.Inventaire = inventaires;
    }

    public Personnage id(Long id) {
        setId(id);
        return this;
    }

    public Personnage nom(String nom) {
        setNom(nom);
        return this;
    }

    public Personnage classe(String classe) {
        setClasse(classe);
        return this;
    }

    public Personnage niveau(Integer niveau) {
        setNiveau(niveau);
        return this;
    }

    public Personnage pointsExperience(Integer pointsExperience) {
        setPointsExperience(pointsExperience);
        return this;
    }

    public Personnage pointsVie(Integer pointsVie) {
        setPointsVie(pointsVie);
        return this;
    }

    public Personnage pointsMana(Integer pointsMana) {
        setPointsMana(pointsMana);
        return this;
    }

    public Personnage pointsforce(Integer pointsforce) {
        setPointsforce(pointsforce);
        return this;
    }

    public Personnage pointsscore(Integer pointsscore) {
        setPointsscore(pointsscore);
        return this;
    }

    // Cette méthode permet de définir les inventaires du personnage et renvoie
    // l'instance de Personnage pour permettre les appels en chaîne
    public Personnage inventaires(Set<Inventaire> inventaires) {
        setInventaires(inventaires);
        return this;
    }

    // Cette méthode redéfinit la méthode equals pour comparer deux instances de
    // Personnage
    @Override
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof Personnage)) {
            return false;
        }
        Personnage personnage = (Personnage) o;
        // Les instances sont considérées comme égales si toutes leurs propriétés sont
        // égales
        return Objects.equals(id, personnage.id) && Objects.equals(nom, personnage.nom)
                && Objects.equals(classe, personnage.classe) && Objects.equals(niveau, personnage.niveau)
                && Objects.equals(pointsExperience, personnage.pointsExperience)
                && Objects.equals(pointsVie, personnage.pointsVie) && Objects.equals(pointsMana, personnage.pointsMana)
                && Objects.equals(pointsforce, personnage.pointsforce)
                && Objects.equals(pointsscore, personnage.pointsscore)
                && Objects.equals(Inventaire, personnage.Inventaire);
    }

    // Cette méthode redéfinit la méthode hashCode pour calculer le code de hachage
    // d'une instance de Personnage
    @Override
    public int hashCode() {
        // Le code de hachage est calculé en utilisant les propriétés de l'instance
        return Objects.hash(id, nom, classe, niveau, pointsExperience, pointsVie, pointsMana, pointsforce, pointsscore,
                Inventaire);
    }

    // Cette méthode redéfinit la méthode toString pour renvoyer une représentation
    // sous forme de chaîne de caractères d'une instance de Personnage
    @Override
    public String toString() {
        return "{" +
                " id='" + getId() + "'" +
                ", nom='" + getNom() + "'" +
                ", classe='" + getClasse() + "'" +
                ", niveau='" + getNiveau() + "'" +
                ", pointsExperience='" + getPointsExperience() + "'" +
                ", pointsVie='" + getPointsVie() + "'" +
                ", pointsMana='" + getPointsMana() + "'" +
                ", pointsforce='" + getPointsforce() + "'" +
                ", pointsscore='" + getPointsscore() + "'" +
                ", inventaires='" + getInventaire() + "'" +
                "}";
    }

    public void setProfil(Profil profil) {
    }

}

Explication Détaillée

1. @Entity et @Table:

   • @Entity déclare que la classe Personnage est une entité JPA, ce qui signifie qu'elle peut être mappée à une table dans la base de données.
   • @Table(name = "personnage") spécifie le nom de la table dans la base de données à laquelle cette entité est mappée.

2. Variables Membres et Annotations:

   • Chaque variable membre de la classe représente un champ ou une colonne dans la table personnage de la base de données.
   • Les annotations telles que @Id, @GeneratedValue, @Column, @OneToMany, et @ManyToOne sont utilisées pour configurer le mappage objet-relationnel entre l'entité Personnage et la table personnage.

3. Relations:

   • La relation @OneToMany entre Personnage et Inventaire indique qu'un personnage peut avoir plusieurs objets dans son inventaire.
   • La relation @ManyToOne entre Personnage et Profil indique qu'un personnage est associé à un seul profil.

4. Sérialisation JSON:

   • Les annotations @JsonIdentityInfo et @JsonIgnore sont utilisées pour gérer la sérialisation et la désérialisation des objets en JSON, notamment pour éviter les problèmes de référence circulaire.

5. Constructeurs, Getters, et Setters:

   • La classe contient des constructeurs pour créer des instances de Personnage, des getters pour accéder aux valeurs des variables membres, et des setters pour modifier ces valeurs.

En résumé, cette classe représente un modèle de données pour un personnage dans une application, avec des configurations spécifiques pour le mappage objet-relationnel et la sérialisation JSON.

Conclusion

La classe Personnage est un exemple d'entité JPA avec divers types de relations avec d'autres entités. Elle utilise des annotations pour définir la manière dont elle doit être persistée dans la base de données et fournit toutes les méthodes nécessaires pour interagir avec ses attributs et les entités liées.

Inventaire.java

package com.example.rest.Model.Personnage;

import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;

import jakarta.persistence.*;
import java.util.Objects;


@Entity // Déclare que cette classe est une entité JPA.
@Table(name = "inventaire") // Spécifie le nom de la table associée à l'entité dans la base de données.
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") // Utilisé pour résoudre les problèmes de référence circulaire entre les objets lors de la sérialisation JSON.
public class Inventaire {

    @Id // Marque le champ comme une clé primaire.
    @GeneratedValue(strategy = GenerationType.AUTO) // La valeur de 'id' sera générée automatiquement.
    private Long id; // Identifiant unique de l'inventaire.
    
    // Définit une relation ManyToOne entre Inventaire et Personnage.
    @ManyToOne(fetch = FetchType.LAZY) // FetchType.LAZY signifie que la relation est chargée à la demande.
    @JoinColumn(name = "personnage_id") // Spécifie la colonne de jointure.
    private Personnage personnage; // Référence à l'entité Personnage associée à cet inventaire.
    
    // Définit une relation ManyToOne entre Inventaire et Objet.
    @ManyToOne(fetch = FetchType.LAZY) // FetchType.LAZY signifie que la relation est chargée à la demande.
    @JoinColumn(name = "objet_id", nullable = false) // Spécifie la colonne de jointure. 'nullable = false' signifie que chaque inventaire doit avoir un objet associé.
    private Objet objet; // Référence à l'entité Objet associée à cet inventaire.
    
    @Column(nullable = false) // 'nullable = false' signifie que la quantité ne peut pas être null.
    private Integer quantite; // Quantité de l'objet dans l'inventaire.


    public Inventaire() {
    }

    public Inventaire(Long id, Personnage personnage, Objet objet, Integer quantite) {
        this.id = id;
        this.personnage = personnage;
        this.objet = objet;
        this.quantite = quantite;
    }

    public Long getId() {
        return this.id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Personnage getPersonnage() {
        return this.personnage;
    }

    public void setPersonnage(Personnage personnage) {
        this.personnage = personnage;
    }

    public Objet getObjet() {
        return this.objet;
    }

    public void setObjet(Objet objet) {
        this.objet = objet;
    }

    public Integer getQuantite() {
        return this.quantite;
    }

    public void setQuantite(Integer quantite) {
        this.quantite = quantite;
    }

    public Inventaire id(Long id) {
        setId(id);
        return this;
    }

    public Inventaire personnage(Personnage personnage) {
        setPersonnage(personnage);
        return this;
    }

    public Inventaire objet(Objet objet) {
        setObjet(objet);
        return this;
    }

    public Inventaire quantite(Integer quantite) {
        setQuantite(quantite);
        return this;
    }

    @Override
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof Inventaire)) {
            return false;
        }
        Inventaire inventaire = (Inventaire) o;
        return Objects.equals(id, inventaire.id) && Objects.equals(personnage, inventaire.personnage) && Objects.equals(objet, inventaire.objet) && Objects.equals(quantite, inventaire.quantite);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, personnage, objet, quantite);
    }

    @Override
    public String toString() {
        return "{" +
            " id='" + getId() + "'" +
            ", personnage='" + getPersonnage() + "'" +
            ", objet='" + getObjet() + "'" +
            ", quantite='" + getQuantite() + "'" +
            "}";
    }

}

Explication Détaillée

1. @Entity et @Table:

   • @Entity déclare que la classe Inventaire est une entité JPA, ce qui signifie qu'elle peut être mappée à une table dans la base de données.
   • @Table(name = "inventaire") spécifie le nom de la table dans la base de données à laquelle cette entité est mappée.

2. Variables Membres et Annotations:

   • Chaque variable membre de la classe représente un champ ou une colonne dans la table inventaire de la base de données.
   • Les annotations telles que @Id, @GeneratedValue, @Column, et @ManyToOne sont utilisées pour configurer le mappage objet-relationnel entre l'entité Inventaire et la table inventaire.

3. Relations ManyToOne:

   • La relation @ManyToOne entre Inventaire et Personnage indique qu'un inventaire est associé à un seul personnage.
   • La relation @ManyToOne entre Inventaire et Objet indique qu'un inventaire est associé à un seul objet.

4. Sérialisation JSON:

   • L'annotation @JsonIdentityInfo est utilisée pour gérer la sérialisation et la désérialisation des objets en JSON, notamment pour éviter les problèmes de référence circulaire.

5. Quantité:

   • La variable quantite représente la quantité de l'objet dans l'inventaire et ne peut pas être null, comme indiqué par l'annotation @Column(nullable = false).

Résumé:

Cette classe représente un modèle de données pour un inventaire dans une application, avec des configurations spécifiques pour le mappage objet-relationnel et la sérialisation JSON.

Objet.java

package com.example.rest.Model.Personnage;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;

import java.util.Objects;
import java.util.Set;


import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;


@Entity // Déclare que cette classe est une entité JPA.
@Table(name = "objet") // Spécifie le nom de la table associée à l'entité dans la base de données.
// Utilisé pour résoudre les problèmes de référence circulaire entre les objets lors de la sérialisation JSON.
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") 
public class Objet {

    @Id // Marque le champ comme une clé primaire.
    @GeneratedValue(strategy=GenerationType.AUTO) // La valeur de 'id' sera générée automatiquement.
    private Long id; // Identifiant unique de l'objet.
    
    private String nom; // Nom de l'objet.
    private String description; // Description de l'objet.
    private String type; // Type de l'objet (ex: arme, armure, potion, etc.).
    private Integer valeur; // Valeur de l'objet en termes de monnaie du jeu.
    private Double poids; // Poids de l'objet.
    private String effet; // Effet de l'objet lorsqu'il est utilisé.
    private Integer niveauRequis; // Niveau requis pour utiliser l'objet.
    
    // Définit une relation OneToMany entre Objet et Inventaire.
    @OneToMany(mappedBy = "objet") // 'mappedBy' spécifie le nom de la variable membre dans la classe 'Inventaire' qui détient la relation.
    private Set<Inventaire> inventaire; // Liste des inventaires dans lesquels cet objet est présent.

    public Objet() {
    }

    public Objet(Long id, String nom, String description, String type, Integer valeur, Double poids, String effet, Integer niveauRequis, Set<Inventaire> inventaire) {
        this.id = id;
        this.nom = nom;
        this.description = description;
        this.type = type;
        this.valeur = valeur;
        this.poids = poids;
        this.effet = effet;
        this.niveauRequis = niveauRequis;
        this.inventaire = inventaire;
    }

    public Long getId() {
        return this.id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNom() {
        return this.nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public String getDescription() {
        return this.description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getType() {
        return this.type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Integer getValeur() {
        return this.valeur;
    }

    public void setValeur(Integer valeur) {
        this.valeur = valeur;
    }

    public Double getPoids() {
        return this.poids;
    }

    public void setPoids(Double poids) {
        this.poids = poids;
    }

    public String getEffet() {
        return this.effet;
    }

    public void setEffet(String effet) {
        this.effet = effet;
    }

    public Integer getNiveauRequis() {
        return this.niveauRequis;
    }

    public void setNiveauRequis(Integer niveauRequis) {
        this.niveauRequis = niveauRequis;
    }

    public Set<Inventaire> getInventaire() {
        return this.inventaire;
    }

    public void setInventaire(Set<Inventaire> inventaire) {
        this.inventaire = inventaire;
    }

    public Objet id(Long id) {
        setId(id);
        return this;
    }

    public Objet nom(String nom) {
        setNom(nom);
        return this;
    }

    public Objet description(String description) {
        setDescription(description);
        return this;
    }

    public Objet type(String type) {
        setType(type);
        return this;
    }

    public Objet valeur(Integer valeur) {
        setValeur(valeur);
        return this;
    }

    public Objet poids(Double poids) {
        setPoids(poids);
        return this;
    }

    public Objet effet(String effet) {
        setEffet(effet);
        return this;
    }

    public Objet niveauRequis(Integer niveauRequis) {
        setNiveauRequis(niveauRequis);
        return this;
    }

    public Objet inventaire(Set<Inventaire> inventaire) {
        setInventaire(inventaire);
        return this;
    }

    @Override
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof Objet)) {
            return false;
        }
        Objet objet = (Objet) o;
        return Objects.equals(id, objet.id) && Objects.equals(nom, objet.nom) && Objects.equals(description, objet.description) && Objects.equals(type, objet.type) && Objects.equals(valeur, objet.valeur) && Objects.equals(poids, objet.poids) && Objects.equals(effet, objet.effet) && Objects.equals(niveauRequis, objet.niveauRequis) && Objects.equals(inventaire, objet.inventaire);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, nom, description, type, valeur, poids, effet, niveauRequis, inventaire);
    }

    @Override
    public String toString() {
        return "{" +
            " id='" + getId() + "'" +
            ", nom='" + getNom() + "'" +
            ", description='" + getDescription() + "'" +
            ", type='" + getType() + "'" +
            ", valeur='" + getValeur() + "'" +
            ", poids='" + getPoids() + "'" +
            ", effet='" + getEffet() + "'" +
            ", niveauRequis='" + getNiveauRequis() + "'" +
            ", inventaire='" + getInventaire() + "'" +
            "}";
    }


}

Explication Détaillée Objet.java

1. @Entity et @Table:

   • @Entity déclare que la classe Objet est une entité JPA, ce qui signifie qu'elle peut être mappée à une table dans la base de données.
   • @Table(name = "objet") spécifie le nom de la table dans la base de données à laquelle cette entité est mappée.

2. Variables Membres et Annotations:

   • Chaque variable membre de la classe représente un champ ou une colonne dans la table objet de la base de données.
   • Les annotations telles que @Id, @GeneratedValue, et @OneToMany sont utilisées pour configurer le mappage objet-relationnel entre l'entité Objet et la table objet.

3. Relation OneToMany:

   • La relation @OneToMany entre Objet et Inventaire indique qu'un objet peut être présent dans plusieurs inventaires.
   • L'attribut mappedBy de l'annotation @OneToMany spécifie le nom de la variable membre dans la classe Inventaire qui détient la relation, indiquant ainsi que la table inventaire contient la clé étrangère.

4. Sérialisation JSON:

   • L'annotation @JsonIdentityInfo est utilisée pour gérer la sérialisation et la désérialisation des objets en JSON, notamment pour éviter les problèmes de référence circulaire.

5. Attributs de l'Objet:

   • Les variables nom, description, type, valeur, poids, effet, et niveauRequis représentent les différents attributs de l'objet dans le jeu, tels que son nom, sa description, son type, sa valeur en monnaie du jeu, son poids, son effet lorsqu'il est utilisé, et le niveau requis pour l'utiliser.

En résumé, cette classe représente un modèle de données pour un objet dans une application de jeu, avec des configurations spécifiques pour le mappage objet-relationnel et la sérialisation JSON.

Liaisons entre Personnage.java, Inventaire.java et Objet.java

1. Personnage.java

• OneToMany avec Inventaire.java:
  • Personnage a une relation OneToMany avec Inventaire, indiquant qu'un Personnage peut avoir plusieurs Inventaire.
  • Cette relation est représentée par la variable Set<Inventaire> inventaire dans Personnage.java.
  • mappedBy = "personnage" signifie que la propriété personnage dans Inventaire.java est le côté propriétaire de la relation.

2. Inventaire.java

• ManyToOne avec Personnage.java:

  • Inventaire a une relation ManyToOne avec Personnage, indiquant qu'un Inventaire appartient à un seul Personnage.
  • Cette relation est représentée par la variable Personnage personnage dans Inventaire.java.
  • @JoinColumn(name = "personnage_id") spécifie que la colonne personnage_id dans la table inventaire est la clé étrangère associée à la clé primaire de Personnage.

• ManyToOne avec Objet.java:

  • Inventaire a aussi une relation ManyToOne avec Objet, indiquant qu'un Inventaire peut contenir un seul Objet.
  • Cette relation est représentée par la variable Objet objet dans Inventaire.java.
  • @JoinColumn(name = "objet_id", nullable = false) spécifie que la colonne objet_id dans la table inventaire est la clé étrangère associée à la clé primaire de Objet et ne peut pas être null.

3. Objet.java

• OneToMany avec Inventaire.java:
  • Objet a une relation OneToMany avec Inventaire, indiquant qu'un Objet peut être présent dans plusieurs Inventaire.
  • Cette relation est représentée par la variable Set<Inventaire> inventaire dans Objet.java.
  • mappedBy = "objet" signifie que la propriété objet dans Inventaire.java est le côté propriétaire de la relation.

Explication des liaisons

1. Concept de Liaison:

   • Les liaisons entre les entités permettent de représenter les relations entre différentes tables dans la base de données, telles que les relations un-à-plusieurs, plusieurs-à-un et plusieurs-à-plusieurs.

2. Personnage et Inventaire:

   • Un Personnage peut posséder plusieurs Inventaire, mais chaque Inventaire appartient à un seul Personnage. Cela est représenté par une relation OneToMany dans Personnage.java et une relation ManyToOne dans Inventaire.java.

3. Inventaire et Objet:

   • Un Inventaire peut contenir un seul Objet, mais un Objet peut être présent dans plusieurs Inventaire. Cela est représenté par une relation ManyToOne dans Inventaire.java et une relation OneToMany dans Objet.java.

4. Importance des Liaisons:

   • Les liaisons entre les entités permettent de naviguer entre les objets associés dans le code, et elles facilitent également la jointure des tables lors de l'exécution des requêtes SQL, permettant ainsi d'obtenir des données liées de manière efficace.

5. Clés Étrangères:

   • Les annotations @JoinColumn dans les relations ManyToOne spécifient les clés étrangères dans les tables, permettant d'associer chaque Inventaire à un Personnage et un Objet spécifique.

6. MappedBy:

   • L'attribut mappedBy dans les relations OneToMany indique le côté propriétaire de la relation, c'est-à-dire le côté qui contient la clé étrangère. En ajustant correctement le côté propriétaire, on peut éviter les problèmes tels que les insertions et les mises à jour redondantes.

7. Conclusion:

   • Comprendre les liaisons entre les entités et savoir comment les configurer correctement est crucial pour construire une application robuste et performante avec un modèle de données relationnel.

package com.example.rest.Model;

import jakarta.persistence.CascadeType;
// Importation des annotations et classes nécessaires pour la persistance JPA
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.OneToOne;
import jakarta.persistence.Table;
import java.util.Objects;

import com.fasterxml.jackson.annotation.JsonIdentityInfo;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;

// Annotation pour indiquer que cette classe est une entité JPA
@Entity
@Table(name = "account")
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")
public class Account {

    // Annotation pour indiquer que c'est la clé primaire de l'entité
    @Id
    // Annotation pour indiquer la stratégie de génération de la clé primaire
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id; // ID unique de l'utilisateur

    @Column(unique = true) // Annotation pour s'assurer que l'email est unique dans la table
    private String email; // Email de l'utilisateur

    private String password; // Mot de passe de l'utilisateur

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "profil_id", referencedColumnName = "id")
    private Profil profil; // Relation OneToOne avec Profil

    public Account(Account account) {
    }

    public Account(Long id, String email, String password, Profil profil) {
        this.id = id;
        this.email = email;
        this.password = password;
        this.profil = profil;
    }

    public Account() {
    }

    public Long getId() {
        return this.id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getEmail() {
        return this.email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPassword() {
        return this.password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Profil getProfil() {
        return this.profil;
    }

    public void setProfil(Profil profil) {
        this.profil = profil;
    }

    public Account id(Long id) {
        setId(id);
        return this;
    }

    public Account email(String email) {
        setEmail(email);
        return this;
    }

    public Account password(String password) {
        setPassword(password);
        return this;
    }

    public Account profil(Profil profil) {
        setProfil(profil);
        return this;
    }

    @Override
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof Account)) {
            return false;
        }
        Account account = (Account) o;
        return Objects.equals(id, account.id) && Objects.equals(email, account.email) && Objects.equals(password, account.password) && Objects.equals(profil, account.profil);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, email, password, profil);
    }

    @Override
    public String toString() {
        return "{" +
            " id='" + getId() + "'" +
            ", email='" + getEmail() + "'" +
            ", password='" + getPassword() + "'" +
            ", profil='" + getProfil() + "'" +
            "}";
    }


}

package com.example.rest.Model;

import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.OneToOne;

import java.util.HashSet;
import java.util.Set;

import com.example.rest.Model.Personnage.Personnage;

import com.fasterxml.jackson.annotation.JsonIdentityInfo;

import com.fasterxml.jackson.annotation.ObjectIdGenerators;

import jakarta.persistence.CascadeType;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.JoinTable;
import jakarta.persistence.ManyToMany;
import jakarta.persistence.OneToMany;

@Entity  // Cette annotation indique que cette classe est une entité JPA.
@JsonIdentityInfo(generator = ObjectIdGenerators.PropertyGenerator.class, property = "id")  // Cette annotation est utilisée pour résoudre les problèmes de référence circulaire entre les objets lors de la sérialisation en JSON, en utilisant l'id de l'entité comme identifiant unique.
public class Profil {

    @Id  // Cette annotation indique que le champ suivant est la clé primaire de l'entité.
    @GeneratedValue(strategy = GenerationType.IDENTITY)  // Cette annotation spécifie comment la valeur de la clé primaire doit être générée automatiquement.
    private Integer id; // ID unique du profil.

    private String name; // Nom du profil.

    @OneToOne(mappedBy = "profil")  // Cette annotation définit une relation un-à-un avec l'entité Account. Le paramètre mappedBy indique que l'entité Profil est le côté non propriétaire de la relation.
    private Account account; // Relation OneToOne avec Account.

    @ManyToMany(fetch = FetchType.EAGER)  // Cette annotation définit une relation de plusieurs à plusieurs avec l'entité Game. Le paramètre fetch avec la valeur FetchType.EAGER signifie que la collection games sera chargée automatiquement à chaque fois que l'entité Profil est récupérée depuis la base de données.
    @JoinTable(  // Cette annotation est utilisée pour définir la table de jointure et les clés étrangères associées.
        name = "profil_game",  // Le nom de la table de jointure.
        joinColumns = @JoinColumn(name = "profil_id"),  // La clé étrangère de l'entité Profil dans la table de jointure.
        inverseJoinColumns = @JoinColumn(name = "game_id"))  // La clé étrangère de l'entité Game dans la table de jointure.
    //@JsonManagedReference  // Cette annotation peut être utilisée pour résoudre les problèmes de référence circulaire entre les objets lors de la sérialisation en JSON, en marquant le côté propriétaire de la relation.
    private Set<Game> games = new HashSet<>();  // L'ensemble des jeux associés à un profil. Il est initialisé avec un HashSet pour éviter les valeurs null et permettre l'ajout de jeux.

    @OneToMany(mappedBy = "profil", cascade = CascadeType.ALL)  // Cette annotation définit une relation un-à-plusieurs avec l'entité Personnage. Le paramètre mappedBy indique que l'entité Profil est le côté non propriétaire de la relation. Le paramètre cascade avec la valeur CascadeType.ALL signifie que toutes les opérations effectuées sur un profil seront répercutées sur ses personnages associés.
    private Set<Personnage> personnages;  // L'ensemble des personnages associés à un profil.


    // Constructeurs, getters et setters

    public Profil() {
    }

    public Profil(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name != null) {
            this.name = name;
        }
    }

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    public Set<Game> getGames() {

        return this.games;

    }

    public Set<Personnage> getPersonnages() {
        return personnages;
    }

    public void setPersonnages(Set<Personnage> personnages) {
        this.personnages = personnages;
    }

    public void addPersonnage(Personnage personnage) {
        personnages.add(personnage);
        personnage.setProfil(this);
    }

}

package com.example.rest.Model;

import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

import jakarta.persistence.ManyToMany;

import java.util.HashSet;
import java.util.Set;

import com.fasterxml.jackson.annotation.JsonBackReference;

import java.util.Objects;

@Entity  // Cette annotation indique que cette classe est une entité JPA (Java Persistence API).
public class Game {

    @Id  // Cette annotation indique que le champ suivant est la clé primaire de l'entité.
    @GeneratedValue(strategy = GenerationType.AUTO)  // Cette annotation spécifie comment la valeur de la clé primaire doit être générée automatiquement.
    private Integer id;  // Déclaration de la variable id qui représente l'identifiant unique du jeu.

    private String name;  // Déclaration de la variable name qui représente le nom du jeu.

    @ManyToMany(mappedBy = "games", fetch = FetchType.EAGER)  // Cette annotation définit une relation de plusieurs à plusieurs avec l'entité Profil. 
                                                              // Le paramètre mappedBy indique que l'entité Game est le côté non propriétaire de la relation.
                                                              // Le paramètre fetch avec la valeur FetchType.EAGER signifie que la collection profils sera chargée automatiquement à chaque fois que l'entité Game est récupérée depuis la base de données.
    @JsonBackReference  // Cette annotation est utilisée pour résoudre les problèmes de référence circulaire entre les objets lors de la sérialisation en JSON.
    private Set<Profil> profils = new HashSet<>();  // Déclaration de la variable profils qui représente l'ensemble des profils associés à un jeu. 
                                                    // Il est initialisé avec un HashSet pour éviter les valeurs null et permettre l'ajout de profils.

    // ... getters, setters, constructeurs ...

    public Game() {
    }

    public Game(Integer id, String name) {
        this.id = id;
        this.name = name;

    }

    public Game(Integer id, String name, Set<Profil> profils) {
        this.id = id;
        this.name = name;
        this.profils = profils;
    }

    public Integer getId() {
        return this.id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Set<Profil> getProfils() {
        return this.profils;
    }

    public void setProfils(Set<Profil> profils) {
        this.profils = profils;
    }

    public Game id(Integer id) {
        setId(id);
        return this;
    }

    public Game name(String name) {
        setName(name);
        return this;
    }

    public Game profils(Set<Profil> profils) {
        setProfils(profils);
        return this;
    }

    @Override
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof Game)) {
            return false;
        }
        Game game = (Game) o;
        return Objects.equals(id, game.id) && Objects.equals(name, game.name) && Objects.equals(profils, game.profils);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, profils);
    }

    @Override
    public String toString() {
        return "{" +
                " id='" + getId() + "'" +
                ", name='" + getName() + "'" +
                ", profils='" + getProfils() + "'" +
                "}";
    }

}