Date de première publication : 2026/11/03
Objectif et contexte
L'objectif de cet exercice est de voir comment fonctionne un ORM et notamment Hibernate dans un programme SpringBoot. Le modèle objet identifie des relations qui ne sont pas de même nature que celles des schémas entité-relations que l'on utilise avec des bases de données relationnelles.
On a sélectionné les options suivantes :
- Project : Gradle - groovy - le logiciel d'automatisation
- Langage : Java
- Spring Boot : 4.1.2 - la version stable la plus récente
- Dependencies
- Spring Boot DevTools
- Spring Web (pour faire une application Web que l'on ne fera pas)
- Lombok (si vous voulez)
- H2
- SpringData JPA
- Project Metadata
- Group : orm
- Artifact : Orm
- Package name : orm
- Java : 25
Vous allez réaliser une implémentation d'un schéma UML et ce schéma sera "traduit" par Hibernate. On se contentera de voir comment tout cela est traduit par l'ORM. Pour rappel, l'URL de consultation de la base de données H2 est la suivante :
http://localhost:8080/h2-console/
Il faut juste donner la base de données à créer en précisant dans le fichier application.properties :
spring.jpa.hibernate.ddl-auto=create-drop
spring.datasource.url=jdbc:h2:file:./orm
on choisit le mode ddl-auto à create-drop (mode par défaut) car on ne veut pas garder de choses dans la base de données d'une exécution à une autre.
Si les tests vous embêtent, soit vous enlevez les dépendances concernant ceux-ci ou alors vous utilisez la ligne de compilation :
./gradlew bootRun -x test
Héritage
- Créez une entité
Personneavec une clé primaire.
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
@Entity
public class Personne {
@Id
protected String nom;
public Personne(String nom) {
this.nom = nom;
}
// protected Personne() {
//
// }
public String getNom() { return nom;}
public void setNom(String nom) {this.nom = nom;};
}
- Créez une nouvelle entité
Enseignantqui dérive dePersonneet qui est dotée d'un attributspecialite - Implémentez le repository pour l'entité
Enseignant - Dans la méthode
run()de l'interfaceCommandLineRunnerimplémentée par l'application, sauvegardez quelques entitésEnseignants - Réglez les différents problèmes que vous pourriez avoir à l'exécution.
- Comment sont stockées les entités
Enseignant?
Explication
Une entité est normalement stockée dans une table qui porte son nom. Dans le cas présent, l'ORM crée une table unique pour la classePersonne et dérivées.
Pour différencier les types, il est alors ajouté un champ DTYPE.
On peut changer ce comportement par défaut avec une annotation :
// import jakarta.persistence.Inheritance
// import jakarta.persistence.InheritanceType
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@Inheritance(strategy = InheritanceType.JOINED)
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
Essayez les deux derniers types pour voir ce que cela donne...
Ce choix n'est pas neutre lors de l'utilisation de la base de données et peut mener à problèmes de performance suivant les requêtes effectuées.
L'entité peut être abstraite, cela ne pose pas de problème également.
Si la classe Personne en devait pas être une entité, l'annotation @MappedSuperclass peut être utilisée. Il faut toujours l'identifiant.
Traces SQL
Il est essentiel de savoir ce que l'ORM fait et traduit ce qu'on lui demande. En particulier, quand on conçoit l'application ou que l'on cherche à améliorer la performance. Il y a deux techniques suivant les bases de données :
- Augmenter le niveau de log de l'application (marche tout le temps)
- Afficher les requêtes faites par le SGBD si le SGBD le permet
On va se contenter de voir ce qu'il se passe au niveau de l'application. Dans le fichier application.properties, ajoutez les éléments suivant :
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
logging.level.org.hibernate.SQL=DEBUG
# Affiche les valeurs des paramètres liés (bind parameters)
# (Attention : le package exact peut varier légèrement selon votre version de Hibernate,
# ex: org.hibernate.type.descriptor.sql pour Hibernate 5,
# ou org.hibernate.orm.jdbc.bind pour Hibernate 6+)
logging.level.org.hibernate.orm.jdbc.bind=TRACE
Essayez maintenant quelques requêtes, comme par exemple:
enseignantRepository.findAll()enseignantRepository.findBySpecialite()
Composition d'un objet simple
- Créez une classe simple nommée
PasClasseavec un attributnom - Créez une entité
Etudiantqui dérive dePersonneavec un attribut de classePasClasse - Compilez et exécutez le programme
À l'exécution, on obtient le message :
Could not determine recommended JdbcType for Java type 'orm.entities.PasClasse'
Embarquer l'attribut complexe
Il faut dire à l'ORM que l'attribut doit être "embarqué" dans la table et que l'attribut est "embarquable".
- Ajoutez l'annotation
jakarta.persistence.Embeddableà la classePasClasse - Ajoutez l'annotation
jakarta.persistence.Embeddedà la classeEtudiant - Compilez et exécutez le programme
On obtient un message du type :
Caused by: org.hibernate.MappingException: Column 'nom' is duplicated in mapping for entity 'orm.entities.Etudiant' (use '@Column(insertable=false, updatable=false)' when mapping multiple properties to the same column)
mapping
Il faut comprendre que l'ORM ne gère pas directement un objet composé mais il considère chaque attribut du composé comme un attribut de l'objet englobant.
On peut donc avoir une collision de nom : un attribut de l'objet englobant qui porte le même nom qu'un attribut du composé. On a alors deux solutions possibles :
- changer le nom d'un des attributs (non souhaitable)
- utiliser une annotation pour changer le nom du mapping.
Pour un seul champ :
@Embedded
@AttributeOverride(name = "attribut", column = @Column(name = "autre_nom_attribut")),
Pour plusieurs champs :
@Embedded
@AttributeOverrides({
@AttributeOverride(name = "attribut1", column = @Column(name = "autre_attribut1")),
@AttributeOverride(name = "attribut2", column = @Column(name = "autre_attribut2"))
})
Même sans instancier d'étudiants, on peut voir ce qui est fait par l'ORM.
Agrégation avec une entité
Il y a deux annotations pour gérer ce cas :
@OneToOne@ManyToOne: par exemple, la classe qui peut être référencée par les élèves de la classe.
Agrégation avec des entités
Il y a également deux annotations pour gérer ce cas :
@OneToMany: la liste des élèves d'une classe@ManyToMany: plusieurs enseignants enseignent à plusieurs classes.
Clé composite
Il est facile en SQL de créer une clé primaire composite :
PRIMARY_KEY(nom, prenom).
Comment peut-on réaliser cela avec Hibernate ? C'est moins évident qu'en objet, et là encore,
il y a deux possibilités... Même si l'idée générale reste la même : créer une classe qui représente cette clé composite.
La classe doit implementer equals() et hashCode() en plus d'être sérialisable.
class Composite{
type champ1;
type champ2;
}
@IdClass(composite)
class ClasseAvecComposite {
@Id
type champ1;
@Id
type champ2
}
L'autre technique s'appelle @EmbeddedId


