DEPARTEMENT DE GENIE INFORMATIQUE ET TELECOMMUNICATION

MASTER PROFESSIONNEL

NIVEAU 1 FILIERE : GÉNIE LOGICIEL

RAPPORT SUR LE FRAMEWORK SPRING BOOT

PROJET DE DEVELOPPEMENT D’UNE APPLICATION

WEB DE GESTION DE RESERVATIONS

Réalisé par :

Nom Participation

MOUNTOU BRIAN DAVID 100%

DJOUOMOU EVARISTE JUNIOR 100%

FOTSO GORDON RUBBEN 100%

AMOUGUI BELIBI CLAUDE WILFRIED 100%

MBELNGAR II STEVE BRIAN 100%

KONTCHE FONGANG JOUNDA MALAIKA 100%

PRISO JOHAN YORICK 100%

Sous la supervision de :

MR SONE SONE
Table de Matières
GLOSSAIRE .............................................................................................................................. 0
INTRODUCTION ...................................................................................................................... 2
1. PRESENTATION DE SPRING BOOT ............................................................................. 3
1.1 Définition et historique ................................................................................................ 3
1.2 Objectifs et avantages du Framework ......................................................................... 3
1.3 Cas d’usage .................................................................................................................. 3
2. CONFIGURATION DU FRAMEWORK ET OUTILS DE DEVELOPPEMENT ........... 5
2.1 Installation et Prérequis ............................................................................................... 5
2.1.1 Environnement requis .............................................................................................. 5
2.1.2 Création du projet .................................................................................................... 5
2.2 Structure typique d’un projet Spring Boot .................................................................. 5
2.3 Lancement de l’application ......................................................................................... 6
2.3.1 Depuis un IDE .......................................................................................................... 6
2.3.2 Depuis la ligne de commande avec Maven .............................................................. 6
2.4 Outils de développement nécessaires .......................................................................... 6
3. ARCHITECTURE ET COMPOSANTS CLES .................................................................. 6
3.1 Structure du projet Spring Boot ................................................................................... 6
3.2 Annotations .................................................................................................................. 7
3.3 Starters et autoconfiguration ........................................................................................ 7
3.4 Serveur embarqué ........................................................................................................ 7
4. CONCEPTS FONDAMENTAUX ..................................................................................... 8
4.1 Injection des dépendances (DI) ................................................................................... 8
4.2 Contrôleurs REST........................................................................................................ 8
4.3 Spring Data JPA et entité............................................................................................. 8
4.4 Requêtes HTTP et gestion des routes .......................................................................... 9
4.5 Gestion des exceptions et validations ........................................................................ 10
5. MISE EN ŒUVRE PRATIQUE ...................................................................................... 11
5.1 Étapes de création d'un projet Spring Boot ............................................................... 11
5.1.1 Initialisation du projet ............................................................................................ 11
5.1.2 Architecture et pattern Repository ......................................................................... 11
 5.1.3 Stack technique ...................................................................................................... 11
5.2 Exemple d'application CRUD ................................................................................... 12
5.2.1 Gestion des chambres (Room Management) ......................................................... 12
5.2.2 Système de réservation (Booking System) ............................................................ 12
5.2.3 Gestion des utilisateurs .......................................................................................... 13
5.3 Connexion à la base de données ................................................................................ 13
5.3.1 Configuration MySQL ........................................................................................... 13
5.3.2 Gestion des données ............................................................................................... 13
5.3.3 Sécurité des données .............................................................................................. 14
5.4 Test et exécution de l'application............................................................................... 14
5.4.1 Architecture REST ................................................................................................. 14
5.4.2 Sécurité des endpoints ............................................................................................ 14
5.4.3 Intégration frontend ............................................................................................... 14
5.4.4 Tests et validation .................................................................................................. 14
5.4.5 Déploiement et exécution....................................................................................... 15
6. FONCTIONNALITES AVANCEES ............................................................................... 16
6.1 Sécurité avec Spring Security .................................................................................... 16
6.2 Spring Boot Actuator ................................................................................................. 16
6.3 Déploiement............................................................................................................... 16
7. AVANTAGES ET LIMITES ........................................................................................... 17
7.1 Bénéfices pour les développeurs ............................................................................... 17
7.2 Limites selon les besoins ........................................................................................... 17
7.3 Comparaison avec d’autres Framework Java ............................................................ 17
CONCLUSION ........................................................................................................................ 18
 GLOSSAIRE

Abréviation Définition Description

API Application Interface permettant à deux applications de

Programming Interface communiquer entre elles.

CRUD Create, Read, Update, Ensemble des opérations de base pour la

Delete gestion des données.

DI Dependency Injection Technique consistant à injecter les dépendances

d'une classe depuis l'extérieur.

DTO Data Transfer Object Objet servant à transporter des données entre
les couches d'une application.

IDE Integrated Development Environnement de développement qui regroupe

Environment éditeur, compilateur et débogueur (ex. IntelliJ,
Eclipse).

IoC Inversion of Control Principe où le contrôle du flux d'exécution est

inversé, typique dans les Framework comme
Spring.

JAR Java ARchive Fichier compressé contenant les classes et

ressources d’une application Java.

JDK Java Development Kit Ensemble d’outils pour développer des

applications Java.

JPA Java Persistence API Spécification pour la gestion des données

relationnelles en Java.

JWT JSON Web Token Format compact pour transmettre de manière

sécurisée des informations entre deux parties.

0
 MVC Model-View-Controller Architecture séparant la logique métier,
l'interface utilisateur et la gestion des données.

ORM Object-Relational Technique de conversion entre des objets et des

Mapping tables de base de données.

REST Representational State Style d'architecture pour concevoir des services

Transfer web.

STS Spring Tool Suite Version d’Eclipse optimisée pour les projets
Spring.

VS Code Visual Studio Code Éditeur de code léger souvent utilisé pour le
développement web.

XSS Cross-Site Scripting Type d’attaque informatique consistant à

injecter du script malveillant dans une page
web.

CSRF Cross-Site Request Attaque où l’utilisateur connecté exécute des

Forgery actions non souhaitées sur une application web.

1
 INTRODUCTION

Dans un contexte où le numérique occupe une place centrale dans les entre- prises, le
développement d’applications web performantes et évolutives est de- venu un enjeu stratégique.
Les technologies modernes permettent de concevoir des solutions robustes, sécurisées et faciles
à maintenir. C’est dans cette optique que s’inscrit ce projet, qui vise à explorer et mettre en
œuvre une application web basée sur Spring Boot, un Framework open-source de l’écosystème
Java. Spring Boot est largement utilisé pour créer des applications web rapides à dé- ployer,
tout en respectant les bonnes pratiques de développement logiciel. Il simplifie la configuration
et l’initialisation des projets Spring, tout en offrant une grande flexibilité pour l’intégration de
bases de données, la gestion de la sécurité et la création d’API RESTful.

Ce rapport présente une analyse détaillée de Spring Boot, couvrant sa présentation, sa

configuration, son architecture, ses concepts fondamentaux, ses fonctionnalités avancées, ainsi
que ses avantages et limites. L’objectif est de démontrer l’intérêt de Spring Boot pour des
projets professionnels à travers une étude structurée et des exemples concrets.

2
1. PRESENTATION DE SPRING BOOT

1.1 Définition et historique

Spring Boot est un Framework open-source développé par Pivotal (aujourd’hui VMware)
pour simplifier le développement d’applications Java basées sur le Framework Spring. Lancé
en 2014, il a été conçu pour éliminer la complexité liée à la configuration manuelle de Spring,
en adoptant une approche basée sur la convention plutôt que la configuration. Spring Boot
permet de créer rapidement des applications autonomes, prêtes à être déployées, avec un
minimum de configuration grâce à l’autoconfiguration, l’utilisation de starters et l’intégration
d’un serveur embarqué (comme Tomcat).

1.2 Objectifs et avantages du Framework

Les principaux objectifs de Spring Boot sont :

— Accélérer le développement d’applications Spring en réduisant la configuration requise.

— Offrir une structure de projet cohérente pour les applications Java modernes.

— Fournir un système d’autoconfiguration intelligent basé sur les dépendances présentes.

— Simplifier les tests et le déploiement grâce à une approche modulaire et indépendante.

Ses avantages incluent :

— Gain de temps considérable lors de la mise en place de projets.

— Facilité de prise en main, notamment pour les débutants.

— Intégration native avec Spring Security, JPA, MVC, etc.

— Déploiement rapide grâce au serveur embarqué.

— Communauté active et documentation riche.

1.3 Cas d’usage

Spring Boot est utilisé dans divers contextes :

— Développement d’API REST performantes et sécurisées.

— Applications web et micro-services distribués dans des architectures cloud natives.

3
— Outils internes ou portails d’entreprise.

— Applications de traitement de données, intégration de services et automatisation.

Grâce à sa souplesse et sa robustesse, Spring Boot est devenu un Framework incontournable

pour le développement d’applications modernes, scalables et main- tenables.

4
2. CONFIGURATION DU FRAMEWORK ET OUTILS DE
DEVELOPPEMENT
2.1 Installation et Prérequis

2.1.1 Environnement requis

— Java JDK : Version 17 ou supérieure (Spring Boot 3.x).

— IDE recommandée : IntelliJ IDEA, Eclipse ou VS Code.

— Gestionnaire de dépendances : Maven ou Gradle.

— Outils complémentaires : Git, Postman, Docker (facultatif).

2.1.2 Création du projet

Un projet Spring Boot peut être créé via Spring Initializr en sélectionnant :

— Type de projet : Maven ou Gradle.

— Langage : Java.

— Version de Spring Boot : 3.x.

— Dépendances de base : Spring Web (API REST), Spring Data JPA (accès base de
données), Spring Boot DevTools (rechargement automatique), H2 Database (base en mémoire
pour tests), Spring Security (optionnel).

2.2 Structure typique d’un projet Spring Boot

Spring Boot adopte une structure organisée facilitant la lisibilité et la maintenabilité :

— Controller : Contient les contrôleurs REST (ex. UserController) pour gérer les requêtes
HTTP.

— Service : Contient la logique métier (ex. UserService).

— Repository : Interfaces d’accès aux données, souvent avec JPA (ex. UserRepository).

— Model : Entités représentant les tables de la base de données (ex. User, Product).

— Dto : Objets de transfert de données pour structurer les échanges.

5
— Config : Configurations personnalisées (ex. sécurité, CORS, Swagger).

— Static : Ressources statiques (CSS, JS, images).

— Templates : Fichiers HTML pour moteurs de templates comme Thymeleaf.

— Test : Tests unitaires et d’intégration.

2.3 Lancement de l’application

2.3.1 Depuis un IDE

1. Ouvre le projet dans l’IDE.

2. Repère la classe principale annotée avec @SpringBootApplication.

3. Clic droit sur la classe Run.

L’application démarre sur localhost :8080 par défaut.

2.3.2 Depuis la ligne de commande avec Maven

Dans le dossier racine du projet (où se trouve [Link]) :

mvn spring-boot:run

2.4 Outils de développement nécessaires

— Java JDK : Java 17 ou 21.

— IntelliJ IDEA ou Eclipse : IntelliJ Community suffit ; Eclipse nécessite

Spring Tools Suite (STS).

— Maven : Gestion des dépendances via [Link].

— Navigateur ou Postman : Pour tester les API REST.

— H2 Database : Base en mémoire accessible via [Link]

3. ARCHITECTURE ET COMPOSANTS CLES

3.1 Structure du projet Spring Boot
Spring Boot utilise une structure standardisée :

6
— src/main/java : Classes Java (contrôleurs, services, entités).

— src/main/resources : Fichiers de configuration ([Link]),

ressources statiques (CSS, JS), templates.

— src/test : Tests unitaires et d’intégration.

— [Link] ou [Link] : Gestion des dépendances et construction du

projet.

3.2 Annotations

Les annotations simplifient la configuration en remplaçant les fichiers XML :

— @SpringBootApplication : Active l’autoconfiguration et marque le point d’entrée.

— @Controller, @Service, @Repository : Définissent les rôles des classes (contrôleur,

logique métier, accès aux données).

— @Autowired : Injecte automatiquement les dépendances.

— @GetMapping, @PostMapping, @RequestMapping : Associent des requêtes HTTP

à des méthodes.

3.3 Starters et autoconfiguration

— Starters : Dépendances préconfigurées, ex. spring-boot-starter-web (applications web),

spring-boot-starter-data-jpa (JPA).

— Autoconfiguration : Configure automatiquement les composants selon les

dépendances, réduisant les configurations manuelles.

3.4 Serveur embarqué

Spring Boot intègre un serveur comme Tomcat, Jetty ou Undertow, permettant :

— Exécution sans serveur externe via un JAR exécutable.

— Personnalisation via [Link] (ex. [Link]=8081).

7
4. CONCEPTS FONDAMENTAUX
4.1 Injection des dépendances (DI)

L’injection des dépendances réduit le couplage entre composants via un conteneur IoC. Les
beans sont créés et injectés avec @Autowired, rendant le code flexible et testable.

4.2 Contrôleurs REST

Les contrôleurs REST, annotés avec @RestController, gèrent les requêtes HTTP et renvoient
des réponses JSON.

Exemple :

1. @RestController
2. @RequestMapping("/api")
3. public class MonControleur {
4.
5. @GetMapping("/bonjour")
6. public String direBonjour() {
7. return "Bonjour, monde !";
8. }
9. }
10.

4.3 Spring Data JPA et entité

Spring Data JPA simplifie l’accès aux bases de données :

— Entités : Classes Java annotées avec @Entity représentant des tables.

Exemples :|

6. @Entity
7. public class Utilisateur {
8.
9. @Id
10. @GeneratedValue(strategy = [Link])
11. private Long id;
12.
13. private String nom;
14.
15. // Getters et setters
16. public Long getId() {

8
17. return id;
18. }
19.
20. public void setId(Long id) {
21. [Link] = id;
22. }
23.
24. public String getNom() {
25. return nom;
26. }
27.
28. public void setNom(String nom) {
29. [Link] = nom;
30. }
31. }
32.

— Repositories : Interfaces étendant JpaRepository pour des opérations CRUD

automatiques.

Exemple :

1. @Repository
2. public interface UtilisateurRepository extends JpaRepository<Utilisateur, Long> {
3. // Méthodes personnalisées éventuelles (ex : findByNom(String nom))
4. }
5.

4.4 Requêtes HTTP et gestion des routes

Les contrôleurs utilisent @GetMapping, @PostMapping, etc., pour définir des routes.
Les données sont extraites via @RequestParam ou @PathVariable.

1. @RestController
2. @RequestMapping("/api/utilisateurs")
3. public class UtilisateurController {
4.
5. // Exemple de GET avec @RequestParam
6. @GetMapping("/rechercher")
7. public String rechercherParNom(@RequestParam String nom) {
8. return "Recherche de l'utilisateur avec le nom : " + nom;
9. }
10.
11. // Exemple de GET avec @PathVariable
12. @GetMapping("/{id}")

9
13. public String obtenirUtilisateur(@PathVariable Long id) {
14. return "Utilisateur avec l'ID : " + id;
15. }
16.
17. // Exemple de POST
18. @PostMapping("/ajouter")
19. public String ajouterUtilisateur(@RequestBody Utilisateur utilisateur) {
20. return "Utilisateur ajouté : " + [Link]();
21. }
22. }
23.

4.5 Gestion des exceptions et validations

— Gestion des exceptions : Centralisée avec @ControllerAdvice et @ExceptionHandler.

— Validations : Utilisation de @Valid, @NotNull, @Size pour valider les

don- nées.

Exemple :

1. @ControllerAdvice
2. public class GlobalExceptionHandler {
3.
4. @ExceptionHandler([Link])
5. public ResponseEntity<String> handleResourceNotFound(ResourceNotFoundException ex) {
6. return [Link](HttpStatus.NOT_FOUND).body([Link]());
7. }

10
5. MISE EN ŒUVRE PRATIQUE
5.1 Étapes de création d'un projet Spring Boot

5.1.1 Initialisation du projet

L'application TechHotel a été créée en utilisant Spring Boot 3.2.0 comme Framework
principal. Le projet a été initialisé avec Spring Initializr pour générer la structure de base et
configurer les dépendances nécessaires. La classe principale TechHotelApplication utilise
l'annotation @SpringBootApplication qui regroupe trois annotations essentielles :
@Configuration, @EnableAutoConfiguration, et @ComponentScan. Cette configuration
permet l'autoconfiguration automatique des composants Spring et le démarrage simplifié de
l'application.
L'application est configurée pour s'exécuter sur le port 9192, ce qui permet d'éviter les conflits
avec d'autres services fonctionnant sur les ports standards. Cette configuration facilite
également le déploiement et les tests en environnement de développement.

5.1.2 Architecture et pattern Repository

L'architecture de l'application suit le pattern Repository avec une séparation claire des
responsabilités en trois couches distinctes :
· Repository : Cette couche gère exclusivement toutes les interactions avec la base de
données MySQL. Elle utilise JDBC pur sans Hibernate pour un contrôle précis des requêtes
SQL et des performances optimisées.
· Service : Cette couche intermédiaire contient toute la logique métier de l'application. Elle
traite les règles business, effectue les validations nécessaires et coordonne les appels vers la
couche Repository.
· Controller : Cette couche expose les Endpoint REST avec les mappings HTTP appropriés.
Elle gère les paramètres de requête (query parameters), les paramètres de chemin (path
variables) et les données du corps de requête (request body).

5.1.3 Stack technique

Le projet utilise Maven comme outil de gestion des dépendances, facilitant la gestion des
versions et l'intégration des différentes bibliothèques. L'ensemble technologique comprend
Spring Security pour l'authentification et l'autorisation, ainsi que JWT (JSON Web Token) pour
la sécurité basée sur les tokens.

11
5.2 Exemple d'application CRUD

5.2.1 Gestion des chambres (Room Management)

L'application implémente un système CRUD complet pour la gestion des chambres d'hôtel. Les
fonctionnalités principales incluent :

● Listing et recherche des chambres : Les utilisateurs peuvent consulter toutes les
chambres disponibles et effectuer des recherches basées sur différents critères. Le
système permet de filtrer les chambres par type (simple, double, suite, etc.) et de vérifier
la disponibilité selon les dates de séjour souhaitées.

● Gestion administrative : Les administrateurs disposent de privilèges étendus pour

ajouter de nouvelles chambres, mettre à jour les informations existantes (prix,
description, équipements) et supprimer des chambres du système. Ces opérations sont
protégées par des autorisations basées sur les rôles utilisateurs.

● Recherche avancée : Le système propose une fonctionnalité de recherche sophistiquée

permettant aux clients de trouver des chambres selon leurs critères spécifiques : type de
chambre, dates de disponibilité, et autres préférences.

5.2.2 Système de réservation (Booking System)

Le système de réservation constitue le cœur fonctionnel de l'application avec plusieurs

composants interconnectés :

● Processus de réservation : Les clients authentifiés peuvent réserver des chambres

disponibles en spécifiant leurs dates de séjour. Le système vérifie automatiquement la
disponibilité et traite la demande de réservation.

● Confirmation et suivi : Chaque réservation génère une confirmation avec un identifiant

unique. Les utilisateurs peuvent consulter l'historique complet de leurs réservations,
incluant les réservations passées, actuelles et futures.

● Gestion des annulations : Le système permet aux utilisateurs d'annuler leurs

réservations selon les conditions définies, avec mise à jour automatique de la
disponibilité des chambres.

12
5.2.3 Gestion des utilisateurs

L'application implémente un système complet de gestion des utilisateurs avec plusieurs niveaux
d'accès :

● Inscription et authentification : Les nouveaux utilisateurs peuvent créer un compte

via un processus d'inscription sécurisé. L'authentification utilise JWT pour maintenir les
sessions utilisateurs de manière stateless.

● Autorisation basée sur les rôles : Le système distingue deux types d'utilisateurs
principaux : les administrateurs qui ont accès à toutes les fonctionnalités de gestion, et
les clients qui peuvent consulter et réserver des chambres.

● Gestion des profils : Les utilisateurs peuvent gérer leurs informations personnelles et
consulter leur historique d'activité sur la plateforme.

5.3 Connexion à la base de données

5.3.1 Configuration MySQL

L'application utilise MySQL comme système de gestion de base de données principal. La

connexion est établie via JDBC pur, sans utiliser Hibernate comme couche ORM. Ce choix
technique permet un contrôle précis des requêtes SQL et optimise les performances pour les
opérations spécifiques à l'application.

5.3.2 Gestion des données

La base de données est structurée pour supporter toutes les fonctionnalités de l'application :
tables pour les chambres, les utilisateurs, les réservations, et les rôles. Les relations entre ces
entités sont maintenues par des contraintes de clés étrangères garantissant l'intégrité
référentielle.
La couche Repository encapsule toutes les opérations de base de données, offrant une interface
claire et maintenir une séparation nette entre la logique métier et l'accès aux données. Cette
approche facilite la maintenance du code et permet des tests unitaires efficaces.

13
5.3.3 Sécurité des données

L'accès à la base de données est sécurisé par des mécanismes d'authentification appropriés. Les
requêtes sont protégées contre les injections SQL grâce à l'utilisation de PreparedStatements
dans la couche JDBC.

5.4 Test et exécution de l'application

5.4.1 Architecture REST

L'application expose une API RESTful bien structurée avec des controllers dédiés pour chaque
domaine fonctionnel : rooms, bookings, authentication, users, et roles. Chaque endpoint
respecte les conventions REST avec les méthodes HTTP appropriées (GET, POST, PUT,
DELETE) et les codes de statut HTTP standards.

5.4.2 Sécurité des endpoints

Spring Security protège l'ensemble des endpoints selon une stratégie d'autorisation fine. Les
endpoints publics permettent la consultation des chambres disponibles, tandis que les
fonctionnalités de réservation nécessitent une authentification. Les opérations administratives
sont restreintes aux utilisateurs ayant le rôle ADMIN.

5.4.3 Intégration frontend

Bien que l'accent soit mis sur l'application Spring Boot, l'API est conçue pour s'intégrer
parfaitement avec le frontend React développé avec Vite. Les endpoints sont configurés avec
CORS pour permettre les requêtes cross-origin depuis l'application cliente.

5.4.4 Tests et validation

L'application inclut une suite de tests pour valider le bon fonctionnement des différentes
couches. Les tests couvrent les aspects fonctionnels (logique métier), les interactions avec la
base de données, et la sécurité des endpoints. L'utilisation de Spring Boot Test facilite l'écriture
et l'exécution de tests d'intégration complets.

14
5.4.5 Déploiement et exécution

L'application peut être exécutée facilement grâce à l'autoconfiguration de Spring Boot. Le

serveur embarqué démarre automatiquement sur le port configuré, rendant l'application
accessible pour les tests et le développement. La configuration externalisée permet l'adaptation
à différents environnements (développement, test, production) sans modification du code
source.

15
6. FONCTIONNALITES AVANCEES

6.1 Sécurité avec Spring Security

Spring Security protège les applications via :

— Authentification et autorisation (formulaires, rôles).

— Gestion des utilisateurs (mémoire, base de données, OAuth2).

— Protection contre CSRF, XSS, session fixation.

— JWT pour les API REST stateless.

6.2 Spring Boot Actuator

Actuator fournit des endpoints pour le monitoring (/actuator/health, /actuator/metric

Ajout via :

1. <dependency>
2. <groupId>[Link]</groupId>
3. <artifactId>spring-boot-starter-actuator</artifactId>
4. </dependency>
5.

6.3 Déploiement

— JAR exécutable : java -jar target/[Link].

— Serveur distant : Copie du JAR, utilisation de Nginx, configuration systemd.

— Cloud : Heroku, AWS, Google Cloud, Azure.

— Docker : Conteneurisation pour Kubernetes.

16
7. AVANTAGES ET LIMITES

7.1 Bénéfices pour les développeurs

— Productivité accrue : Autoconfiguration et Spring Initializr.

— Structure claire : Architecture MVC, DAO, services.

— Écosystème riche : Intégration avec Spring Security, Data, Cloud.

— Tests facilités : Support JUnit, MockMvc.

— Déploiement simplifié : JAR exécutable, serveur embarqué.

— Communauté : Documentation complète, forums actifs.

— Flexibilité et évolutivité : Adapté à divers projets.

7.2 Limites selon les besoins

— Surcharge initiale en mémoire due à l’autoconfiguration.

— Courbe d’apprentissage pour maîtriser l’écosystème Spring.

— Fichiers JAR volumineux.

— Rigidité pour des configurations spécifiques.

— Couplage fort à l’écosystème Spring.

— Moins optimal pour micro-services ultra-légers (comparé à Micronaut,

Quar- kus).

7.3 Comparaison avec d’autres Framework Java

— Spring Boot : Écosystème vaste, forte communauté, mais lourd en ressources.

— Jakarta EE : Standard, intégration entreprise, mais configuration verbeuse.

— Micronaut : Léger, démarrage rapide, mais communauté plus petite.

— Quarkus : Cloud-native, rapide, mais moins mature.

17
 CONCLUSION
Le Framework Spring Boot s’affirme comme une réponse efficace aux limites de la
configuration traditionnelle du Framework Spring. En favorisant une approche basée sur la
simplicité, la rapidité de mise en œuvre et l’autoconfiguration, il permet de concevoir des
applications Java modernes de manière structurée et productive. Son adoption croissante dans
les entreprises témoigne de sa pertinence dans les projets actuels. Toutefois, bien que Spring
Boot soit largement adopté et apprécié, il n’est pas exempt de limites, notamment dans les
environnements nécessitant des configurations très spécifiques ou une maîtrise totale du
comportement de bas niveau. En somme, Spring Boot est un outil puissant et polyvalent, idéal
pour les projets professionnels modernes, tout en nécessitant une compréhension approfondie
pour exploiter pleinement ses capacités.

18 | P a g e
19 | P a g e