• ABOUT US

À propos du Centre Hospitalier Marriott

Contexte du projet

Ce projet a été réalisé dans le cadre d’un projet académique en développement logiciel. Objectif : créer une application de gestion hospitalière complète en utilisant des technologies modernes et en respectant les principes de programmation orientée objet.

Le projet simule un véritable Centre Hospitalier qui permet de :

Gérer les médecins

Gérer les patients

Gérer les rendez-vous

Enregistrer des prescriptions

Gérer différents types de comptes : Admin, Médecin, Patient (à venir)

Technologies utilisées

JavaFX → pour la construction de l’interface graphique

MySQL → base de données relationnelle

JDBC → connexion entre l’application Java et MySQL

CSS léger → pour la personnalisation de l’apparence

Structure orientée POO (Programmation orientée objet)

Objectifs pédagogiques

Apprendre à créer une interface graphique multi-fenêtres et multi-rôle.

Mettre en place une connexion sécurisée avec base de données.

Comprendre la logique de navigation dans une application de gestion.

Gérer des interactions entre plusieurs entités : Médecin, Patient, Rendez-vous.

Ajouter des éléments de personnalisation visuelle : images de fond, design de boutons.

Pourquoi ce projet est intéressant ?

Il représente un cas réel et concret de gestion multi-utilisateur.

Il mêle base de données + interface graphique + POO.

Il m’a permis d’apprendre à Gérer les formulaires JavaFX

Il m’a permis d’apprendre à Manipuler les données avec JDBC et SQL.

Gérer différents types de comptes : Admin, Médecin, Patient (à venir)

Le fichier Main.java est le point d'entrée de l'application JavaFX. C’est la classe qui lance l’application grâce à launch(args) et qui ouvre la fenêtre d’accueil principale avec les boutons de connexion pour Admin, Médecin et Patient.

J’ai construit la page d’accueil dans Main.java en utilisant un VBox pour organiser les boutons verticalement et un StackPane pour pouvoir mettre une image en arrière-plan avec une couche sombre, et par-dessus le contenu.

Chaque bouton de la page d’accueil appelle la méthode showLoginForm() ou show() d’un contrôleur spécifique (AdminLoginController, MedecinLoginController, RendezVousController). Chaque contrôleur ouvre une nouvelle Stage (fenêtre indépendante).

J’utilise principalement :
  • VBox pour empiler verticalement les éléments (boutons, labels, formulaires)
  • StackPane pour mettre une image en fond sous le contenu.

Parce que VBox permet de disposer simplement les boutons verticalement, avec un espacement régulier (spacing) entre eux, et un alignement propre, ce qui convient parfaitement pour un menu de navigation simple.

J’ai utilisé un StackPane, qui permet d’empiler plusieurs éléments : j’ai mis un ImageView contenant l'image logo.png en fond, et par-dessus, j’ai ajouté une couche sombre (Rectangle semi-transparent), puis le contenu (VBox ou autres). Chaque fenêtre utilise ce même principe.

StackPane est un conteneur JavaFX qui permet de superposer plusieurs éléments. Je l’ai utilisé pour pouvoir mettre :
  • l'image de fond
  • une couche sombre pour la lisibilité
  • le contenu (boutons, formulaires).
Cela donne un effet visuel agréable tout en gardant l’interface lisible.

Pour la fenêtre d’accueil (Main.java), la taille de la scène est de 600 x 500 pixels.
Pour les autres fenêtres, les tailles varient selon le contenu :
  • Admin : 300x300, 300x200
  • Médecin : 300x250, 400x300, etc.

J’utilise un VBox avec setAlignment(Pos.CENTER) ou Pos.CENTER_LEFT selon le besoin, et je joue aussi avec le padding (marges internes) pour les décaler un peu vers la droite quand souhaité.

Le padding permet de laisser de l’espace entre le contenu et les bords de la fenêtre, pour que les éléments (boutons, labels) ne soient pas collés aux bords et que l'interface soit plus aérée et agréable à utiliser.

Grâce à la classe Database.java.
Cette classe contient une méthode connect() qui retourne un objet Connection en utilisant le driver JDBC pour MySQL.
Chaque contrôleur (Admin, Médecin...) appelle Database.connect() pour obtenir cette connexion.

J’utilise JDBC (Java Database Connectivity) avec le driver MySQL mysql-connector-java.jar.
Il permet de faire le pont entre Java et une base MySQL.

Database.java est une classe utilitaire que j’ai créée.
Elle se trouve dans le dossier principal de l’application.
Elle sert à centraliser la gestion de la connexion : je ne recode pas la connexion dans chaque contrôleur, j’appelle simplement Database.connect().

Exemple dans listerMedecins() (AdminController) ou listerPatients() (MedecinController) :
  1. J’ouvre une Connection conn = Database.connect();
  2. Je crée un Statement stmt = conn.createStatement();
  3. Je fais ResultSet rs = stmt.executeQuery("SELECT * FROM table");
  4. Je parcours les résultats avec while(rs.next()).

Dans la méthode enregistrerMedecin(), j’utilise un PreparedStatement : 
String sql = "INSERT INTO medecin (nom, specialite) VALUES (?, ?)";
PreparedStatement stmt = conn.prepareStatement(sql);
stmt.setString(1, nom);
stmt.setString(2, specialite);
stmt.executeUpdate();
Cela permet d’ajouter un nouveau médecin.

Dans supprimerRendezVous(), je fais :
PreparedStatement stmt = conn.prepareStatement("DELETE FROM rendezvous WHERE id = ?");
stmt.setInt(1, id);
stmt.executeUpdate();
Cela supprime l’enregistrement correspondant.

Pour plusieurs raisons :
  • Sécurité : PreparedStatement évite les injections SQL.
  • Lisibilité : on peut réutiliser la même requête avec différents paramètres.
  • Performances : le serveur peut optimiser l'exécution.

J’ai créé les tables suivantes :
  • admin (id, username, password)
  • medecin (id, nom, specialite)
  • patient (id, nom)
  • prescription (id, id_medecin, id_patient, contenu)
  • rendezvous (id, date_rdv, id_medecin, id_patient)

CREATE TABLE prescription (
    id INT AUTO_INCREMENT PRIMARY KEY,
    id_medecin INT,
    id_patient INT,
    contenu TEXT,
    FOREIGN KEY (id_medecin) REFERENCES medecin(id),
    FOREIGN KEY (id_patient) REFERENCES patient(id)
);
Chaque prescription est liée à un médecin et à un patient.

Parce qu’une prescription est rédigée par un médecin.
Cela permet de savoir quel médecin a prescrit quoi à quel patient, ce qui est essentiel pour le suivi médical et la traçabilité.

Dans le bouton "Se connecter en tant qu’Admin", je fais apparaître une fenêtre avec :
  • un champ "Nom d’utilisateur"
  • un champ "Mot de passe"
Quand l’utilisateur clique sur "Se connecter", je vérifie le couple nom + mot de passe en consultant la table admin dans la base.

Si les identifiants sont corrects → la fenêtre "Menu Admin" s’ouvre.
Sinon → message d'erreur affiché.

Le formulaire de connexion Admin est dans la méthode appelée par le bouton "Se connecter en tant qu’Admin" sur la page d’accueil (Main.java).

C’est une VBox contenant :
  • 2 TextField (nom + mot de passe)
  • un Button
La logique est codée dans l’action du bouton "Se connecter".

Le mot de passe par défaut est :
👉 "1234"

Le compte admin par défaut est créé manuellement dans la table admin en base de données.

Le médecin ne se connecte qu’avec son nom.

Quand il clique sur "Se connecter", je fais une requête : 
SELECT * FROM medecin WHERE nom = ?
Si je récupère un résultat, je l’autorise à entrer dans l’espace médecin.
Sinon, j’affiche un message "Médecin non trouvé".

Si le nom est trouvé, je récupère son id et son nom, et j'ouvre l'interface "Menu Médecin" (MedecinController.show()) :

Cette interface contient :
  • Un message : "Connecté en tant que Dr. [nom]"
  • Bouton "Liste des patients"
  • Bouton "Enregistrer un patient"
  • Bouton "Enregistrer une prescription"
  • Bouton "Déconnexion"
Le médecin peut ensuite accéder à ces fonctionnalités.

J’ai voulu rendre l’interface plus attrayante et professionnelle.

Comme c’est un centre hospitalier, l’image de fond donne une ambiance plus sérieuse et immersive à chaque espace : admin, médecin, patients.

Cela casse l’aspect "application trop simple" et donne un vrai visuel de qualité.

J’utilise un StackPane avec :
  • l’image de fond dans un BackgroundImage
  • et un VBox au-dessus avec une couleur de fond partiellement transparente (rgba(0,0,0,0.4)), ce qui assombrit un peu l’image.
Cela garantit que les textes et boutons restent bien visibles, même si l’image est contrastée.

J’ai utilisé des TextArea car :
  • c’est rapide à mettre en place
  • cela me permet d’afficher du texte de façon simple, avec scroll automatique si la liste est longue
  • je peux y mettre du texte formaté manuellement (append("ID: … Nom: …\n")) pour la lisibilité.
C’est une solution temporaire, facile pour un projet académique.

J’utilise des propriétés CSS appliquées dans le code :
  • couleur de fond (background-color)
  • taille de police (font-size)
  • arrondi des coins (border-radius)
  • parfois un hover (changement de couleur au passage de la souris)
Cela rend les boutons plus modernes et plus visibles sur le fond d’écran.

Chaque rôle dans un hôpital a des droits et des besoins différents :
  • Admin → gère les médecins, les patients et les rendez-vous → il a donc une interface avec ces 6 fonctions spécifiques.
  • Médecin → doit accéder uniquement à ses patients et prescriptions → interface plus réduite et spécialisée.
Séparer les interfaces permet :
  • de ne pas mélanger les droits
  • de rendre l’application plus sécurisée
  • et de rendre chaque interface plus claire pour l’utilisateur concerné.