Les Jointures des Tables - Annotations

@Autowired

L'annotation `@Autowired` est utilisée par Spring pour effectuer l'injection de dépendances.

Elle permet à Spring de résoudre et d'injecter des beans collaborateurs dans notre bean. Cette annotation peut être appliquée sur les champs, les setters et les constructeurs pour l'injection de dépendances par type. 

Lorsque `@Autowired` est appliquée sur un champ, la dépendance est stockée dans ce champ.

Lorsqu'elle est appliquée sur un setter, le setter est invoqué avec le paramètre déterminé par le même algorithme que pour l'injection de dépendances sur les champs.

Lorsqu'elle est appliquée sur un constructeur, le constructeur est invoqué avec les paramètres déterminés par le même algorithme que pour l'injection de dépendances sur les champs.

 

@OneToMany:

@OneToMany: Cette annotation est utilisée pour définir une relation un-à-plusieurs entre deux entités. Elle est généralement utilisée sur le côté “un” de la relation, c’est-à-dire sur l’entité qui a plusieurs instances de l’autre entité liée à elle.

Par exemple, si nous avons une entité Personne et une entité Voiture, et qu’une personne peut posséder plusieurs voitures, nous utiliserions l’annotation @OneToMany sur la liste des voitures dans l’entité Personne.

@ManyToOne:

@ManyToOne: Cette annotation est utilisée pour définir une relation plusieurs-à-un entre deux entités. Elle est généralement utilisée sur le côté “plusieurs” de la relation, c’est-à-dire sur l’entité qui a une seule instance de l’autre entité liée à elle.

En reprenant l’exemple précédent, nous utiliserions l’annotation @ManyToOne sur la référence à la personne dans l’entité Voiture.

@ManyToMany:

@ManyToMany: Cette annotation est utilisée pour définir une relation plusieurs-à-plusieurs entre deux entités. Elle peut être utilisée sur les deux côtés de la relation. Par exemple, si nous avons une entité Etudiant et une entité Cours, et qu’un étudiant peut s’inscrire à plusieurs cours et qu’un cours peut avoir plusieurs étudiants inscrits, nous utiliserions l’annotation @ManyToMany sur les listes des étudiants et des cours dans les deux entités.

@OneToOne:

@OneToOne: Cette annotation est utilisée pour définir une relation un-à-un entre deux entités. Elle peut être utilisée sur les deux côtés de la relation.

Par exemple, si nous avons une entité Personne et une entité Passeport, et qu’une personne ne peut avoir qu’un seul passeport et qu’un passeport ne peut appartenir qu’à une seule personne, nous utiliserions l’annotation @OneToOne sur les références à la personne et au passeport dans les deux entités.

@JoinColumn:

@JoinColumn: Cette annotation est utilisée pour spécifier la colonne de jointure utilisée pour relier les tables dans une relation entre deux entités. Elle est généralement utilisée en combinaison avec les annotations de relation mentionnées ci-dessus. 

Par exemple, si nous avons une relation un-à-plusieurs entre une entité Personne et une entité Voiture, et que la table des voitures a une colonne personne_id qui contient l’identifiant de la personne propriétaire de la voiture, nous utiliserions l’annotation @JoinColumn(name = "personne_id") sur la liste des voitures dans l’entité Personne ou sur la référence à la personne dans l’entité Voiture

@joinTable

L’annotation @JoinTable dans Spring Data JPA est utilisée pour spécifier la table de jointure utilisée pour relier les tables dans une relation plusieurs-à-plusieurs entre deux entités. Elle est généralement utilisée en combinaison avec l’annotation @ManyToMany pour définir une relation plusieurs-à-plusieurs entre deux entités.

L’annotation @JoinTable a plusieurs attributs qui vous permettent de personnaliser la table de jointure. Les attributs les plus couramment utilisés sont name, qui spécifie le nom de la table de jointure, joinColumns, qui spécifie les colonnes de jointure pour l’entité propriétaire, et inverseJoinColumns, qui spécifie les colonnes de jointure pour l’entité inverse.

Voici un exemple d’utilisation de l’annotation @JoinTable pour définir une relation plusieurs-à-plusieurs entre deux entités Personne et Groupe:

@Entity
public class Personne {
    @Id
    private Long id;

    @ManyToMany
    @JoinTable(
        name = "personne_groupe",
        joinColumns = @JoinColumn(name = "personne_id"),
        inverseJoinColumns = @JoinColumn(name = "groupe_id")
    )
    private Set<Groupe> groupes;
}

Dans cet exemple, nous utilisons l’annotation @JoinTable pour spécifier que la table de jointure s’appelle personne_groupe, que la colonne de jointure pour l’entité Personne s’appelle personne_id, et que la colonne de jointure pour l’entité Groupe s’appelle groupe_id. Cela signifie que la table de jointure aura deux colonnes, personne_id et groupe_id, qui stockeront les identifiants des entités liées.

mappedBy

L’option mappedBy dans l’annotation @OneToMany est utilisée pour indiquer la propriété de l’entité enfant qui est responsable de la relation. Dans votre exemple, la propriété objet de l’entité Inventaire est responsable de la relation entre les entités Inventaire et l’entité parente contenant la propriété inventaires. Cela signifie que la clé étrangère pour la relation se trouve dans la table de l’entité Inventaire.

L’utilisation de mappedBy permet à Hibernate de savoir que la clé pour la relation se trouve de l’autre côté. Cela signifie que bien que vous liiez 2 tables ensemble, seule 1 de ces tables a une contrainte de clé étrangère vers l’autre MappedBy vous permet toujours de lier de la table ne contenant pas la contrainte à l’autre table.

@Table

L’annotation @Table est utilisée pour spécifier les détails de la table qui sera utilisée pour persister l’entité dans la base de données. L’attribut name de l’annotation @Table permet de définir le nom de la table dans la base de données. Dans votre exemple, @Table(name = "inventaire") indique que l’entité sera persistée dans une table nommée inventaire dans la base de données.

@Column

L’annotation @Column dans Spring Data JPA est utilisée pour spécifier les détails de la colonne qui sera utilisée pour persister une propriété d’une entité dans la base de données. Elle peut être utilisée pour définir des attributs tels que le nom de la colonne, sa longueur, si elle peut être nulle ou non, et sa définition de colonne.

Voici quelques exemples d’utilisation de l’annotation @Column:

@Column(name = "nom_colonne"): Spécifie le nom de la colonne dans la base de données.
@Column(length = 30): Spécifie la longueur maximale de la colonne dans la base de données.
@Column(nullable = false): Spécifie que la colonne ne peut pas être nulle.
@Column(columnDefinition = "varchar(22) default 'Aayush'"): Spécifie la définition de la colonne dans la base de données.

@GeneratedValue

L’annotation @GeneratedValue dans Spring Data JPA est utilisée pour spécifier la stratégie de génération des valeurs de clé primaire pour une entité. Elle est généralement utilisée en combinaison avec l’annotation @Id pour indiquer que la propriété est la clé primaire de l’entité1.

Il existe plusieurs stratégies de génération de clés primaires disponibles, qui peuvent être spécifiées en utilisant l’attribut strategy de l’annotation @GeneratedValue. Les stratégies disponibles sont les suivantes:

GenerationType.AUTO: La stratégie par défaut, qui laisse le fournisseur de persistance choisir la stratégie de génération en fonction du dialecte de base de données spécifique1.
GenerationType.IDENTITY: Cette stratégie s’appuie sur une colonne de base de données auto-incrémentée et laisse la base de données générer une nouvelle valeur à chaque opération d’insertion.
GenerationType.SEQUENCE: Cette stratégie utilise une séquence de base de données pour générer des valeurs uniques. Elle nécessite des instructions SELECT supplémentaires pour obtenir la valeur suivante d’une séquence de base de données.
GenerationType.TABLE: Cette stratégie simule une séquence en stockant et en mettant à jour sa valeur actuelle dans une table de base de données, ce qui nécessite l’utilisation de verrous pessimistes qui mettent toutes les transactions dans un ordre séquentiel.

@Id
@GeneratedValue(strategy=GenerationType.AUTO)
@SequenceGenerator(name="car_generator", sequenceName = "car_seq", allocationSize=50)
private Long id;

Dans cet exemple, nous utilisons l’annotation @SequenceGenerator pour définir un générateur de séquence personnalisé nommé “car_generator” qui utilise une séquence de base de données nommée “car_seq” avec une taille d’allocation de 50.

@Transient

L’annotation @Transient dans Spring Data JPA est utilisée pour indiquer qu’une propriété ne doit pas être persistée dans la base de données. Cela signifie que la valeur de la propriété ne sera pas stockée dans la base de données et ne sera pas récupérée lors de la lecture de l’entité à partir de la base de données.

L’annotation @Transient peut être utilisée pour exclure des propriétés qui ne sont pas destinées à être persistées, comme les propriétés calculées ou les propriétés temporaires qui ne sont utilisées que pendant l’exécution de l’application. Par exemple, si nous avons une entité Personne avec une propriété age calculée à partir de la date de naissance, nous pourrions utiliser l’annotation @Transient pour exclure cette propriété de la persistance:

@Entity
public class Personne {
    @Id
    private Long id;

    private LocalDate dateNaissance;

    @Transient
    private int age;

    // ...
}

Dans cet exemple, nous utilisons l’annotation @Transient sur la propriété age pour indiquer qu’elle ne doit pas être persistée dans la base de données. Cela signifie que la valeur de cette propriété ne sera pas stockée dans la base de données et ne sera pas récupérée lors de la lecture de l’entité à partir de la base de données.

@Embedded

L’annotation @Embedded dans Spring Data JPA est utilisée pour spécifier qu’un champ ou une propriété d’une entité est une instance d’une classe incorporable. Cette annotation permet d’incorporer les propriétés d’une classe dans une autre entité, en les mappant à la même table de base de données que l’entité conteneur.

Par exemple, si nous avons une entité Personne qui a des propriétés telles que nom, prenom et adresse, nous pourrions définir une classe Adresse avec des propriétés telles que rue, ville et codePostal, puis incorporer cette classe dans l’entité Personne en utilisant l’annotation @Embedded sur la propriété adresse de l’entité Personne. Cela permettrait de mapper les propriétés de la classe Adresse à la même table de base de données que l’entité Personne.

Il est important de noter que les définitions de colonnes spécifiées dans la classe incorporable s’appliquent à la table de l’entité conteneur par défaut, mais vous pouvez les remplacer en utilisant l’annotation @AttributeOverride. Par exemple, si vous souhaitez remplacer le nom de la colonne pour la propriété ville de la classe Adresse, vous pouvez utiliser l’annotation @AttributeOverride(name = "ville", column = @Column(name = "nom_ville")) sur la propriété adresse de l’entité Personne.

 

@Transactional

L’annotation @Transactional dans Spring est utilisée pour indiquer que la méthode ou la classe sur laquelle elle est appliquée doit être exécutée dans une transaction. Cela signifie que toutes les opérations effectuées dans la méthode ou la classe seront exécutées dans une seule transaction, et si une exception est levée, toutes les modifications seront annulées.

Pour utiliser l’annotation @Transactional, vous devez d’abord activer la prise en charge des transactions dans votre configuration Spring. Cela peut être fait en utilisant l’annotation @EnableTransactionManagement dans une classe de configuration ou en utilisant l’élément <tx:annotation-driven/> dans votre configuration XML.

Une fois que la prise en charge des transactions est activée, vous pouvez utiliser l’annotation @Transactional sur les méthodes ou les classes que vous souhaitez exécuter dans une transaction. Par exemple, vous pouvez annoter une méthode de service comme suit:

@Service
public class MyService {
    @Transactional
    public void myMethod() {
        // code here will be executed in a transaction
    }
}

Vous pouvez également utiliser l’annotation @Transactional au niveau de la classe pour indiquer que toutes les méthodes de la classe doivent être exécutées dans une transaction.

Il est important de noter que l’annotation @Transactional ne fonctionne que sur les méthodes publiques et ne fonctionnera pas sur les méthodes privées ou protégées. De plus, l’annotation ne fonctionnera pas si elle est appliquée à une méthode appelée à partir de la même classe.

@Basic

L’annotation @Basic dans Spring Data JPA est utilisée pour indiquer qu’une propriété doit être persistée dans la base de données. Elle est généralement utilisée pour les propriétés de base, telles que les chaînes de caractères, les nombres et les dates, qui peuvent être mappées directement à une colonne de base de données.

Par défaut, toutes les propriétés non transitoires d’une entité sont considérées comme étant de base et sont persistées dans la base de données. Cependant, vous pouvez utiliser l’annotation @Basic pour personnaliser le comportement de persistance d’une propriété en utilisant ses attributs. Par exemple, vous pouvez utiliser l’attribut fetch pour spécifier si la propriété doit être chargée à la demande ou non, ou l’attribut optional pour spécifier si la propriété peut être nulle ou non.

Voici un exemple d’utilisation de l’annotation @Basic avec l’attribut fetch:

@Entity
public class MyEntity {
    @Id
    private Long id;

    @Basic(fetch = FetchType.LAZY)
    private String myProperty;
}

Dans cet exemple, nous utilisons l’attribut fetch avec la valeur FetchType.LAZY pour indiquer que la propriété myProperty doit être chargée à la demande, c’est-à-dire que sa valeur ne sera chargée que lorsque nous y accéderons explicitement.