Séance 1

Chapitre 1 : Introduction à l’architecture des SI & Spring Frameworks

• Comprendre les concepts fondamentaux de l’architecture des systèmes d’information et leur rôle dans la conception d’applications d’entreprise.
• Identifier les principaux styles architecturaux, analyser leurs domaines d’application et évaluer leurs avantages ainsi que leurs limites.
• Comparer les styles architecturaux au regard des exigences fonctionnelles et non fonctionnelles (performance, scalabilité, disponibilité, sécurité, maintenabilité et coût).
• Identifier les principaux patrons d’architecture et comprendre leur contribution à la modularité, à la flexibilité, à l’évolutivité et à la maintenabilité des systèmes logiciels.
• Découvrir l’écosystème Spring et comprendre son rôle dans le développement d’applications Java d’entreprise.
• Préparer un environnement de développement complet en installant et configurant les outils nécessaires (JDK, IntelliJ IDEA, MySQL, Postman et Git).

Séance 2

Chapitre 2 : Spring Boot, Maven et persistance des données avec Spring Data JPA

• Comprendre le rôle de Spring Boot dans le développement d’applications Java d’entreprise.
• Maîtriser l’arborescence et l’organisation d’un projet Spring Boot.
• Distinguer les apports de Spring Boot : simplification de la gestion des dépendances (Maven), de la configuration (application.properties) et du déploiement (Tomcat embarqué).
• Définir le rôle de Maven, comprendre son cycle de vie et exécuter les principaux goals Maven.
• Comprendre le principe de l’ORM (Object-Relational Mapping) et son intérêt pour le développement d’applications orientées objet.
• Expliquer le rôle de JPA comme spécification de persistance et celui de Hibernate comme implémentation de référence.
• Comprendre le rôle de Spring Data JPA et les avantages qu’il apporte pour simplifier l’accès aux données.
• Créer les premières entités JPA et les mapper avec les tables de la base de données à l’aide des principales annotations (@Entity, @Id, @GeneratedValue, @Column, etc.).
• Utiliser Lombok afin de réduire le code répétitif et d’améliorer la lisibilité des classes métier.
• Réaliser une étude de cas mettant en œuvre la création des entités d’une application Spring Boot.

Séance 3

Chapitre 3 : Spring Data JPA : le mapping des associations

• Comprendre les principes du mapping objet-relationnel (ORM) appliqués aux associations entre entités.
• Identifier les différents types d’associations JPA et leurs cas d’utilisation (@OneToOne, @OneToMany, @ManyToOne, @ManyToMany).
• Concevoir et implémenter les associations entre entités en utilisant les annotations JPA appropriées.
• Distinguer les relations unidirectionnelles et bidirectionnelles et comprendre le rôle de mappedBy.
• Configurer les stratégies de chargement (LAZY et EAGER) en fonction des besoins fonctionnels et des performances.
• Maîtriser les opérations de propagation (CascadeType) et leur impact sur le cycle de vie des entités.
• Gérer la suppression des entités liées (orphanRemoval) et assurer l’intégrité des données.
• Éviter les problèmes de sérialisation JSON liés aux relations bidirectionnelles (@JsonManagedReference, @JsonBackReference ou @JsonIgnore).
• Appliquer les bonnes pratiques de modélisation afin de garantir la cohérence, la maintenabilité et les performances de la couche de persistance.
• Mettre en œuvre les associations à travers une étude de cas et valider leur fonctionnement via des tests.

Séance 4

Chapitre 4 : Les patrons de conception (Design Patterns GoF)

• Comprendre le rôle des Design Patterns dans la résolution de problèmes récurrents de conception logicielle.
• Identifier les trois familles des Design Patterns GoF : créationnels, structurels et comportementaux, ainsi que leurs domaines d’application.
• Reconnaître les principaux Design Patterns utilisés en Java et dans l’écosystème Spring.
• Choisir le Design Pattern adapté selon un problème de conception donné.
• Implémenter des Design Patterns dans une application Java/Spring en appliquant les bonnes pratiques de conception orientée objet.
• Comprendre l’utilisation des Design Patterns par Spring (Injection de dépendances, Factory, Proxy, Singleton, Observer, etc.).
• Analyser les avantages et les limites des Design Patterns sur la qualité, la maintenabilité et l’évolutivité des applications.
• Mettre en œuvre des Design Patterns dans une étude de cas en justifiant les choix de conception retenus.

Séance 5 & 6

Chapitre 5 : Spring Data JPA : JPA Repository

• Comprendre le rôle de Spring Data JPA dans la gestion de la couche de persistance d’une application Spring Boot.
• Identifier l’architecture de Spring Data JPA et les principales interfaces utilisées pour l’accès aux données (CrudRepository, PagingAndSortingRepository et JpaRepository).
• Mettre en place la couche Repository pour encapsuler les opérations d’accès aux données.
• Concevoir et implémenter la couche Service pour centraliser la logique métier et assurer la séparation des responsabilités.
• Réaliser les opérations CRUD sur les entités métier en respectant l’architecture multicouche d’une application Spring Boot.
• Appliquer les bonnes pratiques de conception des couches Repository et Service afin d’améliorer la modularité, la maintenabilité et l’évolutivité du code.
• Utiliser SonarQube for IDE (SonarLint) pour analyser la qualité du code dès la phase de développement.

Chapitre 6 : Inversion of Control (IoC), Dependency Injection (DI)

• Comprendre les principes de l’Inversion de Contrôle (IoC) et de l’Injection de Dépendances (DI) ainsi que leur rôle dans la conception d’applications modulaires et faiblement couplées.
• Comprendre le rôle du conteneur Spring IoC dans la création, la configuration et la gestion du cycle de vie des objets (Beans).
• Identifier le processus de création et de gestion des Beans par Spring à travers le mécanisme de l’IoC.
• Comprendre la notion de scope des Beans Spring et son impact sur le cycle de vie et le comportement des composants.
• Découvrir les différents modes d’injection de dépendances (constructeur, setter et attribut) et identifier les bonnes pratiques associées.
• Maîtriser les principales annotations Spring pour déclarer et configurer les composants (@Component, @Service, @Repository, @Controller, @Bean, @Autowired).
• Comprendre le rôle des annotations de stéréotypes dans la structuration des différentes couches d’une application Spring Boot.
• Mettre en œuvre l’injection de dépendances dans une architecture multicouche (Controller, Service, Repository).
• Appliquer les principes IoC/DI afin d’améliorer la modularité, la testabilité et la maintenabilité d’une application Spring Boot.

Chapitre 7 : Les principes SOLID

• Comprendre le rôle des principes SOLID dans la conception d’applications orientées objet robustes, maintenables et évolutives.
• Identifier les cinq principes SOLID : SRP, OCP, LSP, ISP et DIP et comprendre leur contribution à la qualité du code.
• Expliquer l’impact des principes SOLID sur la qualité logicielle, notamment la modularité, la réutilisabilité, la testabilité et la facilité d’évolution du code.
• Analyser une conception existante afin d’identifier les violations des principes SOLID et leurs impacts.
• Appliquer les principes de faible couplage et de forte cohésion dans la conception d’une application Spring Boot.
• Appliquer les principes SOLID lors de la conception des différentes couches d’une application Spring Boot (Controller, Service, Repository).
• Utiliser le refactoring pour améliorer la modularité, la lisibilité et la maintenabilité du code.
• Mettre en œuvre les principes SOLID dans une étude de cas en justifiant les choix de conception.

Séance 7

Chapitre 8 : Spring MVC et SpringDoc

• Comprendre le cycle de vie d’une requête HTTP dans une application Spring MVC, de sa réception jusqu’à la génération de la réponse.
• Identifier le rôle des principaux composants de Spring MVC (DispatcherServlet, Controller, Service et Repository) dans le traitement d’une requête.
• Concevoir et développer des API REST avec Spring Web MVC en respectant les bonnes pratiques.
• Maîtriser les principales annotations Spring MVC pour l’exposition des ressources REST (@RestController, @RequestMapping, @GetMapping, @PostMapping, etc.).
• Gérer les requêtes et les réponses de manière appropriée.
• Tester les API REST avec Postman.
• Documenter automatiquement les API REST avec SpringDoc OpenAPI afin de faciliter leur utilisation, leur validation et leur maintenance.

Séance 8

Chapitre 9 : Spring Data JPA : gestion des affectations entre entités

• Comprendre le rôle des associations JPA dans la modélisation des relations entre les entités métier.
• Identifier les différents scénarios d’affectation et de désaffectation entre entités au sein d’une application Spring Boot.
• Mettre en œuvre les opérations d’affectation et de désaffectation en exploitant les relations JPA (@OneToOne, @OneToMany, @ManyToOne et @ManyToMany).
• Maintenir la cohérence des associations bidirectionnelles en appliquant les bonnes pratiques de synchronisation (set, add, remove).
• Développer les services métier assurant la gestion des liens entre les entités tout en respectant les règles fonctionnelles.
• Comprendre le rôle des transactions dans la persistance des données et la cohérence des opérations métier.
• Utiliser l’annotation @Transactional pour garantir l’atomicité et l’intégrité des opérations d’affectation et de désaffectation.
• Mettre en pratique ces concepts à travers un atelier de développement intégrant la gestion complète des associations entre entités.

Séance 9

Chapitre 10 : Qualité, maintenabilité et amélioration du code

• Comprendre les principes du Clean Code et leur impact sur la qualité et la maintenabilité des applications.
• Identifier les défauts de qualité, les mauvaises pratiques de développement et les vulnérabilités potentielles à l’aide d’un outil d’analyse statique tel que SonarLint.
• Interpréter les résultats d’une analyse statique et appliquer les corrections nécessaires afin d’améliorer la qualité du code.
• Comprendre le rôle des DTO dans la séparation des couches et la sécurisation des échanges de données.
• Concevoir et implémenter des DTO adaptés aux besoins fonctionnels d’une application Spring.
• Valider les données à l’aide des mécanismes de validation proposés par Spring.
• Appliquer les principales techniques de refactoring afin d’améliorer la lisibilité, la qualité et la maintenabilité du code sans modifier son comportement.
• Adopter les bonnes pratiques de développement pour concevoir des applications Spring plus robustes, évolutives et faciles à maintenir.

Séance 10 & 11

Chapitre 11 : Requêtage avancé avec Spring Data JPA (Méthodes dérivées, Keywords & JPQL)

• Comprendre le fonctionnement de Spring Data JPA pour la gestion de la couche d’accès aux données.
• Concevoir et utiliser des repositories JPA pour manipuler les données.
• Implémenter des méthodes dérivées simples et complexes basées sur les conventions de nommage de Spring Data JPA.
• Exploiter les Keywords (findBy, And, Or, Between, Like, In, OrderBy…) pour réaliser des requêtes personnalisées.
• Concevoir des requêtes JPQL pour interroger les entités et leurs associations.
• Manipuler les jointures (JOIN, LEFT JOIN), les requêtes d’agrégation (COUNT, SUM, AVG, GROUP BY, HAVING) et les requêtes de modification (UPDATE, DELETE) avec @Modifying.
• Utiliser @Query et les DTO pour optimiser la récupération des données et adapter les résultats aux besoins métier.
• Développer et optimiser des fonctionnalités de recherche avancée dans une application Spring.

Chapitre 12 : Spring Scheduler

• Comprendre les principes de l’exécution planifiée et automatisée des traitements dans une application Spring Boot.
• Configurer Spring Scheduler et utiliser l’annotation @Scheduled pour déclencher automatiquement des tâches.
• Maîtriser les différents modes de planification (fixedRate, fixedDelay, cron) selon les besoins fonctionnels.
• Concevoir et implémenter des traitements périodiques pour automatiser des opérations métier (notifications, synchronisations, mises à jour, contrôles périodiques…).
• Gérer les paramètres d’exécution des tâches planifiées et leur intégration dans l’architecture d’une application Spring.
• Comprendre la différence entre exécution synchrone et asynchrone des tâches planifiées.
• Configurer et utiliser les mécanismes d’exécution asynchrone avec @Async lorsque cela est nécessaire.
• Identifier les bonnes pratiques pour assurer la fiabilité, la performance et la maintenabilité des traitements automatisés.
• Mettre en œuvre un scénario métier complet intégrant des tâches planifiées dans une application Spring Boot.

Séance 12

Chapitre 13 : Programmation orientée aspect avec Spring AOP

• Comprendre les principes de la programmation orientée aspect (AOP) et son intérêt dans la séparation des préoccupations transversales.
• Identifier les concepts fondamentaux de l’AOP : Aspect, Join Point, Pointcut et Advice.
• Comprendre le rôle des patterns de conception GoF liés à l’AOP, notamment Proxy, Decorator et Observer.
• Identifier les cas d’utilisation des aspects transversaux dans une application Spring (logging, sécurité, suivi des performances…).
• Comprendre le fonctionnement du mécanisme de Proxy dynamique utilisé par Spring AOP.
• Maîtriser les différents types d’Advice (Before, After, AfterReturning, AfterThrowing, Around).
• Configurer des aspects avec les annotations Spring AOP (@Aspect, @Pointcut, @Before, @After, @Around).
• Implémenter des aspects pour automatiser la journalisation et centraliser les traitements communs dans les couches applicatives.
• Intégrer Spring AOP dans une application Spring Boot afin d’améliorer la modularité, la maintenabilité et la réutilisabilité du code.

Séance 13

Chapitre 14 : Qualité logicielle : métriques, analyse et amélioration continue

• Comprendre les enjeux de la qualité logicielle et son importance dans le cycle de développement.
• Identifier les principaux critères d’évaluation de la qualité d’une application (maintenabilité, fiabilité, performance, sécurité et évolutivité).
• Comprendre les métriques quantitatives utilisées pour mesurer la qualité du code (complexité cyclomatique, volume de code, taux de duplication, couverture des tests…).
• Évaluer les métriques qualitatives à travers l’analyse des bonnes pratiques, des standards de développement et des règles de qualité.
• Identifier et analyser la dette technique ainsi que son impact sur la maintenabilité, l’évolution et le coût de maintenance des applications.
• Utiliser des outils d’analyse de qualité tels que SonarQube pour mesurer la qualité du code, détecter les problèmes et suivre la dette technique.
• Interpréter les rapports d’analyse et définir des actions correctives pour améliorer la qualité logicielle.
• Mettre en œuvre une démarche d’amélioration continue visant à produire des applications Spring Boot plus robustes, maintenables et évolutives.

Séance 14

Révision et évaluation

• Consolider les concepts fondamentaux abordés tout au long du module Architecture des SI & Spring.
• Synthétiser les principales notions liées à la conception, au développement et à la qualité des applications Spring Boot.
• Réviser les différents composants de l’écosystème Spring Boot étudiés (Spring Data JPA, Spring MVC, Spring AOP, Scheduler, validation, qualité du code…).
• Mobiliser les bonnes pratiques d’architecture et de développement applicatif dans des études de cas.
• Analyser des exemples d’applications, identifier les problèmes et proposer des améliorations.
• Se préparer à l’évaluation finale à travers des exercices de synthèse et des mises en situation pratiques.
• Clarifier les points techniques et répondre aux questions liées aux différents chapitres du module.