framework open-source pour Java

utilisé pour créer des applications entreprises, c’est-à-dire des applications robustes,
modulaires et évolutives, souvent complexes.

Complet
Spring est modulaire
il propose plein d’outils pour différents besoins
tu peux utiliser seulement les parties dont tu as
(gestion des données, sécurité, web, etc.)
besoin (par exemple Spring MVC pour le web,
Spring Data pour les bases de données…)

Il rend le développement plus facile grâce à :

injection de dépendances

Simplifies the
development of Java gestion des transactions
applications

configuration centralisée

...

Spring encourage Spring encourage les bonnes pratiques de programmation, comme le pattern

les bonnes MVC, l’inversion de contrôle (IoC), et d’autres design patterns pour avoir un

pratiques code propre et maintenable.

 Avantages

Enterprise-Level
Applications Modular
Pourquoi ? Parce que Spring
Development

gère la scalabilité, la sécurité et

Chaque fonctionnalité peut être

la maintenance facilement. développée et testée séparément.

Tu peux ajouter ou enlever des modules

sans casser le reste de l’application.

Data Access

Spring Data simplifie l’accès aux bases de

données, la gestion des transactions et les
opérations CRUD Web Development
Spring est excellent pour le
développement web grâce à
Spring MVC et Spring Boot
 Advantages of Spring Framework

Tu n’as pas besoin d’écrire tout le code répétitif (connexion, gestion des
exceptions, transactions, fermeture de connexion…).
Avec JdbcTemplate, tu écris seulement la requête SQL — Spring s’occupe du reste.
Predefined Templates (Modèles
prédéfinis)

Spring propose des classes toutes

prêtes (templates) pour travailler avec moins de code

des technologies comme JDBC, de productivité
moins d’erreurs
Hibernate, ou JPA.

Loose Coupling (Faible 👉 Si tu changes une classe, tu n’as pas besoin de tout modifier.
couplage)

Grâce à l’injection de dépendances

(DI), les composants ne dépendent pas

directement les uns des autres. ton application devient

application devient
plus flexible plus maintenable

Easy to Test (Facile à tester)

Comme Spring utilise la DI, tu peux

Note
Tu peux exécuter ou tester ton code sans dépendre d’un serveur
remplacer facilement des dépendances
d’application (comme Tomcat, JBoss, ou GlassFish)
par des objets de test (mocks).

Et contrairement à EJB ou Struts, tu

n’as pas besoin d’un serveur pour
les tests unitaires sont
exécuter tes tests. simples et rapides.
Sans serveur

Lightweight (Léger)

Spring est léger car il repose sur

👉 Tu n’es pas obligé d’étendre une classe ni d’implémenter une
interface propre à Spring.
des POJO (Plain Old Java

Objects) — des classes Java

simples sans héritage spécial.

ton code reste propre indépendant du framework
et simple (non-invasif).
 Fast Development
(Développement rapide)
le développement
Grâce à : devient plus rapide et
efficace
l’injection de dépendances,

la modularité,

et l’intégration avec d’autres

frameworks (Hibernate, JPA, etc.),

6) Powerful Abstraction
(Abstraction puissante)
Spring fournit des couches d’abstraction pour simplifier l’utilisation d’API complexes :
JDBC (accès base de
👉 Tu utilises une interface Spring uniforme sans te soucier des détails techniques.
données)
JPA (gestion d’entités)
JMS (messagerie)

JTA (transactions)
Simplifie les API
complexes

Declarative Support (Support

déclaratif)

Tu peux configurer le
comportement
(transactions, sécurité, etc.)
meilleure séparation des
via des annotations ou des moins de code responsabilités.
fichiers XML, sans écrire de
code métier supplémentaire.
 est un principe clé du framework Spring.

Elle consiste à déléguer la création et la gestion des dépendances d’une classe au

Dependency Injection
framework, au lieu de les instancier directement dans le code.

Cela permet d’obtenir un code faiblement couplé, plus flexible et plus facile à tester.

Ce mécanisme est géré par le conteneur IoC (Inversion of Control) de Spring

IoC (Inversion of Control) de Spring c’est le cœur même de Spring Framework 🌿

C’est lui qui :

crée les objets (appelés beans)

gère leurs dépendances et contrôle leur cycle de vie (création, injection, destruction).

👉 Au lieu que toi, développeuse, tu contrôles la création des objets, c’est le conteneur Spring qui prend le contrôle à ta place.

La relation entre l’inversion de contrôle et l’injection de dépendances

🧠 IoC est le concept, 💉 DI est la technique pour le réaliser.

L’Inversion of Control est un principe selon lequel le framework gère la création et la gestion des

objets à la place du développeur.

La Dependency Injection est le mécanisme utilisé par Spring pour appliquer ce principe, en injectant

automatiquement les dépendances nécessaires aux classes.

 architecture Spring
décrit la structure interne du framework
→ Elle montre comment les différents modules (Core, Web, Data, etc.) s’articulent ensemble pour
construire des applications Java puissantes et modulaires.

Les principaux modules de l’architecture Spring :

 Core Container Tout le reste du framework Spring dépend de lui.
(le cœur du
Il fournit les fonctionnalités essentielles qui permettent à Spring de fonctionner
framework)
Sans le Core Container, les autres modules de Spring (comme Spring
MVC, Spring Data, Spring Security, etc.) ne pourraient pas fonctionner

correctement.

il est divisé en quatre morceaux (sous-modules)

“sous-modules” = des petits modules à l’intérieur du Core Container, chacun s’occupant d’une
fonction précise pour que Spring fonctionne correctement.

Le sous-module Beans s’occupe de comment créer ces objets (appelés beans) , les configurer et les gérer.

Les “beans” = les objets que Spring crée et gère pour toi.
Beans

C’est le noyau de Spring, celui qui fournit les fonctionnalités de base.

Core IoC (Inversion of Control) : Spring décide qui crée quoi, au lieu que ton code fasse tout manuellement.
DI (Dependency Injection) : Spring met automatiquement les bonnes dépendances dans tes objets.

Le Core Container est donc le moteur IoC/DI de Spring.

Permet d’accéder aux objets créés par Spring (les beans).

Context
Il gère aussi le cycle de vie : création, utilisation, destruction des objets

(Spring Expression Language)

SpEL langage d’expression utilisé pour accéder dynamiquement aux objets, propriétés et méthodes dans
les fichiers de configuration.
 Data Access / Gère tout ce qui touche à la persistance et l’intégration des données.
Integration

Sert à accéder à une base de données (comme MySQL, Oracle…).

JDBC Spring fournit JdbcTemplate pour simplifier les opérations (sélection, insertion, suppression, mise à jour).

Sans Spring, tu devrais écrire beaucoup de code pour te connecter, fermer la connexion, gérer les
exceptions… JdbcTemplate fait tout ça automatiquement.

Object Relational Mapping

Permet de lier les objets Java à une base de données.
ORM
Spring peut travailler avec Hibernate, JPA, MyBatis pour que tu n’aies pas à écrire de SQL
compliqué pour chaque objet.

Object-XML Mapping

OXM Sert à convertir des objets Java en XML et vice-versa.

Pratique si tu dois échanger des données en XML avec d’autres systèmes.

Java Messaging Service

Sert à envoyer des messages entre applications de manière asynchrone.
JMS
JMS n’est pas utilisé uniquement en microservices : dans un monolithe, il peut servir à
traiter des tâches en arrière-plan, par exemple envoyer un email après l’inscription d’un
utilisateur.

Permet de gérer les transactions (par ex. base de données) sans écrire beaucoup de code.

Transactions Tu peux dire à Spring : “cette méthode doit être exécutée dans une transaction, si ça échoue, tout est annulé”.

Très utile pour éviter les problèmes quand plusieurs opérations dépendent les unes des autres.
 Web Gère les applications web et REST.
(Développement
Web) Spring Web te permet de développer des applications web modernes facilement.
Cette couche du framework s’occupe de tout ce qui permet à une application Spring
d’interagir avec le web

Sous-modules :

Une servlet est la brique de base du web en Java.

Elle sert à traiter les requêtes HTTP (ex : quand un utilisateur clique sur un bouton ou envoie un formulaire).
Servlet
Spring utilise les servlets, mais il les rend plus simples grâce à son module Spring MVC (on n’a plus besoin
d’écrire les servlets nous-mêmes).

➡️ Donc : Spring MVC repose sur le module Servlet, mais il simplifie énormément son utilisation.

Sans Spring, tu écris :

Avec Spring MVC, c’est plus simple

Sert à faire de la communication bidirectionnelle en temps réel entre le serveur et le navigateur.

WebSocket Contrairement à HTTP (où le client doit toujours demander quelque chose), WebSocket permet
au serveur d’envoyer des messages à tout moment.

C’est le module principal pour les applications web.

Il contient Spring MVC (Model-View-Controller), une architecture très utilisée pour séparer :
Web
1. Model → les données (ex : classes Java, base de données)
2. View → l’interface utilisateur (HTML, Thymeleaf, JSP…)
3. Controller → la logique métier (reçoit les requêtes et renvoie les réponses)

Ancien module, aujourd’hui rarement utilisé.

Servait à créer des applications web dans des portails (comme Liferay).
Portlet Chaque portlet est un petit composant web intégré dans une page plus grande.
🧠 Exemple :
Sur un tableau de bord, tu as un portlet météo, un portlet messages, un portlet tâches.
Chaque petit bloc est une mini-application web.

➡️ Aujourd’hui, la plupart des développeurs n’utilisent plus les portlets, car les applications modernes sont
SPA (Single Page Applications) ou REST APIs.
 AOP = Aspect (AOP = Programmation orientée aspect)
Oriented Spring AOP
Programming AOP sert à séparer le code “technique” du code “métier”, pour éviter
de répéter les mêmes instructions partout dans ton application.

Aspect

une classe spéciale qui contient du code à exécuter automatiquement dans plusieurs endroits de ton

application (sans que tu l’écrives partout).

C’est une façon d’ajouter du comportement commun (comme la sécurité, les logs, les transactions) sans

répéter ce code dans toutes tes classes.

Imaginons que tu développes une application bancaire avec deux méthodes :

Mais à chaque fois, tu veux aussi :

[Link] un message avant chaque opération (“Action commencée”),

[Link] un message après (“Action terminée”).

Mais tu devrais copier-coller ces 2 lignes dans toutes tes méthodes (et c’est nul 😅).

Avec Spring AOP, tu peux écrire ce comportement une seule fois dans une classe
Aspect, et Spring va l’exécuter automatiquement avant et après chaque méthode
que tu choisis.

@Aspect : dit à Spring “cette classe est un aspect”.

@Before(...) : exécute cette méthode avant les méthodes de BankService.
@After(...) : exécute cette méthode après les méthodes de BankService.

Une classe spéciale qui contient du

Aspect code réutilisable (ex : logs, sécurité,
transactions).

Méthode à exécuter avant, après ou

Advice
autour d’une autre méthode.

Indique sur quelles méthodes ou

Pointcut
classes appliquer l’aspect.
 AOP = Aspect
Oriented Aspect
Programming

AOP = la philosophie ou le mécanisme global. Aspect = la mise en pratique de ce concept

Le principe général de séparer les Une classe concrète où tu écris le code transversal
préoccupations transversales

(sécurité, logs, transactions, etc.) du code

métier (le cœur de ton application).

Instrumentation

Ajouter du code ou surveiller le code pendant qu’il s’exécute, sans toucher au code source original.

Comment ça marche :

Spring peut utiliser des outils comme Java Instrumentation API pour « écouter » ou modifier les

classes pendant qu’elles s’exécutent. Par exemple, tu peux compter combien de fois une méthode est

appelée sans toucher à cette méthode.

💡 Exemple concret :
Tu as une méthode processPayment(). Avec l’instrumentation, tu peux mesurer automatiquement

combien de fois elle est appelée et combien de temps elle prend à chaque appel, sans ajouter de

[Link] partout.

3 façons pour faire

Via Spring AOP (le plus simple)

Via Java Instrumentation API (bas niveau)

Avec Spring Boot Actuator

 Messaging

Permet à des applications ou des composants d’échanger des messages de façon

asynchrone, souvent utile dans les microservices.

Test

Le vrai pouvoir de ce module, c’est de permettre de tester les composants Spring

dans un contexte réaliste, mais sans tout démarrer manuellement ni dépendre
d’un serveur.

Tu explores Spring Architecture surtout pour planifier ton application,

résoudre les problèmes et intégrer d’autres technologies.

Pour explorer Spring Architecture, tu dois regarder 6 couches clés :

Core Container → comment Spring gère tes beans
AOP → gérer les comportements transversaux
Data Access → accéder aux données proprement

Transactions → garder la DB cohérente

MVC → construire des applications web

Intégration → connecter Spring aux autres technos

 Le framework :
crée les objets (beans)

les configure

les relie entre eux

gère leur cycle de vie

Tu écris juste les classes, et Spring s’occupe de les faire fonctionner ensemble.

On bénéficie de quoi ?

Comme les classes ne gèrent plus la création des objets, elles peuvent se
concentrer uniquement sur leur rôle (business logic).

( séparer clairement les responsabilités )

Grâce à IoC, Spring injecte les dépendances dans une classe.

Tu peux donc remplacer ces dépendances par :
des mocks,
des fakes,
ou des stubs
lors de tests unitaires.
 Comment peut-on appliquer l’injection des dépendances ?

Constructor Injection → Method Injection → rare, utilisée

dépendances fournies via le
Setter Injection → dépendances dans des cas spécifiques (Spring
injectées via des setters
constructeur (la méthode la plus peut injecter une dépendance au
recommandée) moment de l’appel d’une
méthode)

Spring IoC Container

C’est BeanFactory (conteneur IoC simple)

la création des objets (beans)

l ne fait rien d’autre.
la résolution des dépendances
Il ne gère pas des fonctionnalités avancées comme :
la durée de vie des beans
l’internationalisation
la configuration globale du système
les événements

les aspects Spring AOP

le chargement automatique des beans

C’est ApplicationContext (conteneur IoC complet) ⟶ c’est ce qu’on utilise souvent

Il inclut tout ce que fait BeanFactory, plus beaucoup de fonctionnalités supplémentaires :

✔ Il gère :
Spring AOP

les événements d’application

les messages (internationalisation)

l’injection automatique (@Autowired)

les annotations (@Service, @Controller, etc.)

les profils Spring (@Profile)

la lecture automatique des fichiers de configuration

👉 C’est lui qui fait de Spring un framework moderne, puissant et flexible.

BeanFactory = moteur basique qui crée les objets.

ApplicationContext = moteur complet + toute l’infrastructure Spring autour.

 Configuration — Les 3 façons de configurer IoC dans Spring

Avant, on écrivait la configuration dans un fichier XML comme ceci :

XML Configuration
(ancienne méthode)

tout était écrit dans des fichiers XML

il fallait déclarer chaque bean manuellement

lourd dans les gros projets

presque plus utilisé aujourd’hui

👉 Utilisé surtout dans les anciens projets.

Java-based Configuration
(@Configuration + @Bean)
configuration via du code Java

plus lisible

plus flexible
Ici, tu écris la configuration en Java, pas en XML.
utilisé dans beaucoup de projets modernes

très bon contrôle manuel sur les beans

👉 C’est une méthode moderne mais un peu plus

manuelle que les annotations.

Annotation-based Configuration Avec cette méthode, les classes s’auto-déclarent comme beans grâce aux annotations.
(la plus utilisée) ✔ Déclarer un bean :
Spring détecte automatiquement les classes

plus simple

plus rapide

moins de configuration manuelle ✔ Injection :

c’est la méthode standard dans 95% des projets actuels

Il y a bien d’autres annotations

 Spring Bean --> un objet Java qui est géré par le conteneur Spring IoC

Durée de vie : Spring peut contrôler le scope d’un Bean (singleton par défaut, prototype, session, etc.).

Les Beans permettent de diviser l’application en petits composants indépendants.

Chaque composant (Bean) a une responsabilité spécifique et peut être développé, testé ou modifié séparément
sans affecter le reste de l’application.

Les Beans sont encapsulés, donc tu peux les réutiliser dans plusieurs parties de ton application.
( Une fois qu’un Bean est défini et configuré, tu peux l’injecter partout où tu en as besoin sans
copier-coller le code.)

Spring Beans doivent être déclarés et configurés pour que le conteneur sache comment les créer et les gérer.

[Link] cycle de vie des beans

[Link] bean scopes

 créer une application Spring
demandait beaucoup d’efforts

Avant il y avait
juste Spring Chercher des exemples sur StackOverflow pour

trouver un exemple de fichier [Link] (maven) etc

Lire la documentation officielle pour assembler

différentes parties pour configurer ton projet

Explorer des blogs ou tutoriels d’experts

La solution : Spring Boot + Spring Initializr

Spring Boot : un framework qui simplifie la création de projets Spring, en préconfigurant les

dépendances et modules nécessaires.

Spring Initializr un site officiel pour générer automatiquement un projet Spring Boot prêt à l’emploi.

[Link]

Comment utiliser
Spring Initializr
1- Va sur [Link]

2- Choisis :
Project : Maven ou Gradle

Language : Java (ou Kotlin/Groovy)

Spring Boot version : la version stable recommandée

3- Ajoute les dépendances dont tu as besoin :

Exemple : Spring Web pour un API REST

Spring Data JPA pour la base de données

H2 Database pour une base en mémoire si tu veux tester

4- Clique sur Generate → tu télécharges un fichier zip avec le projet.

5- Décompresse et ouvre le projet dans ton IDE préféré (IntelliJ, Eclipse, VS Code…).
 Fonctionnalités principales de [Link]

Tu peux choisir la version stable ou la plus récente de Spring Boot pour ton projet.

Choix de l’outil de build : maven ou Gradle

Coordonnées du projet :
[Link] : le nom de ton organisation ou package de base (ex : [Link])
[Link] : le nom du projet (ex : myapp)
[Link] : une petite description du projet

Version de Java

Sélection des modules : Spring Data, Spring wev etc

..
 Exemple 1

Configuration basée sur annotations Java (Java Config) ✅ @Configuration Pour dire à Spring :
Cette classe contient des instructions pour créer des objets
(Beans) que tu dois gérer.
Sans @Configuration, Spring ne saurait pas que cette

classe doit être lue pour créer des Beans.

@Bean Pour dire à Spring :

Cette méthode crée un objet que tu dois gérer comme Bean.

Spring va appeler la méthode, récupérer l’objet et le

garder dans son conteneur pour que tu puisses l’utiliser

ailleurs sans refaire new

@Configuration = “Regarde, c’est ici que je fabrique mes objets”

@Bean = “Voici un objet que tu dois garder et gérer”

@SpringBootApplication
est une annotation spéciale de Spring Boot
qui combine en réalité 3 annotations
importantes :

@Configuration

@EnableAutoConfiguration

@ComponentScan

@EnableAutoConfiguration @ComponentScan

Demande à Spring Boot de configurer automatiquement

ton application selon les dépendances présentes dans le
Quand utiliser @Bean
projet.
Tu définis explicitement un Bean dans une classe
Exemple : si tu as spring-boot-starter-web, Spring Boot de configuration annotée @Configuration.
va automatiquement configurer un serveur web
embarqué (Tomcat) et les Beans nécessaires pour créer
des contrôleurs REST.
Ici, toi tu fabriques le Bean et dis à Spring :
“Garde cet objet dans ton conteneur.”

Mais Quand tu utilises @Component (ou @Service, @Repository, @Controller)

Tu mets l’annotation directement sur la classe elle-même.
Spring peut alors la scanner automatiquement grâce à @ComponentScan et l’enregistrer comme Bean.

💡 Astuce mentale :
@Bean = “Je fabrique cet objet moi-même et je le donne à Spring”
@ComponentScan + @Component/@Service/... = “Spring trouve lui-même les objets à gérer”
ApplicationContext context = [Link](...)

👉 Qu’est-ce qu’un ApplicationContext ? C’est le conteneur spring

Le "cerveau" qui :
crée les Beans
gère leur cycle de vie
injecte les dépendances
stocke tous les Beans dans une sorte de grand dictionnaire

Pense à lui comme à un grand frigo où Spring met tous les objets prêts à l’emploi 🍉

👉 [Link](...) fait quoi ?

démarre l’application Spring Boot

crée le conteneur Spring (ApplicationContext)

scanne les packages (@ComponentScan)

instancie tous les Beans

configure les dépendances

retourne ce fameux conteneur

Résultat : context contient tous les Beans prêts à être utilisés.

Book book = [Link]([Link]);

👉 signifie :
“Va dans le conteneur Spring et donne-moi le Bean de type Book.”
Spring regarde dans son frigo (l’ApplicationContext), trouve un Bean Book, et te le renvoie.

ApplicationContext = le frigo [Link] = allumer getBean = sortir un truc du frigo

le frigo (Spring démarre, prépare,
installe tout)
 Exemple 2

Dans cet exemple :

tu crées des classes simples (POJO)
tu crées une classe @Configuration
tu écris @Bean pour déclarer les objets

Cette manière = configuration manuelle (Java Config).

C’est très pédagogique, mais on ne travaille presque plus comme ça dans les vrais projets modernes
➡️ C’était surtout utilisé avant Spring Boot.
Injection dépendance par méthode @Bean
Tu as créé deux classes normales Java : (POJO)

👉 À ce niveau-là : il n’y a AUCUN Bean, juste des classes normales.

Étape 2 — Déclarer les Beans dans une classe @Configuration

Tu as créé une classe annotée : @Configuration

👉 Cette annotation dit à Spring :

“Cette classe contient des méthodes qui
fabriquent des Beans.”

Étape 3 — Démarrer Spring Boot (création du conteneur)

Ça lance Spring Boot.

👉 Ça scanne les configurations.

👉 Ça fabrique les Beans définis dans BookConfig.
Donc Spring crée :

1 Bean Author

1 Bean Book (avec l’Author déjà injecté)

 Exemple 3

👉 ON NE VA PAS créer le Bean avec @Bean

Le principe de
Component
Scanning

Normalement, tu dois déclarer les Beans dans une classe de configuration : c’est ce qu’on a vu avant

👉 Avec Component Scanning, TU NE DÉCLARES PLUS LES BEANS À LA MAIN.

C’est Spring qui les découvre tout seul.

Comment

Grâce à l’annotation :

Et grâce à :

1. Étape 1 — Créer une classe simple (Student)

➡️ À ce stade :
❌ ce n'est pas un Bean Spring
❌ Spring ne connaît pas cette classe
❌ Spring ne peut pas l'injecter

Étape 2 — Dire à Spring où scanner (AppConfig) c’est une classe de configuration

@ComponentScan
Il dit à Spring :
“Va dans le package [Link] et regarde toutes les classes.
Si tu trouves une annotation @Component, crée un Bean
automatiquement.”

Donc AppConfig = “chef qui donne les instructions de scan”.

3. Étape 3 — Transformer Student en Bean avec @Component

Dans le package [Link], tu mets :

Ce que @Component fait pour toi :

✔️ Dit à Spring : “fabrique un Bean de cette classe”
✔️ Ce Bean aura un nom par défaut = "student"
✔️ Tu n’as pas besoin de @Bean dans AppConfig
✔️ Spring va l’ajouter automatiquement à l’ApplicationContext

Il te reste juste à créer le conteneur et apppeler les beans

Lorsque plusieurs
@Primary = le choix par défaut. beans du même type

Spring ne sait pas lequel choisir.

Tu ajoutes @Primary :

Maintenant, quand une classe demande :

➡️ Spring choisit EmailService, car il est marqué @Primary.

 @Qualifier =To
specify the bean
name.

@Qualifier sert à préciser quel bean doit être injecté quand il y a plusieurs beans du même type.

On utilise @Qualifier("beanName") pour indiquer le nom exact du bean qu’on veut injecter.

@Component
un bean Spring génériqu

@Service une classe de logique métier (business logic)

Spring utilise @Service pour indiquer qu’une classe :

contient la logique métier

fait partie de la couche service

doit être détectée automatiquement par Spring grâce au component scanning

doit être gérée comme un bean Spring

Le scope par défaut d’un bean dans

Spring est :
✅
Singleton

Qu’est-ce que ça signifie ?

Spring crée une seule instance du bean dans le conteneur (ApplicationContext).

Cette instance est partagée partout où le bean est injecté.

Autrement dit, un seul objet par type de bean, par conteneur Spring.

les dépendances circulaires Entre setters et constructeur ?