Fiche de révision : Architectures logicielles avancées

📋 Plan du Cours

1. Applications Web et architecture backend
2. Principes et vocabulaire REST
3. Routes REST avec Spring Boot
4. Données et réponses HTTP
5. DTO et marshalling
6. Conception d’API avec OpenAPI
7. Services et mapping objet-relationnel
8. Mapping JPA des entités
9. Repositories et persistance Spring
10. Tests unitaires des routes REST
11. Authentification et sessions
12. Contrôle d’accès des API
13. Risques et protections API
14. Gestion de l’inventaire des API
15. Consommation sûre des API externes
16. Validation automatique des données d’entrée
17. Conception des ressources REST
18. Statuts HTTP et versioning

📖 1. Applications Web et architecture backend

🔑 Notions clés & Définitions

• Front-end : La partie graphique côté client avec laquelle l’utilisateur interagit.
• Back-end : La partie serveur qui fournit des services Web, comme l’accès aux données ou les calculs, avec lesquels le front-end communique.

★ À maîtriser

📌 Une page Web désigne généralement un contenu HTML, CSS et JavaScript basique et statique, tandis qu’une application Web est un logiciel ou groupement de logiciels accessible par Internet, souvent organisé selon une séparation client-serveur.

Compléments

• Un backend moderne recherche notamment: la simplicité et la maintenabilité, l’abstraction et l’extensibilité, la réutilisation et l’optimisation des ressources, la modularité et la séparation des préoccupations, une bonne API et le passage à l’échelle, la fiabilité

• Les outils à utiliser comprennent Java 21, Maven 3, IntelliJ ou Visual Studio Code, Swagger Editor et le dépôt GitLab du cours.

💡 Astuce mémo

Page Web statique ≠ application Web distribuée

📖 2. Principes et vocabulaire REST

🔑 Notions clés & Définitions

• REST : ou Representational State Transfer, est un style d’architecture défini en 2000, fondé sur la séparation client-serveur, l’absence d’état des commandes, la possibilité de mettre en cache et une interface uniforme.
• Ressource REST : Un objet du back-end, souvent une classe Java, qui définit un ensemble de routes REST et est identifiée par une partie d’URI.

📝 Points essentiels

• REST utilise le protocole HTTP, mais une requête REST est un sur-ensemble d’une requête HTTP car elle organise notamment une ressource, une action, des données d’entrée et une réponse.

• Une route REST est identifiée par le couple unique verbe HTTP et URI ; ainsi POST foo/bar et GET foo/bar ne sont pas en conflit, tandis que GET foo/bar/{param1} et GET foo/bar/{param2} sont en conflit car les noms de paramètres ne comptent pas.

• Les verbes REST principaux sont POST pour créer, GET pour lire, DELETE pour supprimer, PUT pour remplacer et PATCH pour modifier une donnée existante.

💡 Astuce mémo

Verbe → URI → données → réponse

📖 3. Routes REST avec Spring Boot

★ À maîtriser

• Pour créer une ressource REST avec Spring Boot, il faut créer une classe annotée avec @RestController et définir l’URI de la ressource avec @RequestMapping.

• Dans Spring Boot, @GetMapping(path = "world", produces = MediaType.TEXT_PLAIN_VALUE) définit une route GET dont l’URI est world et dont la réponse est du texte brut.

📌 Une route POST place généralement la donnée à créer dans le corps de la requête, tandis qu’une route GET sert à récupérer des données en lecture seule.

📌 Avec PATCH, les attributs absents du JSON reçu ne sont pas définis et peuvent rester inchangés, tandis qu’avec PUT la route reçoit théoriquement un objet complet et remplace l’objet ciblé.

Compléments

• Spring Boot 3 utilise l’écosystème JAX-RS, tandis que Spring Boot 2 n’utilise pas JAX-RS ; Spring Boot 3.4.1 est utilisé avec Java 21 et Maven dans ce cours.

💡 Astuce mémo

CRUD : Create, Read, Update, Delete

📖 4. Données et réponses HTTP

★ À maîtriser

• Les données d’une requête REST peuvent être transmises dans le corps HTTP, dans l’URI de la route ou dans les paramètres de l’URI.

• Toute requête REST reçoit toujours une réponse HTTP, même lorsque la méthode Java retourne void ; cette réponse peut contenir un code, des données et un message.

• Les principaux codes HTTP sont:

  • 200 OK
  • 204 No Content
  • 400 Bad Request
  • 404 Not Found
  • 405 Method Not Allowed
  • 500 Internal Server Error

📌 Une API REST doit utiliser des codes HTTP adaptés, notamment ResponseEntity ou ResponseStatusException, plutôt que de laisser une erreur applicative produire systématiquement le code 500.

Compléments

📌 Le body permet de transmettre des données complexes et de moins exposer les données, tandis que l’URI est simple mais pollue l’adresse et affiche les données en clair.

💡 Astuce mémo

Body complexe et discret, URI simple mais exposée

📖 5. DTO et marshalling

🔑 Notions clés & Définitions

• DTO : Une classe dédiée qui représente uniquement les attributs à transférer entre le back-end et le client, afin d’adapter la structure et d’exclure les données sensibles.

★ À maîtriser

• Retourner directement un objet User contenant l’attribut confidentiel pwd peut exposer ce mot de passe, tandis qu’un UserDTO contenant seulement name, address et id l’exclut de la réponse.

📌 Le marshalling transforme un objet en format adapté à la transmission, par exemple un objet Java en JSON puis en texte de body, tandis que le démarshalling effectue la transformation inverse.

Compléments

• Spring gère nativement le marshalling JSON avec Jackson, tandis que le marshalling XML nécessite l’ajout de jackson-dataformat-xml dans les dépendances.

📌 Pour marshaller une hiérarchie comprenant une interface Animal, @JsonTypeInfo ajoute un attribut type au JSON et @JsonSubTypes indique les classes concrètes utilisables lors du démarshalling.

💡 Astuce mémo

Objet adapté → transfert maîtrisé → données sensibles exclues

📖 6. Conception d’API avec OpenAPI

🔑 Notions clés & Définitions

• OpenAPI : Permet de modéliser et de décrire une API REST avant son implémentation, puis de générer notamment un squelette de code du back-end et des tests.

★ À maîtriser

📌 Dans OpenAPI, une route est décrite sous paths avec une URI, un verbe, des paramètres éventuels, une requête, des réponses HTTP et le schéma de son contenu.

📌 Une API orientée CRUD définit des routes génériques Create-Read-Update-Delete pour les objets, tandis qu’une API orientée application adapte ses routes aux besoins précis du front-end.

Compléments

• Une spécification OpenAPI peut être écrite en YAML ou en JSON ; le cours utilise YAML et l’outil Swagger Editor pour la consulter et la modifier.

• La route /albumsSummary est un exemple de route orientée application, car elle fournit les données optimisées nécessaires à l’affichage résumé des albums.

💡 Astuce mémo

Modéliser → documenter → générer → tester

📖 7. Services et mapping objet-relationnel

🔑 Notions clés & Définitions

• Service : En Spring, une classe annotée avec @Service, dédiée à certains types de services comme l’accès aux données, que le contrôleur peut utiliser par injection de dépendances.
• ORM : Le mapping objet-relationnel, ou ORM, intègre une base de données relationnelle à une application orientée objet en convertissant les attributs des objets en valeurs stockables et les valeurs de la base en attributs d’objets.

★ À maîtriser

📌 La séparation des préoccupations consiste à faire gérer les routes par le contrôleur et les données ou la logique métier par un service, plutôt que de stocker directement ces données dans le contrôleur.

📌 Une classe dont les instances doivent être stockées en base doit être annotée avec @Entity et posséder une clé primaire annotée avec @Id.

• JPA ne peut pas déduire automatiquement une relation entre deux références Java comme TodoList et Todo ; il faut donc définir les clés primaires, les clés étrangères et les annotations de relation nécessaires.

Compléments

• JPA, ou Jakarta Persistence API, est l’API d’ORM utilisée avec Spring Boot dans le cours, et plusieurs frameworks se conforment à ce standard.

📌 L’annotation @GeneratedValue permet d’initialiser et d’incrémenter automatiquement la valeur d’un identifiant, avec notamment les stratégies AUTO, SEQUENCE, IDENTITY, TABLE et UUID.

💡 Astuce mémo

Contrôleur = routes ; service = logique ; ORM = objets ↔ tables

📖 8. Mapping JPA des entités

🔑 Notions clés & Définitions

• @Id : Définit l’attribut utilisé comme clé primaire de l’entité JPA.
• @GeneratedValue : Initialise et incrémente automatiquement la valeur d’un attribut identifiant.
• @EmbeddedId : @EmbeddedId permet d’utiliser une clé primaire composée d’un seul attribut JPA de type intégrable, dont la classe doit être annotée par @Embeddable.

★ À maîtriser

📌 Une relation un-à-plusieurs se déclare avec @OneToMany(mappedBy = "list") du côté TodoList et une relation plusieurs-à-un avec @ManyToOne du côté Todo.

📌 JPA peut mapper les héritages avec SINGLE_TABLE, TABLE_PER_CLASS ou JOINED, qui utilisent respectivement une table unique, une table par classe avec duplication des colonnes ou une table par classe avec colonnes factorisées et clé étrangère.

Compléments

• Les stratégies de génération d’identifiant sont:

  • AUTO
  • SEQUENCE
  • IDENTITY
  • TABLE
  • UUID

• FetchType.LAZY charge les données à la demande, tandis que fetch EAGER charge toujours les données.

💡 Astuce mémo

Identifiant → relation → héritage

📖 9. Repositories et persistance Spring

🔑 Notions clés & Définitions

• CrudRepository : CrudRepository définit un repository CRUD pour des objets d’un type donné, identifiés par une clé d’un type donné.

★ À maîtriser

• Les opérations de base d’un repository sont:
  • save pour enregistrer
  • delete pour supprimer
  • findById pour rechercher par clé
  • findAll pour retourner tous les objets

📌 Une entité doit déclarer explicitement son attribut de clé avec @Id pour que le repository sache quelle clé utiliser lors de save et findById.

📌 La persistance d’une entité n’est pas transparente : elle devient persistante lorsque l’application appelle notamment persist ou merge, tandis que Spring Boot automatise la création des gestionnaires d’entités.

Compléments

• Une méthode de repository peut être annotée avec @Query pour exécuter une requête JPQL et être appelée ensuite depuis un service Spring.

💡 Astuce mémo

CrudRepository pour le CRUD, JpaRepository pour le relationnel

📖 10. Tests unitaires des routes REST

★ À maîtriser

• Un test de route REST avec MockMvc exécute une requête avec mvc.perform, vérifie le statut et le contenu avec andExpect, puis peut afficher la réponse avec andDo.

• Un test paramétré JUnit avec @ParameterizedTest et @MethodSource exécute le même test pour chaque donnée fournie par la méthode source.

• Les tests REST vérifient:

  • le fonctionnement nominal
  • les formats d’entrée
  • les réponses
  • les requêtes malformées
  • les injections
  • l’authentification
  • la performance et la montée en charge

Compléments

• jsonPath("$") désigne la racine du JSON, jsonPath("$[0]") un élément de tableau et jsonPath("$[0].name") une propriété de cet élément.

• Le produit cartésien de deux animaux et de deux formats d’entrée, JSON et XML, produit quatre exécutions : chat-JSON, chat-XML, chien-JSON et chien-XML.

💡 Astuce mémo

Requête → réponse → assertions

📖 11. Authentification et sessions

🔑 Notions clés & Définitions

• JSESSIONID : L’identifiant confidentiel de session envoyé dans un cookie et utilisé comme preuve d’identité pour accéder aux routes privées.

★ À maîtriser

📌 Dans Spring Security, les routes correspondant à /api/public/** peuvent être accessibles sans authentification avec permitAll, tandis que les autres routes peuvent exiger authenticated.

• L’authentification crée ou récupère une session, le serveur renvoie son identifiant JSESSIONID, puis le client le renvoie dans ses requêtes privées.

📌 Les mots de passe doivent être transmis dans le body d’un POST via HTTPS et stockés sous forme de hash côté back-end, avec bcrypt dans l’exemple présenté.

Compléments

📌 OAuth 2.0 délègue l’autorisation, tandis qu’un système d’authentification vérifie l’identité de l’utilisateur.

💡 Astuce mémo

Connexion → session JSESSIONID → accès privé

📖 12. Contrôle d’accès des API

📝 Points essentiels

• Le contrôle d’accès à un objet suit trois étapes:

  • récupérer l’identité avec Principal
  • transmettre le login au service
  • vérifier la propriété de l’objet

• API1 Broken Object Level Authorization permet à Alice d’accéder à une commande appartenant à Bob lorsque le serveur vérifie l’existence de la commande mais pas son propriétaire.

• API2 Broken Authentication se corrige en exigeant une session authentifiée pour l’endpoint, ce qui produit 401 Unauthorized sans session valide.

• API3 Broken Object Property Level Authorization se corrige avec un DTO contrôlé par le serveur qui n’accepte explicitement que les propriétés modifiables.

• API4 Unrestricted Resource Consumption se corrige en imposant une pagination et des limites serveur afin que le client ne puisse pas demander une consommation illimitée de ressources.

• API5 Broken Function Level Authorization se corrige en exigeant le rôle nécessaire, par exemple ADMIN avec @PreAuthorize("hasRole('ADMIN')"), ce qui renvoie 403 Forbidden à un utilisateur standard.

💡 Astuce mémo

Authentification identifie, autorisation décide

📖 13. Risques et protections API

★ À maîtriser

• API6 Unrestricted Access to Sensitive Business Flows permet l’automatisation massive d’une fonctionnalité métier pourtant correctement authentifiée.

📌 API7 Server Side Request Forgery se corrige en contrôlant les destinations autorisées et en bloquant notamment les destinations internes pour toute URL fournie par le client.

📌 API10 Unsafe Consumption of APIs se corrige en validant le format et les valeurs reçues d’une API externe avec des DTO et des contraintes telles que @Valid.

Compléments

📌 API8 Security Misconfiguration se corrige en n’exposant que les Actuator nécessaires, en protégeant les routes par rôle et en utilisant une configuration restrictive en production.

📌 API9 Improper Inventory Management se corrige en inventoriant les endpoints, en planifiant leur dépréciation et en supprimant les anciennes versions inutiles.

• OWASP publie le Top 10 des risques des applications web et le API Security Top 10 des principaux risques des API REST.

💡 Astuce mémo

Limiter, contrôler, valider, retirer

📖 14. Gestion de l’inventaire des API

🔑 Notions clés & Définitions

• API9 — Improper Inventory Management : désigne une vulnérabilité liée à une mauvaise gestion de l’inventaire des endpoints et des versions d’API.

📝 Points essentiels

• 🔄 La gestion du cycle de vie des API REST suit ces étapes:
  1. Inventorier les endpoints et les versions
  2. Définir et planifier une politique de dépréciation
  3. Supprimer les anciennes versions devenues inutiles

📌 Une API oubliée augmente la surface d’attaque de l’application.

💡 Astuce mémo

API oubliée → surface d’attaque augmentée

📖 15. Consommation sûre des API externes

🔑 Notions clés & Définitions

• API10 — Unsafe Consumption of APIs : désigne le fait de faire confiance sans vérification aux données provenant d’une API externe dont le format peut évoluer.

★ À maîtriser

📌 Les données provenant d’une API externe doivent être vérifiées sur leur format et leurs valeurs avant d’être utilisées par le back-end.

Compléments

• Dans Spring, un objet UserDTO reçu d’une API externe peut être contrôlé avec un validateur avant d’être renvoyé dans un Optional.

📌 Les annotations @Valid et les contraintes placées sur un DTO permettent de valider les données reçues d’une API externe ou d’une requête entrante.

💡 Astuce mémo

Recevoir → vérifier le format → valider les valeurs

📖 16. Validation automatique des données d’entrée

★ À maîtriser

📌 L’annotation @Valid demande à Spring d’exécuter les contraintes définies dans le DTO passé en entrée.

• Les contraintes de validation comprennent notamment @NotBlank, @Size, @Pattern, @Email, @Min, @Max, @NotNull, @NotEmpty, @Positive, @PositiveOrZero, @Negative, @NegativeOrZero, @Past, @PastOrPresent, @Future et @FutureOrPresent.

📌 Si une contrainte de validation n’est pas respectée, la méthode du contrôleur n’est pas exécutée et Spring renvoie une erreur 400 Bad Request.

Compléments

• L’utilisation de la validation automatique des DTO nécessite la dépendance spring-boot-starter-validation dans le fichier pom.xml.

📖 17. Conception des ressources REST

★ À maîtriser

• GET sert à récupérer des ressources et est idempotent et safe, POST sert à créer une nouvelle ressource, PUT sert à remplacer une ressource existante et est idempotent, PATCH sert à modifier partiellement une ressource, et DELETE sert à supprimer une ressource et est idempotent.

📌 Une URI REST doit utiliser des noms au pluriel pour les collections, des noms descriptifs et cohérents, éviter les verbes et réserver les paramètres de requête aux filtres.

Compléments

• Le filtrage peut être exprimé par GET /users?role=admin&status=active plutôt que par une URI d’action comme GET /getAllActiveAdminUsers.

💡 Astuce mémo

GET récupère ; POST crée ; PUT remplace ; PATCH modifie ; DELETE supprime

📖 18. Statuts HTTP et versioning

★ À maîtriser

• Les codes de statut HTTP courants sont:

  • 200 OK : requête réussie avec contenu
  • 201 Created : ressource créée
  • 204 No Content : requête réussie sans contenu
  • 400 Bad Request : requête non valide
  • 401 Unauthorized : authentification requise
  • 403 Forbidden : accès non autorisé
  • 404 Not Found : ressource introuvable
  • 500 Internal Server Error : erreur serveur

• Le versioning d’une API peut être placé dans l’URI, dans les paramètres de requête ou dans les headers.

Compléments

• Un exemple de versioning par header est Accept: application/vnd.company.v1+json.

📊 Tableaux de synthèse

Verbes REST et opérations

Principales vulnérabilités API