Académique Documents
Professionnel Documents
Culture Documents
TP Mapping D'héritage
TP Mapping D'héritage
TP : Mapping d’héritage
Exercice 1 :
Dans cette stratégie, qui est celle par défaut, le modèle relationnel est fait d'une seule table
pour toute la hiérarchie de classes. Pour spécifier cette stratégie, on ajoute une
annotation @Inheritance(strategy=InheritanceType.SINGLE_TABLE) sur la classe racine.
1. Les entités :
Personne
@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
name = "Type",
discriminatorType = DiscriminatorType.STRING)
public class Personne {
@Id
@GeneratedValue
private int id;
private String nom;
public Personne() {
Page 1 sur 8
Pr. Mohamed LACHGAR
ENSAJ ISIC
Etudiant
@Entity
@DiscriminatorValue(value = "etd")
public class Etudiant extends Personne{
Employe
@Entity
@DiscriminatorValue(value = "emp")
public class Employe extends Personne{
private String matricule;
public String getMatricule() {
return matricule;
}
public void setMatricule(String matricule) {
this.matricule = matricule;
}
}
Page 2 sur 8
Pr. Mohamed LACHGAR
ENSAJ ISIC
<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/projetH7A</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="hibernate.hbm2ddl.auto">create</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>
<mapping class="ma.projet.beans.Employe"/>
<mapping class="ma.projet.beans.Etudiant"/>
<mapping class="ma.projet.beans.Personne"/>
</session-factory>
</hibernate-configuration>
3. La classe HibernateUtil :
static {
try {
sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
} catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
4. Programme de Test :
public static void main(String[] args) {
Personne p = new Personne();
p.setNom("Safi");
Employe emp = new Employe();
emp.setNom("Rami");
emp.setMatricule("14528");
Etudiant et = new Etudiant();
et.setNom("Alami");
et.setCne("145878965");
Session session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
Page 3 sur 8
Pr. Mohamed LACHGAR
ENSAJ ISIC
session.save(p);
session.save(emp);
session.save(et);
session.getTransaction().commit();
session.close();
}
Hibernate:
insert
into
Personne
(nom, Type)
values
(?, 'Personne')
Hibernate:
insert
Vu qu'il n'y a qu'une seule table, toutes les écritures
into
se font dedans, quelle que soit la nature de l'objet
Personne
(nom, matricule, Type) persisté. Au final certaines colonnes sont laissées
values nulles.
(?, ?, 'emp')
Hibernate:
insert
into
Personne
(nom, cne, Type)
values
(?, ?, 'etd')
Avec cette stratégie de mapping, il y a une table pour chaque classe concrète : chaque type de
personne est stocké dans sa propre table. Chaque table reprend les colonnes de la classe mère,
grand-mère, etc... Par contre les classes abstraites ne sont pas représentées.
Le mapping change très peu de la stratégie précédente, la classe racine est toujours la seule
concernée.
Entité Personne :
@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Personneee {
@Id
Page 4 sur 8
Pr. Mohamed LACHGAR
ENSAJ ISIC
public Personneee() {
}
Entité Employe :
@Entity
public class Employeee extends Personneee{
Entité Etudiant :
@Entity
public class Etudiantee extends Personneee{
Page 5 sur 8
Pr. Mohamed LACHGAR
ENSAJ ISIC
}
Personne
Programme de Test :
Hibernate:
insert
into
Personneee
(nom, id) Etudiant
values
(?, ?)
Hibernate:
insert
into
Employeee
Employe
(nom, matricule, id)
values
(?, ?, ?)
Hibernate:
insert
into
Etudiantee
(nom, cne, id)
values
(?, ?, ?)
Ce modèle relationnel est le plus proche du modèle objet : à chaque classe, qu'elle soit concrète ou
abstraite, correspond une table. Autrement dit, les informations concernant une instance de véhicule
sont réparties sur plusieurs tables. La seule colonne commune entre les tables est la colonne ID qui
permet de faire les jointures table mère et table fille.
Entité Personne :
@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Personnee {
Page 6 sur 8
Pr. Mohamed LACHGAR
ENSAJ ISIC
@Id
@GeneratedValue
private int id;
private String nom;
public Personnee() {
}
Entité Employe :
@Entity
public class Employeee extends Personnee{
Entité Etudiant :
@Entity
public class Etudiantee extends Personnee{
Page 7 sur 8
Pr. Mohamed LACHGAR
ENSAJ ISIC
return cne;
}
}
Personne
Programme de Test :
Hibernate:
insert
into
Personnee
(nom) Employe
values
(?)
Hibernate:
insert
into Etudiant
Personnee
(nom)
values
(?)
Hibernate:
insert
into
Employee
(matricule, id)
values
(?, ?)
Hibernate:
insert
into
Personnee
(nom)
values
(?)
Hibernate:
insert
into
Etudiante
(cne, id)
values
(?, ?)
Page 8 sur 8
Pr. Mohamed LACHGAR