TP SPRING 1 Pré-requis

Institut Galilée Programmation et Logiciels sûrs
Année 2016-2017 Master 2 PLS
TP SPRING
Résumé
L’objectif de ce TP est d’être capable de réaliser une application Java de gestion de location de véhicules,voiture
ou camion, à l’aide du framework Spring. Il s’agit de gérer des individus et un parc de véhicules. L’application devra
permettre, entre autres, de :
— de lister les véhicules du parc
— de lister les individus ayant loué un véhicule
— de permettre à des individus d’emprunter et de rendre des véhicules
1 Pré-requis
1.1 L’environnement de développement
Pour ce TP, l’environnement de développement utilisé est Netbeans, entre autre pour le fait que l’IDE intègre le
moteur de base de données Derby. Cet environnement est disponible dans les salles de TP de Galilée. Pour le chapitre
JDBC, il est nécessaire d’utiliser la base Derby intégrée à Glassfish. Dans tous les cas, le lecteur pourra trouver une
version Linux de ces applications à cette adresse : https ://lipn.univ-paris13.fr/∼fortier/Enseignement/Applications/
1.2 Les librairies nécessaires
Les librairies nécessaires sont téléchargeables à cette adresse :
https ://lipn.univ-paris13.fr/∼fortier/Enseignement/Spring/TP/
Il s’agit :
— de certaines librairies Spring :
— org.springframework.context-3.0.6.RELEASE.jar
— org.springframework.core-3.0.6.RELEASE.jar
— org.springframework.beans-3.0.6.RELEASE.jar
— ...
— de la librairie Apache de journalisation :
— commons-logging-1.1.1.jar
— de la librairie Derby permettant d’accéder aux données
1.3 La base de données
On utilise une base de données derby, installée avec Glassfish. Avant tout, il faut créer la base de nom "location",
l’utilisateur "location" et comme mot de passe "mdp" (par exemple) Voila les requêtes SQL de base à exécuter pour
créer les schéma et la première table :
create schema location;
create table location.personne (
personne_id integer generated always as identity primary key,
nom varchar(20),
age numeric
);
insert into location.personne (nom,age) values (’michael’,25);
insert into location.personne (nom,age) values (’christophe’,30);
1.4 Tests unitaires
Les exercices peuvent être testés via des classes Main, mais on préfèrera utiliser des tests unitaires, déjà intégrés
dans l’environnement Netbeans (Cf. Annexes).
1

2 Etape 1 : Une première application Spring
Le but de cette mini-application est de créer des objets dont les propriétés initiales sont stockées dans le fichier de
configuration de Spring. Ce travail s’appuye sur le chapitre "Bean" du cours.
— Créer un projet Java
— Dans les propriétés du projet, ajouter toutes les librairies Spring nécessaires (Cf. pré-requis)
— Créer un package « metier » dans lequel se trouve une classe de nom Personne qui possède les attributs :
— private String nom ; // nom de l’individu
— private int age ; // age de l’individu
— Créer les accesseurs de la classe Personne
— Ajouter les 3 méthodes suivantes :
TP/BEAN/src/metier/Personne.java
// Affichage des informations de l’individu
public String toString() {
return "nom=[" +this.nom +"], age=[" +this.age +"]";
}
// Methodes appelees lors de l’initialisation/suppression du bean
public void init() {
System.out.println("init personne [" +this.toString()+"]");
}
public void close() {
System.out.println("destroy personne [" +this.toString()+"]");
}
— En s’appuyant sur le cours, créer le fichier de propriétés applicationContext.xml à la racine des sources du
projet (ou ailleurs dans le Classpath)
— En s’appuyant sur le cours, créer une classe Main à la racine des sources permettant de lire le fichier de
configuration de Spring et d’afficher les informations.
— Vérifier le comportement de l’application
— Ajouter dans la configuration de Spring un 2
`eme bean personne2
— Ajouter dans la classe de test Main plusieurs appels d’affichage de personne2
→Analyser les résultats de l’exécution : créations d’objets, appels de init(), close()
— Créer une classe voiture possédant les attributs marque, type et un attribut emprunteur de type Personne.
— En plus du constructeur par défaut, créer un constructeur de la forme : Voiture(String marque,String
type,Personne emprunteur)
— Cette fois-ci, la méthode d’affichage devient :
TP/BEAN/src/metier/Voiture.java
public String toString() {
return "Voiture : marque=[" +this.marque +"] type=[" +this.type
+"] emprunteur=[" +this.emprunteur +"]";
}
— Ajouter au fichier de configuration Spring le bean "voiture1" du cours
— Modifier la classe Main pour afficher le bean voiture1
→Analyser les résultats de l’exécution : créations d’objets, appels de init(), close()
3 IoC
Il s’agit à présent de mettre en exergue les avantages de l’inversion de contrôle offert par Spring.
— Dans un nouveau projet Java, écrire les 4 classes de l’étude de cas simple du cours portant sur la location de
véhicules
— Ecrire la classe de tests Main et constater le bon fonctionnement de l’application, en modifiant le type de
véhicule
— Dans un nouveau projet, ajouter l’intégration de Spring (modification de la classe Personne, applicationContext,
Main...)
→Analyser/comparer les résultats de l’exécution
2

4 AOP : Gestion des journaux
Le but de cette mini-application est de créer un système de gestion des journaux en associant Spring à la program-
mation par aspect.
— Créer un projet Java en important toutes les librairies Spring disponibles
— Ecrire l’exemple du cours sans AOP : classe Personne, configuration Spring, et classe de test
→Vérifier les résultats de l’exécution
— Intégrer les aspects éviqués en cours dans la configuration Spring
— Ecrire la classe MonLogger
→Analyser/comparer les résultats de l’exécution
— Modifier la classe MonLogger pour adapter vos journaux (écriture dans un fichier de logs par exemple)
5 JDBC : Avantages de Spring
Le but de cette mini-application est de vérifier les avantages de Spring JDBC : la séparation des couches, la gestion
des connexions...
Il est nécessaire d’utiliser la base de données Derby (Cf. pré-requis).
5.1 Méthode classique
— Créer un projet Java en important toutes les librairies Spring disponibles
— En vous inspirant des exercices précédent, créer la classe Personne
— A l’aide du cours, créer la classe Derby de connexion à la base
— Ecrire les classes d’Exception AgeNegativeException et PersonneNotFoundException
— Ajouter une méthode d’insertion d’une personne
→Tester le projet, les méthodes d’accès aux données (find, update...), les exeptions
5.2 JDBCTemplate
— Créer les packages dao et métier
— A l’aide du cours, écrire les interfaces IPersonneDao, IPersonneMetier, et leurs implémentations
— Ecrire le fichier de configuration de Spring
— Ecrire la classe de tests permettant de valider la mise à jour d’un individu
— Ajouter les méthodes de listing et d’insertion d’une personne
6 Application de gestion de location de véhicules
Cette application se base sur les exercices précédents.
Les données ’personnes’ et ’véhicules’ sont stockées dans une base Derby. Dans un premier temps et pour simplifier la
mise en oeuvre, les véhicules n’ont pas besoin d’être typés (voiture, camion, moto), et ils ne sont loués qu’à un seul
individu à la fois.
— Récupérer et lancer le projet contenu dans l’archive Application.tar.gz
— Créer l’interface dao IVehiculeDao contenant par exemple les prototypes louer(), retourner(), is_loue()
— Créer l’interface métier IVehiculeMetier permettant de gérer les véhicules
— Implémenter les classes/méthodes nécessaires à la gestion :
— d’insertion/suppression de voitures
— d’emprunt/retour de voitures
— de lister les voitures du parc (louées ou non)
— de lister les individus ayant loués une voiture
— ...
— Créer les classes de tests avec JUnit
— Créer une application interactive en ligne de commande permettant d’effectuer chaque opération
— Intégrer un système non intrusif de journalisation des opérations précédentes
3

7 Hibernate
Cette partie nécessite d’avoir déjà utilisé le framework Hibernate (Cf. http ://lipn.univ-
paris13.fr/∼fortier/Enseignement/Hibernate/).
De plus, la base de donnés location doit être en place (Cf. pré-requis)
— Créer un projet Spring avec les librairies nécessaires
— Ajouter les librairies Hibernate
— Créer les fichiers de mapping Personne et Voiture (à la main ou à l’aide des outils hibernate intégrés à Spring)
— A l’aide du cours, créer le fichier de configuration de Spring en intégrant les propriétés d’Hibernate
— Ecrire les interfaces métier et DAO permettant dans un premier d’effectuer des recherches de personnes
— Implémenter les interfaces en utilisant le template Spring Hibernate
— Créer les tests unitaires testant les fonctionnalités de recherche de personnes
— Continuer le projet en intégrant les fonctionnalités de gestion de location
4

8 Annexes
8.1 Tests unitaires - JUnits
Un test unitaire est une méthode permettant de tester une partie code (appelé unité). Le test consiste a vérifier
que le retour de l’exécution de la portion de code correspond a ce que l’on attend.
Il est exécuté indépendamment du programme en créant un environnement d’exécution spécifique à la portion de
code. Cela permet d’eviter de devoir recompiler tout un logiciel pour vérifier la correction d’un bug des fois assez
difficile à déclencher "manuellement" ou pour tester des fonctionnalités profondes dans le logiciel.
JUnits est un framework pour générer des tests unitaires qui est intégré à Netbeans.
Pour générer un test, il suffit de cliquer "Outils" →"Create Junits Tests" (sélectionnez Junit 4.x), puis de choisir la
classe contenant les méthodes à tester.
Tous les tests de chaque méthode sont créés. Il suffit à présent de modifier ces tests pour vérifier la validité des
méthodes.
TP/JUNITS/test/ClasseTest.java
@Test
public void testFaireQuelqueChose() {
System.out.println("Methode faireQuelqueChose : uppercase()");
// Creation d’une instance de la classe testee
Classe instance =new Classe();
// Initialisation du resultat attendu
String expResultat="TEST2";
// Lancement du test de la methode
String resultat =instance.faireQuelqueChose("test");
// Resultat du test de la methode faireQuelqueChose
assertEquals(expResultat,resultat);
}
8.2 Installer Netbeans et Glassfish
Dans le cas où l’on se trouve sur une machine ne disposant pas de Netbeans ou Glassfish, il peut suivre les
procédures suivantes qui lui permettront d’effectuer le TP.
Pour netbeans, décompiler l’archive située à :
http ://www-lipn.univ-paris13.fr/ fortier/Enseignement/Applications/netbeans-6.7.1_fr.tar.gz
L’application se lance avec le commande bin/netbeans (pensez à régler les droits d’execution). Pour glassfish, charger
l’archive disponible :
http ://www-lipn.univ-paris13.fr/ fortier/Enseignement/Applications/glassfish-installer-v2.1.1-b31g-linux-ml.jar
Entrez les commandes :
— java -Xmx256m -jar glassfish-installer-v2.1.1-b31g-linux-ml.jar
— cd glassfish
— chmod -R +x lib/ant/bin
— ./lib/ant/bin/ant -f setup.xml
5