Enonce en cours de modification

Le TP sera évalué en deux fois. Une première évaluation sur le code produit, en particulier, mais pas uniquement, l'implémentation des méthodes de la classe RecetteORMDAO. Une deuxième évaluation aura lieu sous la forme d'une évaluation écrite (réalisée en cours ou en TD) portant sur des points techniques du TP.

<note important>Afin de pouvoir évaluaer fonctionnellement le code rendu, il est demandé de ne pas modifier la signature des méthodes publiques fournies dans le projet de base. Il est par contre possible, et parfois nécessaire, d'ajouter d'autres méthodes aux classes existantes.</note>

L'objectif de ce TP est de mettre en place un mapping Objet/Relationnel via l'API JPA.

Quelques liens:

• API JEE 5 → package javax.persistence
• JPA
• Hibernate
• Tutoriel JPA en anglais
• Transparents du cours ORM
• Un ancien TP sur les ORM

Maven est un utilitaire de compilation/exécution/test de projet Java qui sera utilisé dans le cadre des TP de l'UE. Configurer Maven comme indiqué dans l'aide. Voir également le TP maven/forge.

Télécharger et décompresser le projet de base: inf1018m-orm.zip ou mieux le cloner depuis la forge:

hg clone https://forge.univ-lyon1.fr/hg/inf1018m-orm

Un projet Maven possède deux répertoires de sources: src/main et src/test. Le premier contient les classes “métier” alors que le second ne contient que le code de test.

Dans Eclipse, il faut importer le projet en utilisant Import existing maven project. Le projet peut être directement ou vert dans Netbeans. Il est également possible d'utiliser IntelliJ en important le projet et en spécifiant d'utiliser un type de projet maven à l'import.

<note tip>Il est possible d'utiliser la ligne de commande plutot que l'IDE. Pour compiler et tester le mapping depuis le répertoire du projet¹⁾, faire:

mvn test

</note>

Le fichier pom.xml contient les dépendances sur les bibliothèques nécessaires au TP.

Le fichier src/main/resources/META-INF/persistence.xml contient les informations pour mettre en place le cadre de persistance.

H2 est une base de donnée Java qui sera utilisée dans ce TP²⁾. Télécharger et décompresser le fichier h2-2014-08-06.zip et lancer la console H2 à l'aide du fichier h2.sh ou h2.bat. Une page web s'ouvre. Utiliser la configuration Generic H2 (Server). <note important> Vérifier la configuration:

• Pilote JDBC: org.h2.Driver
• URL JDBC: jdbc:h2:tcp://localhost/~/test
• Nom d'utilisateur: sa
• Mot de passe: vide

</note> Tester la connexion, puis se connecter.

Le fichier src/main/resources/schema.sql du projet embryonnaire permet de mettre en place le schéma relationnel dans la base H2. Utiliser la console H2 dans le navigateur pour mettre en place ce schéma.

schema.sql

CREATE TABLE Recette(
  nom VARCHAR(255) PRIMARY KEY,
  description CLOB,
  url_image VARCHAR(1024)
);
 
CREATE TABLE Ingredient(
  nom VARCHAR(255) PRIMARY KEY,
  description CLOB
);
 
CREATE TABLE Quantite(
  recette VARCHAR(255) REFERENCES Recette(nom),
  ingredient VARCHAR(255) REFERENCES Ingredient(nom),
  quantite DOUBLE,
  unite VARCHAR(40),
  PRIMARY KEY (recette,ingredient)
);
 
CREATE TABLE Instruction(
  recette VARCHAR(255) REFERENCES Recette(nom),
  ordre INTEGER,
  description CLOB,
  PRIMARY KEY (recette,ordre)
);

Un embryon de modèle objet correspondant aux données en base peut être trouvé dans le package univlyon1.recettes.modele. Ces classes contiennent un certain nombre de méthodes publiques utilisées par l'application fournie.

L'interaction avec la base de donnée est encapsulée dans la classe RecetteORMDAO. Les méthodes de cette classes sont vides

suite à réviser

1. Concevoir un modèle objet correspondant au modèle relationnel fourni et créer des classes Java correspondantes.
2. Annoter les classes via des annotations du package javax.persistence, afin d'établir les liens entre le modèle relationnel et votre modèle objet.
   • Un début de classe Cinema annoté peut servir de point de départ.
   • Dans la mesure du possible, les associations devront être bidirectionnelles
     • Dans le cas d'associations bidirectionnelles, la cohérence des informations en mémoire devra être garantie.

Le mapping relationnel objet peut être tester à travers le TestCase JUnit placé dans src/test/java/mif18/orm/MappingTest.java. Cette classe est exécutable directement comme test JUnit dans Eclipse, Netbeans ou IntelliJ.

• Lorsqu’une entité/classe possède un identifiant portant sur plusieurs attributs, il faut créer une classe spécifique (qui n'est pas une entité) pour regrouper ces champs, et utiliser un champ de cette classe en lieu et place du groupe de champs servant d'identifiants dans votre modèle objet. Voir @EmbeddedId, @Embbedable. Voir également @ElementCollection si les éléments de la collection ne sont pas des entités.
• Les annotations @Column, @JoinColumn, @JoinTable sont à utiliser dans le mapping
• Avec le paramètre mappedBy, il est possible d'utiliser une valeur du type maCle.unChamp pour indiquer que la relation inverse est référencée à partir d'un champ dans une clé composée (i.e. en présence de @Embbedable/@EmbbeddedId).
• Changer hibernate.hbm2ddl.auto de validate à update permet au framework de modifier le schéma relationnel. Cela peut être utile pour comprendre à quoi correspond le mapping en cours de développement, mais cela écrase le schéma de l'énoncé. A la fin du TP, le mapping doit fonctionner avec le schéma de fourni plus haut. En cas d'impossibilité, justifier les différences dans des commentaires appropriés dans les classes Java.
• L'ordre suivant est suggéré dans la mise en place des classes et du mapping:
  • Classes Salle, Seance, Client, Reservation sans traiter les associations
    • il est possible pour cela d'utiliser des type primitifs comme int ou String pour les champs qui sont des clés étrangères. Ces champ seront remplacés par des champs désignant des classes du modèle le moment venu (par exemple un champ String cinema pourra plus tard être remplacé par un champ Cinema cinema
  • Association Salle ↔ Cinema
  • Association Seance ↔ Salle
  • Associations Reservation ↔ Seance et Reservation ↔ Client