M2PLS - M2EID TP SPRING

Transcription

1 M2PLS - M2EID TP SPRING Référence du document : Dernière modification : 25/11/11 Type de document : Travaux pratiques Rédacteur : Fortier Michael fortier@univ-paris13,fr L'objectif de ce TP est de réaliser une application de gestion de location de voitures à l'aide de Spring. Il s'agit de gérer des individus et un parc de voitures. L'application devra permettre, entre autres, de : de lister les voitures du parc de lister les individus ayant loués une voiture de permettre à des individus d'emprunter et de rendre des voitures Ce TP a pour vocation de permettre à l'étudiant de prendre en main une partie de la technologie Spring progressivement. SOMMAIRE PRE-REQUIS...2 L'environnement de développement...2 Les librairies nécessaires...2 La base de données...2 Étape 1 : Une première application Spring...3 Étape 2 : IoC...5 Étape 3 : Découplage des couches...7 Étape 4 : JDBCTemplate...8 Étape 5 : AOP...9 Étape 6 : Extension de l'application...9 Annexes Tests unitaires - Utiliser JUnits Installer Netbeans et Glassfish...11

2 PRE-REQUIS 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. A partir de l'étape 4, 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 : Les librairies nécessaires Les librairies nécessaires sont téléchargeables à cette adresse : Il s'agit : de certaines librairies Spring : org.springframework.beans release.jar org.springframework.context release.jar org.springframework.core release.jar... de la librairie Apache de journalisation : commons-logging jar de la librairie Derby permettant d'accéder aux données La base de données On utilise une base de donénes derby, installée avec Glassfish. Avant tou, il faut créer la base de nom "location", l'utilisateur "user" 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 25/11/11 Université Paris 13 Page 2 / 11

3 Étape 1 : Une première application Spring Le but de cette mini-application est de créer des objets «Personne» dont les informations initiales sont stockées dans le fichier de configuration de String. Créer un projet Java de nom TP_spring_1 Créer un dossier lib et ajouter toutes les libraires nécessaires (Cf. pré-requis) Dans les propriétés du projet, ajouter dans la zone «Bibliothèques» toutes les archives jar des librairies 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 ; // ages de l'individu Créer les accesseurs de la classe Personne Ajouter les 3 méthodes suivantes : // Affichage des informations de l'individu public String tostring() { return "nom=[" + this.nom + "], age=[" + this.age + "]"; // Méthodes appelées 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() + "]"); Créer le fichier de propriétés applicationcontext.xml à la racine des sources du projet (ou ailleurs dans le Classpath) <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" " <beans> <bean id="personne1" class="metier.personne" init-method="init" destroy-method="close"> <property name="nom"> <value>bob</value> <property name="age"> <value>40</value> </bean> <bean id="personne2" class="metier.personne" init-method="init" destroy-method="close"> <property name="nom"> <value>roger</value> <property name="age"> <value>20</value> 25/11/11 Université Paris 13 Page 3 / 11

4 </bean> </beans> Créer une classe main à la racine des sources permettant de lire le fichier de configuration de Spring et d'afficher les informations. Ce fichier peut ressembler à : import metier.personne; import org.springframework.beans.factory.listablebeanfactory; import org.springframework.beans.factory.xml.xmlbeanfactory; import org.springframework.core.io.classpathresource; /** * Classe de tests des TPs Spring fortier */ public class Main { /** args the command line arguments */ public static void main(string[] args) { ListableBeanFactory bf; bf = new XmlBeanFactory(new ClassPathResource("applicationContext.xml")); // Appel de la méthode testant le TP1 test_tp1(bf); /** * Méthode testant le TP1 de lecture des infos de configuration */ public static void test_tp1(listablebeanfactory bf) { Personne personne1 = (Personne) bf.getbean("personne1"); System.out.println("personne1=" + personne1.tostring()); Personne personne2 = (Personne) bf.getbean("personne2"); System.out.println("personne2=" + personne2.tostring()); personne2 = (Personne) bf.getbean("personne2"); System.out.println("personne2=" + personne2.tostring()); Remarque : Des classes de tests unitaires sont préférables à cette classe main (Cf. Paragraphe sur Junits) Analyser les résultats de l'exécution : le dernier appel de bf.getbean("personne2"); n'a pas provoqué la création d'un nouvel objet de type Personne. Sinon, les logs auraient affichés la méthode [init] Spring ne crée qu'un seul exemplaire (Singleton) nulle trace de la méthode [close] (garbage collector?) 25/11/11 Université Paris 13 Page 4 / 11

5 Étape 2 : IoC Il s'agit à présent de créer le bean représentant une voiture. Comme dans le TP précédent, créer une classe voiture possédant les attributs String marque, type et un attribut emprunteur de type Personne. Cette fois-ci, la méthode d'affichage devient : public String tostring() { return "Voiture : marque=[" + this.marque + "] type=[" + this.type + "] emprunteur=[" +this.emprunteur + "]"; En plus du constructeur par défaut, créer un constructeur de la forme : public Voiture(String marque,string type,personne emprunteur){ this.marque=marque; this.type=type; this.emprunteur=emprunteur; Modifier le fichier de configuration de Spring précédent : <beans>... <bean id="voiture1" class="metier.voiture" init-method="init" destroy-method="close"> <constructor-arg index="0"> <value>peugeot</value> </constructor-arg> <constructor-arg index="1"> <value>307</value> </constructor-arg> <constructor-arg index="2"> <ref bean="personne2"></ref> </constructor-arg> </bean>... </beans> Remarque : Ce fichier peut-être écrit de la même façon que le TP précédent : <beans>... <bean id="voiture1" class="metier.voiture" init-method="init" destroy-method="close"> <property name="marque"> <value>peugeot</value> <property name="type"> <value>307</value> <property name="propriétaire"> <ref bean="personne2"/> </bean>... </beans> 25/11/11 Université Paris 13 Page 5 / 11

6 Créer la méthode dans la classe main de test : public static void test_tp2(listablebeanfactory bf) { // récupération du bean [voiture1] Voiture Voiture1 = (Voiture) bf.getbean("voiture1"); System.out.println("Voiture1=" + Voiture1.toString()); Analyser le comportement : en exécutant la méthode test_tp1() puis test_tp2() en exécutant que test_tp2() en exécutant la méthode test_tp2() puis test_tp1() 25/11/11 Université Paris 13 Page 6 / 11

7 Étape 3 : Découplage des couches Créer un package Dao Créer une interface IDao de la forme : package dao; import java.util.list; import metier.personne; public interface IDao { // Liste tous les éléments List findall(); Cette interface a pour but de référencer l'ensemble des méthodes que l'on pourrait effectuer sur un objet type personne, voir voiture. C'est elle qui va permettre de découpler les couches métier (traitements) de la couche d'accès aux données. Elle sera à compléter au fur et à mesure de l'avancée du développement de l'application Créer une classe FichierDao qui implémente l'interface précédente : package dao; import public class FichierDao implements IDao { ListableBeanFactory bf; public List<Personne> findall() { bf = new XmlBeanFactory(new ClassPathResource("applicationContext.xml")); ArrayList liste = (ArrayList)bf.getBean("exemples"); return liste; Cette classe implémente la méthode findall() qui retourne l'ensemble des individus trouvés dans le bean "exemples" Configurer le fichier de configuration de Spring pour 1. faire apparaître le bean d'exemples d'individus 2. référencer l'implémentation de l'interface Dao <beans>... <bean id="fichierdao" class="dao.fichierdao" /> <bean id="exemples" class="org.springframework.beans.factory.config.listfactorybean"> <property name="sourcelist"> <list> <ref bean="personne1" /> <ref bean="personne2" /> </list> </bean> </beans> Créer une méthode dans la classe Main qui lit le fichier de configuration du bean fichierdao bean et qui liste tous les individus Vérifier le comportement de l'application 25/11/11 Université Paris 13 Page 7 / 11

8 Étape 4 : JDBCTemplate Pour cette étape, il faut utiliser la table location créée en pré-requis. Le but est de créer les méthodes d'accès de la couche DAO. Créer la classe DerbyDao qui implémente l'interface Idao package dao; import... public class DerbyDao implements IDao { private JdbcTemplate jdbctemplate; public void setdatasource(datasource datasource) { this.jdbctemplate = new JdbcTemplate(datasource); public int getcount() { return this.jdbctemplate.queryforint("select count(*) from location.personne"); public void insertpersonne(personne p) { this.jdbctemplate.update("insert into location.personne (nom,age) values (?,?)", new Object[]{p.getNom(),p.getAge()); public List<Personne> findall() { return this.jdbctemplate.query("select * from location.personne", new BeanPropertyRowMapper(Personne.class)); En plus de la méthode findall(), on trouve dans cette classe des méthodes de comptage et d'insertion d'individus qui pourront être utilisées par la suite. Modifier le fichier de configuration de Spring pour ajouter le bean d'accès à la base de données et le bean implémentant l'interface DAO. Il faut s'inspirer pour cela de l'exemple du cours (p. 57). Écrire une méthode de test dans le main pour insérer et lister les individus de la base 25/11/11 Université Paris 13 Page 8 / 11

9 Étape 5 : AOP Dans un premier temps, cette étape n'est pas à rattacher aux autres. Elle est autonome dans le sens où elle présente concrètement la programmation par aspect. Il s'agit de coder l'exemple que l'on peut trouver dans le cours (page 44 et suivantes) : la classe métier metier.personne la classe de journalisation aop.monlogger la classe service.messageservice le fichier de configuration de Spring Cette étape effectuée, il sera aisé d'intégrer les aspects au programme général de gestion de location de véhicules. Étape 6 : Extension de l'application A présent que les bases sont posées, l'application de gestion de location de voitures peut réellement débuter : 1. Créer dans la base de données une table "voiture" qui est composée au minimum des champs "marque", "type", référence de l emprunteur une table location composée au minimum des champs référence de la voiture, référence de l'individu, date d'emprunt et de retour 2. Créer les classes métiers et les implémentations DAO nécessaires pour gérer les fonctions : 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 des classes de tests (avec ou sans JUnit) 4. Créer une application interactive en ligne de commande permettant d'effectuer chaque opération 5. Intégrer un système non intrusif de journalisation des opérations précédentes (via des aspects) 25/11/11 Université Paris 13 Page 9 / 11

10 Annexes 1. Tests unitaires - Utiliser 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 a 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. Par exemple, on a généré le test de la méthode fairequelquechose() : Voila ce a quoi correspond chaque ligne : 1. On écrit sur la sortie console de test le nom du test 2. On initialise x qui sera envoyé en argument à la fonction testée 3. On créé un instance de fonction 4. On définit result qui est le résultat devant être retourné par la fonction 5. On teste la fonction a proprement dit en vérifiant que le résultat et le résultat attendu soit égaux Pour exécuter le test il suffit de faire un clic droit sur le projet et choisir test. Voila un exemple de retour : 25/11/11 Université Paris 13 Page 10 / 11

11 Dans cet exemple, la fonction fairequelqueche() de la classe testing.functiontest est passée avec succès alors que la fonction testmain() de la classe testing.maintest() a retourné un erreur de prototype. 2. Installer Netbeans et Glassfish Dans le cas ou l'étudiant se trouve sur une machine sous Linux 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 à : L'application se lance avec le commande bin/netbeans (pensez à régler les droits d'execution). Pour glassfish, charger l'archive disponible : 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 25/11/11 Université Paris 13 Page 11 / 11