Spring Boot 3 : Développez un Finance Manager complet

Dans cette leçon, nous allons créer notre premier projet Spring Boot à l'aide de Spring Initializr. Nous sélectionnerons les dépendances nécessaires et générerons la structure de base de notre future application.

À la fin de cette leçon, vous serez capable de créer un nouveau projet Spring Boot correctement configuré et prêt à être développé dans IntelliJ IDEA.

Dans cette leçon, nous allons découvrir la structure d’un projet Spring Boot généré par Spring Initializr. Nous explorerons les principaux dossiers, les fichiers essentiels ainsi que leur rôle dans le développement d’une application.

À la fin de cette leçon, vous comprendrez l'organisation d'un projet Spring Boot et saurez où trouver les différents composants nécessaires au développement de votre application.

Dans cette leçon, nous allons découvrir les principales fonctionnalités offertes par Spring Boot, notamment l'auto-configuration, la gestion des dépendances et les mécanismes qui simplifient le développement d'applications Java.

À la fin de cette leçon, vous comprendrez comment Spring Boot configure automatiquement votre application et pourquoi cette approche permet de développer plus rapidement des applications robustes et maintenables.

Dans cette leçon, nous allons créer notre première API REST avec Spring Boot en mettant en place un endpoint simple qui renvoie un message « Hello World ».

À la fin de cette leçon, vous comprendrez le rôle d’un contrôleur REST et serez capable de créer, démarrer et tester un premier endpoint HTTP dans votre application Spring Boot.

Dans cette leçon, nous allons mettre en pratique les notions précédentes en développant pas à pas notre première API REST « Hello World ». Nous écrirons le code ensemble et analyserons chaque partie afin de comprendre son fonctionnement.

À la fin de cette leçon, vous serez capable de créer un contrôleur REST, d'implémenter un endpoint simple et de tester son fonctionnement directement depuis votre navigateur ou un outil comme Postman.

Dans cette leçon, nous allons découvrir comment utiliser Spring Boot DevTools afin d'accélérer le développement grâce au redémarrage automatique de l'application et au rechargement instantané des modifications.

À la fin de cette leçon, vous serez capable de configurer et d'utiliser Spring Boot DevTools pour gagner du temps lors du développement et tester vos changements sans redémarrer manuellement votre application.

Dans cette leçon, nous allons découvrir les annotations @RestController, @GetMapping et @PostMapping, indispensables pour créer des API REST avec Spring Boot. Nous verrons leur rôle et apprendrons à les utiliser pour exposer des endpoints HTTP.

À la fin de cette leçon, vous comprendrez le fonctionnement de ces annotations et serez capable de créer des endpoints permettant de recevoir et de renvoyer des données dans une application Spring Boot.

Dans cette leçon, nous allons mettre en pratique les annotations @RestController, @GetMapping et @PostMapping en développant une API REST simple. Nous écrirons le code pas à pas afin de comprendre le rôle de chaque annotation et le traitement des requêtes HTTP.

À la fin de cette leçon, vous serez capable de créer un contrôleur REST complet, d'implémenter des endpoints GET et POST, et de tester leur fonctionnement avec un navigateur ou un outil comme Postman.

Dans cette leçon, nous allons découvrir les annotations @RequestBody, @PathVariable et @RequestParam, qui permettent de récupérer les données envoyées par le client dans une requête HTTP. Nous verrons dans quels cas utiliser chacune d'elles et leurs différences.

À la fin de cette leçon, vous comprendrez le rôle de ces annotations et serez capable de recevoir des données provenant du corps d'une requête, de l'URL ou des paramètres de requête dans vos API Spring Boot.

Dans cette leçon, nous allons mettre en pratique les annotations @RequestBody, @PathVariable et @RequestParam en développant plusieurs endpoints REST. Nous écrirons le code pas à pas afin de comprendre comment récupérer les différentes données envoyées par le client.

À la fin de cette leçon, vous serez capable de créer des API REST capables de traiter des données provenant du corps d'une requête, de l'URL et des paramètres de requête, en utilisant les annotations adaptées à chaque situation.

Dans cette leçon, nous allons découvrir les principaux codes de statut HTTP ainsi que la classe ResponseEntity. Nous verrons comment renvoyer des réponses adaptées en fonction du résultat d'une requête et pourquoi cela est essentiel pour concevoir des API REST professionnelles.

À la fin de cette leçon, vous comprendrez la signification des principaux codes HTTP et serez capable d'utiliser ResponseEntity pour personnaliser les réponses de vos API Spring Boot.

Dans cette leçon, nous allons mettre en pratique les différents codes de statut HTTP et la classe ResponseEntity en développant plusieurs endpoints REST. Nous apprendrons à renvoyer des réponses adaptées selon les différents scénarios rencontrés par une API.

À la fin de cette leçon, vous serez capable d'utiliser ResponseEntity pour personnaliser les réponses de vos API et de renvoyer les codes HTTP appropriés afin de respecter les bonnes pratiques du développement REST.

Dans cette leçon, nous allons découvrir comment Jackson permet de convertir automatiquement les objets Java en JSON et inversement. Nous verrons comment Spring Boot utilise cette bibliothèque pour faciliter les échanges de données entre le client et l'API.

À la fin de cette leçon, vous comprendrez le rôle de Jackson dans une application Spring Boot et serez capable d'échanger des données au format JSON entre votre backend et vos clients REST.

Dans cette leçon, nous allons découvrir comment valider les données reçues par une API grâce à @Valid et à Bean Validation. Nous verrons comment définir des règles de validation et empêcher l'enregistrement de données invalides.

À la fin de cette leçon, vous serez capable de mettre en place une validation automatique des données dans vos API Spring Boot et de garantir que seules des informations conformes soient traitées par votre application.

Dans cette leçon, nous allons mettre en pratique @Valid et Bean Validation en développant une API capable de vérifier automatiquement les données reçues. Nous écrirons le code pas à pas et testerons différents cas afin de comprendre le comportement de la validation.

À la fin de cette leçon, vous serez capable d'ajouter des règles de validation à vos objets, d'utiliser @Valid dans vos contrôleurs et de garantir que seules des données valides soient acceptées par votre application.

Dans cette leçon, nous allons découvrir JPA et Hibernate, les technologies utilisées par Spring Boot pour simplifier l'accès aux bases de données. Nous verrons leur rôle, leur fonctionnement et pourquoi elles sont devenues la référence pour la persistance des données en Java.

À la fin de cette leçon, vous comprendrez les principes fondamentaux de JPA et Hibernate et serez capable d'expliquer comment ces technologies facilitent la manipulation des données dans une application Spring Boot.

Dans cette leçon, nous allons découvrir les classes Entity ainsi que les principales annotations de JPA, telles que @Entity, @Id, @GeneratedValue et @Column. Nous verrons comment représenter les données d'une base de données sous forme d'objets Java.

À la fin de cette leçon, vous comprendrez le rôle des classes Entity et serez capable de créer des entités correctement annotées pour les utiliser avec Spring Data JPA.

Dans cette leçon, nous allons mettre en pratique la création d'une classe Entity en utilisant les principales annotations de JPA. Nous développerons une entité complète, analyserons chaque annotation et verrons comment elle est associée à une table de la base de données.

À la fin de cette leçon, vous serez capable de créer vos propres classes Entity, de les annoter correctement et de préparer votre modèle de données pour une utilisation avec Spring Data JPA.

Dans cette leçon, nous allons découvrir les interfaces Repository et plus particulièrement JpaRepository, qui permettent de manipuler les données d'une base de données sans écrire de requêtes SQL. Nous verrons les principales méthodes fournies par Spring Data JPA et leur fonctionnement.

À la fin de cette leçon, vous comprendrez le rôle de JpaRepository et serez capable de créer des interfaces Repository pour effectuer facilement les opérations CRUD sur vos entités.

Dans cette leçon, nous allons mettre en pratique JpaRepository en créant notre première interface Repository. Nous utiliserons les méthodes fournies par Spring Data JPA pour enregistrer, rechercher, modifier et supprimer des données.

À la fin de cette leçon, vous serez capable de créer une interface JpaRepository et d'effectuer facilement les principales opérations CRUD sur vos entités.

Dans cette leçon, nous allons découvrir la base de données H2 et apprendre à la configurer dans une application Spring Boot. Nous verrons également comment accéder à la console H2 afin de consulter les données enregistrées.

À la fin de cette leçon, vous serez capable de configurer une base de données H2, de lancer votre application avec cette base de données et d'explorer son contenu grâce à la console H2.

Dans cette leçon, nous allons découvrir comment combiner les contrôleurs REST et les interfaces Repository afin de réaliser les principales opérations CRUD sur une base de données.

À la fin de cette leçon, vous comprendrez comment les différentes couches d'une application Spring Boot collaborent pour créer, lire, modifier et supprimer des données.

Dans cette leçon, nous allons développer pas à pas une API REST complète permettant d'effectuer les opérations CRUD. Nous relierons les contrôleurs REST aux interfaces Repository afin de manipuler les données de manière professionnelle.

À la fin de cette leçon, vous serez capable de développer une API REST complète reposant sur Spring Data JPA et de réaliser toutes les opérations CRUD sur vos entités.

Dans cette leçon, nous allons comparer SQL et JPQL afin de comprendre leurs différences, leurs avantages et les cas dans lesquels chacun doit être utilisé. Nous verrons également comment JPQL interagit avec les entités JPA.

À la fin de cette leçon, vous comprendrez les différences entre SQL et JPQL et serez capable de choisir le langage de requête le plus adapté selon vos besoins.

Dans cette leçon, nous allons découvrir les méthodes de requête proposées par Spring Data JPA ainsi que l'annotation @Query. Nous verrons comment créer des recherches personnalisées sans écrire beaucoup de code.

À la fin de cette leçon, vous comprendrez comment Spring Data JPA génère automatiquement des requêtes et comment personnaliser ces requêtes grâce à @Query.

Dans cette leçon, nous allons mettre en pratique les méthodes de requête et l'annotation @Query en développant plusieurs recherches personnalisées sur nos entités. Nous analyserons chaque exemple afin de comprendre leur fonctionnement.

À la fin de cette leçon, vous serez capable de créer des méthodes de recherche avancées, d'utiliser @Query pour personnaliser vos requêtes et d'interroger efficacement vos données avec Spring Data JPA.

Dans cette leçon, nous allons découvrir les notions fondamentales de classe et d'objet en Java. Nous verrons comment définir une classe, créer des objets et comprendre leur rôle dans la programmation orientée objet.

À la fin de cette leçon, vous comprendrez les concepts de classes et d'objets et serez capable de créer vos propres objets Java pour structurer votre code.

Dans cette leçon, nous allons mettre en pratique les notions de classes et d'objets en développant plusieurs exemples concrets. Nous créerons des objets, manipulerons leurs attributs et utiliserons leurs méthodes.

À la fin de cette leçon, vous serez capable de créer des classes, d'instancier des objets et de les utiliser efficacement dans vos applications Java.

Dans cette leçon, nous allons découvrir les méthodes en Java et comprendre leur rôle dans une classe. Nous verrons comment les déclarer, leur transmettre des paramètres et récupérer une valeur de retour.

À la fin de cette leçon, vous comprendrez le fonctionnement des méthodes et serez capable de créer des comportements réutilisables dans vos classes Java.

Dans cette leçon, nous allons mettre en pratique la création et l'utilisation de méthodes à travers plusieurs exemples. Nous apprendrons à utiliser des paramètres, des valeurs de retour et à appeler des méthodes depuis d'autres classes.

À la fin de cette leçon, vous serez capable de développer des méthodes claires, réutilisables et adaptées aux besoins de vos applications Java.

Dans cette leçon, nous allons découvrir les notions d'interface et d'abstraction, deux concepts essentiels de la programmation orientée objet. Nous verrons leurs avantages et les situations dans lesquelles ils doivent être utilisés.

À la fin de cette leçon, vous comprendrez le rôle des interfaces et de l'abstraction et serez capable de concevoir un code plus flexible, maintenable et évolutif.

Dans cette leçon, nous allons mettre en pratique les interfaces et l'abstraction en développant plusieurs exemples concrets. Nous verrons comment définir des interfaces, les implémenter et exploiter le polymorphisme.

À la fin de cette leçon, vous serez capable de créer vos propres interfaces et de les utiliser pour développer des applications Java plus modulaires.

Dans cette leçon, nous allons découvrir le mécanisme de gestion des exceptions en Java. Nous verrons comment détecter, traiter et propager les erreurs afin de rendre nos applications plus robustes et plus fiables.

À la fin de cette leçon, vous comprendrez le fonctionnement des exceptions et serez capable de gérer efficacement les erreurs dans vos applications Java.

Dans cette leçon, nous allons mettre en pratique la gestion des exceptions en développant plusieurs scénarios concrets. Nous utiliserons les blocs try, catch, finally ainsi que le mot-clé throw afin de traiter différentes situations d'erreur.

À la fin de cette leçon, vous serez capable d'implémenter une gestion des exceptions efficace et de sécuriser vos applications contre les erreurs les plus courantes.

Dans cette leçon, nous allons découvrir le framework Collections de Java ainsi que les principales structures de données telles que List, Set et Map. Nous verrons leurs différences et apprendrons à choisir la collection la plus adaptée selon le contexte.

À la fin de cette leçon, vous comprendrez le fonctionnement des principales collections Java et serez capable de les utiliser efficacement pour manipuler des ensembles de données.

Dans cette leçon, nous allons découvrir les principales annotations stéréotypes de Spring, telles que @Component, @Service, @Repository et @Controller. Nous verrons leur rôle et comment Spring les utilise pour gérer automatiquement les composants de l'application.

À la fin de cette leçon, vous comprendrez le fonctionnement des annotations stéréotypes et serez capable de choisir l'annotation la plus adaptée selon la responsabilité de chaque classe.

Dans cette leçon, nous allons découvrir l'architecture en couches utilisée dans les applications Spring Boot. Nous analyserons le rôle des couches Controller, Service et Repository, ainsi que les interactions entre elles.

À la fin de cette leçon, vous comprendrez l'organisation d'une application Spring Boot professionnelle et serez capable de répartir correctement les responsabilités entre les différentes couches.

Dans cette leçon, nous allons découvrir pourquoi la logique métier doit être placée dans la couche Service plutôt que dans les contrôleurs. Nous verrons comment cette approche améliore la lisibilité, la réutilisabilité et la maintenabilité du code.

À la fin de cette leçon, vous comprendrez le rôle de la couche Service et serez capable d'y implémenter une logique métier claire et bien structurée.

Dans cette leçon, nous allons mettre en pratique la création d'une couche Service en implémentant plusieurs traitements métier. Nous relierons cette couche aux contrôleurs et aux repositories afin de construire une architecture propre et évolutive.

À la fin de cette leçon, vous serez capable de développer des services réutilisables et de séparer efficacement la logique métier de la couche de présentation.

Dans cette leçon, nous allons découvrir l'annotation @ControllerAdvice, qui permet de centraliser la gestion des exceptions dans une application Spring Boot. Nous verrons pourquoi cette approche facilite la maintenance et améliore la qualité des API REST.

À la fin de cette leçon, vous comprendrez le fonctionnement de @ControllerAdvice et serez capable de mettre en place une gestion globale des erreurs dans vos applications.

Dans cette leçon, nous allons mettre en pratique @ControllerAdvice en créant un gestionnaire global d'exceptions. Nous développerons plusieurs scénarios afin de renvoyer des réponses d'erreur claires et cohérentes aux clients de l'API.

À la fin de cette leçon, vous serez capable d'implémenter une gestion centralisée des exceptions et de produire des réponses d'erreur professionnelles dans vos API REST.

Dans cette leçon, nous allons découvrir comment utiliser @Validated et @Valid dans la couche Service afin de garantir la validité des données avant l'exécution de la logique métier. Nous verrons également les différences entre ces deux annotations.

À la fin de cette leçon, vous comprendrez comment mettre en place une validation efficace dans la couche Service et serez capable de sécuriser les traitements de votre application.

Dans cette leçon, nous allons mettre en pratique @Validated et @Valid en développant plusieurs cas de validation dans la couche Service. Nous analyserons le comportement de l'application lorsque les données sont valides ou non.

À la fin de cette leçon, vous serez capable d'implémenter une validation robuste dans vos services et de garantir l'intégrité des données traitées par votre application.

Dans cette leçon, nous allons découvrir SLF4J et Logback, les outils de journalisation utilisés par Spring Boot. Nous verrons comment enregistrer des informations utiles sur le fonctionnement de l'application et faciliter le diagnostic des erreurs.

À la fin de cette leçon, vous comprendrez les principes de la journalisation et serez capable d'utiliser SLF4J et Logback pour suivre et analyser le comportement de vos applications.

Dans cette leçon, nous allons mettre en pratique SLF4J et Logback en ajoutant des journaux à différentes étapes de notre application. Nous apprendrons à choisir le bon niveau de log et à produire des messages utiles pour le développement et le débogage.

À la fin de cette leçon, vous serez capable d'intégrer une journalisation efficace dans vos applications Spring Boot et d'exploiter les logs pour diagnostiquer et résoudre les problèmes.

Dans cette leçon, nous allons découvrir les principes fondamentaux des tests unitaires avec JUnit dans une application Spring Boot. Nous verrons pourquoi les tests sont essentiels pour garantir la fiabilité du code et faciliter son évolution.

À la fin de cette leçon, vous comprendrez le rôle des tests unitaires et serez capable de mettre en place les bases d'une stratégie de test avec JUnit.

Dans cette leçon, nous allons créer nos premiers tests unitaires avec JUnit. Nous écrirons plusieurs cas de test et analyserons leur fonctionnement afin de vérifier le comportement de notre application.

À la fin de cette leçon, vous serez capable de créer et d'exécuter des tests unitaires avec JUnit pour valider le bon fonctionnement de votre code.

Dans cette leçon, nous allons découvrir Mockito et ArgumentCaptor, deux outils indispensables pour tester la couche Service de manière isolée. Nous verrons comment simuler les dépendances et vérifier les interactions entre les composants.

À la fin de cette leçon, vous comprendrez comment utiliser Mockito et ArgumentCaptor afin de tester efficacement la logique métier de vos services.

Dans cette leçon, nous allons mettre en pratique Mockito et ArgumentCaptor en développant plusieurs tests unitaires sur la couche Service. Nous simulerons les dépendances et vérifierons le comportement de nos méthodes dans différents scénarios.

À la fin de cette leçon, vous serez capable de créer des tests unitaires complets pour vos services en utilisant Mockito et ArgumentCaptor.

Dans cette leçon, nous allons découvrir MockMvc et apprendre à tester les contrôleurs REST sans démarrer l'application complète. Nous verrons également comment vérifier le comportement des validations.

À la fin de cette leçon, vous comprendrez comment tester vos contrôleurs REST et valider les réponses de votre API à l'aide de MockMvc.

Dans cette leçon, nous allons mettre en pratique MockMvc en développant plusieurs tests sur nos contrôleurs REST. Nous vérifierons les codes de réponse, les données retournées ainsi que le comportement des validations.

À la fin de cette leçon, vous serez capable de créer des tests fiables pour vos contrôleurs REST et de garantir le bon fonctionnement de vos endpoints.

Dans cette leçon, nous allons découvrir l'annotation @DataJpaTest, spécialement conçue pour tester la couche Repository. Nous verrons comment vérifier le fonctionnement des accès aux données dans une base de données de test.

À la fin de cette leçon, vous comprendrez le rôle de @DataJpaTest et serez capable de tester efficacement vos repositories Spring Data JPA.

Dans cette leçon, nous allons découvrir comment vérifier les messages de journalisation générés pendant l'exécution des tests. Nous verrons pourquoi la validation des logs peut être utile pour contrôler certains comportements de l'application.

À la fin de cette leçon, vous comprendrez comment intégrer la vérification des journaux dans vos tests et garantir que les messages importants sont correctement produits.

Dans cette leçon, nous allons mettre en pratique la vérification des logs en développant plusieurs tests qui contrôlent les messages générés par l'application. Nous utiliserons des outils adaptés afin de valider le contenu des journaux.

À la fin de cette leçon, vous serez capable de tester la journalisation de vos applications Spring Boot et de vérifier que les événements importants sont correctement enregistrés.

Dans cette leçon, nous allons découvrir comment mesurer la couverture du code et évaluer la qualité de nos tests. Nous verrons les principaux indicateurs utilisés pour identifier les parties de l'application qui nécessitent davantage de tests.

À la fin de cette leçon, vous comprendrez comment analyser la couverture de votre code et interpréter les résultats afin d'améliorer la qualité de votre suite de tests.

Dans cette leçon, nous allons mettre en pratique les outils de mesure de couverture du code et analyser les résultats obtenus sur notre projet Spring Boot. Nous identifierons les zones insuffisamment testées et verrons comment améliorer la qualité globale des tests.

À la fin de cette leçon, vous serez capable de mesurer la couverture de votre code, d'interpréter les rapports générés et d'optimiser vos tests pour renforcer la fiabilité de votre application.

Dans cette leçon, nous allons mettre en pratique @DataJpaTest en développant plusieurs tests sur nos repositories. Nous vérifierons les opérations CRUD ainsi que les méthodes de recherche personnalisées.

À la fin de cette leçon, vous serez capable d'écrire des tests fiables pour la couche Repository et de valider le bon fonctionnement de vos accès aux données.

Dans cette leçon, nous allons découvrir le rôle des DTO (Data Transfer Objects) ainsi que les bibliothèques ModelMapper et MapStruct. Nous verrons comment séparer les modèles de données des objets exposés par une API et automatiser leur conversion.

À la fin de cette leçon, vous comprendrez l'intérêt des DTO et serez capable de choisir une solution adaptée pour convertir efficacement vos objets dans une application Spring Boot.

Dans cette leçon, nous allons mettre en pratique la création de DTO ainsi que leur conversion avec ModelMapper et MapStruct. Nous développerons plusieurs exemples afin de comparer les deux approches.

À la fin de cette leçon, vous serez capable de créer des DTO et d'automatiser leur conversion pour construire des API plus propres et plus sécurisées.

Dans cette leçon, nous allons découvrir comment mettre en place la pagination et le tri avec Spring Data JPA. Nous verrons pourquoi ces fonctionnalités sont essentielles pour manipuler efficacement de grands volumes de données.

À la fin de cette leçon, vous comprendrez le fonctionnement de la pagination et du tri et serez capable de les intégrer dans vos API REST.

Dans cette leçon, nous allons mettre en pratique la pagination et le tri en développant plusieurs endpoints REST. Nous apprendrons à retourner des résultats paginés et ordonnés selon différents critères.

À la fin de cette leçon, vous serez capable d'implémenter des API performantes grâce aux fonctionnalités de pagination et de tri de Spring Data.

Dans cette leçon, nous allons découvrir les profils Spring Boot et comprendre comment adapter la configuration d'une application selon les environnements de développement, de test et de production.

À la fin de cette leçon, vous comprendrez le fonctionnement des profils Spring Boot et serez capable de gérer plusieurs configurations au sein d'une même application.

Dans cette leçon, nous allons mettre en pratique les profils Spring Boot en configurant différents environnements. Nous verrons comment activer un profil et adapter automatiquement le comportement de l'application.

À la fin de cette leçon, vous serez capable de configurer et d'utiliser plusieurs profils Spring Boot pour répondre aux besoins de différents environnements.

Dans cette leçon, nous allons découvrir comment externaliser la configuration d'une application Spring Boot afin de la rendre plus flexible et plus facile à maintenir. Nous verrons les principaux fichiers de configuration et les mécanismes proposés par Spring Boot.

À la fin de cette leçon, vous comprendrez comment gérer efficacement les propriétés de votre application et adapter sa configuration selon vos besoins.

Dans cette leçon, nous allons mettre en pratique l'externalisation de la configuration en utilisant différents fichiers et propriétés Spring Boot. Nous analyserons plusieurs exemples afin de comprendre leur impact sur le fonctionnement de l'application.

À la fin de cette leçon, vous serez capable d'organiser et de gérer la configuration de vos applications Spring Boot de manière professionnelle.

Dans cette leçon, nous allons découvrir Swagger et OpenAPI, deux outils permettant de documenter automatiquement les API REST. Nous verrons comment générer une documentation interactive et faciliter l'utilisation de nos services.

À la fin de cette leçon, vous comprendrez l'intérêt de Swagger et OpenAPI et serez capable de documenter efficacement vos API Spring Boot.

Dans cette leçon, nous allons mettre en pratique Swagger et OpenAPI en générant automatiquement la documentation de notre API REST. Nous explorerons également l'interface interactive permettant de tester les différents endpoints.

À la fin de cette leçon, vous serez capable de mettre en place une documentation API complète et interactive pour vos applications Spring Boot.

Dans cette leçon, nous allons découvrir les fonctionnalités d'audit automatique proposées par Spring Data JPA. Nous verrons comment enregistrer automatiquement les dates de création, de modification et les informations associées aux entités.

À la fin de cette leçon, vous comprendrez le fonctionnement de l'audit automatique et serez capable de l'intégrer dans vos applications Spring Boot.

Dans cette leçon, nous allons mettre en pratique les fonctionnalités d'audit de Spring Data JPA en configurant des entités capables d'enregistrer automatiquement les informations de suivi.

À la fin de cette leçon, vous serez capable d'implémenter un système d'audit automatique afin d'améliorer la traçabilité des données de votre application.

Dans cette leçon, nous allons découvrir Flyway, un outil permettant de gérer l'évolution du schéma d'une base de données grâce aux migrations versionnées. Nous verrons pourquoi cette approche est indispensable dans les projets professionnels.

À la fin de cette leçon, vous comprendrez le fonctionnement de Flyway et serez capable de gérer les évolutions de votre base de données de manière fiable et sécurisée.

Dans cette leçon, nous allons mettre en pratique Flyway en créant et en exécutant plusieurs scripts de migration. Nous observerons comment Spring Boot applique automatiquement les changements au démarrage de l'application.

À la fin de cette leçon, vous serez capable de créer, versionner et exécuter des migrations de base de données avec Flyway.

Dans cette leçon, nous allons découvrir les traitements asynchrones ainsi que la planification de tâches avec Spring Boot. Nous verrons comment exécuter certaines opérations en arrière-plan et automatiser des traitements périodiques.

À la fin de cette leçon, vous comprendrez le fonctionnement des traitements asynchrones et des tâches planifiées, et serez capable de les intégrer dans vos applications Spring Boot.

Dans cette leçon, nous allons mettre en pratique les traitements asynchrones et la planification de tâches en développant plusieurs exemples avec @Async et @Scheduled. Nous analyserons leur comportement et les cas d'utilisation les plus courants.

À la fin de cette leçon, vous serez capable d'implémenter des traitements asynchrones et des tâches planifiées afin d'améliorer les performances et l'automatisation de vos applications Spring Boot.

Dans cette leçon, nous allons découvrir les principes fondamentaux de Spring Security et comprendre son rôle dans la protection des applications Spring Boot.

À la fin de cette leçon, vous comprendrez les bases de Spring Security et serez capable de l'intégrer dans une application Spring Boot.

Dans cette leçon, nous allons mettre en pratique les concepts fondamentaux de Spring Security en sécurisant une première application.

À la fin de cette leçon, vous serez capable de configurer une protection de base avec Spring Security.

Dans cette leçon, nous allons découvrir le processus d'authentification et le rôle du SecurityContext dans Spring Security.

À la fin de cette leçon, vous comprendrez comment Spring Security gère l'utilisateur authentifié tout au long d'une requête.

Dans cette leçon, nous allons découvrir le rôle de AuthenticationManager, ProviderManager et UserDetailsService dans le processus d'authentification.

À la fin de cette leçon, vous comprendrez comment ces composants collaborent pour authentifier un utilisateur.

Dans cette leçon, nous allons mettre en pratique ces composants en développant une authentification complète.

À la fin de cette leçon, vous serez capable de configurer et d'utiliser les principaux composants d'authentification de Spring Security.

Dans cette leçon, nous allons découvrir les bonnes pratiques de gestion des mots de passe et les mécanismes de sécurité proposés par Spring Security.

À la fin de cette leçon, vous comprendrez comment protéger efficacement les identifiants des utilisateurs.

Dans cette leçon, nous allons mettre en pratique le chiffrement des mots de passe et les principaux mécanismes de sécurité.

À la fin de cette leçon, vous serez capable de sécuriser les mots de passe dans une application Spring Boot.

Dans cette leçon, nous allons découvrir le fonctionnement de SecurityFilterChain et son rôle dans la sécurisation des requêtes HTTP.

À la fin de cette leçon, vous comprendrez comment Spring Security applique ses règles de sécurité aux requêtes.

Dans cette leçon, nous allons mettre en pratique SecurityFilterChain en configurant des règles de sécurité pour différents endpoints.

À la fin de cette leçon, vous serez capable de personnaliser la sécurité de vos API grâce à SecurityFilterChain.

Dans cette leçon, nous allons découvrir le fonctionnement des JSON Web Tokens (JWT) et leur utilisation pour sécuriser des API REST.

À la fin de cette leçon, vous comprendrez les principes de l'authentification basée sur les tokens avec JWT.

Dans cette leçon, nous allons mettre en pratique SecurityFilterChain en configurant des règles de sécurité pour différents endpoints.

À la fin de cette leçon, vous serez capable de personnaliser la sécurité de vos API grâce à SecurityFilterChain.

Dans cette leçon, nous allons découvrir Spring Boot Actuator et les principaux endpoints permettant de surveiller l'état d'une application.

À la fin de cette leçon, vous comprendrez le rôle de Spring Boot Actuator et serez capable d'utiliser les Health Checks pour superviser votre application.

Dans cette leçon, nous allons mettre en pratique Spring Boot Actuator en configurant différents endpoints de supervision et de diagnostic.

À la fin de cette leçon, vous serez capable d'intégrer Actuator dans une application Spring Boot et d'exploiter ses fonctionnalités de monitoring.

Dans cette leçon, nous allons découvrir Micrometer et Prometheus, deux outils permettant de collecter et d'exposer les métriques d'une application Spring Boot.

À la fin de cette leçon, vous comprendrez comment mesurer les performances de votre application grâce aux métriques.

Dans cette leçon, nous allons mettre en pratique Micrometer et Prometheus afin de collecter et consulter les métriques de notre application.

À la fin de cette leçon, vous serez capable de configurer et d'utiliser des métriques pour superviser vos applications Spring Boot.

Dans cette leçon, nous allons découvrir comment créer une image Docker et déployer une application Spring Boot dans un conteneur.

À la fin de cette leçon, vous comprendrez les bases du déploiement d'une application Spring Boot avec Docker.

Dans cette leçon, nous allons mettre en pratique Docker en créant une image et en exécutant notre application dans un conteneur.

À la fin de cette leçon, vous serez capable de conteneuriser une application Spring Boot avec Docker.

Dans cette leçon, nous allons découvrir comment utiliser Docker Compose pour exécuter simultanément une application Spring Boot et une base de données PostgreSQL.

À la fin de cette leçon, vous comprendrez comment orchestrer plusieurs services avec Docker Compose.

Dans cette leçon, nous allons mettre en pratique Docker Compose en configurant une application Spring Boot avec PostgreSQL.

À la fin de cette leçon, vous serez capable de déployer une application complète à l'aide de Docker Compose.

Dans cette leçon, nous allons découvrir comment déployer une application Spring Boot sur le cloud avec Render et Fly.io.

À la fin de cette leçon, vous serez capable de publier votre application Spring Boot sur une plateforme cloud.

Dans cette leçon, nous allons découvrir les principes du CI/CD et le fonctionnement de GitHub Actions pour automatiser le build et les tests d'une application.

À la fin de cette leçon, vous comprendrez les bases de l'intégration et du déploiement continus avec GitHub Actions.

Dans cette leçon, nous allons mettre en pratique GitHub Actions en créant un workflow automatisé pour construire et tester notre application.

À la fin de cette leçon, vous serez capable de mettre en place une pipeline CI/CD simple avec GitHub Actions.

Dans cette leçon, nous allons découvrir les bonnes pratiques pour préparer une application Spring Boot à un environnement de production. Nous verrons les principaux réglages liés à la sécurité, aux performances et à la configuration.

À la fin de cette leçon, vous serez capable de configurer une application Spring Boot pour un déploiement en production en appliquant les bonnes pratiques professionnelles.