tete du loic

 Loïc YON [KIUX]

  • Enseignant-chercheur
  • Référent Formation Continue
  • Responsable des contrats pros ingénieur
  • Référent entrepreneuriat
  • Responsable de la filière F2 ingénieur
  • Secouriste Sauveteur du Travail
mail
loic.yon@isima.fr
phone
(+33 / 0) 4 73 40 50 42
location_on
ISIMA
  • twitter
  • linkedin
  • viadeo

eco ORM JPA eco

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 :

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


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;};
}

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 classe Personne 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 :

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:

Composition d'un objet simple

À 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".

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 :

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 :

Agrégation avec des entités

Il y a également deux annotations pour gérer ce cas :

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