SPRING BOOT

■
Cours Complet pour Débutants

Architecture · Annotations · REST API · JPA · Sécurité

Version Java 17+ · Spring Boot 3.x · 2024

TABLE DES MATIÈRES

Sommaire du cours
1. Introduction à Spring & Spring Boot
› Qu'est-ce que Spring ?
› Pourquoi Spring Boot ?
› Différences Spring vs Spring Boot

2. Installation & Premier Projet

› Prérequis
› Spring Initializr
› Structure d'un projet
› Hello World !

3. Les Annotations Essentielles

› @SpringBootApplication
› @Component, @Service, @Repository
› @Controller & @RestController
› @Autowired & Injection de dépendances

4. Créer une API REST

› Les verbes HTTP
› @GetMapping, @PostMapping…
› Retourner du JSON
› Gestion des erreurs

5. Base de Données avec Spring Data JPA

› Qu'est-ce que JPA ?
› @Entity & @Repository
› CRUD automatique
› Requêtes personnalisées

6. Configuration & Propriétés

› [Link]
› Profils (dev/prod)
› Variables d'environnement

7. Sécurité avec Spring Security

› Concepts de base
› Authentification simple
› Sécuriser les routes

8. Tests avec Spring Boot

› Tests unitaires
› @SpringBootTest
 › MockMvc

9. Aller plus loin

› Actuator & monitoring
› Docker
› Prochaines étapes
CHAPITRE 1

Introduction à Spring & Spring Boot

1.1 Qu'est-ce que Spring ?

Spring Framework est l'un des frameworks Java les plus populaires au monde. Créé en 2002 par Rod
Johnson, il a révolutionné le développement d'applications Java en simplifiant la création d'applications
robustes et maintenables. Spring propose une multitude de modules : gestion de la base de données,
sécurité, messagerie, web, etc.

Son principe central est l'Inversion of Control (IoC) : plutôt que votre code crée ses propres
dépendances, c'est Spring qui les gère et les injecte automatiquement. Cela rend le code plus modulaire
et testable.

1.2 Pourquoi Spring Boot ?

Spring Framework est très puissant, mais sa configuration initiale était longue et complexe (fichiers XML
volumineux, multiples dépendances à gérer manuellement). Spring Boot, lancé en 2014, résout ce
problème avec trois grandes idées :

• Convention over Configuration : des choix intelligents par défaut, vous ne configurez que ce qui
diffère.
• Auto-configuration : Spring Boot détecte ce que vous utilisez et configure automatiquement les
beans nécessaires.
• Standalone : votre application embarque un serveur Tomcat, pas besoin de déployer sur un serveur
externe.

1.3 Spring vs Spring Boot — Comparaison

Critère Spring Framework Spring Boot

Configuration Manuelle (XML / Java) Automatique (auto-config)

Serveur web Externe (WildFly, Tomcat…) Embarqué (Tomcat/Netty)

Démarrage Complexe Rapide (quelques minutes)

Dépendances Gestion manuelle Starters tout-en-un

Courbe d'apprentissage Élevée Modérée

■ Note : Spring Boot ne remplace pas Spring : il s'appuie dessus et le simplifie. Tout ce que Spring peut
faire, Spring Boot peut le faire aussi — et plus facilement !
CHAPITRE 2

Installation & Premier Projet

2.1 Prérequis
• Java JDK 17+ — Spring Boot 3.x requiert Java 17 minimum. Vérifiez avec : java -version
• Maven ou Gradle — gestionnaires de dépendances Java. Maven est recommandé pour les
débutants.
• Un IDE — IntelliJ IDEA (recommandé), Eclipse (avec plugin Spring Tools), ou VS Code.

# Vérifier Java java -version # Résultat attendu : java version "17.x.x" ou supérieur #
Vérifier Maven mvn -version

2.2 Spring Initializr — Créer votre projet

La façon la plus simple de démarrer est d'utiliser Spring Initializr (disponible sur [Link]). C'est un
générateur de projet en ligne.

Champ Valeur recommandée

Project Maven

Language Java

Spring Boot 3.2.x (dernière stable)

Group [Link]

Artifact mon-api

Packaging Jar

Java 17

Dependencies Spring Web, Spring Data JPA, H2 Database

Cliquez sur GENERATE, décompressez l'archive et ouvrez-la dans votre IDE.

2.3 Structure d'un projet Spring Boot

mon-api/ ■■■ src/ ■ ■■■ main/ ■ ■ ■■■ java/com/exemple/monapi/ ■ ■ ■ ■■■
[Link] ← Point d'entrée ■ ■ ■■■ resources/ ■ ■ ■■■
[Link] ← Configuration ■ ■■■ test/ ■ ■■■ java/com/exemple/monapi/ ■
■■■ [Link] ■■■ [Link] ← Dépendances Maven

2.4 Hello World !

Le fichier [Link] est le point d'entrée de votre application :
 package [Link]; import [Link]; import
[Link]; @SpringBootApplication //
Annotation magique ! public class MonApiApplication { public static void main(String[]
args) { [Link]([Link], args); } }

Lancez l'application depuis votre IDE ou via le terminal :

mvn spring-boot:run # Vous verrez dans la console : # Started MonApiApplication in 2.3

seconds

■ Note : L'annotation @SpringBootApplication active trois choses à la fois : @Configuration (config Java),
@EnableAutoConfiguration (auto-config) et @ComponentScan (scan des composants).
CHAPITRE 3

Les Annotations Essentielles

Les annotations sont au cœur de Spring Boot. Ce sont des marqueurs (préfixés par @) qui indiquent à
Spring comment traiter vos classes et méthodes. Voici les plus importantes à connaître.

3.1 Stéréotypes — Déclarer vos composants

Annotation Rôle Utilisé pour…

@Component Composant générique Tout bean Spring

@Service Couche métier Logique business

@Repository Couche données Accès BDD

@Controller Couche web (MVC) Pages HTML

@RestController Couche web (REST) APIs JSON/XML

@Configuration Classe de configuration Beans de config

3.2 L'Injection de Dépendances — @Autowired

L'injection de dépendances (DI) est le mécanisme qui permet à Spring de fournir automatiquement les
objets dont une classe a besoin. Vous n'avez plus besoin de faire new MonService() — Spring le fait
pour vous.

@Service public class ProduitService { // Spring injecte automatiquement

ProduitRepository private final ProduitRepository repository; // Injection par
constructeur (méthode recommandée) public ProduitService(ProduitRepository repository) {
[Link] = repository; } public List<Produit> getTousProduits() { return
[Link](); } }

■ Note : Préférez l'injection par constructeur (comme ci-dessus) plutôt que @Autowired directement sur
le champ. C'est plus testable et recommandé par Spring.

3.3 Architecture en couches

Spring Boot encourage une architecture en 3 couches clairement séparées :

Couche Annotation Rôle

Présentation @RestController Reçoit les requêtes HTTP, retourne des réponses

Service @Service Contient la logique métier

Données @Repository Communique avec la base de données

CHAPITRE 4

Créer une API REST

Une API REST (Representational State Transfer) est une interface qui permet à des applications de
communiquer via HTTP. Spring Boot excelle dans la création d'APIs REST grâce à Spring Web MVC et
l'annotation @RestController.

4.1 Les verbes HTTP — CRUD

Verbe HTTP Opération CRUD Annotation Spring Exemple URL

GET Read (lire) @GetMapping GET /produits

POST Create (créer) @PostMapping POST /produits

PUT Update (modifier) @PutMapping PUT /produits/1

DELETE Delete (supprimer) @DeleteMapping DELETE /produits/1

PATCH Update partiel @PatchMapping PATCH /produits/1

4.2 Exemple complet — Controller REST

Voici un controller REST complet pour gérer des produits :

package [Link]; import [Link]; import

[Link]; import [Link];
import [Link]; import
[Link].*; import [Link]; @RestController
@RequestMapping("/api/produits") // URL de base public class ProduitController { private
final ProduitService service; public ProduitController(ProduitService service) {
[Link] = service; } // GET /api/produits @GetMapping public List<Produit>
getTous() { return [Link](); } // GET /api/produits/1
@GetMapping("/{id}") public ResponseEntity<Produit> getParId(@PathVariable Long id) {
return [Link](id) .map(ResponseEntity::ok)
.orElse([Link]().build()); } // POST /api/produits @PostMapping
@ResponseStatus([Link]) // Retourne 201 public Produit creer(@RequestBody
Produit produit) { return [Link](produit); } // DELETE /api/produits/1
@DeleteMapping("/{id}") @ResponseStatus(HttpStatus.NO_CONTENT) // Retourne 204 public
void supprimer(@PathVariable Long id) { [Link](id); } }

4.3 Annotations des paramètres

Annotation Source Exemple

@PathVariable URL path GET /produits/{id}

@RequestParam Query string GET /produits?nom=pizza

@RequestBody Corps JSON POST avec body JSON

@RequestHeader En-tête HTTP Authorization: Bearer...

CHAPITRE 5

Base de Données avec Spring Data JPA

JPA (Java Persistence API) est une spécification Java pour mapper des objets Java vers des tables de
base de données. Spring Data JPA simplifie encore plus son utilisation en générant automatiquement les
requêtes SQL courantes.

5.1 L'Entité — @Entity

Une entité est une classe Java qui représente une table en base de données :

package [Link]; import [Link].*; @Entity // Marque la

classe comme table BDD @Table(name = "produits") // Nom de la table (optionnel) public
class Produit { @Id // Clé primaire @GeneratedValue(strategy = [Link])
// Auto-increment private Long id; @Column(nullable = false, length = 100) private
String nom; private Double prix; private Integer stock; // Constructeurs, getters,
setters... public Produit() {} // Constructeur vide obligatoire ! public Long getId() {
return id; } public void setId(Long id) { [Link] = id; } // ... autres getters/setters }

5.2 Le Repository — Accès automatique aux données

Spring Data JPA génère automatiquement les méthodes CRUD. Il suffit d'étendre JpaRepository :

package [Link]; import [Link]; import

[Link]; import [Link];
@Repository public interface ProduitRepository extends JpaRepository<Produit, Long> { //
Ces méthodes sont AUTOMATIQUEMENT disponibles : // - findAll() : retourne tous les
produits // - findById(id) : retourne un produit par ID // - save(produit) : crée ou met
à jour // - deleteById(id) : supprime par ID // - count() : nombre total // Méthodes
personnalisées (Spring génère le SQL !) List<Produit> findByNom(String nom);
List<Produit> findByPrixLessThan(Double prix); List<Produit>
findByNomContainingIgnoreCase(String mot); }

5.3 Configuration base de données — H2 (développement)

Pour le développement, utilisez H2 (base de données en mémoire). Ajoutez dans [Link]
:

# [Link] # Base de données H2 en mémoire

[Link]=jdbc:h2:mem:testdb
[Link]-class-name=[Link] [Link]=sa
[Link]= # Console H2 (accessible sur /h2-console)
[Link]=true # Afficher les requêtes SQL dans la console
[Link]-sql=true [Link]-auto=create-drop

■ Note : Pour passer à MySQL/PostgreSQL en production, changez simplement l'URL, le driver, et les
credentials dans [Link]. Le reste du code reste identique !

5.4 Requêtes avec @Query

// Requête JPQL (Java Persistence Query Language) @Query("SELECT p FROM Produit p WHERE
[Link] BETWEEN :min AND :max") List<Produit> findPrixEntre(@Param("min") Double min,
@Param("max") Double max); // Requête SQL native @Query(value = "SELECT * FROM produits
WHERE stock = 0", nativeQuery = true) List<Produit> findEnRuptureDeStock();
CHAPITRE 6

Configuration & Propriétés

6.1 [Link] / [Link]

Le fichier [Link] (ou [Link]) est le fichier de configuration central de Spring
Boot. Voici les propriétés les plus utiles :

# ■■ Serveur ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ [Link]=8080

# Port d'écoute [Link]-path=/api # Préfixe URL global # ■■ Application
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ [Link]=mon-api #
■■ Base de données MySQL ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
[Link]=jdbc:mysql://localhost:3306/mabase [Link]=root
[Link]=monmotdepasse # ■■ JPA
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
[Link]-sql=true [Link]-auto=update # update, create,
create-drop, validate # ■■ Logs
■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ [Link]=INFO
[Link]=DEBUG

6.2 Profils Spring — dev / prod

Spring Boot permet de définir plusieurs profils de configuration. Créez des fichiers séparés :

• [Link] — config locale

• [Link] — config production
# Activer un profil au démarrage : [Link]=dev # Ou via ligne de commande
: java -jar [Link] --[Link]=prod # Dans [Link]
: [Link]=jdbc:mysql://[Link]/mabase
[Link]-sql=false

6.3 Propriétés personnalisées

# [Link] [Link]-produits=100 [Link]-admin=admin@[Link]
# Java — Récupérer ces valeurs @Service public class AppConfig {
@Value("${[Link]-produits}") private int maxProduits;
@Value("${[Link]-admin}") private String emailAdmin; }
CHAPITRE 7

Sécurité avec Spring Security

Spring Security est le module de sécurité de Spring. Il permet de gérer l'authentification (qui êtes-vous ?)
et l'autorisation (que pouvez-vous faire ?). Par défaut, quand Spring Security est sur le classpath, toutes
les routes sont protégées.

7.1 Ajouter Spring Security

Ajoutez la dépendance dans [Link] :

<dependency> <groupId>[Link]</groupId>
<artifactId>spring-boot-starter-security</artifactId> </dependency>

Dès cet ajout, Spring Boot génère un mot de passe par défaut dans la console et protège toutes vos
routes. Vous devez vous connecter avec user / pour accéder à votre API.

7.2 Configuration personnalisée

@Configuration @EnableWebSecurity public class SecurityConfig { @Bean public
SecurityFilterChain filterChain(HttpSecurity http) throws Exception { http
.authorizeHttpRequests(auth -> auth // Routes publiques
.requestMatchers("/api/produits").permitAll()
.requestMatchers("/api/public/**").permitAll() // Routes réservées aux admins
.requestMatchers("/api/admin/**").hasRole("ADMIN") // Tout le reste : authentification
requise .anyRequest().authenticated() ) .httpBasic([Link]()); // Auth
basique HTTP return [Link](); } @Bean public UserDetailsService users() {
UserDetails user = [Link]() .username("admin") .password("{noop}motdepasse") //
{noop} = pas de hashage .roles("ADMIN") .build(); return new
InMemoryUserDetailsManager(user); } }

■ Note : En production, n'utilisez jamais {noop} pour les mots de passe. Utilisez BCryptPasswordEncoder
pour hasher les mots de passe.
CHAPITRE 8

Tests avec Spring Boot

Spring Boot intègre JUnit 5 et Mockito par défaut via le starter spring-boot-starter-test. Les tests
sont essentiels pour garantir la qualité de votre code.

8.1 Test d'un Service (@ExtendWith Mockito)

@ExtendWith([Link]) class ProduitServiceTest { @Mock ProduitRepository
repository; // Mock : simule le repo @InjectMocks ProduitService service; // Service à
tester @Test void getTousProduits_retourneListe() { // GIVEN (préparation) List<Produit>
liste = [Link](new Produit("Pizza", 12.0));
when([Link]()).thenReturn(liste); // WHEN (exécution) List<Produit> resultat
= [Link](); // THEN (vérification) assertEquals(1, [Link]());
assertEquals("Pizza", [Link](0).getNom()); } }

8.2 Test d'intégration (@SpringBootTest + MockMvc)

@SpringBootTest @AutoConfigureMockMvc class ProduitControllerTest { @Autowired MockMvc
mockMvc; // Simule des requêtes HTTP @Test void getProduits_retourne200() throws
Exception { [Link](get("/api/produits")) .andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON)); } @Test void
creerProduit_retourne201() throws Exception { String json =
"{\"nom\":\"Pizza\",\"prix\":12.0}"; [Link](post("/api/produits")
.contentType(MediaType.APPLICATION_JSON) .content(json))
.andExpect(status().isCreated()); } }

8.3 Lancer les tests

# Tous les tests mvn test # Résultats dans target/surefire-reports/
CHAPITRE 9

Aller Plus Loin

9.1 Spring Boot Actuator — Monitoring

Actuator expose des endpoints de monitoring pour surveiller votre application en production.

# [Link] <dependency> <groupId>[Link]</groupId>

<artifactId>spring-boot-starter-actuator</artifactId> </dependency> #
[Link] [Link]=health,info,metrics #
Endpoints disponibles : # GET /actuator/health -> état de l'application # GET
/actuator/info -> infos de l'app # GET /actuator/metrics -> métriques

9.2 Packager & Déployer

# Créer un JAR exécutable mvn clean package # Lancer le JAR java -jar
target/[Link] # Avec un profil spécifique java -jar
target/[Link] --[Link]=prod

9.3 Dockerfile — Conteneuriser avec Docker

FROM eclipse-temurin:17-jdk-alpine WORKDIR /app COPY target/[Link]
[Link] EXPOSE 8080 ENTRYPOINT ["java", "-jar", "[Link]"]

# Builder l'image docker build -t mon-api . # Lancer le conteneur docker run -p

8080:8080 mon-api

9.4 Prochaines étapes recommandées

Sujet Ce que vous apprendrez Difficulté

Spring Boot + JWT Authentification par tokens ■■

Spring Boot + React Fullstack : API + frontend ■■

Spring Data + PostgreSQL BDD relationnelle en production ■■

Spring Cloud Microservices & architecture cloud ■■■

Spring WebFlux Programmation réactive ■■■

Docker Compose Orchestrer API + BDD ■■

9.5 Ressources recommandées

• Documentation officielle : [Link] — la référence absolue
• [Link] — tutoriels Spring très complets en anglais
• Spring Guides : [Link]/guides — guides pratiques officiels
• YouTube : chaînes Amigoscode, Daily Code Buffer — vidéos Spring Boot
RÉCAPITULATIF

Ce que vous avez appris

Chapitre Concepts clés retenus

1. Introduction Spring Framework, IoC, avantages de Spring Boot

2. Installation JDK 17, Maven, Spring Initializr, structure projet

3. Annotations @Component, @Service, @Repository, @RestController, @Autowired

4. API REST @GetMapping, @PostMapping, @PathVariable, @RequestBody, ResponseEntity

5. JPA @Entity, @Id, JpaRepository, requêtes automatiques et @Query

6. Configuration [Link], profils dev/prod, @Value

7. Sécurité Spring Security, SecurityFilterChain, roles & permissions

8. Tests JUnit 5, Mockito, @SpringBootTest, MockMvc

9. Déploiement JAR exécutable, Actuator, Docker

■ Votre prochain objectif

Créez une API REST complète avec : un modèle @Entity, un @Repository, un @Service et un
@RestController. Testez vos endpoints avec Postman ou Insomnia. C'est le meilleur moyen de
consolider ce que vous venez d'apprendre !