PROJET JAVA BD MySQL

Présenté par :
Coumba DIA
Rodrigue TIANI
Encadré par :
Houssem Eddine LASSOUED
Année Universitaire: 2012-2013
MINI PROJET JAVA ET
BASE DE DONNEE

Mini-projetJAVA/BD ESPRIT/2013
DIA/TIANI TEL 4B1 Page 2
SOMMAIRE
SOMMAIRE..........................................................................................2
INTRODUCTION .................................................................................3
PHASE 1 : ETUDE ET SPECIFICATION...........................................5
I. ENONCE DU CAHIER DE CHARGES....................................................................... 5
II. Etude de l’existant.......................................................................................................... 6
a) Solutions existantes................................................................................................ 6
b) Critique de l’existant .............................................................................................. 8
c) Solution .................................................................................................................. 9
PHASE 2 : ANALYSE ET CONCEPTION .......................................10
I. Analyse......................................................................................................................... 10
a) Description de base .............................................................................................. 10
b) Spécification des besoins ..................................................................................... 10
c) Description détaillée............................................................................................. 11
d) Identification des cas d’utilisation et affectation des priorités............................. 11
II. Conception ................................................................................................................... 12
a) Diagramme de cas d’utilisation............................................................................ 13
1. Cas d’utilisation 1: S’authentifier................................................................... 13
2. Cas d’utilisation 2 : Remplir liste de présence ............................................... 14
3. Cas d’utilisation 3 : Consulter les absences.................................................... 16
4. Cas d’utilisation 4 : Gérer les absences.......................................................... 16
5. Cas d’utilisation 4.1 : Consulter absences...................................................... 17
6. Cas d’utilisation 4.2 : Annuler absences ........................................................ 17
7. Cas d’utilisation 4.3 : Imprimer listes d’absences.......................................... 18
8. Cas d’utilisation 4.4 : Envoyer des mails d’alertes aux étudiants .................. 19
9. Cas d’utilisation 4.5: Générer un graphe........................................................ 19
b) Diagramme de séquences..................................................................................... 20
1. Diagramme de séquences du CU « S’authentifier»....................................... 20
2. Diagramme de séquences du CU « Remplir liste de présence » ................... 21
3. Diagramme de séquences du CU « Consulter absences »............................ 21
4. Diagramme des séquences du CU « Annuler absences ».............................. 22

5. Diagramme de séquences du CU « Imprimer liste »..................................... 22
6. Diagramme de séquences du CU « Envoyer mails »..................................... 23
7. Diagramme de séquences du CU « Générer graphe »................................... 23
c) Diagramme de classes d’analyse.......................................................................... 24
Phase 3 : DEVELLOPEMENT, TEST ET VALIDATION ...............25
I. Développement............................................................................................................. 25
a) Systèmes et ressources : ....................................................................................... 25
b) Langage de programmation.................................................................................. 26
c) Plateforme ............................................................................................................ 26
d) Base de données : ................................................................................................. 27
II. TEST ET VALIDATION............................................................................................. 28
1. Interface d’accueil .......................................................................................... 28
2. Interface de l’enseignant................................................................................. 28
3. Interface de l’étudiant..................................................................................... 29
4. Interface du responsable ................................................................................. 30
CONCLUSION....................................................................................32
BIBLIOGRAPHIE/WEBOGRAPHIE ................................................33
Table des figures
Figure 1 Equinoxe 2008 ............................................................................................................. 7
Figure 2 Diagramme de cas d’utilisation ................................................................................. 13
Figure 3 Diagramme de séquences du CU « S’authentifier ».................................................. 20
Figure 4 Diagramme de séquences du CU « Remplir liste de présence »............................... 21
Figure 5 Diagramme des séquences du CU « Consulter absences »....................................... 21
Figure 6 Diagramme de séquences du CU « Annuler absences ».......................................... 22
Figure 7 Diagramme de séquences du CU « Imprimer liste » ................................................ 22
Figure 8 Diagramme des séquences du CU « Envoyer mails » .............................................. 23
Figure 9 Diagramme des séquences du CU « Générer graphe »............................................. 23
Figure 10 Diagramme de classe d’analyse............................................................................... 24
Figure 11 Interface de connexion............................................................................................. 28
Figure 12 Interface principale de l’enseignant......................................................................... 28
Figure 13 liste de présence....................................................................................................... 29
Figure 14 fiche d’absence de l’étudiant ................................................................................... 29
Figure 15 liste d’absence d’une classe ..................................................................................... 30
Figure 16 statistiques des absences par filière ......................................................................... 31
Figure 17 Interface d’envoi de mails........................................................................................ 31

INTRODUCTION
Sachant qu’un des critères majeurs d’un bon ingénieur est la polyvalence, un ingénieur
en réseaux télécoms doit être aussi un bon développeur.
C’est en ce sens que plusieurs modules de développement ont été implémentés dans notre
programme tel que le module JAVA/Base de données.
Afin de mieux ce familiariser avec la plateforme de développement JAVA, un mini projet
portant sur la « réalisation d’une application de gestion des absences à ESPRIT nous a été
affecté.
En génie logiciel, on distingue trois phases dans le cycle de vie d’un logiciel :
 la phase d’étude et de spécification,
 la phase de conception
 et la phase de développement.
Donc pour mener à bien notre étude on suivra ce procédé.

PHASE 1 : ETUDE ET SPECIFICATION
Dans cette première phase d’étude et spécification des besoins, on établit les
contraintes, les buts et les services du système.
En effet, nous commencerons par l’élaboration du cahier de charges ensuite nous entamerons
l’étude de l’existant.
I. ENONCE DU CAHIER DE CHARGES
L’intitulé : Développement d'un outil de gestion des absences des étudiants à ESPRIT.
L'objet : Elaboration d’une application permettant de gérer les absences des étudiants
ESPRIT.
Le commanditaire : ESPRIT dans le cadre du projet JAVABD
Le contexte : La réalisation d’une application de gestion des absences est opportune car
permettra aux enseignants de se passer des feuilles de présence et d’utiliser directement
l’application. Cela permettra aussi à la scolarité de gérer les absences avec souplesse.
La motivation : L'idée de ce projet est d’alléger la gestion des absences en automatisant tout
le processus.
Les enjeux : Sachant que tout le processus de gestion sera automatisé, Esprit gagnera du
point de vue espace de stockage ou d’archivage des feuilles d’absences et éventuellement du
budget qui lui a été consacré.
L'objectif technique : est d’automatiser tout le processus de gestion des absences des
étudiants.
Les objectifs économiques : sachant qu’on aura plus besoin de feuilles d’absences, le budget
réservé pour les rames de papiers et ainsi les cartouches d’impression pourra être redistribué.
Le délai : 12 semaines

Les marges de manœuvre : Dans le délai qui nous est imparti, nous essayerons de mettre au
point une application aussi complète que performante offrant les différentes fonctionnalités de
gestion des absences à ESPRIT.
Les données d'entrée : recueil d’information sur le procédé de gestion actuel.
Le périmètre : Notre projet sera définit par une application axée sur 3 interfaces ; à savoir
l’interface de gestion des enseignants, celle du personnel administratif et celle des étudiants.
Les invariants : lors de l’élaboration de l’application, les données de gestion resteront les
mêmes ; les changements s’articuleront autour de la forme.
Les contraintes : Les seules limites seront celle que nous fixerons la plateforme de
développement(JAVA) de notre application (software).
Les choix stratégiques : Nous avons choisi de structurer notre application en trois interfaces
principales sachant qu’on aura trois principaux intervenants. La plateforme de développement
utilisée sera celle de JAVA et on notera aussi une interaction avec une base de
données(WAMP) pour le traitement des données
Les livrables : Une application JAVA souple qui sera exploitable en local par la scolarité, les
enseignants ainsi que les étudiants pour la bonne gestion des absences à ESPRIT.
II. Etude de l’existant
Afin de mieux répondre aux besoins des futurs utilisateurs de notre application, la première
partie de notre étude portera sur les méthodes actuelles de gestion des absences, les
applications disponibles et leurs principales fonctionnalités. Cette partie nous sera d’une
utilité lors de la conception de l’application.
a) Solutions existantes
Plusieurs applications actuelles répondent aux besoins de gestion de des absences parmi
lesquelles on cite :

 Equinoxe2008:
Figure 1 Equinoxe 2008
Pour les profs, surveillants, ou toute autre autorité chargée de faire un suivi des
élèves, Equinoxe2008 pourrait bien leur être utile. Il s’agit d’un logiciel de gestion des
absences des élèves.
 Caractéristiques
Editeur : CYRANO54
Version : 1.0
Langue : Français
Système :
Windows 95
Windows 98
Windows Me
Windows 2000
Windows Vista
Licence :
gratuite

 Les principales fonctionnalités :
 Gestion des absences : il faut reconnaître que la tâche de suivi de chaque élève est
assez fastidieuse. De plus, celle-ci doit se faire quotidiennement. Mais comme la
technologie facilite la vie, il existe des logiciels qui peuvent assister dans cette
opération. Equinoxe2008 aide l’utilisateur dans la gestion des absences ainsi que tous
les actes relatifs à cette gestion. A titre d’illustration, l’application est capable de saisir
les absences, les retards, les excuses ainsi que les dispenses.
 Envoi de mails : en cas d’irrégularité d’un élève, le logiciel permet facilement
d’envoyer une lettre personnalisée à ce dernier. Pour faciliter la tâche de l’utilisateur,
il existe des modèles de lettres prédéfinies dans le logiciel. De plus, le programme est
capable d’envoyer des mails automatiquement. Il suffit de définir quelques critères et
il se charge du reste
 Interface : le logiciel Equinoxe2008 dispose d’une interface intuitive et conviviale.
Cette dernière facilite plus la manipulation de l’application. Ainsi, toute personne
ayant besoin de ce logiciel peut l’utiliser.
 Configurations requises:
• Systèmes d’exploitation: Windows 95, Windows 98, Windows Me, Windows 2000,
Windows Vista.
• Espace disque requis : 4 Mo.
• Connexion Internet : pour l’envoi des mails.
b) Critique de l’existant
Avantages :
• Ce logiciel est léger et ne consomme pas trop de ressources système.
• Il est en français.
• Il est entièrement gratuit.

Inconvénients :
• L’accès à ses fonctionnalités est assez compliqué.
• Toutes les fonctionnalités sont implémentées sur une même interface.
Plusieurs études de marché sur la question de la gestion des absences révèlent que les
applications actuelles :
• sont imbriquées dans les logiciels de gestion d’école, d’académie…
• prennent en compte qu’un utilisateur( le responsable de gestion) ;
• les fonctionnalités sont implémentées sur une même interface ;
• sont payantes en majorité
c) Solution
L’application que nous envisageons développer reproduira quelques fonctionnalités
offertes par les solutions précédemment citées. Ceci dit, elle représente aussi le noyau simple
mais extensible d’une future application plus riche, plus complète et plus conviviale.

PHASE 2 : ANALYSE ET CONCEPTION
La seconde phase de cycle de vie d’un logiciel consiste à représenter les fonctions du
système de manière à ce qu’elles soient facilement transformables en un ou plusieurs
programmes exécutables lors de la phase de réalisation. C’est une étape primordiale, qui nous
permettra de relier les fonctionnalités et le comportement de l’application avec l’ensemble de
services que l’utilisateur s’attend à avoir.
I. Analyse
a) Description de base
Ce projet consiste à réaliser une application qui permet de :
 Gérer les absences des étudiants à ESPRIT,
 Générer des rapports, des statistiques et des états des absences par étudiant, par classe
et par niveau d’étude.
b) Spécification des besoins
Afin de mieux répondre aux exigences du cahier des charges, il est indispensable définir :
 Les besoins fonctionnels :
Ces besoins englobent les fonctionnalités de base que devra offrir notre outil de gestion des
absences. Ainsi notre application devra permettre :
 L’identification des différents utilisateurs de l’application ;
 le remplissage des listes de présence pour chaque classe à chaque cours ;
 la consultation des absences enregistrées pour une classe ou un étudiant donné ;
 l’annulation d’une absence enregistrée en cas de justification par l’étudiant ;
 l’envoie de mails d’alertes aux étudiants absentéistes ;
 la génération de graphe, statistique du taux d’absentéisme par classe, par filière ou par
niveau d’étude.

 Les besoins optionnels :
L’interface de l’application doit répondre à un minimum de règles de conception des
interfaces hommes-machines, en plus pour un usage personnel et une meilleure confidentialité
des notions de sécurités s’imposent ; pour ce on définit les besoins optionnels suivants :
 une optimisation de l’interface graphique pour une meilleure convivialité ;
 l’impression d’une liste de présence ou d’une liste d’étudiants absents si le besoin se
présente ;
 le contrôle les entrées saisies (les champs obligatoires)
 la création d’un fichier d’aide aux utilisateurs
c) Description détaillée
Dans notre projet, on se propose de réaliser application pour la gestion des absences à
ESPRIT. Notre application interagira avec une base de donnée dans laquelle seront stockées
les informations tels que :
- Les identifiants des utilisateurs de l’application
- Les différentes tables participant à la gestion de l’application
Les principaux utilisateurs de notre application seront :
- Les enseignants
- Le(s) responsable(s) administratif(s)
- Les étudiants
d) Identification des cas d’utilisation et affectation des
priorités
Après étude des données du système, les cas d’utilisation et les acteurs que nous avons
eue a identifiés sont les suivants :

Cas d’utilisation Acteur(s)
S’authentifier Enseignant, Responsable administratif, Etudiant
Remplir listes de présence Enseignant
Consulter les absences Enseignant, Responsable administratif, Etudiant
Gérer les absences Responsable administratif
Annuler absence(s) Responsable administratif
Imprimer liste(s) d’absences Responsable administratif
Générer graphe(s) Responsable administratif
Envoyer des mails d’alertes aux
étudiants
Responsable administratif
Notons que le cas d’utilisation « Gérer les absences » imbrique les cas d’utilisation suivant:
- Consulter les absences
- Annuler absence(s)
- Imprimer listes d’absences
- Générer graphes
- Envoyer des mails d’alertes aux étudiants
II. Conception
Pour la conception de notre application, nous avons eu recours au langage de modélisation
objet unifié UML (Unified Modeling Language) dans le but de bénéficier de ce standard
incontournable.
Dans notre phase de conception nous nous sommes intéressés à trois diagrammes de
conception, à savoir :
 Le diagramme de cas d’utilisation,
 Le diagramme de séquences,
 Le diagramme de classes.

a) Diagramme de cas d’utilisation
Cette représentation nous permet d’avoir une vue globale sur les fonctionnalités du système
ainsi que les catégories d’utilisateurs.
Figure 2 Diagramme de cas d’utilisation
Description textuelle des cas d’utilisation
Nous allons maintenant décrire textuellement les différents cas d’utilisation de notre
diagramme s’y dessus :
1. Cas d’utilisation 1: S’authentifier
Scénario «S’authentifier»
 Objectif : Permettre à l’utilisateur à s’identifier et d’accéder à l’application.
 Acteurs concernés : Tous les utilisateurs de l’application
System
Enseignant(s)
Responsable(s) administratif(s)
Remplir liste(s) de présence
Gérer les absences
Consulter les absences
S'authentifier
<<include>>
<<include>>
<<include>>
Annuler absence(s)
Imprimer des listes d'absences
Générer graphe(s)
Envoyer des mails d’alertes aux étudiants
Etudiant(s)

 Pré-conditions :
- Bases de données crée, structurée et contenant les données d’authentification
- Application correctement installée et exécutée.
 Scénario nominal :
1-N.1.1. L’utilisateur introduit son login et son mot de passe dans les champs
appropriés.
1-N.1.2. L’utilisateur valide ses entrées en appuyant sur valider.
1-N.1.3. L’application vérifie l’authenticité des informations introduites par
l’utilisateur.
1-N.1.4. L’application affiche la fenêtre principale de l’utilisateur concerné
 Scénario alternatifs :
Deux scénarios alternatifs se présentent pour ce cas d’utilisation :
 Scénario alternatif 1 : «Ne pas remplir les données d’identifications»
1-A.1.1. L’utilisateur clique sur le bouton valider sans avoir introduit son nom
d’utilisateur et/ou son mot de passe
1-A.1.2. L’application indique le champ vide et qu’il faut le remplir
1-A.1.3. Le cas d’utilisation reprend à l’action 1-N.1.1 du scénario nominal
 Scénario alternatif 2 :«Fournir des données d’identification erronées»
Ce scénario débute avec l’échec de la comparaison des données d’identification fournis
par l’utilisateur avec celle stockées sur la base de données, soit à l’étape 1-N.3
1-A.2.1. Le cas d’utilisation reprend à l’action 1-N.1.1 du scénario nominal
2. Cas d’utilisation 2 : Remplir liste de présence
Scénario «Remplir liste de présence»

 Objectif : Permettre le remplissage d’une liste de présence d’une classe.
 Acteurs concernés : Enseignant.
- Enseignant authentifié
- L’enseignant entre les paramètres d’affichage de la liste voulue
- Liste de présence affichée
Ce scénario débute à l’affichage de la liste demandée :
2-N.1. L’enseignant entre les paramètres demandés pour l’affichage de la liste de
présence (classe, matière)
2-N.2. L’application affiche la liste en ce basant sur les paramètres spécifiés
2-N.3. L’enseignant choisi le numéro de la séance concernée.
2-N.4. L’enseignant coche les cases des périodes concernées pour chaque étudiant
présent.
2-N.5. L’enseignant valide les données introduites.
2-N.6. L’application vérifie que tous les champs obligatoires sont remplis
2-N.7. L’application enregistre les informations de la liste de présence dans la base
des données.
2-N.8. L’application retourne vers la fenêtre principale.
 Scénario Alternatif :
 Scénario alternatif 1 :« Valider une liste de présence sans sélectionner le
numéro de séance»
Ce scénario débute avec l’échec de l’étape 2-N.6.
2-A.1.1. L’application réaffiche la liste de présence en lançant un message
d’alerte
2-A.1.2. Le cas d’utilisation reprend à l’action 2-N.2. du scénario nominal

3. Cas d’utilisation 3 : Consulter les absences
Scénario «Consulter les absences»
 Objectif : Permettre la consultation des absences enregistrées.
 Acteurs concernés : tous les utilisateurs de l’application.
 Pré-condition :
- Utilisateur authentifié
4-N.3.1. L’utilisateur entre les paramètres demandés pour l’affichage de la liste
des étudiants (classe, matière)
4-N.3.2. L’application affiche une liste d’absence selon les paramètres entrés
(pour le cas de l’étudiant la liste de ses absences s’affiche directement après
son authentification)
4-N.3.3. L’utilisateur clique sur une absence de la liste afin d’afficher les détails
4-N.3.4. Détails affichés
 Scénario alternatif :
Ce cas d’utilisation n’a aucun scénario alternatif
4. Cas d’utilisation 4 : Gérer les absences
Scénario «Gérer les absences»
 Objectif : Permettre la gestion des absences.
 Acteurs concernés : Responsable administratif.

4-N..1. Le responsable sélectionne un des cas d’utilisations imbriqués.
4-N..2. Le responsable effectue les actions voulues puis revient à son menu
principal ou quitte l’application.
 Scénario Alternatif :
 Définit au niveau des cas d’utilisation imbriqués
5. Cas d’utilisation 4.1 : Consulter absences
Ce cas d’utilisation est idem que le cas d’utilisation 3(consulter absences)
6. Cas d’utilisation 4.2 : Annuler absences
Scénario «Annuler absences»
 Objectif : Permettre l’annulation d’une absence après une justification de l’étudiant
concerné.
 Acteur concerné : responsable administratif.
- Liste d’absence affichée selon les paramètres entrés
4-N.2.1. L’utilisateur sélectionne le ou les absences à supprimer.
4-N.2.2. L’application demande la validation de la suppression
4-N.2.3. L’utilisateur valide la suppression.
4-N.2.4. L’application demande la confirmation de la suppression
4-N.2.5. L’utilisateur confirme la suppression

4-N.2.6. L’application supprime le ou les absences sélectionnées de la base de
données.
4-N.2.7. L’application donne l’état de la suppression
7. Cas d’utilisation 4.3 : Imprimer listes d’absences
Scénario «Imprimer listes d’absences»
 Objectif : Permettre l’impression d’une liste de présence ou d’une liste d’étudiants
absents si le besoin se présente.
 Acteurs concernés : Utilisateur enregistré.
- la liste d’absences ou de présence des étudiants affichés selon les paramètres
(classe, matière)
- Imprimante connectée et bien configurée
4-N.4.1. L’utilisateur clique sur le bouton imprimer
4-N.4.2. L’application lance la fenêtre d’impression
4-N.4.3. L’utilisateur modifie les paramètres d’impression (s’il veut) et lance
l’impression de la liste
Ce cas d’utilisation n’a aucun scénario alternatif.

8. Cas d’utilisation 4.4 : Envoyer des mails d’alertes aux étudiants
Scénario «Envoyer des mails d’alertes aux étudiants»
 Objectif : Permettre l’envoie de mails d’alertes aux étudiants absentéistes.
 Acteurs concernés : Utilisateur enregistré.
- Liste d’absence affichée selon les paramètres entrés
4-N.4.1. Le responsable clique sur le bouton envoyer mail(s)
4-N.4.2. L’application lance la fenêtre d’édition de mail
4-N.4.3. Le responsable édite le mail puis l’envoi au(x) destinataire(s)
4-N.4.4. L’application donne l’état de l’envoi
9. Cas d’utilisation 4.5: Générer un graphe
Scénario «Générer un graphe»
 Objectif : Permettre à l’utilisateur de générer des graphiques suivant le taux
d’absentéisme
 Acteurs concernés : responsable administratif
4-N.5.1. Le responsable clique sur l’onglet graphe
4-N.5.2. L’application lance l’interface de génération de graphe

4-N.5.3. L’utilisateur paramètre le graphe à générer (données et type)
4-N.5.4. L’utilisateur valide sa demande de graphe.
4-N.5.5. L’application collète les données sélectionnées et génère le graphe dans
une nouvelle fenêtre.
b) Diagramme de séquences
Le diagramme de séquence représente la succession chronologique des opérations réalisées
par un acteur pour l’analyse des mesures et l’étude de différentes statistiques.
Ce diagramme montre les étapes qui doivent faire l’utilisateur pour pouvoir accéder à
l’application.
1. Diagramme de séquences du CU « S’authentifier»
Figure 3 Diagramme de séquences du CU « S’authentifier »
vérification login et passwordalt
[if][if]
: Utilisateur
Application Base de données
1 : Lancer application()
2 : Interface de connexion afficher()
3 : Demande d'authentification()
4 : Vérifier validité login et password()
5 : login et password corrects
6 : Afficher Interface de l'utilisateur
else
7 : login et password incorrects
8 : Afficher interface de connexion et message d'erreur()

2. Diagramme de séquences du CU « Remplir liste de présence »
Figure 4 Diagramme de séquences du CU « Remplir liste de présence »
3. Diagramme de séquences du CU « Consulter absences »
Figure 5 Diagramme des séquences du CU « Consulter absences »
S'authentifierRef
vérification saisiesalt
[if saisies correctes][if saisies correctes]
: enseignant
Application
Base de donées
1 : Entrer paramètres d'affichage de la liste()
2 : récupérer les données()
3 : données recupérées
4 : Afficher liste de présence
5 : valider liste remplie()
6 : sauvegarder saisies()
7 : saisiies sauvagardées()
8 : Afficher message de confirmation()
else
9 : réafficher la liste de présence et un message d’alerte()
end if
10 : retour ou quitter()
S'authentifierRef
: Utilisateur
1 : Entrer les paramètres pour l’affichage de la liste()
2 : Récupérer données()
3 : Données récupérées()
4 : Afficher lidte d'absence()
5 : Afficher les détails d'une absence()
6 : Détails affichés()
7 : Retour ou quitter()

4. Diagramme des séquences du CU « Annuler absences »
Figure 6 Diagramme de séquences du CU « Annuler absences »
5. Diagramme de séquences du CU « Imprimer liste »
Figure 7 Diagramme de séquences du CU « Imprimer liste »
S'authentifierRef:
Consulter absencesRef:
: Responsable administratif
1 : Sélectionner le ou les absences à supprimer()
2 : Demande de validation de la suppression()
3 : Valider la suppression()
4 : Supprimer absences sélectionnées de la base de données()
5 : Retour état de suppression()
6 : Afficher état de suppression()
S'authentifierRef:
Consulter absence(s)Ref:
1 : Cliquer sur le bouton imprimer()
2 : Lancer la fenêtre d’impression()
3 : Editer et lancer l’impression de la liste()

6. Diagramme de séquences du CU « Envoyer mails »
Figure 8 Diagramme des séquences du CU « Envoyer mails »
7. Diagramme de séquences du CU « Générer graphe »
Figure 9 Diagramme des séquences du CU « Générer graphe »
S'authentifierRef:
Consulter absencesRef:
1 : Cliquer sur le bouton envoyer mail()
2 : Lancer la fenêtre d’édition de mail()
3 : Editer et envoyer mail au destinataire()
4 : Afficher l’état de l’envoi()
S'authentifierRef:
1 : Cliquer sur l’onglet graphe()
2 : Lancer l’interface de génération de graphe()
3 : Entrer les paramètre du graphe()
4 : Collecter les données nécessaires()
5 : Données collectées()
6 : Génèrer le graphe()

c) Diagramme de classes d’analyse
Le diagramme de classes est généralement considéré comme le plus important dans un
développement orienté objet. Il représente l’architecture conceptuelle du système : il décrit les
classes que le système utilise, ainsi que leurs liens, que ceux-ci représentent un emboîtage
conceptuel (héritage) ou une relation organique (agrégation).
Figure 10 Diagramme de classe d’analyse
Enseignant
-id
+nom
+prenom
+login
+pwd
+Ajout absence(s): boolean
+lister absence(s): absence
Etudiant
-id: int
+nom: String
+prenom: String
+id_classe: int
+login: String
+pwd: String
+Lister absence(s): absence
Responsable
-id: int
+nom: String
+prenom: String
+login: String
+pwd: String
+Lister_absence(s): absence
+Annuler_absence(s): boolean
+Imprimer liste(): boolean
+Envoyer mail(s): boolean
+Générer graphe(s): void
classe
-id: int
+libelle: String
+niveau: int
+filiere: String
matiere
-id: int
+libelle: string
absence
-id: int
+id_etudiant: int
+id_enseignant: int
+id_matiere: int
+id_classe: int
+numseance: int
+date: date
+periode1: boolean
+periode2: boolean
Correspondance
+id_classe: int
+id_enseignant: int
+id_matiere: int
+1,n
+1,n
+1,n+1,1
+0,n
+1,1
+1,n+1,1
+1,n +1,1
+1,n
+1,1
+1,n
+1,1
+1,n
+1,1

Phase 3 : DEVELLOPEMENT, TEST ET
VALIDATION
Les deux premières phases de la réalisation de ce projet ont été le fruit de très longues
réflexions et de plusieurs recherches qui ont servi à concevoir un outil de gestion des
absences, nous entamons dans ce chapitre la phase de développement et de test et validation
de cette application.
Nous commencerons tout d’abord, par présenter l’environnement de développement afin de
justifier le choix de cet environnement.
Enfin, la phase s’achèvera par la validation et le test de l’application.
I. Développement
a) Systèmes et ressources :
Ce mini projet est affecté par binôme, n’ayant pas le même model d’ordinateur, nous avons
élaboré cette application avec deux systèmes et ressources différents :

b) Langage de programmation
Outre sa robustesse et sa performance, JAVA présente le grand avantage d'être portable sur
plusieurs plateformes (Windows, Linux,...). La sélection de JAVA comme notre langage de
programmation est justifiée par le fait qu’il :
 Utilise le concept orienté objet et s'apprête parfaitement à notre cas.
 Permet la création d'interfaces graphiques sophistiquées (menus déroulants, boutons,
cases à cocher,...) essentiels pour la conception de l'interface graphique de notre
application.
 Inclut le concept du modèle évènementiel. En effet il est capable de réagir à des
évènements et permet de faire de la programmation évènementielle.
 Du point de vue temps, les délais d'exécution qu'il offre sont acceptables.
c) Plateforme
La plateforme de développement utilisé est NetBeans IDE 6.7.1, le choix de cet IDE est
plutôt intuitif, car il comporte les outils nécessaires pour la réalisation des interfaces
graphiques ce que nous a facilité énormément le travail, de plus d’autres IDE tels que éclipse
nécessite l’installation des plugins.

d) Base de données :
Dans le cadre de notre projet, nous avons choisi WAMPServer pour stocker et gérer des
données de notre application. Dans cette base on distingue toutes les tables et les requêtes
nécessaires pour l’exécution de l’application.
WAMPServer (WAMP signifiant Windows Apache Mysql PHP) est une plate forme de
développement Web sous Windows. Il vous permet de développer des sites Web dynamiques
à l'aide du serveur Apache, du langage de scriptsPHP5 et d'une base de
données MySQL version 5. Il possède également PHPMyAdmin et SQLite Manager pour
gérer plus facilement vos bases de données. Il s'installe facilement et son utilisation très
intuitive permet de le configurer très rapidement (sans toucher aux fichiers de configuration).

II. TEST ET VALIDATION
1. Interface d’accueil
C’est la première interface de l’application qui permet au utilisateur de s’identifier.
Figure 11 Interface de connexion
2. Interface de l’enseignant
Nous avons présenté quelques interfaces de l’enseignant à savoir : l’interface principale de
l’enseignant et l’affichage de la liste de présence.
Figure 12 Interface principale de l’enseignant

Figure 13 liste de présence
3. Interface de l’étudiant
Après s’être identifié, l’étudiant accède directement à sa fiche d’absence et il peut voir les
détails en cliquant sur une absence.
Figure 14 fiche d’absence de l’étudiant

4. Interface du responsable
Nous présentons quelques interfaces du responsable gestion des absences à savoir : la liste
d’absence d’une classe donnée, l’interface de génération de graphe et l’interface d’envoi de
mails.
Figure 15 liste d’absence d’une classe

Figure 16 statistiques des absences par filière
Figure 17 Interface d’envoi de mails

CONCLUSION
Ce mini projet nous a été vraiment bénéfique car elle nous a permis d’illustrer les
notions acquises au cours de ce module.
Dans un premier temps, nous avons effectués une étude approfondie les besoins
fonctionnels su système de gestion des absences, cerné les différents contraintes et entamé la
phase d’analyse et de conception.
Ensuite nous avons réalisé notre application via le langage de programmation JAVA,
en utilisant l’IDE NetBeans et la base de bonnée de WAMPServer.
Sachant qu’aucun travail n’est parfait, nous espérons avoir atteint le maximuum des
objectifs que nous avions fixés.

BIBLIOGRAPHIE/WEBOGRAPHIE
http://fr.wikipedia.org/wiki/WampServer
http://www.javafr.com/codes

PROJET JAVA BD MySQL

Contenu connexe

Tendances

En vedette

Similaire à PROJET JAVA BD MySQL

Plus de Wilfried Tiani

Dernier

PROJET JAVA BD MySQL