1
0. Introduction
Ce document présente la conception et l’implémentation d’un mini-système de
gestion des commandes réalisé en Java avec une base de données MySQL.
L’application permet de gérer les clients, les articles (produits) et les commandes
(relation N-à-N entre commandes et articles). L’objectif est de fournir un outil simple
mais complet pour effectuer les opérations courantes d’un magasin :
ajout/édition/activation de clients et d’articles, gestion du stock et création de
commandes transactionnelles garantissant la cohérence des stocks.
Ce projet couvre : la modélisation (UML : diagramme de classes et cas d’utilisation),
la conception de la base de données MySQL, le développement Java (DAO, modèles,
interface Swing) et les tests fonctionnels (captures d’écran + explications). Le
document inclut aussi le code source complet et des recommandations pour l’évolution
du système (authentification, gestion des rôles, passage à une architecture Web).
2
1. Présentation de la problématique
1.1. Définition de la question de travail
Les entreprises de vente au détail ont besoin d’un système simple et fiable pour gérer
leurs clients, articles et commandes. La problématique traitée est : comment concevoir
et implémenter un mini-système permettant de gérer les ventes et le stock de manière
sûre et cohérente, tout en offrant une interface utilisable par le gestionnaire du magasin
?
1.2. Objectifs du mini-système
Concevoir une base de données relationnelle (`gestion_commande`) modélisant
clients, articles, commandes et items de commande.
Implémenter en Java les couches d’accès aux données (DAO) et la logique
métier (création de commande, mise à jour de stock) avec gestion
transactionnelle.
Proposer une interface graphique Swing pour effectuer les opérations : CRUD
clients/articles, création de commandes, affichage des historiques.
Documenter la démarche (UML, scripts SQL, captures d’écran et explications).
2. Implémentation de l’application
2.1. Cas d’utilisation :
a. Diagramme de cas d’utilisation pour la création des articles**
Figure 1 : Diagramme de cas d’utilisation – Gestion des articles
Description
Le diagramme de cas d’utilisation ci-dessous illustre les principales interactions entre
le gestionnaire du système et le module Articles.
Le gestionnaire est le seul acteur autorisé à créer, modifier ou supprimer les articles
disponibles dans la boutique.
3
Il peut aussi activer ou désactiver un article selon sa disponibilité, mettre à jour le
stock lorsqu’il reçoit de nouveaux produits et consulter la liste des articles enregistrés
dans la base de données.
Ces cas d’utilisation représentent l’ensemble des opérations nécessaires pour
maintenir le catalogue produit à jour.
L’objectif est de garantir que les informations sur les articles (désignation, catégorie,
prix, stock et état actif/inactif) soient toujours exactes avant qu’une commande ne
puisse être passée par un client.
b. Diagramme de cas d’utilisation pour la commande des articles
Figure 2 : Diagramme de cas d’utilisation – Gestion des commandes
Diagramme
Le diagramme de cas d’utilisation suivant présente les interactions liées à la gestion
des commandes.
Deux acteurs principaux interviennent : le client et le gestionnaire.
Le client peut consulter la liste des articles, sélectionner les produits souhaités
(création d’un panier) et passer une commande.
Une fois la commande créée, le gestionnaire la valide, ce qui entraîne la mise à jour
automatique du stock et la génération d’une facture ou d’un récapitulatif.
Le client comme le gestionnaire peuvent aussi consulter l’historique des commandes
et annuler une commande avant sa validation.
4
Ce diagramme met en évidence la collaboration entre les deux acteurs pour assurer
le bon déroulement du processus d’achat, depuis la sélection des articles jusqu’à la
validation finale et la gestion du stock.
3. Présentation et interprétation des résultats
Figure 1 : Écran d’accueil présentant le module Client
L’écran d’accueil de l’application affiche le menu principal permettant d’accéder aux
différents modules : Clients, Articles et Commandes.
Dans cette vue, le gestionnaire peut visualiser la liste des clients enregistrés dans le
système. Chaque ligne du tableau correspond à un client avec ses informations
principales (nom, prénom, contact, type, et état actif/inactif).
Cet écran représente la porte d’entrée du module Client, offrant une vision claire et
structurée des données enregistrées.
Figure 2 : Fenêtre d’ajout d’un nouveau client
Cette fenêtre apparaît lorsqu’on clique sur le bouton « Ajouter » du module Client.
Elle permet au gestionnaire de saisir les informations personnelles d’un nouveau client
: nom, prénom, sexe, contact et type.
5
Une fois les données complétées et validées, le nouveau client est automatiquement
enregistré dans la base de données MySQL et visible dans la liste principale. Cette
étape correspond à la fonction Créer un client du système.
Figure 3 : Module Articles – Liste des articles disponibles
Cet écran présente la liste de tous les articles actuellement enregistrés dans le système.
Chaque article est affiché avec sa désignation, sa catégorie, son prix unitaire, son stock
disponible et son état d’activité. Le gestionnaire peut consulter rapidement les
informations des produits et décider de les modifier, désactiver ou supprimer.
Cette vue représente la base du module de gestion du stock et des produits.
Figure 4 : Fenêtre d’ajout d’un nouvel article
Cet écran montre la fenêtre permettant au gestionnaire d’ajouter un nouvel article. Le
gestionnaire y renseigne la désignation du produit, sa catégorie, son prix, le stock
initial et son état (actif ou inactif). Une fois l’article validé, il est inséré dans la base de
données et immédiatement visible dans le tableau principal. Cette opération
correspond à la fonction Créer un article, qui alimente la base pour les futures
commandes.
6
Figure 5 : Module Commande – Liste des commandes enregistrées
Cet écran présente le module de gestion des commandes. Chaque commande effectuée
est affichée avec ses informations clés : l’identifiant de la commande, le nom du client,
la date de la commande, le type (ex. comptant, à crédit) et l’état de validation. Cet
écran permet au gestionnaire de suivre toutes les commandes passées et de vérifier leur
statut. Il représente le cœur fonctionnel du système, reliant clients et articles.
Figure 6 : Sélection d’un client lors de la création d’une commande
Lorsqu’une nouvelle commande est créée, le gestionnaire sélectionne le client
concerné dans la liste déroulante. Cette étape permet d’associer chaque commande à
un client spécifique et d’assurer le suivi des achats. Le système récupère
automatiquement les informations du client choisi depuis la table des clients.
Cela garantit la traçabilité des ventes et la cohérence entre les tables.
Figure 7 : Message de confirmation après validation d’une commande
7
Une fois la commande enregistrée, l’application affiche un message de confirmation.
Ce message informe le gestionnaire que la commande a été validée avec succès et que
le stock des articles concernés a été mis à jour dans la base de données. Ce retour
visuel confirme la bonne exécution de l’opération et la fiabilité du système. Il s’agit de
la dernière étape du processus de commande, garantissant que la transaction est bien
complétée.
3.2 Interprétation des résultats
Les captures précédentes démontrent le bon fonctionnement du mini-système de
gestion des commandes. Les différentes opérations (ajout, modification, consultation
et validation) s’exécutent correctement et les données sont stockées de manière
cohérente dans la base MySQL. Le système répond donc à la problématique initiale :
fournir un outil simple, fiable et intuitif pour la gestion des clients, des articles et des
commandes d’un magasin.
4. Code source de l’application
4.1. Classe de connexion :
5. package [Link];
import [Link];
import [Link];
import [Link];
public class DBConnection {
// URL de connexion : modifie le user/motdepasse si nécessaire
private static final String URL =
"jdbc:mysql://localhost:3306/gestion_commande?
useSSL=false&serverTimezone=UTC";
private static final String USER = "root";
private static final String PASS = "MELANIE2005";
private static Connection conn = null;
// méthode pour obtenir une connexion unique (singleton basique)
public static Connection getConnection() throws SQLException {
if (conn == null || [Link]()) {
try {
// charge le driver (souvent optionnel avec JDBC 4+, mais safe)
[Link]("[Link]");
} catch (ClassNotFoundException e) {
throw new SQLException("Driver JDBC non trouvé", e);
}
conn = [Link](URL, USER, PASS);
8
}
return conn;
}
// permet de fermer la connexion si besoin
public static void closeConnection() {
if (conn != null) {
try {
[Link]();
} catch (SQLException ignored) {}
}
}
}
5.1. Classe Client :
6. package [Link];
public class Client {
private int id;
private String nom;
private String prenom;
private String sexe;
private String typeClient;
private String contact;
private boolean active;
public Client() {}
public Client(String nom, String prenom, String sexe, String
typeClient, String contact, boolean active) {
[Link] = nom;
[Link] = prenom;
[Link] = sexe;
[Link] = typeClient;
[Link] = contact;
[Link] = active;
}
// getters & setters
public int getId() { return id; }
public void setId(int id) { [Link] = id; }
public String getNom() { return nom; }
public void setNom(String nom) { [Link] = nom; }
public String getPrenom() { return prenom; }
public void setPrenom(String prenom) { [Link] = prenom; }
public String getSexe() { return sexe; }
9
public void setSexe(String sexe) { [Link] = sexe; }
public String getTypeClient() { return typeClient; }
public void setTypeClient(String typeClient) { [Link] =
typeClient; }
public String getContact() { return contact; }
public void setContact(String contact) { [Link] = contact;
}
public boolean isActive() { return active; }
public void setActive(boolean active) { [Link] = active; }
@Override
public String toString() {
return id + " - " + nom + " " + prenom;
}
}
6.1. Classe Commande / Article :
7. // src/main/java/com/monprojet/model/[Link]
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
public class Commande {
private int id;
private int clientId;
private Timestamp dateCommande;
private String typeCommande;
private String statut;
private BigDecimal total;
private List<CommandeItem> items = new ArrayList<>();
public Commande() {}
public int getId() { return id; }
public void setId(int id) { [Link] = id; }
public int getClientId() { return clientId; }
public void setClientId(int clientId) { [Link] = clientId; }
public Timestamp getDateCommande() { return dateCommande; }
10
public void setDateCommande(Timestamp dateCommande) {
[Link] = dateCommande; }
public String getTypeCommande() { return typeCommande; }
public void setTypeCommande(String typeCommande) { [Link] =
typeCommande; }
public String getStatut() { return statut; }
public void setStatut(String statut) { [Link] = statut; }
public BigDecimal getTotal() { return total; }
public void setTotal(BigDecimal total) { [Link] = total; }
public List<CommandeItem> getItems() { return items; }
public void setItems(List<CommandeItem> items) { [Link] = items; }
@Override
public String toString() {
return id + " - client:" + clientId + " total:" + total;
}
}
Classe articles
// src/main/java/com/monprojet/model/[Link]
package [Link];
import [Link];
import [Link];
public class Article {
private int id;
private String designation;
private String categorie;
private BigDecimal prix;
private int stock;
private boolean active;
private Timestamp createdAt;
public Article() {}
public Article(String designation, String categorie, BigDecimal prix, int stock,
boolean active) {
[Link] = designation;
[Link] = categorie;
[Link] = prix;
[Link] = stock;
[Link] = active;
}
public int getId() { return id; }
public void setId(int id) { [Link] = id; }
11
public String getDesignation() { return designation; }
public void setDesignation(String designation) { [Link] = designation; }
public String getCategorie() { return categorie; }
public void setCategorie(String categorie) { [Link] = categorie; }
public BigDecimal getPrix() { return prix; }
public void setPrix(BigDecimal prix) { [Link] = prix; }
public int getStock() { return stock; }
public void setStock(int stock) { [Link] = stock; }
public boolean isActive() { return active; }
public void setActive(boolean active) { [Link] = active; }
public Timestamp getCreatedAt() { return createdAt; }
public void setCreatedAt(Timestamp createdAt) { [Link] = createdAt; }
@Override
public String toString() {
return id + " - " + designation;
}
}
7.1. Classe principale : `[Link]` / `
package [Link];
import [Link];
import [Link];
public class Main {
public static void main(String[] args) {
[Link](() -> {
MainFrame frame = new MainFrame();
[Link](true);
});
}
}
`[Link]
package [Link];
import [Link].*;
public class MainFrame extends JFrame {
public MainFrame() {
setTitle("Gestion Commande - Mini système");
setSize(800, 600);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
12
setLocationRelativeTo(null);
JTabbedPane tabs = new JTabbedPane();
[Link]("Clients", new ClientPanel());
[Link]("Articles", new ArticlePanel()); // à implémenter
[Link]("Commandes", new CommandePanel()); // à implémenter
add(tabs);
}
}
13
Conclusion
Ce mini-système de gestion des commandes a permis de mettre en pratique les
principes fondamentaux de la programmation orientée objet, la conception de bases de
données relationnelles et la manipulation des données via Java et MySQL.
L’application développée offre au gestionnaire un outil simple et intuitif pour gérer les
clients, les articles et les commandes, avec la possibilité d’ajouter, modifier,
consulter et supprimer les enregistrements tout en maintenant la cohérence des
données entre les différentes tables.
Sur le plan fonctionnel, le système répond aux objectifs fixés :
centralisation des informations clients et articles,
mise à jour automatique du stock lors de la validation d’une commande,
affichage clair des informations dans une interface graphique développée avec
Swing.
Cependant, certaines limites ont été identifiées :
l’application ne gère pour l’instant qu’un seul utilisateur (le gestionnaire),
il n’existe pas encore de système d’authentification (connexion avec nom
d’utilisateur et mot de passe),
le design reste simple et pourrait être amélioré pour une meilleure ergonomie,
les tests unitaires et la gestion des erreurs peuvent être renforcés.
Pour les perspectives d’évolution, plusieurs pistes peuvent être envisagées :
intégrer un module de connexion et de rôles utilisateurs (administrateur,
vendeur, etc.),
développer une interface Web ou une application mobile afin de rendre le
système accessible à distance,
ajouter des fonctionnalités de reporting (statistiques de ventes, suivi du stock,
performance des clients),
mettre en place des tests unitaires automatisés pour garantir la fiabilité du
code,
connecter le système à un serveur en ligne afin de permettre le travail
collaboratif.
En conclusion, ce projet constitue une première version fonctionnelle d’un système de
gestion des commandes, à la fois pédagogique et pratique, démontrant la capacité à
concevoir une application complète reliant base de données, logique métier et interface
graphique.
Il ouvre la voie à des améliorations futures qui permettront d’en faire un outil encore
plus robuste, moderne et évolutif.
14
Références / Bibliographie
1. Oracle. The Java Tutorials — Getting Started with Swing. Oracle
Documentation.[[Link]
[Link]/javase/tutorial/uiswing/) (consulté pour la conception de
l’interface Swing).
2. Oracle. JDBC API Documentation.
[[Link]
[Link]/javase/8/docs/technotes/guides/jdbc/) (référence pour
l’utilisation de `DriverManager, Connection, PreparedStatement).
3. MySQL. MySQL 8.0 Reference Manual. Oracle Corporation.
[[Link] (script SQL, types,
contraintes, transactions).
4. Ambler, S. (2005). The Object Primer: Agile Model-Driven Development with
UML 2. (Pour principes UML et cas d’utilisation — optionnel).
5. Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns:
Elements of Reusable Object-Oriented Software. (pour bonnes pratiques de
conception — DAO pattern).
6. Bloch, J. (2018). Effective Java. (pour bonnes pratiques Java, immutabilité,
BigDecimal, etc.)
7. Tutoriels/Articles en ligne (exemples pratiques) :
« JDBC PreparedStatement Tutorial » — ressources en ligne pour la
prévention des injections SQL.
Guides sur `BigDecimal` pour représenter les montants monétaires en
Java.