📦 Smart Delivery Management System

Un système de gestion logistique moderne et centralisé développé avec Spring Core (sans Spring Boot)

Caractéristiques • Technologies • Architecture • Installation • Utilisation • API REST

📋 Table des matières

À propos
Problématique
Caractéristiques
Technologies
Architecture
Diagramme de classes
Prérequis
Installation
Configuration
Utilisation
API REST (Bonus)
Structure du projet
Concepts Spring implémentés
Livrables

🎯 À propos

Le Smart Delivery Management System (Logismart) est une solution développée pour la société SmartLogi afin de moderniser et automatiser la gestion de ses livraisons. Ce système remplace le suivi manuel effectué via Excel et registres papier par une solution centralisée, fiable et efficace.

🎓 Contexte pédagogique

Ce projet a été réalisé dans le cadre de la formation Concepteur Développeur d'Applications chez Simplon, avec pour objectif l'implémentation du Framework Spring Core (sans Spring Boot) dans un contexte de gestion logistique.

Durée: 5 jours (20/10/2025 - 24/10/2025)

🔴 Problématique

Le système manuel actuel entraîne plusieurs problèmes :

Problème	Impact
❌ Erreurs de saisie	Colis enregistrés avec des informations incorrectes (adresse, poids, destinataire)
⏰ Retards de livraison	Difficulté de planification des tournées et suivi en temps réel
🔄 Doublons/Pertes	Enregistrements multiples ou colis non suivis correctement
👁️ Visibilité limitée	Rapports imprécis sur l'état des livraisons et charge de travail

✨ Caractéristiques

User Stories implémentées

✅ Gérer les livreurs (CRUD) - Centralisation des informations, prévention des doublons
✅ Enregistrer et assigner un colis - Traçabilité précise des livraisons
✅ Mettre à jour le statut - Visibilité en temps réel (PREPARATION → EN_TRANSIT → LIVRE)
✅ Lister les colis par livreur - Planification efficace des tournées
✅ Supprimer/Corriger les données - Intégrité et fiabilité des données

🎁 Fonctionnalités bonus

🚀 API REST complète avec Spring MVC
🔍 Filtrage des colis par livreur via endpoint REST
🎨 Menu console interactif pour tester la logique métier
🔐 Utilisation d'UUID au lieu d'ID numériques (sécurité et unicité globale)
📄 Documentation API Postman complète

🛠 Technologies

Framework Spring (SANS Spring Boot!)

Spring Core 6.1.2 - IoC, DI, Bean Management
Spring Data JPA 3.2.1 - Persistance et repositories
Spring MVC 6.1.2 - API REST (Bonus)
Spring AOP - Gestion transactionnelle

Persistance

Hibernate 6.4.1 - ORM
PostgreSQL 42.7.1 - Base de données relationnelle
JPA 3.1.0 - Spécification de persistance

Build et Outils

Maven 3.6+ - Gestion des dépendances et build
Java 17 - Langage de programmation
Git/GitHub - Versioning
Postman - Tests API REST

🏗 Architecture

Architecture en couches (Layered Architecture)

┌────────────────────────────────────────────┐
│   Couche Présentation                      │
│   - LivreurController / ColisController    │
│   - Menu.java (Console interactive)        │
│   - Main.java                              │
└──────────────────┬─────────────────────────┘
                   │
┌──────────────────▼─────────────────────────┐
│   Couche Service (Logique métier)          │
│   - LivreurService (Constructor Injection) │
│   - ColisService (Setter Injection)        │
└──────────────────┬─────────────────────────┘
                   │
┌──────────────────▼─────────────────────────┐
│   Couche Repository (Accès données)        │
│   - LivreurRepository (JpaRepository)      │
│   - ColisRepository (JpaRepository)        │
└──────────────────┬─────────────────────────┘
                   │
┌──────────────────▼─────────────────────────┐
│   Couche Entités (Modèle de données)       │
│   - Livreur (OneToMany avec Colis)         │
│   - Colis (ManyToOne avec Livreur)         │
│   - StatutColis (Enum)                     │
└────────────────────────────────────────────┘

Configuration Spring

Le projet utilise configuration XML pure (applicationContext.xml) :

❌ Pas de @Configuration
❌ Pas de @ComponentScan automatique
✅ Définition explicite des beans en XML
✅ 3 types d'injection de dépendances démontrés

📊 Diagramme de classes

📝 Note: Le diagramme de classes UML est disponible dans le fichier class-diagram.png à la racine du projet.

Modèle de données

Entités principales:

┌─────────────────┐              ┌─────────────────┐
│   Livreur       │              │     Colis       │
├─────────────────┤              ├─────────────────┤
│ - id: UUID      │ 1        * │ - id: UUID      │
│ - nom: String   │◄───────────┤ - destinataire  │
│ - prenom: String│              │ - adresse       │
│ - vehicule      │              │ - poids: Double │
│ - telephone     │              │ - statut: Enum  │
└─────────────────┘              │ - livreur: FK   │
                                 └─────────────────┘
                                          │
                                          │
                                  ┌───────▼────────┐
                                  │  StatutColis   │
                                  ├────────────────┤
                                  │ - PREPARATION  │
                                  │ - EN_TRANSIT   │
                                  │ - LIVRE        │
                                  └────────────────┘

📋 Prérequis

Avant de commencer, assurez-vous d'avoir installé :

☕ Java JDK 17 ou supérieur
🗄️ PostgreSQL 12 ou supérieur
📦 Maven 3.6 ou supérieur
🐱 Git (pour le clonage)
🚀 Apache Tomcat 10.1 (pour l'API REST)
📮 Postman (optionnel, pour tester l'API REST)

🚀 Installation

1. Cloner le projet

git clone https://github.com/votre-username/Logismart-DeliveryManagementSystem.git
cd Logismart-DeliveryManagementSystem

2. Créer la base de données

-- Connectez-vous à PostgreSQL
psql -U postgres

-- Créez la base de données
CREATE DATABASE Logismart;

3. Configurer la base de données

Modifiez src/main/resources/application.properties :

db.driver=org.postgresql.Driver
db.url=jdbc:postgresql://localhost:5432/Logismart
db.username=postgres
db.password=VOTRE_MOT_DE_PASSE

hibernate.dialect=org.hibernate.dialect.PostgreSQLDialect
hibernate.show_sql=true
hibernate.hbm2ddl.auto=update
hibernate.packagesToScan=com.Logismart.model

4. Compiler le projet

mvn clean install

5. Générer les fichiers exécutables

# Générer le WAR (pour API REST sur Tomcat)
mvn package

# Générer le JAR console (pour menu interactif)
mvn assembly:single

Cela crée:

target/Logismart-DeliveryManagement.war → pour Tomcat
target/Logismart-Console.jar → pour le menu console

⚙️ Configuration

Configuration Spring (applicationContext.xml)

Le projet utilise configuration XML pure avec:

<!-- DataSource Bean - Scope: singleton -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" scope="singleton">
    <property name="driverClassName" value="${db.driver}"/>
    <property name="url" value="${db.url}"/>
    <property name="username" value="${db.username}"/>
    <property name="password" value="${db.password}"/>
</bean>

<!-- Constructor Injection (LivreurService) -->
<bean id="livreurService" class="com.Logismart.service.LivreurService" scope="singleton">
    <constructor-arg ref="livreurRepository" />
</bean>

<!-- Setter Injection (ColisService) -->
<bean id="colisService" class="com.Logismart.service.ColisService" scope="singleton">
    <property name="colisRepository" ref="colisRepository" />
    <property name="livreurRepository" ref="livreurRepository" />
</bean>

💻 Utilisation

Mode 1: Menu Console Interactif

java -jar target/Logismart-Console.jar

Le menu propose:

╔════════════════════════════════════════╗
║         MENU PRINCIPAL                 ║
╚════════════════════════════════════════╝
  1. Gestion des Livreurs
  2. Gestion des Colis
  0. Quitter

Gestion des Livreurs:

Créer un livreur
Afficher tous les livreurs
Rechercher par UUID
Modifier un livreur
Supprimer un livreur

Gestion des Colis:

Créer et assigner un colis
Afficher tous les colis
Rechercher par UUID
Modifier le statut (PREPARATION → EN_TRANSIT → LIVRE)
Afficher les colis d'un livreur
Supprimer un colis

Mode 2: API REST avec Tomcat

Déployer sur Tomcat

Copiez le WAR dans Tomcat:

cp target/Logismart-DeliveryManagement.war /path/to/tomcat/webapps/

Démarrez Tomcat:

/path/to/tomcat/bin/startup.sh  # Linux/Mac
/path/to/tomcat/bin/startup.bat # Windows

L'API est accessible sur:
```
http://localhost:8080/Logismart/
```

🌐 API REST (Bonus)

URL de base

http://localhost:8080/Logismart

⚠️ Important: Utilisation d'UUID

Tous les IDs sont des UUID au format:

550e8400-e29b-41d4-a716-446655440000

Endpoints Livreurs

Méthode	Endpoint	Description
`GET`	`/livreurs`	Récupérer tous les livreurs
`GET`	`/livreurs/{uuid}`	Récupérer un livreur par UUID
`POST`	`/livreurs`	Créer un nouveau livreur
`PUT`	`/livreurs/{uuid}`	Modifier un livreur
`DELETE`	`/livreurs/{uuid}`	Supprimer un livreur

Endpoints Colis

Méthode	Endpoint	Description
`GET`	`/colis`	Récupérer tous les colis
`GET`	`/colis/{uuid}`	Récupérer un colis par UUID
`GET`	`/colis/livreur/{livreurUuid}`	Récupérer les colis d'un livreur
`POST`	`/colis?livreurId={uuid}`	Créer et assigner un colis
`PUT`	`/colis/{uuid}/statut?statut={statut}`	Mettre à jour le statut
`DELETE`	`/colis/{uuid}`	Supprimer un colis

📝 Exemples de requêtes Postman

1. Créer un livreur

POST http://localhost:8080/Logismart/livreurs
Content-Type: application/json

{
  "nom": "Dupont",
  "prenom": "Jean",
  "vehicule": "Camionnette",
  "telephone": "0612345678"
}

Réponse (201 Created):

{
  "id": "550e8400-e29b-41d4-a716-446655440000",
  "nom": "Dupont",
  "prenom": "Jean",
  "vehicule": "Camionnette",
  "telephone": "0612345678"
}

2. Créer un colis

POST http://localhost:8080/Logismart/colis?livreurId=550e8400-e29b-41d4-a716-446655440000
Content-Type: application/json

{
  "destinataire": "Marie Leblanc",
  "adresse": "123 Rue de la Paix, Paris",
  "poids": 2.5,
  "statut": "PREPARATION"
}

3. Mettre à jour le statut

PUT http://localhost:8080/Logismart/colis/7c9e6679-7425-40de-944b-e07fc1f90ae7/statut?statut=EN_TRANSIT

4. Lister les colis d'un livreur

GET http://localhost:8080/Logismart/colis/livreur/550e8400-e29b-41d4-a716-446655440000

Statuts disponibles

PREPARATION - Colis en préparation
EN_TRANSIT - Colis en cours de livraison
LIVRE - Colis livré

Documentation complète

📄 Consultez POSTMAN_API_TESTS.md pour la documentation complète avec exemples et workflows de test.

📁 Structure du projet

Logismart-DeliveryManagementSystem/
│
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── Logismart/
│   │   │           ├── config/
│   │   │           │   └── WebAppInitializer.java
│   │   │           │
│   │   │           ├── enums/
│   │   │           │   └── StatutColis.java
│   │   │           │
│   │   │           ├── model/
│   │   │           │   ├── Livreur.java
│   │   │           │   └── Colis.java
│   │   │           │
│   │   │           ├── repository/
│   │   │           │   ├── LivreurRepository.java
│   │   │           │   └── ColisRepository.java
│   │   │           │
│   │   │           ├── service/
│   │   │           │   ├── LivreurService.java
│   │   │           │   └── ColisService.java
│   │   │           │
│   │   │           ├── controller/
│   │   │           │   ├── LivreurController.java
│   │   │           │   └── ColisController.java
│   │   │           │
│   │   │           ├── Main.java
│   │   │           └── Menu.java
│   │   │
│   │   ├── resources/
│   │   │   ├── applicationContext.xml
│   │   │   └── application.properties
│   │   │
│   │   └── webapp/
│   │       └── WEB-INF/
│   │           ├── web.xml
│   │           └── dispatcher-servlet.xml
│   │
│   └── test/
│       └── java/
│
├── target/
│   ├── Logismart-DeliveryManagement.war
│   └── Logismart-Console.jar
│
├── pom.xml
├── README.md
├── POSTMAN_API_TESTS.md
├── class-diagram.png
└── .gitignore

🎓 Concepts Spring implémentés

1. Inversion of Control (IoC)

Le conteneur Spring gère le cycle de vie des beans via applicationContext.xml:

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" scope="singleton">
    <!-- Configuration -->
</bean>

2. Injection de Dépendances (DI) - Les 3 types

a) Constructor Injection (LivreurService)

<bean id="livreurService" class="com.Logismart.service.LivreurService" scope="singleton">
    <constructor-arg ref="livreurRepository" />
</bean>

public class LivreurService {
    private final LivreurRepository livreurRepository;

    public LivreurService(LivreurRepository livreurRepository){
        this.livreurRepository = livreurRepository;
    }
}

b) Setter Injection (ColisService)

<bean id="colisService" class="com.Logismart.service.ColisService" scope="singleton">
    <property name="colisRepository" ref="colisRepository" />
    <property name="livreurRepository" ref="livreurRepository" />
</bean>

public class ColisService {
    private ColisRepository colisRepository;
    private LivreurRepository livreurRepository;

    public void setColisRepository(ColisRepository colisRepository){
        this.colisRepository = colisRepository;
    }

    public void setLivreurRepository(LivreurRepository livreurRepository){
        this.livreurRepository = livreurRepository;
    }
}

c) Field Injection (Repositories via component-scan)

<context:component-scan base-package="com.Logismart.repository"/>

@Repository
public interface LivreurRepository extends JpaRepository<Livreur, UUID> {
}

3. Scopes des Beans

Tous les beans ont des scopes explicitement définis:

<!-- Singleton: une seule instance partagée (par défaut) -->
<bean id="dataSource" ... scope="singleton">

<!-- Singleton pour les services (stateless) -->
<bean id="livreurService" ... scope="singleton">
<bean id="colisService" ... scope="singleton">

Scopes utilisés:

✅ Singleton - Pour DataSource, Services, Repositories (performance optimale)

4. Spring Data JPA

public interface LivreurRepository extends JpaRepository<Livreur, UUID> {
    // Méthodes CRUD automatiques fournies par Spring Data
}

public interface ColisRepository extends JpaRepository<Colis, UUID> {
    List<Colis> findByLivreurId(UUID livreurId); // Query method dérivée
}

5. Gestion Transactionnelle (AOP)

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="save*" propagation="REQUIRED"/>
        <tx:method name="update*" propagation="REQUIRED"/>
        <tx:method name="delete*" propagation="REQUIRED"/>
        <tx:method name="find*" propagation="REQUIRED" read-only="true"/>
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:pointcut id="serviceOperation" expression="execution(* com.Logismart.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceOperation"/>
</aop:config>

6. Spring MVC (Bonus)

@Controller
@RequestMapping("/livreurs")
public class LivreurController {

    @Autowired
    private LivreurService livreurService;

    @RequestMapping(method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<List<Livreur>> getAllLivreurs() {
        List<Livreur> livreurs = livreurService.findAllLivreurs();
        return ResponseEntity.ok(livreurs);
    }
}

📊 Critères de performance respectés

Critère	Statut
Opérations CRUD via logique métier	✅
Relation Livreur-Colis fonctionnelle	✅
Spring Core et Spring Data JPA	✅
Les 3 types d'injection de dépendances	✅
Scopes des beans définis	✅
Architecture en couches	✅
Configuration XML (pas annotations Boot)	✅
Git/GitHub pour versioning	✅
Code de qualité et lisible	✅
BONUS: API REST Spring MVC	✅
BONUS: Filtrage colis par livreur	✅
BONUS: Menu console interactif	✅

📄 Licence

Ce projet est réalisé dans le cadre d'une formation pédagogique chez Simplon - Promotion Javalution 2025.

Name		Name	Last commit message	Last commit date
Latest commit History 13 Commits
.idea		.idea
UML		UML
src/main		src/main
.gitignore		.gitignore
PostmanApiTests.md		PostmanApiTests.md
README.md		README.md
package-lock.json		package-lock.json
pom.xml		pom.xml

hajarwalfi/Logismart-DeliveryManagementSystem

Folders and files

Latest commit

History

Repository files navigation