Introduction à Spring Boot
Mehdi Selem
Qu'est-ce que Spring Boot ?
• Définition: Framework Java basé sur Spring
pour simplifier le développement
d'applications.
• Avantages:
• Configuration minimale
• Serveur intégré
• Productivité accrue
Caractéristiques Principales de Spring
Boot
• Configuration automatique (Auto-
Configuration): Simplifie la configuration
initiale en fonction des dépendances déclarées.
• Système de gestion des dépendances
(Spring Initializr) : Outil puissant pour la
génération rapide de projets configurés selon vos
besoins.
• Injection de dépendances : Favorise un
développement découplé grâce à la gestion
automatisée des objets.
• Facilité de test :Offre un support intégré pour
les tests unitaires et d'intégration, accélérant le
cycle de développement.
Architecture Spring Boot (Vue
d'ensemble)
• Présentation des couches:
• Contrôleur (Controller) :Responsable de la
gestion des requêtes HTTP et de la communication
avec la couche service. Les contrôleurs servent
d’interface entre l’utilisateur et l’application
• Service : Contient la logique métier. Cette couche
centralise les règles fonctionnelles pour garantir une
séparation claire des responsabilités
• Référentiel (Repository): Interagit directement
avec la base de données pour effectuer les
opérations CRUD (Créer, Lire, Mettre à jour,
Supprimer).
IoC (Inversion de Contrôle)
• Définition :Principe de conception où la responsabilité de
créer et de gérer les objets est transférée à un conteneur
(Spring IoC). Ce conteneur centralise la gestion des
dépendances et facilite leur injection dans les différentes
couches de l’application.
• Avantage:
•Découplage des composants : Les classes ne dépendent plus
directement les unes des autres, ce qui améliore la modularité et
la maintenabilité.
•Réduction de la complexité : Le développeur se concentre sur
la logique métier, tandis que le conteneur gère les dépendances.
• Exemple:
•@Component : Déclare un composant générique.
•@Service : Spécifique aux composants contenant la logique métier.
•@Repository : Spécifique aux composants d’accès aux données
Comment fonctionne IoC dans Spring ?
• Rôle du Conteneur IoC :
Le conteneur IoC (Inversion of Control) de Spring gère les beans de
l’application. Il s’assure de leur création, leur configuration, leur
gestion et leur destruction tout au long du cycle de vie de l’application.
• Création Automatisée des Instances :
•Les développeurs définissent les dépendances via des annotations
(@Component, @Service, @Repository, etc.) ou des méthodes annotées
(@Bean).
•Le conteneur détecte ces définitions et crée automatiquement les
instances nécessaires, injectant les dépendances au bon moment.
Qu'est-ce qu'un Spring Bean ?
• Définition:
Un Spring Bean est un objet instancié, configuré et géré par le conteneur
IoC (Inversion of Control) de Spring. Les Spring Beans sont les composants
fondamentaux de toute application Spring. Ils permettent de centraliser et
de simplifier la gestion des objets et leurs dépendances, favorisant ainsi
une architecture modulaire, maintenable et découplée.
• Caractéristique de Spring beans
• Gestion par le conteneur IoC :
– Le conteneur IoC de Spring est responsable de la
création, l'injection, la gestion du cycle de vie et la
destruction des beans.
– Cela favorise une injection de dépendances (DI) fluide
et un couplage faible entre les composants de
l’application.
• Configuration déclarative :
– Un bean peut être déclaré dans un fichier de
configuration XML, un fichier de configuration Java
(via la classe annotée avec @Configuration), ou
directement grâce à des annotations.
• Portée (Scope) :
– Par défaut, les beans Spring sont de portée singleton
(une seule instance partagée dans tout le conteneur
IoC). Cependant, d'autres portées sont disponibles,
comme prototype, request, session, ou encore application.
Cycle de Vie d’un Bean :
• Instantiation : Le conteneur IoC crée une instance du bean.
• Injection des Dépendances : Les dépendances nécessaires
sont injectées (via constructeur, setters ou champs).
• Initialisation : Méthodes spécifiques, comme celles annotées
avec @PostConstruct, sont exécutées.
• Utilisation : Le bean est prêt à être utilisé dans l’application.
• Destruction : Avant la suppression du bean, le conteneur
exécute les méthodes annotées avec @PreDestroy pour
libérer les ressources.
Déclaration d’un Spring Bean
• Spring fournit plusieurs annotations et approches pour
déclarer un bean :
• 1. Annotation @Component (et dérivées)
L'annotation @Component marque une classe comme un
Spring Bean détecté automatiquement par le mécanisme de
scan des composants (@ComponentScan).
Exemple :
@Component
public class MonBean {
public void afficherMessage() {
[Link]("Bonjour, je suis un bean Spring !");
}
}
• 2. Annotations dérivées de @Component :
Ces annotations spécialisent les rôles des beans dans l'application :
– @Service : Utilisée pour les composants de logique métier.
– @Repository : Utilisée pour les classes qui accèdent à la base de
données. Elle active également des fonctionnalités spécifiques comme
la gestion des exceptions JDBC.
– @Controller : Utilisée dans le cadre des applications Web pour
désigner un contrôleur Spring MVC.
Exemple avec un service :
@Service
public class MonService {
public String fournirService() {
return "Service fourni par MonService.";
}
}
• 3. Annotation @Bean
• L'annotation @Bean est utilisée dans une classe de configuration
pour déclarer manuellement un bean au conteneur Spring. Cette
méthode est idéale lorsque vous avez besoin d’un contrôle plus fin
ou d’une configuration personnalisée.
• Exemple :
@Configuration
public class ConfigurationBeans {
@Bean
public MonBean monBean() {
return new MonBean();
}
}
Injection de Dépendances
• Définition:
• L’injection de dépendances est une technique de conception utilisée pour fournir les
dépendances nécessaires à une classe, au lieu que cette dernière les crée elle-même.
Cette approche est rendue possible par l'Inversion of Control (IoC), où le conteneur IoC
gère la création, la gestion et l’injection des objets.
• En termes simples, au lieu que votre classe soit responsable de créer ou de localiser ses
dépendances, celles-ci lui sont fournies par une entité externe (par exemple, le
conteneur Spring).
• Types d’Injection de Dépendances
• Spring propose plusieurs méthodes pour
injecter des dépendances dans une classe :
• 1. Injection par Constructeur
• Les dépendances sont passées via le constructeur de la classe.
• Cette méthode est recommandée lorsque les dépendances sont obligatoires pour que la classe fonctionne
correctement.
• Exemple :
@Component
public class MonService {
private final MonRepository repository;
// Injection par constructeur
@Autowired
public MonService(MonRepository repository) {
[Link] = repository;
}
public void traiter() {
[Link]();
}
}
@Component
public class MonRepository {
public void executerRequete() {
[Link]("Requête exécutée !");
}
}
• Ici, MonService dépend de MonRepository, et la dépendance est injectée via le constructeur
• Injection par Setter
Les dépendances sont fournies via des méthodes setters (mutateurs).
Cette méthode est idéale lorsque les dépendances sont facultatives ou
peuvent être modifiées après l’instanciation de l’objet.
• Exemple :
@Component
public class MonService {
private MonRepository repository;
// Injection par setter
@Autowired
public void setRepository(MonRepository repository) {
[Link] = repository;
}
public void traiter() {
[Link]();
}
}
Injection par
Critère Injection par Setter
Constructeur
Obligation des Recommandée pour les Recommandée pour les
dépendances dépendances obligatoires dépendances facultatives
Plus lisible, car les Moins explicite, car les
Lisibilité dépendances sont claires dépendances peuvent être
dès l’instanciation définies ultérieurement
Favorise l’immuabilité des Peut conduire à des
Immutabilité
dépendances dépendances modifiables
Contrôleur (Controller)
• Rôle :
• Un Controller est une classe en Spring Boot responsable de traiter
les requêtes HTTP (GET, POST, PUT, DELETE, etc.) reçues par
l'application et de fournir une réponse appropriée. Il agit comme
une passerelle entre les services (logique métier) et les clients
(navigateur, API client, etc.).
• Les Controllers sont des composants majeurs dans les applications
web basées sur le modèle MVC (Model-View-Controller) :
• Ils reçoivent les requêtes des clients.
• Ils appellent les services pour exécuter la logique métier.
• Ils renvoient les réponses (au format JSON, HTML, XML, etc.).
• @Controller : Indique une classe qui gère les requêtes et retourne
généralement des vues HTML via un moteur de rendu comme Thymeleaf
ou JSP.
• @RestController : Une combinaison de @Controller et @ResponseBody,
utilisée pour retourner des réponses directement sous forme JSON ou
XML (API REST).
Explication des annotions :
• @RestController :Spécifie que cette classe est un Controller REST et que les
réponses seront directement converties en JSON ou XML grâce à Jackson ou
un autre convertisseur.
• · @RequestMapping("/ ") :
• Définit une URL de base pour toutes les méthodes de ce Controller, example :
comme /products. Les requêtes à /products et /products/{id} seront routées
vers ce Controller.
• · @GetMapping, @PostMapping, @PutMapping, @DeleteMapping :
• Indiquent le type de requête HTTP (GET, POST, PUT ou DELETE) que chaque
méthode est censée gérer.
• · @RequestBody :
• Lie le corps de la requête HTTP au paramètre de la méthode. Par exemple,
dans une requête POST ou PUT, on utilise cette annotation pour récupérer les
données envoyées (généralement en JSON).
• · @PathVariable :
• Permet de récupérer les variables dans l’URL, comme l’identifiant d’un produit
(par exemple : /products/3 récupère l’ID 3).
Service
Rôle :
• Un Service est une classe dans Spring Boot qui contient la logique
métier de l'application. Il s'agit d'une couche intermédiaire entre le
Controller (interface utilisateur) et le Repository (accès à la base de
données).
• Le Service s'occupe de traiter les données et d'appliquer les règles
métier avant de les transmettre à un Repository ou de les renvoyer
au Controller.
• Il favorise une séparation claire des responsabilités et permet un
code mieux organisé et plus facile à tester.
Annotation principale :
• @Service : Indique que la classe est un composant métier. Spring la
détecte automatiquement comme un Spring Bean, ce qui permet
l'injection de dépendances
Repository
Rôle :
• Un Repository est une interface ou une classe dans Spring Boot
utilisée pour accéder à la base de données. Il fournit des
opérations CRUD (Create, Read, Update, Delete) en interagissant
avec des entités JPA.
• Il simplifie l'interaction avec la base de données grâce à Spring
Data JPA.
• Les Repository encapsulent les requêtes SQL et permettent
d'utiliser un code Java orienté objet pour manipuler les données.
Annotation principale :
• @Repository : Indique que cette interface/classe est un composant
de la couche d'accès aux données. Elle permet à Spring de gérer les
exceptions liées à la base de données de manière transparente.
Couche Rôle
Gère les requêtes HTTP. Appelle les
Controller
Services.
Service Contient la logique métier.
Repository Accède aux données de la base.
