Apprendre Spring Boot avec Java

📘 Sommaire

Introduction à Spring Boot
- Qu’est-ce que Spring Boot ?
- Différences entre Spring Framework et Spring Boot
- Avantages de Spring Boot : simplicité, rapidité, convention over configuration
- Installation de l’environnement de développement (JDK, IDE, Maven/Gradle)
- Création d’un projet Spring Boot avec Spring Initializr
Architecture d’une application Spring Boot
- Structure d’un projet Spring Boot
- Les annotations principales : @SpringBootApplication, @RestController, @Service, @Repository
- Le rôle de la classe principale avec public static void main
- Configuration de l’application via application.properties ou application.yml
Injection de dépendances et gestion des beans
- Principe de l’inversion de contrôle (IoC)
- Types d’injection : par constructeur, par setter, par champ
- Cycle de vie des beans : initialisation, destruction
- Profils Spring : gestion des environnements (dev, prod, test)
Développement d’une application Web avec Spring MVC
- Architecture MVC : Modèle, Vue, Contrôleur
- Création de contrôleurs avec @GetMapping, @PostMapping, etc.
- Gestion des vues avec Thymeleaf et Bootstrap
- Validation des formulaires avec @Valid et BindingResult
- Gestion des erreurs et des exceptions
Accès aux données avec Spring Data JPA
- Introduction à JPA et Hibernate
- Création d’entités avec @Entity, @Id, @GeneratedValue
- Définition de repositories avec JpaRepository
- Requêtes personnalisées avec @Query et Query Methods
- Gestion des transactions avec @Transactional
Développement d’API RESTful
- Principes REST : stateless, ressources, verbes HTTP
- Création de services REST avec @RestController
- Sérialisation et désérialisation JSON avec Jackson
- Gestion des codes de statut HTTP et des réponses personnalisées
- Sécurisation des API avec Spring Security et JWT
Tests avec Spring Boot
- Tests unitaires avec JUnit 5 et Mockito
- Tests d’intégration avec @SpringBootTest
- Tests de contrôleurs avec @WebMvcTest
- Tests de services avec @MockBean
- Utilisation de Postman pour tester les API
Sécurisation d’une application Spring Boot
- Introduction à Spring Security
- Authentification : en mémoire, en base de données, via LDAP
- Autorisation : rôles et permissions
- Sécurisation des API REST avec JWT
- Gestion des sessions et des cookies
Déploiement d’une application Spring Boot
- Création d’un fichier exécutable .jar ou .war
- Déploiement sur un serveur Tomcat ou Jetty
- Déploiement sur des plateformes cloud : Heroku, AWS, Azure
- Création d’une image Docker pour l’application
- Déploiement avec Kubernetes
Bonnes pratiques et outils complémentaires
- Utilisation de Spring Boot DevTools pour le redémarrage automatique
- Surveillance de l’application avec Spring Boot Actuator
- Gestion des logs avec SLF4J et Logback
- Documentation de l’API avec Swagger/OpenAPI
- Gestion des dépendances avec Maven ou Gradle

1. Introduction à Spring Boot

Qu’est-ce que Spring Boot ?

Spring Boot est un projet du Spring Framework qui vise à simplifier la création d’applications Spring autonomes, prêtes à l’emploi (“production-ready”). Il met l’accent sur la “convention over configuration”, réduisant ainsi la quantité de configuration boilerplate nécessaire pour démarrer un projet Spring.

Les objectifs principaux de Spring Boot sont :

Fournir une expérience de développement Spring plus rapide et largement accessible.
Réduire la configuration XML et Groovy.
Offrir un ensemble de fonctionnalités non fonctionnelles communes (comme les métriques, les contrôles de santé et la configuration externalisée) prêtes à l’emploi.
Éviter la nécessité d’une configuration XML complexe.

Différences entre Spring Framework et Spring Boot

Spring Framework est un framework d’application Java complet qui fournit une infrastructure pour le développement d’applications d’entreprise. Il offre une large gamme de fonctionnalités, notamment l’injection de dépendances, la gestion transactionnelle, l’accès aux données, le développement web (Spring MVC), etc. Cependant, la configuration initiale d’un projet Spring Framework peut être complexe et fastidieuse, nécessitant souvent beaucoup de configuration XML ou Java.

Spring Boot s’appuie sur Spring Framework mais simplifie considérablement le processus de démarrage et de configuration. Il offre des configurations automatiques basées sur les dépendances présentes dans le classpath, des serveurs embarqués (Tomcat, Jetty, Undertow), et une approche opinionated pour le développement d’applications Spring. En bref, Spring Boot rend le développement avec Spring plus rapide et plus facile.

Avantages de Spring Boot : simplicité, rapidité, convention over configuration

Simplicité : Spring Boot simplifie grandement la configuration des applications Spring grâce à l’auto-configuration et aux starters.
Rapidité : Le démarrage rapide des applications et la réduction de la configuration permettent de développer et de déployer des applications plus rapidement.
Convention over Configuration : Spring Boot favorise les conventions par défaut, ce qui réduit la nécessité de configurer explicitement de nombreux aspects de l’application. Cela permet aux développeurs de se concentrer sur la logique métier.
Serveurs embarqués : Il inclut des serveurs web embarqués (Tomcat, Jetty, Undertow), ce qui permet de créer des applications autonomes qui peuvent être exécutées directement avec un simple java -jar.
Starters : Les “Starters” sont des ensembles de dépendances préconfigurées qui facilitent l’ajout de fonctionnalités à votre application (par exemple, spring-boot-starter-web pour le développement web, spring-boot-starter-data-jpa pour l’accès aux données).

Installation de l’environnement de développement (JDK, IDE, Maven/Gradle)

Pour développer avec Spring Boot, vous aurez besoin des éléments suivants :

JDK (Java Development Kit) : Spring Boot nécessite Java 8 ou une version ultérieure. Vous pouvez télécharger le JDK depuis le site d’Oracle ou utiliser une distribution OpenJDK.
IDE (Integrated Development Environment) : Un IDE facilite grandement le développement. Les IDE populaires pour le développement Spring Boot incluent :
- Spring Tool Suite (STS) : Basé sur Eclipse, spécifiquement conçu pour le développement Spring.
- IntelliJ IDEA : Une option très populaire avec une excellente prise en charge de Spring.
- VS Code : Avec les extensions Java et Spring Boot appropriées.
Outil de build : Vous aurez besoin d’un outil pour gérer les dépendances et construire votre projet. Les plus couramment utilisés sont :
- Maven : Un outil de gestion de projet basé sur le concept de Project Object Model (POM).
- Gradle : Un outil de build flexible et performant.

Assurez-vous que le JDK est installé et que les variables d’environnement JAVA_HOME et PATH sont correctement configurées. Installez votre IDE préféré et l’outil de build de votre choix.

Création d’un projet Spring Boot avec Spring Initializr

Spring Initializr est un service web qui permet de générer rapidement la structure de base d’un projet Spring Boot. C’est le moyen le plus simple et le plus recommandé pour démarrer un nouveau projet.

Étapes pour créer un projet avec Spring Initializr :

Ouvrez votre navigateur et allez sur https://start.spring.io/.
Configurez les options de votre projet :
- Project : Choisissez Maven Project ou Gradle Project.
- Language : Choisissez Java.
- Spring Boot : Sélectionnez la version de Spring Boot (il est recommandé d’utiliser la dernière version stable).
- Project Metadata : Remplissez les informations du projet (Group, Artifact, Name, Description, Package name).
- Packaging : Choisissez Jar (pour une application autonome avec serveur embarqué) ou War (pour déployer sur un serveur d’applications externe).
- Java : Sélectionnez la version de Java que vous souhaitez utiliser.
- Dependencies : Ajoutez les dépendances nécessaires pour votre application. Par exemple, pour une application web, ajoutez “Spring Web”. Pour l’accès aux données, ajoutez “Spring Data JPA” et le driver de base de données approprié (par exemple, “H2 Database” pour une base de données en mémoire).
Cliquez sur le bouton “Generate”. Cela téléchargera un fichier ZIP contenant la structure de base de votre projet.
Extrayz le fichier ZIP et importez le projet dans votre IDE.

Votre projet Spring Boot est maintenant prêt à être développé !

2. Architecture d’une application Spring Boot

Structure d’un projet Spring Boot

Un projet Spring Boot généré par Spring Initializr a généralement une structure de répertoire standard qui facilite l’organisation du code. Voici une structure typique :

myproject/
├── pom.xml (ou build.gradle)
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/myproject/
│   │   │       ├── MyprojectApplication.java  // Classe principale
│   │   │       ├── controller/             // Contrôleurs REST ou MVC
│   │   │       ├── service/                // Services métier
│   │   │       ├── repository/             // Repositories pour l'accès aux données
│   │   │       └── model/                  // Classes de modèle (entités JPA, DTOs)
│   │   └── resources/
│   │       ├── application.properties (ou application.yml) // Fichier de configuration
│   │       ├── static/                     // Fichiers statiques (CSS, JS, images)
│   │       └── templates/                  // Templates de vues (Thymeleaf, FreeMarker)
│   └── test/
│       └── main/
│           └── java/
│               └── com/example/myproject/
│                   └── MyprojectApplicationTests.java // Classe de test
└── target/ (ou build/)
    └── myproject.jar (ou .war) // Fichier exécutable ou déployable

pom.xml (Maven) ou build.gradle (Gradle) : Fichier de configuration du build, listant les dépendances et les plugins.
src/main/java : Contient le code source Java principal de l’application.
src/main/resources : Contient les fichiers de configuration, les fichiers statiques et les templates de vues.
src/test/java : Contient le code source des tests.
target/ (Maven) ou build/ (Gradle) : Contient les fichiers générés par le build (classes compilées, JAR/WAR).

Les annotations principales : `@SpringBootApplication`, `@RestController`, `@Service`, `@Repository`

Spring Boot utilise intensivement les annotations pour configurer et définir les composants de l’application. Voici quelques-unes des annotations les plus courantes :

@SpringBootApplication: Cette annotation est une annotation de commodité qui combine @Configuration, @EnableAutoConfiguration et @ComponentScan. Elle est généralement placée sur la classe principale de l’application et active l’auto-configuration de Spring Boot et la recherche de composants dans le package courant et ses sous-packages.
```
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class MyprojectApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyprojectApplication.class, args);
    }
}
```

@RestController: Une annotation spécialisée pour les contrôleurs RESTful. Elle combine @Controller et @ResponseBody, ce qui signifie que les méthodes de ce contrôleur retournent directement des données (généralement au format JSON ou XML) plutôt que des noms de vues.

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class MyController {
 
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, Spring Boot!";
    }
}

@Service: Indique qu’une classe est un composant de service, généralement utilisé pour encapsuler la logique métier. Spring gère le cycle de vie de ces beans.

import org.springframework.stereotype.Service;
 
@Service
public class MyService {
    public String processData() {
        return "Processed data";
    }
}

@Repository: Indique qu’une classe est un composant de repository, généralement utilisé pour l’accès aux données (interactions avec la base de données). Spring fournit des fonctionnalités supplémentaires pour les repositories, comme la traduction des exceptions spécifiques aux bases de données en exceptions Spring DataAccessException.
```
import org.springframework.stereotype.Repository;
 
@Repository
public class MyRepository {
    // Méthodes d'accès aux données
}
```

Le rôle de la classe principale avec `public static void main`

La classe principale d’une application Spring Boot est le point d’entrée de l’application. Elle contient la méthode main standard de Java, annotée avec @SpringBootApplication.

La méthode SpringApplication.run():

Démarre le conteneur Spring.
Effectue l’auto-configuration.
Lance le serveur web embarqué (si applicable).

C’est cette méthode qui initialise et exécute l’application Spring Boot.

Configuration de l’application via `application.properties` ou `application.yml`

Spring Boot permet de configurer facilement votre application à l’aide de fichiers de propriétés. Les formats les plus courants sont application.properties et application.yml (YAML). Ces fichiers sont généralement placés dans le répertoire src/main/resources.

Exemple dans application.properties:

server.port=8080
spring.datasource.url=jdbc:h2:mem:mydb
spring.datasource.username=sa
spring.datasource.password=
spring.h2.console.enabled=true

Exemple dans application.yml:

server:
  port: 8080
spring:
  datasource:
    url: jdbc:h2:mem:mydb
    username: sa
    password:
  h2:
    console:
      enabled: true

Ces fichiers permettent de configurer divers aspects de l’application, tels que le port du serveur, la configuration de la base de données, les paramètres de logging, etc. Spring Boot charge automatiquement ces configurations au démarrage.

3. Injection de dépendances et gestion des beans

Principe de l’inversion de contrôle (IoC)

L’Inversion de Contrôle (IoC) est un principe de conception logicielle dans lequel le contrôle de l’objet ou de la fonction est transféré à un conteneur ou un framework. Dans le contexte de Spring, le conteneur IoC (représenté par l’interface ApplicationContext) est responsable de l’instanciation, de la configuration et de l’assemblage des beans (objets gérés par Spring).

Au lieu que les objets créent ou recherchent leurs dépendances, le conteneur IoC injecte les dépendances dans les objets. Cela réduit le couplage entre les composants et rend l’application plus modulaire et plus facile à tester.

Types d’injection : par constructeur, par setter, par champ

Spring prend en charge plusieurs types d’injection de dépendances :

Injection par constructeur : Les dépendances sont fournies via les arguments du constructeur de la classe. C’est le type d’injection recommandé car il garantit que les dépendances requises sont présentes lors de la création de l’objet et facilite les tests unitaires.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class MyService {
 
    private final MyRepository myRepository;
 
    @Autowired
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }
 
    // ...
}

Injection par setter : Les dépendances sont injectées via les méthodes setter de la classe. Cela rend les dépendances optionnelles et permet de modifier les dépendances après la création de l’objet.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class MyService {
 
    private MyRepository myRepository;
 
    @Autowired
    public void setMyRepository(MyRepository myRepository) {
        this.myRepository = myRepository;
    }
 
    // ...
}

Injection par champ : Les dépendances sont injectées directement dans les champs de la classe à l’aide de l’annotation @Autowired. Bien que plus concise, cette méthode est généralement déconseillée car elle rend la classe plus difficile à tester (les dépendances sont cachées) et viole le principe de l’encapsulation.
```
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class MyService {
 
    @Autowired
    private MyRepository myRepository;
 
    // ...
}
```

Cycle de vie des beans : initialisation, destruction

Les beans gérés par le conteneur Spring ont un cycle de vie qui comprend plusieurs étapes, notamment l’initialisation et la destruction. Vous pouvez définir des méthodes de callback pour exécuter du code à ces étapes.

Initialisation : Des méthodes peuvent être appelées après que le bean a été instancié et que ses dépendances ont été injectées. Vous pouvez utiliser :
- L’annotation @PostConstruct (JSR-250).
- L’interface InitializingBean (méthode afterPropertiesSet()).
- Une méthode spécifiée dans la configuration du bean (par exemple, l’attribut init-method en XML).
```
import javax.annotation.PostConstruct;
import org.springframework.stereotype.Component;
 
@Component
public class MyBean {
 
    @PostConstruct
    public void init() {
        // Code exécuté après l'initialisation du bean
        System.out.println("MyBean initialized");
    }
 
    // ...
}
```

Destruction : Des méthodes peuvent être appelées avant que le bean ne soit retiré du conteneur. Vous pouvez utiliser :

L’annotation @PreDestroy (JSR-250).
L’interface DisposableBean (méthode destroy()).
Une méthode spécifiée dans la configuration du bean (par exemple, l’attribut destroy-method en XML).

import javax.annotation.PreDestroy;
import org.springframework.stereotype.Component;
 
@Component
public class MyBean {
 
    // ...
 
    @PreDestroy
    public void cleanup() {
        // Code exécuté avant la destruction du bean
        System.out.println("MyBean destroyed");
    }
}

Profils Spring : gestion des environnements (dev, prod, test)

Les profils Spring permettent de gérer des configurations spécifiques à différents environnements (développement, production, test, etc.). Vous pouvez marquer des beans ou des configurations avec l’annotation @Profile pour indiquer qu’ils ne doivent être activés que lorsque le profil correspondant est actif.

Exemple :

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
 
@Configuration
@Profile("dev")
public class DevConfig {
 
    @Bean
    public MyService devService() {
        return new MyService("Development Service");
    }
}
 
@Configuration
@Profile("prod")
public class ProdConfig {
 
    @Bean
    public MyService prodService() {
        return new MyService("Production Service");
    }
}

Vous pouvez activer un profil en utilisant la propriété spring.profiles.active dans application.properties ou application.yml, ou via une variable d’environnement ou un argument de ligne de commande.

Exemple dans application.properties:

spring.profiles.active=dev

4. Développement d’une application Web avec Spring MVC

Architecture MVC : Modèle, Vue, Contrôleur

Spring MVC suit le modèle de conception Model-View-Controller (MVC), qui sépare l’application en trois composants principaux :

Modèle (Model) : Représente les données de l’application et la logique métier. Il est indépendant de l’interface utilisateur.
Vue (View) : Est responsable de l’affichage des données du modèle à l’utilisateur. Elle peut être implémentée à l’aide de technologies comme Thymeleaf, JSP, etc.
Contrôleur (Controller) : Agit comme un intermédiaire entre le Modèle et la Vue. Il reçoit les requêtes de l’utilisateur, interagit avec le Modèle pour récupérer ou mettre à jour les données, et sélectionne la Vue appropriée pour afficher la réponse.

Spring MVC fournit les outils nécessaires pour implémenter cette architecture, notamment le DispatcherServlet qui agit comme le contrôleur frontal, acheminant les requêtes vers les contrôleurs appropriés.

Création de contrôleurs avec `@GetMapping`, `@PostMapping`, etc.

Dans Spring MVC, les contrôleurs sont des classes annotées avec @Controller ou @RestController. Les méthodes de ces contrôleurs gèrent les requêtes HTTP entrantes et retournent une réponse.

Les annotations de mapping les plus courantes sont :

@RequestMapping: Annotation générale pour mapper les requêtes web aux méthodes du contrôleur.
@GetMapping: Raccourci pour @RequestMapping(method = RequestMethod.GET).
@PostMapping: Raccourci pour @RequestMapping(method = RequestMethod.POST).
@PutMapping: Raccourci pour @RequestMapping(method = RequestMethod.PUT).
@DeleteMapping: Raccourci pour @RequestMapping(method = RequestMethod.DELETE).
@PatchMapping: Raccourci pour @RequestMapping(method = RequestMethod.PATCH).

Exemple de contrôleur simple :

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
 
@Controller
public class WebController {
 
    @GetMapping("/greeting")
    public String greeting(@RequestParam(name="name", required=false, defaultValue="World") String name, Model model) {
        model.addAttribute("name", name);
        return "greeting"; // Retourne le nom de la vue (template)
    }
}

Dans cet exemple, la méthode greeting gère les requêtes GET sur /greeting, prend un paramètre de requête name, ajoute un attribut au modèle et retourne le nom de la vue “greeting”.

Gestion des vues avec Thymeleaf et Bootstrap

Spring Boot prend en charge plusieurs technologies de vues. Thymeleaf est un moteur de templates côté serveur populaire pour les applications web Java. Il s’intègre bien avec Spring et permet de créer des vues dynamiques en utilisant des attributs spéciaux dans les balises HTML.

Pour utiliser Thymeleaf, ajoutez la dépendance spring-boot-starter-thymeleaf.

Exemple de template Thymeleaf (src/main/resources/templates/greeting.html):

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Getting Started: Serving Web Content</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
    <p th:text="'Hello, ' + ${name} + '!'" />
</body>
</html>

Bootstrap est un framework CSS populaire pour développer des interfaces utilisateur responsives et modernes. Vous pouvez l’inclure dans vos templates Thymeleaf en ajoutant les liens vers les fichiers CSS et JS de Bootstrap dans la section <head> de votre HTML.

Validation des formulaires avec `@Valid` et `BindingResult`

Spring MVC intègre la validation des données d’entrée à l’aide de l’API Bean Validation (JSR 303/380). Vous pouvez utiliser des annotations comme @NotNull, @Size, @Email, etc., sur les champs de vos objets de formulaire (DTOs ou entités).

Pour déclencher la validation, annotez l’argument de la méthode du contrôleur avec @Valid ou @Validated. Utilisez l’objet BindingResult pour vérifier s’il y a des erreurs de validation.

Exemple :

import javax.validation.Valid;
import javax.validation.constraints.Size;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
 
public class MyForm {
    @Size(min = 1, max = 10)
    private String name;
 
    // Getters and setters
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}
 
@Controller
public class FormController {
 
    @PostMapping("/submitForm")
    public String submitForm(@Valid @ModelAttribute("myForm") MyForm myForm, BindingResult bindingResult) {
        if (bindingResult.hasErrors()) {
            // Gérer les erreurs de validation
            return "form"; // Retourne la vue du formulaire avec les erreurs
        }
        // Traiter les données du formulaire
        return "success"; // Redirige vers une page de succès
    }
}

Gestion des erreurs et des exceptions

Spring MVC offre plusieurs mécanismes pour gérer les erreurs et les exceptions :

Gestion globale des exceptions : Vous pouvez utiliser l’annotation @ControllerAdvice avec @ExceptionHandler pour gérer les exceptions de manière centralisée dans votre application.

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.ModelAndView;
 
@ControllerAdvice
public class GlobalExceptionHandler {
 
    @ExceptionHandler(Exception.class)
    public ModelAndView handleException(Exception ex) {
        ModelAndView modelAndView = new ModelAndView("error");
        modelAndView.addObject("errorMessage", ex.getMessage());
        return modelAndView;
    }
}

Gestion des erreurs spécifiques au contrôleur : Vous pouvez définir des méthodes annotées avec @ExceptionHandler directement dans un contrôleur pour gérer les exceptions spécifiques à ce contrôleur.
Pages d’erreur personnalisées : Vous pouvez configurer des pages d’erreur personnalisées pour différents codes de statut HTTP (par exemple, 404, 500) en créant des fichiers de template nommés d’après le code de statut dans le répertoire src/main/resources/templates/error/ (par exemple, 404.html, 500.html).

5. Accès aux données avec Spring Data JPA

Introduction à JPA et Hibernate

JPA (Java Persistence API) est une spécification Java qui définit une API standard pour la gestion de la persistance des données relationnelles dans les applications Java. Elle permet aux développeurs de mapper des objets Java à des tables de base de données (Object-Relational Mapping - ORM).

Hibernate est une implémentation populaire de la spécification JPA. C’est un framework ORM puissant qui fournit des fonctionnalités supplémentaires au-delà de la spécification JPA. Spring Data JPA utilise JPA et peut être configuré pour utiliser Hibernate comme fournisseur de persistance par défaut.

Spring Data JPA simplifie considérablement l’implémentation des couches d’accès aux données en fournissant des abstractions de haut niveau et en réduisant la quantité de code boilerplate nécessaire pour les opérations CRUD (Create, Read, Update, Delete).

Création d’entités avec `@Entity`, `@Id`, `@GeneratedValue`

Dans JPA, les entités sont des classes Java qui représentent des tables dans la base de données. Elles sont annotées avec @Entity. Chaque entité doit avoir une clé primaire, généralement annotée avec @Id. L’annotation @GeneratedValue est utilisée pour spécifier la stratégie de génération de la clé primaire (par exemple, auto-incrémentée).

Exemple d’entité simple :

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
 
@Entity
public class Product {
 
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String name;
    private double price;
 
    // Getters and setters
    public Long getId() {
        return id;
    }
 
    public void setId(Long id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public double getPrice() {
        return price;
    }
 
    public void setPrice(double price) {
        this.price = price;
    }
}

D’autres annotations JPA courantes incluent @Table, @Column, @Transient, @OneToOne, @OneToMany, @ManyToOne, @ManyToMany pour définir le mapping entre les objets et la base de données.

Définition de repositories avec `JpaRepository`

Spring Data JPA fournit une abstraction appelée “Repository” qui simplifie l’accès aux données. En étendant l’interface JpaRepository, vous obtenez automatiquement des méthodes CRUD de base (comme save, findById, findAll, deleteById) sans avoir à écrire d’implémentation.

L’interface JpaRepository est générique et prend deux paramètres : le type de l’entité et le type de la clé primaire.

Exemple de repository :

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
 
@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    // Spring Data JPA générera automatiquement les méthodes CRUD
}

Spring Data JPA crée automatiquement une implémentation de cette interface au moment de l’exécution. Vous pouvez ensuite injecter ce repository dans vos services pour interagir avec la base de données.

Requêtes personnalisées avec `@Query` et `Query Methods`

En plus des méthodes CRUD automatiques, Spring Data JPA permet de définir des requêtes personnalisées de deux manières principales :

Query Methods : Spring Data JPA peut générer automatiquement des requêtes basées sur le nom des méthodes de l’interface du repository. En suivant une convention de nommage spécifique, vous pouvez créer des requêtes complexes sans écrire de code SQL ou JPQL.

Exemples de Query Methods :
- findByName(String name) : Trouve un produit par son nom.
- findByPriceGreaterThan(double price) : Trouve les produits dont le prix est supérieur à une valeur donnée.
- findByNameContainingIgnoreCase(String name) : Trouve les produits dont le nom contient une chaîne de caractères (insensible à la casse).
```
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.List;
 
@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    List<Product> findByName(String name);
    List<Product> findByPriceGreaterThan(double price);
}
```

@Query: Pour des requêtes plus complexes qui ne peuvent pas être exprimées avec les Query Methods, vous pouvez utiliser l’annotation @Query pour définir des requêtes JPQL (Java Persistence Query Language) ou SQL natives.

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
import java.util.List;
 
@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
 
    @Query("SELECT p FROM Product p WHERE p.name = ?1")
    List<Product> findProductByNameJPQL(String name);
 
    @Query(value = "SELECT * FROM product WHERE price > ?1", nativeQuery = true)
    List<Product> findProductsExpensiveSQL(double price);
}

Gestion des transactions avec `@Transactional`

La gestion des transactions est essentielle pour garantir l’intégrité des données lors des opérations sur la base de données. Spring offre une gestion déclarative des transactions à l’aide de l’annotation @Transactional.

En annotant une méthode ou une classe avec @Transactional, vous indiquez à Spring de gérer la transaction pour cette méthode ou toutes les méthodes de la classe. Spring ouvrira une transaction au début de la méthode, exécutera le code, et commitera ou rollbackera la transaction en fonction du résultat (succès ou exception).

Exemple de service avec gestion transactionnelle :

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class ProductService {
 
    private final ProductRepository productRepository;
 
    @Autowired
    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }
 
    @Transactional
    public Product createProduct(Product product) {
        // Logique métier
        return productRepository.save(product);
    }
 
    @Transactional(readOnly = true)
    public Product getProductById(Long id) {
        return productRepository.findById(id).orElse(null);
    }
 
    // ... autres méthodes
}

L’attribut readOnly = true est utilisé pour les opérations de lecture seule afin d’optimiser les performances.

6. Développement d’API RESTful

Principes REST : stateless, ressources, verbes HTTP

REST (Representational State Transfer) est un style d’architecture logicielle pour les systèmes hypermédia distribués. Les principes clés de REST incluent :

Client-Server : Séparation des préoccupations entre l’interface utilisateur (client) et le stockage des données (serveur).
Stateless : Chaque requête du client au serveur doit contenir toutes les informations nécessaires pour comprendre et traiter la requête. Le serveur ne doit pas stocker d’informations sur l’état du client entre les requêtes.
Cacheable : Les réponses du serveur peuvent être mises en cache par le client pour améliorer les performances.
Layered System : L’architecture peut être composée de plusieurs couches, et chaque couche ne peut “voir” que la couche directement adjacente.
Code on Demand (Optional) : Le serveur peut étendre la fonctionnalité du client en téléchargeant et en exécutant du code (par exemple, JavaScript).
Uniform Interface : Un ensemble de contraintes architecturales qui simplifient et découplent l’architecture, permettant à chaque partie d’évoluer indépendamment. Les contraintes de l’interface uniforme incluent :
- Identification des ressources : Les ressources sont identifiées par des URIs (Uniform Resource Identifiers).
- Manipulation des ressources via des représentations : Les clients interagissent avec les ressources en utilisant des représentations de celles-ci (par exemple, JSON, XML).
- Messages auto-descriptifs : Chaque message contient suffisamment d’informations pour décrire comment traiter le message.
- Hypermedia as the Engine of Application State (HATEOAS) : Le client interagit avec l’application entièrement via les hyperliens contenus dans les représentations des ressources.

Les API RESTful utilisent généralement les verbes HTTP standard pour effectuer des opérations sur les ressources :

GET : Récupérer une ressource ou une collection de ressources.
POST : Créer une nouvelle ressource.
PUT : Mettre à jour une ressource existante.
DELETE : Supprimer une ressource.
PATCH : Appliquer des modifications partielles à une ressource.

Création de services REST avec `@RestController`

Dans Spring Boot, la création d’API RESTful est simplifiée grâce à l’annotation @RestController. Comme mentionné précédemment, @RestController combine @Controller et @ResponseBody, ce qui signifie que les méthodes de cette classe retournent directement les données de réponse (sérialisées en JSON ou XML par défaut) plutôt que des noms de vues.

Exemple de contrôleur REST simple :

import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;
 
@RestController
@RequestMapping("/api/products")
public class ProductRestController {
 
    private List<Product> products = new ArrayList<>();
 
    // Initialisation (pour l'exemple)
    public ProductRestController() {
        products.add(new Product(1L, "Laptop", 1200.00));
        products.add(new Product(2L, "Mouse", 25.00));
    }
 
    @GetMapping
    public List<Product> getAllProducts() {
        return products;
    }
 
    @GetMapping("/{id}")
    public Product getProductById(@PathVariable Long id) {
        return products.stream()
                       .filter(p -> p.getId().equals(id))
                       .findFirst()
                       .orElse(null);
    }
 
    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        product.setId((long) (products.size() + 1));
        products.add(product);
        return product;
    }
 
    @PutMapping("/{id}")
    public Product updateProduct(@PathVariable Long id, @RequestBody Product updatedProduct) {
        for (int i = 0; i < products.size(); i++) {
            if (products.get(i).getId().equals(id)) {
                products.set(i, updatedProduct);
                return updatedProduct;
            }
        }
        return null; // Ou lancer une exception
    }
 
    @DeleteMapping("/{id}")
    public void deleteProduct(@PathVariable Long id) {
        products.removeIf(p -> p.getId().equals(id));
    }
}
 
// Classe Product (simplifiée pour l'exemple)
class Product {
    private Long id;
    private String name;
    private double price;
 
    public Product() {}
 
    public Product(Long id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }
 
    // Getters and setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
}

@RequestMapping("/api/products"): Définit le chemin de base pour toutes les méthodes de ce contrôleur.
@GetMapping, @PostMapping, etc. : Mappent les requêtes HTTP spécifiques aux méthodes du contrôleur.
@PathVariable: Extrait une partie de l’URI de la requête (par exemple, l’ID du produit).
@RequestBody: Indique qu’un paramètre de méthode doit être lié au corps de la requête HTTP. Spring utilise un convertisseur de messages (comme Jackson) pour désérialiser le corps de la requête en un objet Java.

Sérialisation et désérialisation JSON avec Jackson

Spring Boot utilise Jackson par défaut pour la sérialisation (conversion d’objets Java en JSON) et la désérialisation (conversion de JSON en objets Java). Lorsque vous utilisez @RestController et retournez un objet Java, Spring Boot, avec l’aide de Jackson, convertit automatiquement cet objet en réponse JSON. De même, lorsque vous utilisez @RequestBody, Jackson désérialise le corps de la requête JSON en l’objet Java spécifié.

Vous pouvez personnaliser le comportement de Jackson en ajoutant des annotations Jackson à vos classes de modèle (par exemple, @JsonIgnore, @JsonProperty) ou en configurant l’objet ObjectMapper de Jackson.

Gestion des codes de statut HTTP et des réponses personnalisées

Il est important de retourner les codes de statut HTTP appropriés dans vos API RESTful pour indiquer le résultat de l’opération. Spring MVC vous permet de contrôler le code de statut HTTP de la réponse.

Codes de statut par défaut : Par défaut, Spring retourne un code 200 OK pour les requêtes réussies. Pour les requêtes POST, il retourne un code 200 OK ou 201 Created si une nouvelle ressource est créée.

@ResponseStatus: Vous pouvez utiliser cette annotation sur une méthode de contrôleur ou une classe d’exception pour spécifier le code de statut HTTP de la réponse.

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;
 
@ResponseStatus(HttpStatus.CREATED)
@PostMapping
public Product createProduct(@RequestBody Product product) {
    // ...
    return product;
}
 
@ResponseStatus(HttpStatus.NOT_FOUND)
public class ProductNotFoundException extends RuntimeException {
    // ...
}

ResponseEntity: Pour un contrôle plus fin sur la réponse (y compris les en-têtes HTTP et le corps de la réponse), vous pouvez retourner un objet ResponseEntity depuis votre méthode de contrôleur.

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
@RequestMapping("/api/products")
public class ProductRestController {
 
    // ...
 
    @GetMapping("/{id}")
    public ResponseEntity<Product> getProductById(@PathVariable Long id) {
        Product product = products.stream()
                               .filter(p -> p.getId().equals(id))
                               .findFirst()
                               .orElse(null);
        if (product != null) {
            return ResponseEntity.ok(product); // Code 200 OK avec le corps du produit
        } else {
            return ResponseEntity.notFound().build(); // Code 404 Not Found
        }
    }
}

Sécurisation des API avec Spring Security et JWT

La sécurisation des API RESTful est cruciale. Spring Security est un framework puissant et hautement configurable pour l’authentification et l’autorisation dans les applications Spring. Pour les API RESTful, une approche courante consiste à utiliser l’authentification basée sur les tokens, comme JWT (JSON Web Tokens).

Les étapes générales pour sécuriser une API REST avec Spring Security et JWT incluent :

Ajouter les dépendances Spring Security et JWT.
Configurer Spring Security pour désactiver la protection CSRF (Cross-Site Request Forgery) car elle n’est généralement pas nécessaire pour les API stateless.
Configurer un filtre pour intercepter les requêtes et valider les tokens JWT.
Implémenter un mécanisme d’authentification (par exemple, nom d’utilisateur/mot de passe) pour générer des tokens JWT lors de la connexion réussie.
Protéger les endpoints de l’API en utilisant des annotations de sécurité (par exemple, @PreAuthorize) ou une configuration de sécurité.

C’est un sujet complexe qui nécessite une configuration détaillée, mais Spring Security fournit les blocs de construction nécessaires pour implémenter une sécurité robuste pour vos API REST.

7. Tests avec Spring Boot

Spring Boot facilite l’écriture de tests pour votre application en fournissant des annotations et des utilitaires de test pratiques. Une bonne stratégie de test inclut généralement des tests unitaires, des tests d’intégration et des tests de tranche (slice tests).

Tests unitaires avec JUnit 5 et Mockito

Les tests unitaires visent à tester de petites unités de code isolément, généralement des méthodes ou des classes individuelles, sans dépendances externes (comme une base de données ou un serveur web). JUnit 5 est le framework de test le plus couramment utilisé en Java, et Mockito est une bibliothèque de mocking populaire pour créer des objets simulés (mocks) et vérifier les interactions.

Pour les tests unitaires, vous n’avez généralement pas besoin de démarrer le contexte Spring complet.

Exemple de test unitaire avec JUnit 5 et Mockito :

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
 
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
 
@ExtendWith(MockitoExtension.class)
public class MyServiceTest {
 
    @Mock
    private MyRepository myRepository;
 
    @InjectMocks
    private MyService myService;
 
    @Test
    void testProcessData() {
        when(myRepository.getData()).thenReturn("Mocked Data");
 
        String result = myService.processData();
 
        assertEquals("Processed: Mocked Data", result);
    }
}
 
// Classes simulées pour l'exemple
class MyRepository {
    public String getData() {
        return "Real Data";
    }
}
 
class MyService {
    private final MyRepository myRepository;
 
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }
 
    public String processData() {
        return "Processed: " + myRepository.getData();
    }
}

@ExtendWith(MockitoExtension.class): Intègre Mockito avec JUnit 5.
@Mock: Crée un mock de l’interface ou de la classe spécifiée.
@InjectMocks: Injecte les mocks créés avec @Mock dans l’instance de la classe annotée.
when(...).thenReturn(...) : Définit le comportement d’une méthode mockée.

Tests d’intégration avec `@SpringBootTest`

Les tests d’intégration testent l’interaction entre plusieurs composants de l’application, voire l’application complète avec ses dépendances externes (base de données, serveurs externes, etc.). L’annotation @SpringBootTest est l’annotation principale pour les tests d’intégration Spring Boot. Elle démarre un contexte Spring complet pour votre application.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.assertNotNull;
 
@SpringBootTest
public class MyprojectApplicationTests {
 
    @Autowired
    private MyService myService;
 
    @Test
    void contextLoads() {
        assertNotNull(myService);
    }
}

@SpringBootTest peut être configuré avec différents attributs (par exemple, webEnvironment) pour contrôler la manière dont le contexte Spring est chargé.

Tests de contrôleurs avec `@WebMvcTest`

@WebMvcTest est une annotation de test de tranche (slice test) qui se concentre sur les composants de la couche web (contrôleurs). Elle démarre un contexte Spring limité qui ne contient que les beans pertinents pour tester les contrôleurs (contrôleurs, filtres, etc.), sans démarrer le serveur web complet ni charger d’autres couches (services, repositories).

Elle est souvent utilisée en combinaison avec MockMvc pour envoyer des requêtes HTTP simulées aux contrôleurs et vérifier les réponses.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.test.web.servlet.MockMvc;
 
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
 
@WebMvcTest(WebController.class) // Spécifie le contrôleur à tester
public class WebControllerTests {
 
    @Autowired
    private MockMvc mockMvc;
 
    @Test
    void testGreeting() throws Exception {
        mockMvc.perform(get("/greeting?name=Test"))
               .andExpect(status().isOk())
               .andExpect(content().string("Hello, Test!"));
    }
}

@WebMvcTest(WebController.class): Configure le test pour se concentrer sur WebController.
MockMvc: Permet d’envoyer des requêtes simulées.
mockMvc.perform(get("/greeting?name=Test")) : Exécute une requête GET simulée.
.andExpect(status().isOk()) : Vérifie que le code de statut HTTP est 200 OK.
.andExpect(content().string("...")) : Vérifie le contenu de la réponse.

Tests de services avec `@MockBean`

Lors des tests de tranche ou d’intégration, vous pourriez vouloir simuler (mock) certaines dépendances pour isoler la couche que vous testez. L’annotation @MockBean est utilisée dans les tests Spring Boot pour ajouter des mocks Mockito au contexte de l’application Spring.

Cela est particulièrement utile dans les tests @WebMvcTest ou @SpringBootTest où vous voulez simuler les services ou les repositories pour tester la logique du contrôleur ou d’autres composants sans interagir avec les dépendances réelles.

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
 
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
 
@SpringBootTest
public class MyServiceIntegrationTest {
 
    @MockBean // Simule MyRepository dans le contexte Spring
    private MyRepository myRepository;
 
    @Autowired
    private MyService myService;
 
    @Test
    void testProcessDataWithMockRepository() {
        when(myRepository.getData()).thenReturn("Mocked Data in Integration Test");
 
        String result = myService.processData();
 
        assertEquals("Processed: Mocked Data in Integration Test", result);
    }
}

Dans cet exemple, @MockBean remplace l’implémentation réelle de MyRepository par un mock Mockito dans le contexte Spring démarré par @SpringBootTest.

Utilisation de Postman pour tester les API

En plus des tests automatisés, il est souvent utile de tester manuellement les API RESTful à l’aide d’outils comme Postman. Postman est un outil populaire qui permet d’envoyer des requêtes HTTP (GET, POST, PUT, DELETE, etc.) à vos endpoints d’API, d’inspecter les réponses, de gérer les environnements et de créer des collections de requêtes.

Pour tester une API Spring Boot avec Postman :

Démarrez votre application Spring Boot.
Ouvrez Postman.
Créez une nouvelle requête.
Sélectionnez la méthode HTTP appropriée (GET, POST, etc.).
Entrez l’URL de votre endpoint d’API (par exemple, http://localhost:8080/api/products).
Si nécessaire, ajoutez des paramètres de requête, des en-têtes (par exemple, Content-Type: application/json), ou un corps de requête (pour les requêtes POST ou PUT).
Cliquez sur “Send” pour envoyer la requête.
Inspectez la réponse (code de statut, corps de la réponse, en-têtes).

Postman est un outil précieux pour le développement et le débogage des API RESTful.

8. Sécurisation d’une application Spring Boot

La sécurisation des applications web est une préoccupation majeure. Spring Security est un framework puissant et flexible qui fournit des solutions complètes pour l’authentification et l’autorisation dans les applications Spring.

Introduction à Spring Security

Spring Security est un framework de sécurité déclaratif qui s’intègre facilement aux applications Spring. Il offre une large gamme de fonctionnalités de sécurité, notamment :

Authentification : Vérification de l’identité d’un utilisateur.
Autorisation : Détermination si un utilisateur authentifié a la permission d’accéder à une ressource ou d’effectuer une action.
Protection contre les attaques courantes : CSRF, XSS, etc.
Intégration avec d’autres technologies de sécurité : LDAP, OAuth2, JWT, etc.

Spring Security utilise une chaîne de filtres pour intercepter les requêtes et appliquer les règles de sécurité. Vous configurez Spring Security en créant des classes de configuration qui étendent WebSecurityConfigurerAdapter (dans les versions plus anciennes) ou en utilisant des classes de configuration basées sur des composants (dans les versions plus récentes avec Spring Security 5.x et au-delà).

Authentification : en mémoire, en base de données, via LDAP

Spring Security prend en charge diverses méthodes d’authentification :

Authentification en mémoire : Utile pour les applications simples ou les tests. Les informations d’identification des utilisateurs sont stockées directement en mémoire.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
 
@Configuration
@EnableWebSecurity
public class InMemorySecurityConfig {
 
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests((requests) -> requests
                .requestMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin((form) -> form
                .loginPage("/login")
                .permitAll()
            )
            .logout((logout) -> logout.permitAll());
 
        return http.build();
    }
 
    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails user = User.withDefaultPasswordEncoder()
            .username("user")
            .password("password")
            .roles("USER")
            .build();
        return new InMemoryUserDetailsManager(user);
    }
}

Authentification en base de données : Les informations d’identification des utilisateurs sont stockées dans une base de données. Vous implémentez une interface UserDetailsService pour charger les détails de l’utilisateur depuis la base de données.
Authentification via LDAP : Intégration avec un serveur LDAP (Lightweight Directory Access Protocol) pour l’authentification.

Autorisation : rôles et permissions

Une fois qu’un utilisateur est authentifié, Spring Security détermine s’il est autorisé à accéder à une ressource ou à effectuer une action. L’autorisation est généralement basée sur les rôles ou les permissions attribués à l’utilisateur.

Rôles : Vous pouvez définir des rôles (par exemple, ROLE_USER, ROLE_ADMIN) et les attribuer aux utilisateurs. Vous pouvez ensuite configurer Spring Security pour autoriser l’accès à certaines URLs ou méthodes uniquement aux utilisateurs ayant des rôles spécifiques.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;
 
@Configuration
@EnableWebSecurity
public class MethodSecurityConfig {
 
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests((requests) -> requests
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .requestMatchers("/user/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().permitAll()
            );
        // ... autres configurations (formLogin, logout, etc.)
        return http.build();
    }
}

Permissions : Pour un contrôle d’autorisation plus fin, vous pouvez utiliser des permissions (par exemple, READ_PRODUCT, WRITE_PRODUCT) et les vérifier au niveau de la méthode à l’aide d’annotations comme @PreAuthorize.

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Service;
 
@Service
public class ProductService {
 
    @PreAuthorize("hasRole('ADMIN') or hasPermission('product', 'read')")
    public Product getProductById(Long id) {
        // ...
        return null;
    }
 
    @PreAuthorize("hasRole('ADMIN') or hasPermission('product', 'write')")
    public Product createProduct(Product product) {
        // ...
        return null;
    }
}

Sécurisation des API REST avec JWT

Comme mentionné dans la section précédente, JWT est une approche courante pour sécuriser les API RESTful stateless. Le flux typique est le suivant :

L’utilisateur s’authentifie (par exemple, avec nom d’utilisateur/mot de passe) auprès d’un endpoint de connexion.
Si l’authentification réussit, le serveur génère un token JWT contenant des informations sur l’utilisateur (claims) et le renvoie au client.
Le client stocke le token (par exemple, dans le stockage local du navigateur).
Pour les requêtes ultérieures vers les endpoints sécurisés, le client inclut le token JWT dans l’en-tête Authorization (généralement au format Bearer <token>).
Le serveur, configuré avec Spring Security, intercepte la requête, extrait le token JWT, le valide (signature, expiration, etc.), et authentifie l’utilisateur en fonction des informations contenues dans le token.
Spring Security applique ensuite les règles d’autorisation basées sur les rôles ou permissions extraits du token.

L’implémentation de l’authentification JWT avec Spring Security implique la configuration de filtres personnalisés et l’utilisation d’une bibliothèque JWT (comme JJWT).

Gestion des sessions et des cookies

Pour les applications web traditionnelles basées sur des sessions, Spring Security gère automatiquement les sessions et les cookies pour maintenir l’état d’authentification de l’utilisateur entre les requêtes.

Pour les API RESTful stateless, il est généralement recommandé de désactiver la gestion des sessions côté serveur pour garantir que l’API est véritablement stateless. Cela peut être fait dans la configuration de Spring Security :

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.web.SecurityFilterChain;
 
@Configuration
@EnableWebSecurity
public class StatelessSecurityConfig {
 
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable() // Désactiver la protection CSRF pour les API stateless
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) // Configurer la gestion des sessions
            .and()
            .authorizeHttpRequests((requests) -> requests
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers("/api/private/**").authenticated()
                .anyRequest().denyAll()
            );
        // ... ajouter des filtres JWT, etc.
        return http.build();
    }
}

En définissant sessionCreationPolicy(SessionCreationPolicy.STATELESS), vous indiquez à Spring Security de ne pas créer ni utiliser de sessions HTTP pour gérer l’état de sécurité.

9. Déploiement d’une application Spring Boot

Spring Boot facilite le déploiement de vos applications grâce à ses fonctionnalités intégrées et à la possibilité de créer des fichiers exécutables autonomes.

Création d’un fichier exécutable `.jar` ou `.war`

La manière la plus courante de déployer une application Spring Boot est de créer un fichier JAR exécutable (“fat JAR” ou “uber JAR”) qui contient toutes les dépendances nécessaires, y compris le serveur web embarqué. Cela permet d’exécuter l’application avec un simple commande java -jar.

Si vous avez choisi l’empaquetage WAR lors de la création du projet (par exemple, pour déployer sur un serveur d’applications externe comme Tomcat), vous obtiendrez un fichier .war.

Pour créer le fichier exécutable, utilisez votre outil de build :

Maven : Exécutez la commande suivante dans le répertoire racine de votre projet :
```
./mvnw clean package
```
Cela créera un fichier JAR exécutable dans le répertoire target/.
Gradle : Exécutez la commande suivante dans le répertoire racine de votre projet :
```
./gradlew clean build
```
Cela créera un fichier JAR exécutable dans le répertoire build/libs/.

Le fichier JAR exécutable peut ensuite être exécuté à partir de la ligne de commande :

java -jar your-application.jar

Déploiement sur un serveur Tomcat ou Jetty

Bien que Spring Boot inclue des serveurs embarqués, vous pouvez également déployer votre application sur un serveur d’applications externe comme Tomcat ou Jetty en empaquetant votre application sous forme de fichier WAR.

Assurez-vous que votre projet est configuré pour produire un fichier WAR (dans pom.xml ou build.gradle).
Construisez le projet pour générer le fichier WAR.
Déployez le fichier WAR sur votre serveur d’applications (les étapes spécifiques dépendent du serveur d’applications).

Déploiement sur des plateformes cloud : Heroku, AWS, Azure

Spring Boot est bien adapté au déploiement sur des plateformes cloud. La nature autonome des fichiers JAR exécutables simplifie le processus.

Heroku : Heroku prend en charge nativement les applications Spring Boot. Vous pouvez déployer votre application en poussant votre code vers un dépôt Git Heroku. Heroku détectera qu’il s’agit d’une application Spring Boot et la construira et la déploiera automatiquement.
AWS (Amazon Web Services) : Vous pouvez déployer des applications Spring Boot sur diverses services AWS, notamment :
- Elastic Beanstalk : Un service facile à utiliser pour déployer et gérer des applications web.
- EC2 (Elastic Compute Cloud) : Vous pouvez déployer votre JAR exécutable sur une instance EC2.
- ECS (Elastic Container Service) ou EKS (Elastic Kubernetes Service) : En utilisant Docker (voir ci-dessous).
Azure (Microsoft Azure) : Azure offre également plusieurs options de déploiement pour les applications Spring Boot, comme Azure App Service ou Azure Kubernetes Service (AKS).

Les étapes spécifiques varient en fonction de la plateforme cloud et du service choisi, mais l’idée générale est de fournir votre fichier JAR exécutable ou une image Docker de votre application à la plateforme.

Création d’une image Docker pour l’application

Docker est une plateforme populaire pour le développement, l’expédition et l’exécution d’applications dans des conteneurs. La création d’une image Docker pour votre application Spring Boot permet de la déployer de manière cohérente dans différents environnements.

Vous aurez besoin d’un fichier Dockerfile dans le répertoire racine de votre projet. Voici un exemple simple :

FROM openjdk:17-jdk-slim
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

FROM openjdk:17-jdk-slim : Utilise une image de base OpenJDK légère.
ARG JAR_FILE=target/*.jar : Définit un argument de build pour le chemin du fichier JAR.
COPY ${JAR_FILE} app.jar : Copie le fichier JAR construit dans le conteneur.
ENTRYPOINT ["java","-jar","/app.jar"] : Définit la commande à exécuter lorsque le conteneur démarre.

Pour construire l’image Docker :

docker build -t my-spring-boot-app .

Pour exécuter le conteneur Docker :

docker run -p 8080:8080 my-spring-boot-app

Cela démarrera votre application Spring Boot dans un conteneur Docker, mappant le port 8080 du conteneur au port 8080 de votre machine locale.

Déploiement avec Kubernetes

Kubernetes est un système open source pour l’automatisation du déploiement, de la mise à l’échelle et de la gestion des applications conteneurisées. Si vous utilisez Docker, vous pouvez déployer vos images Docker Spring Boot sur un cluster Kubernetes.

Cela implique généralement la création de fichiers de configuration YAML qui décrivent vos déploiements, services et autres ressources Kubernetes.

Exemple simplifié d’un fichier de déploiement Kubernetes (deployment.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-spring-boot-app
spec:
  replicas: 3 # Nombre d'instances de l'application
  selector:
    matchLabels:
      app: my-spring-boot-app
  template:
    metadata:
      labels:
        app: my-spring-boot-app
    spec:
      containers:
      - name: my-spring-boot-app
        image: my-spring-boot-app:latest # Nom de l'image Docker
        ports:
        - containerPort: 8080

Pour appliquer ce déploiement à votre cluster Kubernetes :

kubectl apply -f deployment.yaml

Le déploiement avec Kubernetes est un sujet vaste, mais Spring Boot s’intègre bien dans un pipeline de déploiement conteneurisé géré par Kubernetes.

10. Bonnes pratiques et outils complémentaires

Cette section couvre quelques bonnes pratiques et outils utiles pour le développement d’applications Spring Boot.

Utilisation de Spring Boot DevTools pour le redémarrage automatique

Spring Boot DevTools est un ensemble d’outils qui améliorent l’expérience de développement. L’une de ses fonctionnalités les plus utiles est le redémarrage automatique de l’application lorsque des fichiers sont modifiés. Cela accélère considérablement le cycle de développement en évitant d’avoir à redémarrer manuellement le serveur après chaque changement de code.

Pour utiliser DevTools, ajoutez la dépendance suivante à votre pom.xml (Maven) ou build.gradle (Gradle) :

Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

Gradle:

dependencies {
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
}

Avec cette dépendance, votre application redémarrera automatiquement chaque fois que vous compilez des classes ou modifiez des fichiers dans le classpath.

Surveillance de l’application avec Spring Boot Actuator

Spring Boot Actuator fournit des endpoints prêts pour la production qui vous permettent de surveiller et de gérer votre application lorsqu’elle est déployée. Il offre des informations sur l’état de santé de l’application, les métriques, les informations de configuration, etc.

Pour utiliser Actuator, ajoutez la dépendance suivante :

Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Gradle:

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
}

Une fois la dépendance ajoutée, plusieurs endpoints seront disponibles par défaut (par exemple, /actuator/health, /actuator/info). Vous pouvez configurer les endpoints exposés et leur sécurité via les fichiers de configuration (application.properties ou application.yml).

Gestion des logs avec SLF4J et Logback

Une bonne gestion des logs est essentielle pour le débogage et la surveillance des applications. Spring Boot utilise SLF4J (Simple Logging Facade for Java) comme façade de logging par défaut, avec Logback comme implémentation par défaut.

Vous pouvez configurer le logging via le fichier application.properties ou application.yml, ou en fournissant un fichier de configuration Logback (logback-spring.xml).

Exemple de configuration de logging dans application.properties:

logging.level.root=INFO
logging.level.org.springframework=INFO
logging.level.com.example.myapp=DEBUG
logging.file.name=myapp.log

Cela configure le niveau de logging pour différentes parties de l’application et spécifie un fichier de sortie pour les logs.

Documentation de l’API avec Swagger/OpenAPI

Documenter vos API RESTful est crucial pour les développeurs qui les consomment. Swagger (maintenant partie de l’initiative OpenAPI) est un framework populaire pour concevoir, construire, documenter et consommer des API RESTful.

Spring Boot s’intègre bien avec les implémentations d’OpenAPI comme Springdoc OpenAPI. En ajoutant la dépendance appropriée, Springdoc générera automatiquement la documentation de votre API basée sur les annotations de vos contrôleurs.

Pour utiliser Springdoc OpenAPI, ajoutez la dépendance suivante :

Maven:

<dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.0.2</version> <!-- Utilisez la dernière version -->
</dependency>

Gradle:

dependencies {
    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.2' // Utilisez la dernière version
}

Une fois la dépendance ajoutée et l’application démarrée, vous pourrez accéder à l’interface utilisateur Swagger UI à l’adresse http://localhost:8080/swagger-ui.html (par défaut) pour visualiser et interagir avec la documentation de votre API.

Gestion des dépendances avec Maven ou Gradle

Spring Boot s’appuie sur Maven ou Gradle pour la gestion des dépendances. Les “Starters” de Spring Boot simplifient la déclaration des dépendances en fournissant des ensembles de dépendances préconfigurées et compatibles.

Assurez-vous de bien comprendre comment gérer les dépendances avec l’outil de build de votre choix, y compris la gestion des versions, les exclusions de dépendances et la création de profils de build.

En suivant ces bonnes pratiques et en utilisant les outils complémentaires appropriés, vous pouvez développer, tester, sécuriser et déployer vos applications Spring Boot de manière plus efficace.

Al AMINE

Explorer

spring-boot

Apprendre Spring Boot avec Java

📘 Sommaire

1. Introduction à Spring Boot

Qu’est-ce que Spring Boot ?

Différences entre Spring Framework et Spring Boot

Avantages de Spring Boot : simplicité, rapidité, convention over configuration

Installation de l’environnement de développement (JDK, IDE, Maven/Gradle)

Création d’un projet Spring Boot avec Spring Initializr

2. Architecture d’une application Spring Boot

Structure d’un projet Spring Boot

Les annotations principales : @SpringBootApplication, @RestController, @Service, @Repository

Le rôle de la classe principale avec public static void main

Configuration de l’application via application.properties ou application.yml

3. Injection de dépendances et gestion des beans

Principe de l’inversion de contrôle (IoC)

Types d’injection : par constructeur, par setter, par champ

Cycle de vie des beans : initialisation, destruction

Profils Spring : gestion des environnements (dev, prod, test)

4. Développement d’une application Web avec Spring MVC

Architecture MVC : Modèle, Vue, Contrôleur

Création de contrôleurs avec @GetMapping, @PostMapping, etc.

Gestion des vues avec Thymeleaf et Bootstrap

Validation des formulaires avec @Valid et BindingResult

Gestion des erreurs et des exceptions

5. Accès aux données avec Spring Data JPA

Introduction à JPA et Hibernate

Création d’entités avec @Entity, @Id, @GeneratedValue

Définition de repositories avec JpaRepository

Requêtes personnalisées avec @Query et Query Methods

Gestion des transactions avec @Transactional

6. Développement d’API RESTful

Principes REST : stateless, ressources, verbes HTTP

Création de services REST avec @RestController

Sérialisation et désérialisation JSON avec Jackson

Gestion des codes de statut HTTP et des réponses personnalisées

Sécurisation des API avec Spring Security et JWT

7. Tests avec Spring Boot

Tests unitaires avec JUnit 5 et Mockito

Tests d’intégration avec @SpringBootTest

Tests de contrôleurs avec @WebMvcTest

Tests de services avec @MockBean

Utilisation de Postman pour tester les API

8. Sécurisation d’une application Spring Boot

Introduction à Spring Security

Authentification : en mémoire, en base de données, via LDAP

Autorisation : rôles et permissions

Sécurisation des API REST avec JWT

Gestion des sessions et des cookies

9. Déploiement d’une application Spring Boot

Création d’un fichier exécutable .jar ou .war

Déploiement sur un serveur Tomcat ou Jetty

Déploiement sur des plateformes cloud : Heroku, AWS, Azure

Création d’une image Docker pour l’application

Déploiement avec Kubernetes

10. Bonnes pratiques et outils complémentaires

Utilisation de Spring Boot DevTools pour le redémarrage automatique

Surveillance de l’application avec Spring Boot Actuator

Gestion des logs avec SLF4J et Logback

Documentation de l’API avec Swagger/OpenAPI

Gestion des dépendances avec Maven ou Gradle

Graph View

Table of Contents

Les annotations principales : `@SpringBootApplication`, `@RestController`, `@Service`, `@Repository`

Le rôle de la classe principale avec `public static void main`

Configuration de l’application via `application.properties` ou `application.yml`

Création de contrôleurs avec `@GetMapping`, `@PostMapping`, etc.

Validation des formulaires avec `@Valid` et `BindingResult`

Création d’entités avec `@Entity`, `@Id`, `@GeneratedValue`

Définition de repositories avec `JpaRepository`

Requêtes personnalisées avec `@Query` et `Query Methods`

Gestion des transactions avec `@Transactional`

Création de services REST avec `@RestController`

Tests d’intégration avec `@SpringBootTest`

Tests de contrôleurs avec `@WebMvcTest`

Tests de services avec `@MockBean`

Création d’un fichier exécutable `.jar` ou `.war`