Cycle de Formations

Technologique
avancées : Your partner of choice

Framework Spring
M. Belhassen OUESLATI
Ingénieur Java/J2EE

Travaux dirigés TD N°1

Passage vers Spring

Objectifs

 Développer un premier exemple de composants liés

 Détecter le besoin d'Ioc

Belhassen.oueslati@gmail.com Passage vers Spring

1. Cas pratique : « Gestion des contacts » (cahier technique)

1.1 Sujet
 Le but de cet exercice est de créer une application permettant de gérer une
liste de contacts.
 On doit pouvoir lister, ajouter, supprimer, modifier, rechercher ces contacts.

1.2 Analyse
 Dans un premier temps, avant l’écriture des premières lignes de codes, nous
allons définir les entités et les fonctionnalités requises pour notre application.

1.2.1 Définition des entités

 D’après le sujet, on a besoin de "gérer une liste de contacts" ;
 Cela signifie donc que l’on doit créer une classe Contact qui aura pour
attributs toutes les informations d’un contact : nom, prénom, …

1.2.2 Définition des fonctionnalités

 On a besoin d’ajouter, lister, supprimer nos contacts.

 Cas d’utilisation « Ajouter un contact » :

1. Entrée des informations du contact
2. Validation des entrées
a. Vérification de la conformité des informations (nom, prénom, …).
i. Si les données sont conformes, le programme ajoute le contact et
indique un message positif au client.
ii. Si les données ne sont pas conformes, le programme renvoie une
erreur à l’utilisateur

 Cas d’utilisation « Lister les contacts » :

1. Récupération de l’ensemble des informations du support de stockage
a. Si la récupération s’est bien passée
i. S’il existe au moins un contact dans le support de stockage, le
programme affiche la liste des contacts (nom, prénom, adresse,
email…).
ii. S’il n’existe aucun contact dans la base de données, le programme
affiche un message indiquant qu’aucun contact n’a été trouvé.
b. Si la récupération s’est mal passée, le programme renvoie au client un
message d’erreur logicielle.

Belhassen.oueslati@gmail.com Passage vers Spring

  Cas d’utilisation « Supprimer un contact » :
1. Liste des contacts affichée dans la console avec le numéro Id
correspondant
2. Choix du numéro Id du contact à supprimer
3. Le programme vérifie que le contact existe bien :
o Si le contact existe bien, le programme tente de supprimer le contact
demandé :
 Si la suppression a échoué, le programme renvoie à l’utilisateur
une erreur lui indiquant une erreur logicielle.
 Si la suppression a réussi, le programme renvoie à l’utilisateur un
message de confirmation de suppression du contact
o Si le contact n’existe pas, le programme renvoie un message indiquant
l’absence de ce contact dans le support de stockage.

1.2.3 Architecture
 Nous allons séparer au maximum les différents types de traitement de
l’application en tenant compte des explications du cours
(Présentation, métiers/Service, Dao, Persistance).

Belhassen.oueslati@gmail.com Passage vers Spring

 1. Couche Objets persistance : Classe Contact

 Cette couche est composée d'objets Java simples qui représentent les
données persistantes de l'application comme par exemple un client ou
une facture. Pour cette partie, nous utilisons la technologie Hibernate qui
va permettre de mapper ces objets avec la base de données.

 Nous y ajoutons la classe Contact avec, pour variables d’instances :

o String nom;
o String prenom;

 Ces variables doivent évidemment être déclarées en privées et des

getter/setter sont implémentés.

 Note : Hibernate permet une certaine indépendance vis à vis du SGBD

qu'on souhaite utiliser avec l'application développée.

Voici l'implémentation de la classe Contact : class Contact

public class Contact {

private String nom;

private String prenom;

public String getNom() {

public void setNom(String nom) {

this.nom = nom;
}

public String getPrenom() {

return prenom;
}

public void setPrenom(String prenom) {

this.prenom = prenom;
}

Belhassen.oueslati@gmail.com Passage vers Spring

 2. Couche Dao : Classe ContactDao

 Cette couche a pour objectif d'encapsuler et d'abstraire l'accès aux

données.

 Concrètement, les développeurs vont utiliser cette couche pour

récupérer, mettre à jour, supprimer ou insérer des nouvelles données.
L'utilité de cette couche est que le développeur va utiliser des fonctions
simples qui vont masquer toute la complexité sous jacente. Par exemple :
void createContact(Contact contact), boolean deleteContact(String
numero) ou List < Contact > getListContacts().

 Le développeur utilisateur de ces fonctions n'aura même pas à connaitre

les détails de l'implémentation, il ne saura même pas si la technologie
utilisée est Hibernate, SQL ou EJB3. Il ne verra que de simples fonctions
Java.

 On y place la classe ContactDao qui contiendra les méthodes suivantes

- void createContact (Contact c)
- boolean deleteContact(String numero)
- List < Contact > getListContacts().
-

 Nous ajoutons par ailleurs l’interface ContactDao implémentée par la

classe ContactDaoImp.

Voici l'interface ContactDao : interface ContactDao

public interface ContactDao {

void createContact(Contact contact);

boolean deleteContact(String numero);

List < Contact > getListContacts();

Belhassen.oueslati@gmail.com Passage vers Spring

 Voici l'implémentation de l’interface ContactDao :
class ContactDaoImplementation

public class ContactDaoImplementation implements ContactDao {

public void createContact(Contact contact) {

save(contact); (HIBERNATE)
}

public boolean deleteContact(String numero) {

delete(deleteContact); (HIBERNATE)

return true;
}

public List < Contact > getListContacts() {

return (List) loadAll(Contact.class); (HIBERNATE)

 Note : Comme vous vous en doutez, les développeurs ne verront jamais

l'implémentation, ils se contenteront d'utiliser l'interface ContactDAO. En
cas de changement de technologie, il suffira de réécrire seulement
l'implémentation, tout le reste du code n'aura pas à être migré.

Belhassen.oueslati@gmail.com Passage vers Spring

 3. Couche Service : Classe ContactService

 Cette couche contient la logique métier de l'application.

 Voici un exemple qui illustre la différence entre couche DAO et couche

service. La fonction deleteContact() dans la couche DAO va supprimer un
contact quel qu’il soit. Dans la couche service, nous allons ajouter le code
qui va gérer les règles particulières de l'application, par exemple, nous
allons peut être tester que le contact n'est pas un administrateur, dans le
cas où s'en est un, nous allons déclencher une exception qui indiquera
qu'une règle interdit la suppression de cet utilisateur particulier. Ce qu'il
faut bien saisir avec cet exemple, c'est que les DAO se chargent de gérer
la persistance des données de manière basique, la couche service elle y
ajoute la logique liée au métier.

 Nous créerons donc une classe ContactService qui fera définira les
méthodes :
- ajouterContact(Contact c)
- supprimerContact(Contact c)
- recupererListContacts()

 Afin de toujours garder un code propre, nous séparons les services grâce
aux notions d'interfaces :

Voici l’interface ContactService : interface ContactService

public interface ContactService {

void ajouterContact(Contact contact);

Boolean supprimerContact (String numero);

List < Contact > recupererListContacts ();

Belhassen.oueslati@gmail.com Passage vers Spring

 Voici l'implémentation de l’interface ContactService :
class ContactServiceImplementation

public class ContactServiceImplementation implements ContactService {

private ContactDao contactDao = new ContactDaoImp();

public void ajouterContact (Contact contact) {
Contact nouveauContact = null;

Etape d’initialisation de nouveauContact

contactDao.createContact(nouveauContact);
}

public boolean deleteContact(String numero) {

if (numero == null || numero.isEmpty())

{
Etape Génération d’une exception
}

return contactDao.deleteContact(numero);
}

public List < Contact > recupererListContacts () {

final List < Contact > contactList = contactDao.getListContacts();

return contactList;
}

getter/setter de contactDao

Belhassen.oueslati@gmail.com Passage vers Spring

 1.3 Réaliser l'exemple

 Exécuter la classe ContactServiceTest.java

Voici l'implémentation de la classe ContactServiceTest

public class ContactServiceTest {

public static void main(String[] args) throws Exception {

ContactService cs = new ContactServiceImplementation ();

List < Contact > contactList = cs. recupererListContacts ;

1.4 Question ?

 Qu'est ce qu'on remarque ?

 Si on veut utiliser une autre implémentation de ContactDao, qu'est ce qu'il faut

faire?

Belhassen.oueslati@gmail.com Passage vers Spring