Mini Projet Java

GESTION DE STOCK

Soutenu par : MOUENGATH Axell Sous la direction de : Mrs MARAH

Rubbenn

1
Année Universitaire 2024-2025

2
 Remerciements

Je remercie chaleureusement l'ensemble de l'équipe pédagogique du Centre d’ESTEM pour leur

soutien et leur accompagnement durant toute ma formation. Je souhaite exprimer ma gratitude à
mon professeur encadrant pour ses conseils précieux. Merci également à ma famille et mes amis
pour leur soutien indéfectible.
*

Résume

Ce mini-projet avait pour objectif de développer, en Java et en mode console, une application de
gestion de stock destinée à centraliser et automatiser le suivi des produits au sein d’un entrepôt. En
l’absence d’interface graphique, l’accent a été mis sur la simplicité d’utilisation via des commandes
en ligne, tout en garantissant la fiabilité et la traçabilité des mouvements de marchandises.

Pour répondre au problème des ruptures et des surstocks, l’application adopte une architecture
modulaire fondée sur les principes SOLID :

 Couche métier pour la gestion des règles de stock et des cas d’utilisation (réceptions,
ventes, transferts, retours).
 Couche de persistance reposant sur PostgreSQL, accessible via JDBC, assurant intégrité et
cohérence transactionnelle.
 Couche présentation en console (I/O), offrant des commandes pour interroger l’état des
stocks, générer l’historique des flux et produire des rapports synthétiques (seuils critiques,
alertes de stock bas).
Par ailleurs, une suite de tests unitaires (JUnit) et d’intégration a permis de valider la
robustesse de chaque composant, notamment face aux cas d’erreur (quantités négatives,
références inconnues).

Les principaux résultats incluent la mise en place d’un enregistrement systématique et horodaté de
tous les mouvements, la génération de rapports automatisés et la fiabilité éprouvée du module de
persistance. Parmi les solutions envisagées pour enrichir l’outil figure la gestion multi-entrepôts,
l’export des rapports en CSV/Excel et l’automatisation des réapprovisionnements selon des seuils
dynamiques.

3
 Sommaire

Remerciements..............................................................................................................................1
Résumé..........................................................................................................................................1
Sommaire ......................................................................................................................................2
INTRODUCTION ....................................................................................................................... 3
CHAPITRE I ............................................................................................................................... 4
PRESENTATION DU PROJET .............................................................................. :.. ............... 5
1. Contexte et Problématique................................................................................................6
2. Objectifs du Projet........................................................................................................... 7
CHAPITRE II .............................................................................................................................. 8
CONCEPTION. ....................................................................................................................... ....8
[Link]éma UML des Classes.......................................................................................................9
[Link]éma UML des Sous classes......................................................... ........................................16
CHAPITRE III ............................................................................................................................. 11
RÉALISATION..........................................................................................................................11
1. Code..................................................................................................................................12
CONCLUSION..........................................................................................................................16

4
 Introduction

La gestion des stocks constitue un enjeu stratégique pour les entreprises : il

s’agit de piloter les flux entrants et sortants de marchandises pour garantir la
disponibilité des produits tout en maîtrisant les coûts et en limitant les pertes.
Un suivi précis de chaque opération est essentiel : « La traçabilité évite les
pertes » et un contrôle rigoureux des mouvements assure la fiabilité des
données. Dans ce contexte, l’application de stock développée dans ce mini-
projet vise à renforcer la qualité des informations (suivi des entrées/sorties,
inventaire) et à faciliter la prise de décision logistique.

Sur le plan technique, le projet a été réalisé en Java pour bénéficier de sa

robustesse et de ses capacités orientées objet (Java est particulièrement
adapté aux systèmes back-end manipulant de forts volumes de données).
L’interface est de type console, ce qui simplifie la saisie et la consultation
rapides des données. La persistance des données est assurée
par PostgreSQL, un SGBD relationnel open-source réputé pour son intégrité
et sa fiabilité. Le code est structuré selon une architecture en
couches classique (couche présentation, couche métier, couche d’accès aux
données). Cette organisation découple les responsabilités et facilite la
maintenance. De plus, les principes SOLID ont été appliqués en conception :
cela garantit un code modulaire, extensible et maintenable.

Les fonctionnalités principales du système couvrent le cycle de gestion

habituel : enregistrement des réceptions fournisseurs (entrées de stock), suivi
des ventes (sorties de stock) et transferts de marchandises entre sites, ainsi
que consultation permanente des niveaux d’inventaire. Concrètement, le
logiciel offre une vision en temps réel des achats, des réceptions et des
mouvements de stock, ainsi que des quantités disponibles. Il gère également
les transferts inter-entrepôts pour un pilotage optimal des stocks, tout en
assurant la traçabilité des flux entre les points de vente. Ces fonctionnalités
reflètent les exigences opérationnelles d’un système de gestion de stock
moderne.

5
Ce mini-projet a un intérêt pédagogique majeur : il permet de mobiliser des
compétences essentielles en programmation orientée objet (modélisation
par classes, héritage, interfaces), en conception de base de données
relationnelle (modélisation du schéma, normalisation) et en tests
logiciels (tests unitaires et fonctionnels pour valider le comportement des
fonctionnalités). L’objectif est de familiariser l’étudiant avec les bonnes
pratiques du développement logiciel (conception modulaire, respect des
spécifications, qualité du code) dans un contexte concret de gestion logistique.

C
HAPITRE I
Présentation du projet

6
1 . Contexte et problématique

La gestion des stocks est un levier stratégique essentiel pour les entreprises industrielles
contemporaines, directement liée à leur compétitivité globale. Pour rester concurrentielles sur un
marché mondialisé, les entreprises doivent prévenir les ruptures de stock par une gestion proactive
des [Link] effet, un stock mal géré impacte tous les niveaux de l’entreprise (ventes,
logistique, finances, satisfaction client) et n’est en rien une fonction secondaire, mais bien un pilier
de la performance globale.

Les ruptures de stock (out-of-stock) ont des conséquences directes lourdes. Elles entraînent un
manque à gagner significatif et une perte de clients : en moyenne, 20 % des consommateurs qui ne
trouvent pas le produit désiré se tournent vers une marque concurrente. Ces indisponibilités nuisent
également à la réputation et à la satisfaction des clients – chaque commande non honorée risque
d’entraîner l’annulation de contrats et ternit durablement l’image de l’entreprise. En résumé, la
rupture de stock se traduit par une « perte de clients » et une « image dégradée » pour l’entreprise,
d’où l’importance d’anticiper la demande et de maintenir un taux de disponibilité élevé.

À l’inverse, le surstockage génère des coûts excessifs. Chaque unité immobilisée en entrepôt coûte
de l’espace, de l’assurance et du capital gelé. Les entreprises qui tentent de compenser les ruptures
en augmentant massivement leurs niveaux de stock créent souvent un cercle vicieux de surstock et
d’immobilisation financière. Dans certains secteurs (produits périssables, technologie à cycle court),
l’excès de stock accroît en outre le risque d’obsolescence et de gaspillage. Dans tous les cas,
ruptures et excédents dégradent l’efficience opérationnelle et nuisent au retour sur investissement
lié à l’inventaire.

7
Ces risques sont accentués par l’usage de méthodes manuelles et déconnectées. La gestion des
stocks en différé, sur tableurs ou supports papier, est reconnue comme une « erreur à éviter » car
elle empêche une vision réactive du stock. En l’absence de solution automatisée, l’entreprise ne
dispose alors que d’un « contrôle partiel » de son inventaire, reposant sur les dernières saisies
manuelles. Ce mode de fonctionnement favorise les erreurs humaines et les écarts entre l’inventaire
théorique et la réalité, risquant in fine des ruptures inattendues ou des surplus d’autant plus difficiles
à corriger.

L’automatisation et la centralisation des données logistiques sont par conséquent incontournables.

Un système informatisé de gestion des stocks en temps réel « permet de contrôler et d’assurer une
traçabilité complète des produits » en suivant chaque mouvement. Cette visibilité instantanée savoir
à tout moment ce qui est disponible, où et en quelle quantité facilite la prise de décision rapide et
prévient les mauvaises surprises. Un stock optimisé s’accompagne ainsi d’un meilleur service client
: une disponibilité élevée des produits améliore la satisfaction et fidélise la clientèle. En somme,
l’entreprise qui digitalise sa chaîne logistique gagne en réactivité et en qualité de service, ce qui se
traduit par une meilleure compétitivité sur le marché.

2. Objectifs du projet

L’objectif principal de l’application console Java est de centraliser et d’automatiser le suivi complet
du cycle de vie des produits stockés. Concrètement, le logiciel remplace les méthodes manuelles
(tableurs, registres papier) par une solution unique offrant une vision globale de l’inventaire. Cette
centralisation garantit la cohérence des données et réduit les erreurs : toutes les opérations
s’effectuent dans un référentiel commun, ce qui simplifie les processus métier et fiabilise
l’information destinée à la prise de décision.

Les composantes fonctionnelles du système sont les suivantes :

 Gestion des références : ce module gère la base des articles. Chaque produit est défini par
un identifiant unique (code-barres ou code interne) et des attributs (désignation, fournisseur,
unité, etc.). L’utilisateur peut créer une nouvelle référence, modifier les informations
existantes ou supprimer les références obsolètes. On intègre également des champs de
traçabilité indispensables (numéro de lot, date de péremption, fournisseur, date de réception,
etc.) pour chaque article, conformément aux exigences réglementaires et logistiques. Ainsi,
le système assure la cohérence des fiches produits et permet de rattacher tous les
mouvements au bon lot, garantissant une traçabilité fine des articles.

8
  Enregistrement des mouvements : ce module journalise tous les flux physiques affectant
le stock. Il s’agit notamment des réceptions de marchandises (entrées depuis les
fournisseurs), des retours (sorties vers les fournisseurs ou retours clients), des transferts
internes (déplacement de stock d’un dépôt à un autre) et des ventes ou sorties de stock.
Chaque opération est saisie avec sa date, sa nature (réception, vente, transfert, retour) et les
quantités concernées. L’ensemble de ces enregistrements constitue un historique des
mouvements du stockGrâce à ce dispositif, l’état des stocks est recalculé automatiquement
après chaque mouvement et l’historique complet est disponible pour reconstituer tout flux
logistique.

 Consultation des stocks en temps réel : ce composant permet d’interroger le système à

tout moment pour connaître les niveaux de stock actuels. L’application affiche la quantité
disponible pour chaque référence, mise à jour en temps réel à partir des dernières opérations
enregistrées. La consultation inclut également l’historique détaillé des transactions associées
à la référence (entrées, sorties, transferts, etc.), offrant ainsi une vue chronologique du cycle
de vie produit. L’utilisateur bénéficie ainsi d’une « visibilité instantanée » sur l’ensemble
des stocks, avec un accès immédiat à l’historique des mouvements. Cette fonctionnalité de
suivi continu soutient la prise de décision en fournissant des données fiables et actualisées.

En résumé, l’application regroupera ces modules clés pour fournir un outil complet de gestion de
stock. L’accès centralisé et l’automatisation du suivi permettront de fiabiliser les informations
d’inventaire, d’accélérer les traitements logistiques et d’améliorer la qualité de service. Cette
structuration fonctionnelle claire gestion des références, enregistrement exhaustif des mouvements
et consultation en temps réel répond aux besoins des entreprises souhaitant optimiser leur supply
chain et soutenir leur prise de décision métier.

9
 CHAPITRE II
Conception

1 . Shéma UML des classes

La conception du projet repose sur une modélisation orientée objet, où chaque entité métier est
représentée par une classe dédiée. Le système est structuré de manière à garantir la clarté, la
maintenabilité et l’évolutivité du code, conformément aux principes SOLID. Le schéma UML ci-
dessous illustre les relations fondamentales entre les classes principales.

10
Liste des classes principales :

 Produit : représente un article avec ses propriétés (code, désignation, unité, seuil critique).
 Article Stock : gère l’état du stock d’un produit dans un entrepôt.
 Entrepôt : regroupe l’ensemble des articles en stock et permet la gestion multi-localisée.
 Gestionnaire Stock : assure le traitement métier, l’enregistrement des mouvements et la
génération des rapports.
 Rapport (classe abstraite) : structure générale des rapports.
o Sous-classes : Etat Stock, Alertes Seuil, Historique Mouvements.
 Exportateur CSV : module externe pour l’exportation des rapports au format CSV.
 Produit Repository (interface) : assure la persistance des objets Produit.
 Mouvement Repository (interface) : assure la persistance des objets Mouvement.

Relations UML :

 Composition : Entrepôt contient plusieurs Article Stock.

 Association : Article Stock est lié à un Produit.
 Dépendance : Gestionnaire Stock utilise Produit Repository et Mouvement
Repository.
 Héritage : Rapport est une classe mère abstraite, étendue par Etat Stock, Alertes Seuil,
et Historique Mouvements.

Ce découpage favorise la séparation des responsabilités et permet l’extension du système sans

modifier les composants existants (principe ouvert/fermé).

11
2. Shéma UML des Sous classes

La gestion des mouvements de stock repose sur une hiérarchie de classes permettant de représenter
les différentes opérations possibles sur les articles. Cette hiérarchie repose sur une classe mère
abstraite, Mouvement, étendue par des sous-classes spécialisées.

Classe abstraite :

 Mouvement : contient les attributs communs à toutes les opérations (date, produit,
quantité). Elle définit une méthode abstraite éxecuter().

Sous-classes spécialisées :

 Réception : représente l’entrée de produits dans le stock (approvisionnement, livraison

fournisseur).
 Vente : gère la sortie des produits pour les ventes client.
 Transfert : permet de déplacer un stock d’un entrepôt source à un entrepôt destination.
 Retour : enregistre le retour d’un produit, que ce soit d’un client ou à un fournisseur.

Avantages de cette structure :

 Permet d’ajouter facilement de nouveaux types de mouvements (ex : Dons, Inventaire)

sans modifier la classe Mouvement.
 Garantit une logique métier claire et centralisée pour chaque opération spécifique.
 Favorise la factorisation du code, en mutualisant les attributs et comportements communs
dans la classe Mouvement.

L’usage de cette hiérarchie assure une grande flexibilité et améliore la lisibilité du code. Chaque
opération de mouvement étant encapsulée dans une classe dédiée, les tests unitaires peuvent être
menés plus efficacement.

Projet de Fin d’année 2024-2025

 Shéma UML des Classes et Sous Classes

Projet de Fin d’année 2024-2025

 CHAPITRE III
Réalisation

Projet de Fin d’année 2024-2025

[Link] code du projet

Projet de Fin d’année 2024-2025

Projet de Fin d’année 2024-2025
Projet de Fin d’année 2024-2025
Projet de Fin d’année 2024-2025
 CONCLUSION
Ce mini-projet a permis de concevoir une application console en Java pour la gestion de stock,
répondant à des enjeux concrets comme les ruptures et les surstocks. En s’appuyant sur une
architecture modulaire et les principes SOLID, nous avons mis en place un système fiable, capable
de gérer les mouvements de marchandises (réception, vente) et de fournir un suivi en temps réel des
quantités disponibles.

Les résultats obtenus valident la pertinence de la solution : traçabilité des flux, alertes sur les seuils
critiques et structure évolutive. Ce projet constitue ainsi une première étape vers des outils de
gestion plus complets, avec des pistes d'amélioration comme la gestion multi-entrepôts ou l’export
de rapport

Projet de Fin d’Année 2024-2025