Académique Documents
Professionnel Documents
Culture Documents
Sujet :
Remerciements
Il nous est agréable de nous acquitter d’une dette de reconnaissance auprès de toutes les
personnes dont l’intervention au cours de ce projet a favorisé son aboutissement.
Tout d’abord nous adressons nos vifs remerciements à notre encadrant Monsieur
KRIOUILE pour ses directives précieuses et ses conseils pertinents qui nous ont été d’un
appui considérable dans la réalisation de notre projet.
Nous ne saurions oublier dans nos remerciements tout le cadre professoral de l’ENSIAS,
pour la formation consistante qu’il nous a prodiguée.
Que tous ceux qui nous ont aidés, de prés ou de loin, trouvent ici l’expression de nos
sentiments les meilleurs.
Enfin, nous présentons notre profond respect aux membres du jury notamment Monsieur
ELKETTANI pour leur bienveillance à vouloir évaluer notre travail
Résumé :
Nous proposons dans le cadre de ce projet de fin d’études, d’appliquer la méthode 2TUP
au problème de la gestion des ventes de la société AGRI.
C’est pour ça que nous avons choisi d’axer notre travail sur une méthode de
développement qui est née de travaux poussés vers la standardisation et la flexibilité, et ce
pour répondre aux contraintes actuelles de gestion des développements.
Abréviation Signification
Remerciements............................................................................................................................3
Résumé........................................................................................................................................4
Liste des abréviations..................................................................................................................5
Liste des figures...........................................................................................................................6
Liste des tableaux........................................................................................................................7
Introduction générale...............................................................................................................10
1.1 Le contexte de travail................................................................................................10
1.2 Objectifs....................................................................................................................10
1.3 Comparaison entre les différentes approches............................................................11
1.3.1 Modélisation......................................................................................................11
1.3.2 Conduite de projet.............................................................................................11
1.4 Présentation de l’application à réaliser......................................................................11
Description de la méthode 2TUP............................................................................................12
2.1 Définition d’un processus de developpement logiciel...............................................13
2.2 Le processus unifié....................................................................................................13
2.3 Le processus 2TUP....................................................................................................14
2.4 Un processus de modélisation avec UML.................................................................16
Chapitre 1.................................................................................................................................18
Analyse et Conception.............................................................................................................18
I- Etude préliminaire...................................................................................................................18
1- Présentation du projet à réaliser.........................................................................................18
2- Recueil des besoins fonctionnels.......................................................................................18
3- Choix techniques................................................................................................................19
4- Identification des acteurs...................................................................................................20
5- Identification des messages................................................................................................21
6- Modélisation du contexte...................................................................................................21
II- Capture des besoins fonctionnels..........................................................................................23
1- Déterminer les cas d’utilisations........................................................................................23
1-1 Utilisation d’outils de génération de diagrammes UML..............................................23
1-2 Identification des cas d’utilisations..............................................................................24
Bien que des méthodes de développement existent depuis 30 ans (Merise, SADT), nous ne
pouvons constater aujourd’hui l’existence d’une règle qui soit à la fois formelle et commune aux
différentes cultures.
Par ailleurs, des méthodes séquentielles comme celles se basant sur le cycle en V, ont montré
leur limite dans un environnement régi par des changements réguliers, impliquant une impossibilité
à revenir en arrière, et de ce fait, laissant une très petite marge à l’erreur.
Sur cet élan, les spécialistes ont aussi pensé à unifier non pas les processus, mais plus
exactement les meilleures pratiques de développement orienté objet.
1.2 Objectifs
Notre but est d’appliquer une méthode rigoureuse de conduite d’un projet réel. Le projet en
question concerne la gestion des ventes.
Ce projet a pour objectif principal de proposer une solution à un problème concret, et ceci en
partant d’une définition des besoins. Nous espérons à travers celui-ci, démontrer l’importance de
l’application d’une méthodologie de développement, et aussi permettre par la suite que ce produit
puisse être évolutif et facilement maintenable par des intervenants tiers.
Une méthode semi-itérative est apparut (RAD) pour pallier aux carences de ce dernier.
L’itératif s’est ensuite imposé, parce qu’il réduit la complexité de réalisation des phases, en
travaillant par approches successives et incrémentales.
Une méthode fortement axée sur l’itératif et le modèle UML est alors apparut, il s’agit de UP
(Unified Process). Cette méthode comme son nom l’indique, a été le fruit de travail de plusieurs
personnes voulants « unifier » les différentes méthodes objets existantes à ce moment comme
Booch, OMT et OOSE.
On constate aujourd’hui, l’émergence d’une nouvelle approche : les méthodes agiles (Agile
Modeling). C’est des méthodes itératives à planification souple qui leur permettent de s’adapter à la
fois aux changements du contexte et de spécifications du projet. (Chromatic, 2005)
De nos jours, une des tendances les plus en vue et qui concerne tout les secteurs de
développement, est l’informatisation.
Le projet que nous proposons nous permettra de faciliter la gestion de ventes de la société, à
travers la conception d’un logiciel avec une méthode que nous allons présenter.
Comment faire participer le client au développement afin de capter les besoins de celui-ci
Comment éviter des dérives et de mauvaises estimations qui vont allonger les coûts et le temps
de développement.
Comment vais-je procéder pour que le produit soit évolutif et facilement maintenable.
Nous pouvons citer à ce propos les méthodes de développement objet suivantes : 2TUP, RUP,
XP, AUP et OpenUP.
Notre choix s’est porté vers la méthode 2TUP, du fait de son approche nouvelle, originale.
Notre projet est basé sur un processus de développement bien défini qui va de la détermination
des besoins fonctionnels attendus du système jusqu’à la conception et le codage final.
Ce processus se base lui-même sur le Processus Unifié (Unified Process) qui est devenu un
standard général réunissant les meilleures pratiques de développement.
Cette méthode ne se base aucunement sur un processus linéaire mais bien, sur un
développement itératif et incrémental.
Nous allons d’abord définir les différents concepts qui vont être utilisés dans ce document.
Un processus définit une séquence d’étapes, en partie ordonnées, qui concourent à l’obtention
d’un système logiciel ou à l’évolution d’un système existant.
L’objet d’un processus de développement est de produire des logiciels de qualité qui répondent
aux besoins de leurs utilisateurs dans des temps et des coûts prévisibles. (Rocques & Vallée, 2004)
itérative et incrémentale : la méthode est itérative dans le sens où elle propose de faire des
itérations lors de ses différentes phases, ceci garantit que le modèle construit à chaque phase ou
étape soit affiné et amélioré. Chaque itération peut servir aussi à ajouter de nouveaux incréments.
conduite par les cas d’utilisation : elle est orientée utilisateur pour répondre aux besoins de
celui-ci.
centrée sur l’architecture : les modèles définit tout au long du processus de développement vont
contribuer à établir une architecture cohérente et solide.
pilotée par les risques : en définissant des priorités pour chaque fonctionnalité, on peut
minimiser les risques d’échec du projet.
La gestion d’un tel processus est organisée d’après les 4 phases suivantes :
Pré-étude (Inception) : c’est ici qu’on évalue la valeur ajoutée du développement et la capacité
technique à le réaliser (étude de faisabilité).
Elaboration : sert à confirmer l’adéquation du système aux besoins des utilisateurs et à livrer
l’architecture de base.
Notons que ces différentes étapes (ou disciplines) peuvent se dérouler à travers plusieurs
phases.
Le processus unifié doit donc être compris comme une trame commune des meilleures
pratiques de développement.
On dit de la méthode UP qu’elle est générique c.à.d. qu’elle définit un certain nombre de
critères de développement, que chaque société peut par la suite personnaliser afin de créer son
propre processus plus adapté à ses besoins.
2TUP signifie « 2 Track Unified Process» .C’est un processus qui répond aux
caractéristiques du Processus Unifié. Le processus 2TUP apporte une réponse aux contraintes
de changement continuel imposées aux systèmes d’information de l’entreprise. En ce sens, il
renforce le contrôle sur les capacités d’évolution et de correction de tels systèmes.
« 2 Track» signifie littéralement que le processus suit deux chemins. Il s’agit des «
chemins fonctionnels » et « d’architecture technique », qui correspondent aux deux axes de
changement imposés au système d’information.
La capture des besoins fonctionnels, qui produit un modèle des besoins focalisé sur le
métier des utilisateurs.
L’analyse.
La conception générique.
La conception préliminaire.
La conception détaillée.
Le codage.
L’intégration.
UML unifie à la fois les notations et les concepts orientés objet.il ne s’agit pas d’une
simple notation, mais les concepts transmis par un diagramme ont une sémantique précise et
sont porteurs de sens au même titre que les mots d’un langage, c’est pour ça qu’UML est
présenté parfois comme une méthode alors qu’il ne l’est absolument pas.
UML unifie également les notations nécessaires aux différentes activités d’un processus
de développement et offre, par ce biais, le moyen d’établir le suivi des décisions prises, depuis
la définition des besoins jusqu’au codage. (Roques, 2006)
Le diagramme de classes : sûrement l’un des diagrammes les plus importants dans un
développement orienté objet. Sur la branche fonctionnelle, ce diagramme est prévu pour
développer la structure des entités manipulées par les utilisateurs.
Le diagramme d’états : représente le cycle de vie d’un objet. Il spécifie les états
possibles d’une classe et leur enchainement.
I-Etude préliminaire
L’étude préliminaire (ou Préetude) est la toute première étape du processus 2TUP. Elle
consiste à effectuer un premier repérage des besoins fonctionnels et opérationnels, en utilisant
principalement le texte, ou diagrammes très simples. Elle prépare les activités plus formelles
de capture des besoins fonctionnels et de capture techniques.
Gestion du catalogue :
Ce catalogue est mis à jour tous les 6 mois par la direction de la
société AGRI (Modification des prix unitaires des produits
existants ou Ajout/Suppression de produits).
Gestion du stock :
Chaque agence de la société AGRI gère son propre stock.
Gestion de la livraison :
Un produit n’est livré que si la quantité commandée est disponible
dans le stock de l’agence.
Un contrôle est effectué sur les informations du client et qui sont
portées sur le bon de livraison pour vérifier l’état de la remise.
Seul les clients de types détaillants ont droit à une remise.
Gestion de la facturation :
Le service de facturation établie une facture par bon de livraison
reçu.
La comptabilité reçoit la facture et met à jour le journal de ventes
de la société AGRI le lendemain de la transaction de vente.
3- Choix techniques
Voici les choix techniques qui ont été adoptés pour le projet :
o La modélisation avec UML.
Définition : un acteur représente l'abstraction d'un rôle joué par des entités externes
(utilisateur, dispositif matériel ou autre système) qui interagissent directement avec le système
étudié.
6- Modélisation du contexte
A partir des informations obtenues lors des deux précédentes étapes, nous allons
modéliser le contexte de notre application. Ceci va nous permettre dans un premier temps, de
définir le rôle de chaque acteur dans le système
Utilisateurs finaux Description des besoins fonctionnels
S’authentifier
S’authentifier
Proposer de nouveaux produits.
Consulter le catalogue
Vendeur d’une agence L’application doit permettre au vendeur d’une agence de :
S’authentifier
Etablir le bon de commande, ainsi que le bon de
livraison des produits commandés par un client de
l’agence.
Modifier le stock de l’agence concerné.
Consulter le catalogue
S’authentifier.
Créer/Modifier la fiche client d’un client d’une
agence de la société.
Etablir la facture pour les produits livrés.
Consulter le catalogue.
Comptable L’application doit permettre à un comptable du service de
comptabilité de :
S’authentifier.
Mettre à jour le journal de ventes de la société
AGRI.
Membre de la direction L’application doit permettre à un membre de la direction
de :
S’authentifier.
S’authentifier.
Créer des profils d’utilisateurs de l’application.
Attribuer des droits et des privilèges selon les
utilisateurs du système.
STAR UML : c’est un outil gratuit écrit avec Java, nous l’avons utilisé au début puis
nous l’avons délaissé pour sa lourdeur et son interface peu intuitive.
Bouml : sûrement l’outil le plus léger sur le marché, il est très puissant et agréable à
utiliser, et en plus il est gratuit.
Reçoit : Les
propositions
de nouveaux produits
en provenance du
fournisseur
Reçoit : La demande
de Création/
modification des
informations des
clients de la part d’une
des agences de la
société.
Reçoit : La commande
du client de la part du
client ainsi que
l’approuvation des
informations du client
de la part du service
de facturation.
Reçoit : Bon de
livraison
Reçoit : facture
Acteurs : Utilisateur.
Scénario nominal : Ce cas d’utilisation commence lorsque l’utilisateur saisi son login
et son mot de passe.
Enchaînements alternatifs :
Acteurs : Administrateurs
Résumé : le client effectue la demande auprès d’une des agences, l’agence transmet la
demande au service de facturation pour traitement
Enchaînements alternatifs :
Exceptions :
Résumé : le client effectue la commande auprès d’une des agences, après avoir vérifié
les informations du client auprès du service de facturation, le client rempli le bon de
commande
Scénario nominal : Ce cas d’utilisation commence lorsque le client vient passer une
commande auprès d’une agence.
Enchaînements alternatifs :
Exceptions :
Résumé : l’agence vérifie l’état du stock et vérifie les infos client auprès du service de
facturation pour savoir l’état de la remise et après elle établit le bon de livraison
Exceptions :
Résumé : le service de facturation établit une facture à chaque bon de livraison reçu
ensuite l’envoi au comptable pour l’écrire au journal de ventes
Enchaînements alternatifs :
Exceptions :
La structuration des cas d’utilisations se fait par domaine d’expertise métier c.à.d. les
éléments contenus dans un package doivent représenter un ensemble fortement cohérent et
sont généralement de même nature et de même niveau sémantique.
Gestion client
Gérer les commandes du client Agence, Service de facturation
Gestion de la livraison
Gérer la facturation Service de facturation
Agences
Application
Comptabilité
Internet
Application
LAN
Serveur
Application Application
Base de données
LAN
IV-Analyse
1- Développement du modèle statique
Le développement du modèle statique constitue une étape importante de la phase de
conception. Ce modèle rassemble les différentes classes et associations du système. Cette
partie va nous permettre d’illustrer les principales constructions du diagramme de classes
UML durant l’étape d’analyse. Le diagramme de classes a toujours été le diagramme le plus
important dans toutes les méthodes orientées objet. C’est également celui qui contient la plus
grande gamme de notation et de variantes. Les diagrammes de classes expriment de manière
générale la structure statique d’un système, en terme de classes et de relations entre ces
classes. De même qu’une classe décrit un ensemble d’objets, une association décrit un
ensemble de liens ; les objets sont instances de classes et les liens sont instances des relations.
Cette partie va nous permettre d’illustrer l’utilisation des concepts dynamiques d’UML et
des diagrammes associés en phase d’analyse en décrivant des scénarios mettant en jeu un
ensemble d’objets échangeant des messages. Ces interactions seront décrites au moyen de
diagrammes de séquence qui met l’accent sur la chronologie des messages.
Il faut signaler que tous les scénarios possibles ne peuvent être énumérés et décrits du fait
qu’ils en existent beaucoup. C’est pour cette raison que nous allons faire une description des
scénarios les plus pertinents.
a) Scénario d’authentification :
On recourt au concept de machine à états finis, qui consiste à s’intéresser au cycle de vie
d’un objet générique d’une classe particulière au fil de ses interactions avec les autres classes,
dans tous les cas possibles. Cette vue locale d’un objet, décrivant comment il réagit à des
événements en fonction de son état courant et passe dans un nouvel état, est représentée
graphiquement sous forme d’un diagramme d’états.
1- Outils de développement :
1-1 NetBeans
NetBeans est un environnement de développement intégré (EDI), placé en Open
Source par Sun. En plus de Java, NetBeans permet également de supporter différents autres
langages, comme C, C++, JavaScript, PHP, HTML … Il comprend toutes les
caractéristiques d'un IDE moderne (éditeur en couleur, projets multi-langage, refactoring,
éditeur graphique d'interfaces et de pages Web).
Conçu en Java, NetBeans est disponible sous Windows, Linux, Solaris, Mac OS X ou
sous une version indépendante des systèmes d'exploitation (requérant une machine virtuelle
Java). Un environnement Java Development Kit (JDK) est requis pour les développements en
Java.
L'IDE Netbeans s'enrichit à l'aide de plugins.
1-2PowerAMC
PowerAMC est un logiciel de conception créé par la société SDP, qui permet de
modéliser les traitements informatiques et leurs bases de données associées.
PowerAMC permet de réaliser tous les types de modèles informatiques. Il reste un des
seuls qui permet de travailler avec la méthode Merise. Selon Riff News, cela permet
d'améliorer la modélisation, les processus, le coût et la production d'applications.
Figure 27:PowerAMC
La couche « Métier » est la logique métier de l’application, elle est le coeur et c’est elle
qui définit toutes les règles régissantes au fonctionnement de l’application.
a) Le stockage de données : La technique choisie pour persister les données est :
la sérialisation. Une technique plus aboutie aurait été un meilleur choix comme : le
mapping Objet/Relationnel avec un outil comme Hibernate. Cependant,
l’apprentissage de cet outil demande un temps supplémentaire. Mais la solution de la
sérialisation réponds largement à nos besoins pour ce projet, c’est pour ça que nous
avons jugé pertinent de la garder.
b) La couche Métier :
Voici quelques figures représentants un échantillon du code source de cette couche :
Figure 29:Classe Saisie produit qui permet l’insertion d’un nouveau produit dans le catalogue
c) La couche Présentation :
3- Conclusion :
Nous pouvons constater que l’ajout de nouvelles fonctionnalités peut être simplifié, pour
peu qu’on respecte bien les étapes définies par 2TUP. Ça demande de faire une itération
complète ou partielle selon le besoin, du cycle Y, et ne pas succomber à la tentation de
toucher rapidement au code.
Webographie
http://laurent-audibert.developpez.com/Cours-UML/html/Cours-UML.html
http://uml.free.fr/index-cours.html
http://java.developpez.com/cours/