COURS DE DEVELOPPEMENT WEB:

JAVA EE
GENIE LOGICIEL
INTRODUCTION

Le développement d'applications web modernes exige des technologies robustes et

flexibles. Java EE (Enterprise Edition) est une plateforme standard pour créer des applications
d'entreprise, offrant des API pour la gestion des transactions, la sécurité et la persistance des
données. Toutefois, sa complexité et ses configurations parfois lourdes peuvent poser des défis.

Le Spring Framework, en revanche, propose une approche plus légère et flexible grâce à
des concepts comme l’Inversion de Contrôle (IoC) et l’Injection de Dépendances. Spring Boot,
une extension de Spring, simplifie le développement d'applications en fournissant des
configurations par défaut et en facilitant la création d'APIs RESTful.

Objectifs du Cours

Ce cours vise à :

 Enseigner le développement d'applications web avec Java EE et Spring.

 Intégrer des concepts pratiques comme Spring MVC, Spring Data JPA, et Spring Security.
 Former les étudiants aux meilleures pratiques de test et de déploiement.

À l'issue de ce cours, les étudiants disposeront d'une base solide en développement Java, leur
permettant de relever les défis du monde professionnel.
Activité 1: Introduction à Java EE et aux Frameworks Modernes (Spring)

Objectifs de l’activité :

 Découvrir l’évolution de Java EE et comprendre son architecture.

 Comparer Java EE classique à Spring, en soulignant les avantages de ce dernier.

1. Vue d'ensemble de Java EE

1.1. Qu'est-ce que Java EE ?

Java EE (Enterprise Edition) est une extension de Java SE (Standard Edition) et une
plateforme robuste pour le développement d’applications d'entreprise. Elle propose un ensemble
d’API (Application Programming Interfaces) et de spécifications standardisées, facilitant la
création d’applications évolutives, sécurisées et robustes, adaptées aux environnements complexes
d'entreprise.

1.2. Les principaux composants de Java EE

 Servlets : Composants Java utilisés pour gérer les requêtes HTTP dans les applications
web.
 Java Server Pages (JSP) : Outil permettant de générer des pages HTML dynamiques,
souvent utilisé avec les Servlets.
 Java Persistence API (JPA) : API standard pour la gestion des bases de données
relationnelles via le mapping objet-relationnel.
 Enterprise JavaBeans (EJB) : Composants pour la gestion des transactions et des
fonctionnalités de sécurité dans les systèmes distribués.
 Java Messaging Service (JMS) : API pour la communication asynchrone entre
applications.
 Java EE suit une architecture en trois couches (ou "tiers") :

1. Tier 1 - Côté client : Interface utilisateur qui interagit avec l'application (navigateur,
mobile).
2. Tier 2 - Serveur d'application : Contient la logique métier, comme la gestion des
transactions et les services web.
3. Tier 3 - Système de base de données : Gère la persistance des données.

2. Les frameworks modernes et Spring

2.1. Qu'est-ce qu'un framework ?

Un framework est une structure logicielle qui fournit un ensemble d’outils, de

bibliothèques et de bonnes pratiques pour faciliter le développement d’applications. Ils offrent une
solution pré-configurée à des problèmes courants, comme la gestion des dépendances, les services
REST, et la sécurité.

2.2. Introduction à Spring

Spring est un framework open-source qui simplifie le développement d'applications Java,

tout en conservant les aspects robustes de Java EE. Son principal atout réside dans sa flexibilité et
sa modularité, qui permettent aux développeurs de choisir les modules dont ils ont besoin sans
adopter l’intégralité de la plateforme.

Les concepts clés de Spring :

 Inversion of Control (IoC) : Plutôt que le code contrôle ses dépendances, Spring gère la
création et l’injection des objets nécessaires (injection de dépendances).
 AOP (Aspect-Oriented Programming) : Gestion transversale des aspects comme la
sécurité ou la gestion des transactions sans affecter directement la logique métier.
 Spring Boot : Un sous-projet de Spring, qui permet de créer des applications rapidement
avec des configurations minimales.
3. Les avantages de Spring par rapport à Java EE classique

3.1. Simplicité et Flexibilité

 Configuration simplifiée : Avec Java EE classique, les configurations XML peuvent

devenir lourdes et difficiles à gérer. Spring, surtout avec Spring Boot, propose des
configurations minimales basées sur des annotations, ce qui rend le développement
beaucoup plus fluide.
 Modularité : Java EE est une plateforme monolithique où vous devez souvent charger tout
un ensemble de spécifications même si seules quelques-unes sont nécessaires. Spring est
modulaire, vous permettant de n'utiliser que les modules nécessaires, ce qui allège
l’application.

3.2. Testabilité

 Test unitaire et d’intégration : Grâce à l'injection de dépendances, Spring facilite

l’écriture de tests unitaires et d'intégration. Il est possible de tester les composants Spring
sans démarrer tout l’environnement (mocking des dépendances).

3.3. Spring Boot : une révolution pour le développement

 Démarrage rapide : Spring Boot inclut un serveur web embarqué (Tomcat par défaut) qui
permet de lancer rapidement des applications, sans configuration complexe.
 Auto-configuration : Spring Boot auto-configure la plupart des composants en fonction
des dépendances ajoutées, réduisant ainsi la charge sur les développeurs.
 Microservices : Avec l’essor des architectures microservices, Spring Boot est
particulièrement adapté pour développer des services légers et indépendants.

4. Conclusion

Java EE a été la pierre angulaire du développement d’applications d’entreprise en Java

pendant de nombreuses années, avec une architecture solide et bien définie. Cependant, les besoins
des développeurs ont évolué, et des frameworks comme Spring sont devenus une alternative plus
flexible et moderne, simplifiant les configurations, offrant une grande modularité, et permettant
une meilleure intégration avec les technologies actuelles comme les microservices.

Résumé des points clés :

 Java EE offre une architecture solide pour les applications d’entreprise avec un ensemble
de spécifications standardisées.
 Spring apporte flexibilité, simplicité, et modularité, tout en offrant des outils comme
Spring Boot qui accélèrent le développement.
 La testabilité et la modularité de Spring sont de véritables atouts pour les projets
modernes.
Activité 2: Servlets, JSP et JavaBeans

Objectifs de l’activité :

 Comprendre le fonctionnement des Servlets et leur rôle dans le traitement des requêtes et
des réponses HTTP.
 Découvrir JavaServer Pages (JSP) pour la génération dynamique de contenu web.
 Introduire les JavaBeans et l’utilisation de l'Expression Language (EL) pour simplifier
l’accès aux données dans les pages JSP.

1. Servlets : traitement des requêtes et réponses HTTP

1.1. Qu'est-ce qu'une Servlet ?

Une Servlet est une classe Java qui étend les capacités des serveurs capables de répondre
aux requêtes HTTP. Elles sont principalement utilisées pour traiter les requêtes des clients et
générer des réponses. Les Servlets sont une partie centrale de la couche de présentation dans les
applications Java EE.

1.2. Cycle de vie d’une Servlet

Le cycle de vie d'une Servlet comprend trois étapes :

1. Initialisation : La méthode init() est appelée une seule fois lorsque la Servlet est chargée
en mémoire par le conteneur (ex: Tomcat, Jetty).
2. Traitement des requêtes : La méthode service() gère les requêtes entrantes (souvent
redéfinie via doGet() ou doPost() pour les requêtes spécifiques).
3. Destruction : La méthode destroy() est appelée pour libérer les ressources lorsque la
Servlet est arrêtée ou retirée du service.
1.3. Exécution d'une Servlet

Voici un exemple d'implémentation d'une Servlet simple qui gère une requête HTTP GET
:

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.IOException;
import java.io.PrintWriter;

public class HelloServlet extends HttpServlet {

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse
response)throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html><body>");
out.println("<h1>Hello, bienvenue dans les Servlets !</h1>");
out.println("</body></html>");
}
}

Dans cet exemple, la Servlet reçoit une requête HTTP GET et renvoie une réponse HTML simple.

2. JSP : génération de pages dynamiques

2.1. Qu'est-ce que JSP ?

Java Server Pages (JSP) est une technologie qui permet de générer dynamiquement des
pages web en combinant du code Java et du HTML. Elle permet d'inclure de la logique métier dans
les pages web tout en facilitant l’affichage du contenu dynamique généré par une application Java.

2.2. Utilisation de JSP

Dans une page JSP, vous pouvez insérer du code Java au sein de balises spéciales <% %>.
JSP compile ces pages en Servlets lors de leur première exécution. Exemple de page JSP :

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<html>
<head>
<title>Page JSP Exemple</title>
</head>
<body>
<h1>Bienvenue dans le monde de JSP</h1>
<%
 String nom = request.getParameter("nom");
out.println("Bonjour, " + nom + " !");
%>
</body>
</html>

Ici, la variable nom est récupérée depuis une requête HTTP, puis affichée dans la page web.

2.3. Avantages de JSP par rapport aux Servlets

Les Servlets sont parfaits pour gérer la logique métier, mais pour l'affichage HTML, cela
peut devenir verbeux et difficile à maintenir. JSP simplifie ce processus en permettant d'écrire du
HTML et d'insérer des fragments de code Java seulement là où c'est nécessaire.

3. Introduction à JavaBeans et Expression Language (EL)

3.1. Qu'est-ce qu'un JavaBean ?

Un JavaBean est une classe Java ordinaire, mais elle suit une convention stricte :

 Elle possède un constructeur par défaut (sans arguments).

 Les propriétés sont privées et accessibles via des méthodes getter et setter.
 Elle est sérialisable, ce qui signifie que l'objet peut être converti en un flux de données.

Les JavaBeans sont souvent utilisés pour encapsuler des données et les échanger entre
différentes couches d’une application (ex: de la couche métier vers la couche présentation).

Exemple d’un JavaBean :

public class Utilisateur {

private String nom;
private String email;

public Utilisateur() {}

public String getNom() {

return nom;
}
 public void setNom(String nom) {
this.nom = nom;
}

public String getEmail() {

return email;
}

public void setEmail(String email) {

this.email = email;
}
}

3.2. Utilisation des JavaBeans dans JSP

Dans une page JSP, vous pouvez créer et utiliser des JavaBeans pour accéder et afficher
des données.

Exemple :

<jsp:useBean id="user" class="com.example.Utilisateur" scope="session" />

<jsp:setProperty name="user" property="nom" value="Jean" />
<jsp:setProperty name="user" property="email" value="jean@example.com" />

<h2>Nom: <jsp:getProperty name="user" property="nom" /></h2>

<h2>Email: <jsp:getProperty name="user" property="email" /></h2>

Ici, un objet Utilisateur est créé et ses propriétés sont définies à partir de la requête HTTP. Ces
propriétés peuvent ensuite être affichées dynamiquement dans la page.

3.3. Expression Language (EL)

L’Expression Language (EL) simplifie l’accès aux objets comme les JavaBeans dans les
pages JSP. Plutôt que d’utiliser les balises JSP comme jsp:getProperty, EL permet d’accéder
aux propriétés directement à l’aide d’une syntaxe plus concise :

<h2>Nom: ${user.nom}</h2>
<h2>Email: ${user.email}</h2>

Grâce à EL, le code JSP devient plus lisible et plus facile à maintenir.
4. Conclusion

Les Servlets et JSP sont des composants essentiels pour la création d'applications web en
Java EE, offrant une combinaison puissante pour la gestion des requêtes HTTP et la génération de
pages web dynamiques. L’introduction des JavaBeans permet une gestion plus efficace des
données, tandis que l'Expression Language (EL) facilite l'accès aux données dans les pages JSP.

Résumé des points clés :

 Les Servlets permettent de traiter les requêtes et réponses HTTP.

 JSP génère des pages dynamiques en combinant du code Java et HTML.
 Les JavaBeans encapsulent les données, et l'Expression Language (EL) simplifie leur
utilisation dans les pages JSP.
Activité 3: Introduction à Spring Framework

Objectifs de l’activité :

 Comprendre les concepts fondamentaux du Spring Framework : Inversion of Control

(IoC) et injection de dépendances.
 Apprendre à configurer une application Spring à l’aide de XML et de la configuration Java.
 Créer un premier projet Spring avec un bean et une injection de dépendances.

1. Concepts clés de Spring : Inversion of Control (IoC) et injection de dépendances

1.1. Qu'est-ce que l'Inversion of Control (IoC) ?

L'Inversion of Control (IoC) est un concept central du framework Spring.

Traditionnellement, dans une application Java, un objet est responsable de la création et de la
gestion de ses dépendances (autres objets dont il a besoin pour fonctionner). Avec l'IoC, c'est le
framework qui prend en charge la création et la gestion des dépendances des objets, inversant ainsi
le contrôle par rapport à la méthode traditionnelle.

L'IoC est implémenté dans Spring via le conteneur IoC, qui gère les objets, leur cycle de
vie et leurs relations de dépendances.

1.2. Injection de dépendances

L'injection de dépendances (Dependency Injection, DI) est une implémentation de l’IoC dans
Spring. Elle consiste à fournir les dépendances (objets) d'une classe de l'extérieur plutôt que de
laisser la classe les créer elle-même. Il existe trois types d'injection de dépendances dans Spring :

 Injection par constructeur : Les dépendances sont injectées dans un objet via son
constructeur.
 Injection par setter : Les dépendances sont injectées via des méthodes setter.
 Injection via les champs : Moins courante, cette méthode utilise directement les
annotations sur les propriétés de la classe.
Exemple avec injection par constructeur :

public class Service {

private Repository repository;

public Service(Repository repository) {

this.repository = repository;
}

public void doSomething() {

repository.saveData();
}
}

Dans cet exemple, la classe Service dépend d'une instance de Repository. Plutôt que de
la créer elle-même, Repository lui est injecté via le constructeur.

2. Configuration avec XML vs Java-based configuration

2.1. Configuration basée sur XML

Historiquement, la configuration des dépendances dans Spring se faisait principalement

avec des fichiers XML. Ce type de configuration consiste à définir les beans et leurs dépendances
dans un fichier XML que le conteneur Spring utilise pour les injecter.

Exemple d’un fichier de configuration XML (applicationContext.xml) :

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="repository" class="com.example.Repository" />

<bean id="service" class="com.example.Service">

<constructor-arg ref="repository" />
</bean>
</beans>

Dans cet exemple, un bean Repository est défini, ainsi qu'un bean Service qui reçoit
Repository via son constructeur.
2.2. Configuration basée sur Java (Java-based configuration)

Avec les versions récentes de Spring, la configuration Java (ou Java-based configuration)
est devenue plus populaire, car elle est plus intuitive et permet de tirer parti des annotations et des
classes Java sans nécessiter de fichiers XML.

Exemple d'une configuration Java à l’aide de l’annotation @Configuration :

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

@Bean
public Repository repository() {
return new Repository();
}

@Bean
public Service service() {
return new Service(repository());
}
}

Ici, la classe AppConfig contient des méthodes annotées avec @Bean qui retournent des
instances des objets à injecter. Ces méthodes définissent les beans et leur cycle de vie.

2.3. Avantages de la configuration Java

 Lisibilité : La configuration est plus lisible et intuitive, car elle utilise directement le
langage Java.
 Type-safe : Avec la configuration Java, vous bénéficiez des avantages de la vérification
des types à la compilation.
 Réduction de la dépendance XML : Moins de fichiers XML à gérer et plus de contrôle
dans le code.
3. Premier projet Spring : création d’un bean et injection de dépendances

Pour mettre en pratique ces concepts, nous allons créer un petit projet Spring qui définit et
injecte un bean dans une classe.

3.1. Structure du projet

Voici les étapes pour créer une petite application Spring :

1. Créer les classes de base :

o Repository : une classe simple qui simule la gestion des données.
o Service : une classe qui dépend de Repository pour effectuer des opérations
métier.
2. Configurer Spring pour gérer les beans : Utiliser soit un fichier XML, soit une
configuration Java pour déclarer les beans.

3.2. Exemple de classes pour l’application

Voici une classe Repository simple :

public class Repository {

public void saveData() {
System.out.println("Données enregistrées !");
}
}

Et la classe Service qui dépend de Repository :

public class Service {

private Repository repository;

public Service(Repository repository) {

this.repository = repository;
}

public void process() {

System.out.println("Service en cours...");
repository.saveData();
}
}
3.3. Configuration du conteneur Spring

Nous allons utiliser une configuration Java pour injecter Repository dans Service.

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {

public static void main(String[] args) {
ApplicationContext context = new
AnnotationConfigApplicationContext(AppConfig.class);

Service service = context.getBean(Service.class);

service.process();
}
}

3.4. Fichier de configuration Java (AppConfig.java)

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

@Bean
public Repository repository() {
return new Repository();
}

@Bean
public Service service() {
return new Service(repository());
}
}

3.5. Résultat attendu

En exécutant l’application, vous devriez obtenir la sortie suivante :

Service en cours...
Données enregistrées !

Spring a géré l'injection de dépendances et a exécuté les méthodes de manière fluide.

4. Conclusion

Le Spring Framework introduit des concepts puissants comme l'Inversion of Control (IoC) et
l'injection de dépendances, qui simplifient la gestion des objets et de leurs relations dans une
application. La configuration via XML ou Java offre des approches flexibles pour déclarer les
beans, et grâce à l'injection de dépendances, les applications deviennent plus modulaires, testables
et maintenables.

Résumé des points clés :

 IoC et DI sont des concepts centraux dans Spring, offrant un contrôle flexible sur la création
et la gestion des dépendances.
 Spring permet deux types principaux de configuration : XML (plus ancien) et Java-based
configuration (plus moderne et intuitive).
 La création d’un projet Spring simple avec l’injection de dépendances permet de bien
comprendre ces concepts.
Activité 4: Spring MVC pour le Développement Web

Objectifs de l’activité :

 Découvrir le framework Spring MVC pour le développement d'applications web.

 Apprendre à créer et configurer un contrôleur Spring.
 Comprendre la gestion des requêtes HTTP (GET et POST) dans Spring MVC.
 Apprendre à utiliser des vues et des modèles avec des moteurs de template comme JSP et
Thymeleaf.

1. Introduction à Spring MVC

1.1. Qu'est-ce que Spring MVC ?

Spring MVC (Model-View-Controller) est un module du Spring Framework qui facilite le

développement d'applications web en utilisant une architecture basée sur le modèle MVC. Ce
modèle permet de séparer la logique métier (modèle), l'affichage (vue), et le contrôle des
interactions utilisateur (contrôleur), améliorant ainsi la maintenabilité et l'organisation du code.

1.2. Architecture MVC

 Modèle (Model) : Représente les données de l'application. Il contient la logique métier et

récupère les données nécessaires à partir de la base de données.
 Vue (View) : Représente la présentation des données. Dans Spring MVC, cela peut être
géré par des moteurs de templates comme JSP ou Thymeleaf.
 Contrôleur (Controller) : Gère les interactions avec l'utilisateur, reçoit les requêtes HTTP,
traite la logique métier via le modèle, et renvoie une vue appropriée à l'utilisateur.

L'architecture Spring MVC repose principalement sur l'utilisation de contrôleurs pour gérer
les requêtes HTTP et retourner des vues correspondantes.
2. Création d’un contrôleur Spring

2.1. Définition d’un contrôleur

Dans Spring MVC, un contrôleur est une classe Java annotée avec @Controller qui gère
les requêtes HTTP. Chaque méthode du contrôleur peut être associée à une requête spécifique
(GET, POST, etc.) en utilisant des annotations comme @GetMapping ou @PostMapping.

2.2. Exemple de contrôleur Spring

Voici un exemple de contrôleur Spring basique qui gère une requête HTTP GET et renvoie
une vue :

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
@RequestMapping("/home")
public class HomeController {

@GetMapping
public ModelAndView home() {
ModelAndView mav = new ModelAndView("home");
mav.addObject("message", "Bienvenue dans Spring MVC !");
return mav;
}
}

 @Controller : Indique que cette classe est un contrôleur Spring.

 @RequestMapping("/home") : Mappe la classe à l'URL "/home".
 @GetMapping : Gère les requêtes HTTP GET pour "/home".
 ModelAndView : Retourne une vue nommée home et y associe un modèle contenant un
message à afficher.
3. Gestion des requêtes HTTP : GET, POST

3.1. Gestion des requêtes GET

Les requêtes GET sont principalement utilisées pour récupérer des données. Spring MVC
utilise l'annotation @GetMapping pour définir des méthodes qui traitent ces requêtes.

Exemple d'une méthode qui gère une requête GET pour afficher un formulaire de contact :

@GetMapping("/contact")
public String showContactForm(Model model) {
model.addAttribute("contact", new Contact());
return "contact-form";
}

Ici, le contrôleur renvoie la vue contact-form et ajoute un objet vide Contact au modèle.

3.2. Gestion des requêtes POST

Les requêtes POST sont utilisées pour envoyer des données, comme des informations de
formulaire. Spring MVC utilise @PostMapping pour gérer les requêtes POST.

Exemple de méthode qui gère une soumission de formulaire de contact :

@PostMapping("/contact")
public String submitContactForm(@ModelAttribute("contact") Contact contact, Model
model) {
// Logique de traitement du contact (sauvegarde, validation, etc.)
model.addAttribute("message", "Formulaire soumis avec succès !");
return "contact-result";
}

 @ModelAttribute : Lie les données envoyées via le formulaire à l'objet Contact.

 La méthode traite les données et renvoie une vue pour afficher le résultat.
3.3. Modèle et Vue (ModelAndView)

Spring MVC permet de combiner des objets de modèle avec des vues pour rendre des
réponses dynamiques. L’objet ModelAndView contient à la fois le modèle (les données) et la vue
(le modèle d'affichage).

4. Vue et gestion des modèles (JSP, Thymeleaf)

4.1. Utilisation de JSP comme moteur de vue

JSP (Java Server Pages) est un moteur de template couramment utilisé avec Spring MVC.
Il permet de créer des pages web dynamiques en combinant HTML et des balises JSP pour intégrer
des données Java dans la vue.

Exemple d'une page JSP (home.jsp) :

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<html>
<head>
<title>Page d'accueil</title>
</head>
<body>
<h1>${message}</h1>
</body>
</html>

Dans cet exemple, la variable message ajoutée dans le modèle par le contrôleur est affichée dans
la vue.

4.2. Utilisation de Thymeleaf comme moteur de vue

Thymeleaf est un moteur de template moderne et plus flexible que JSP. Il s'intègre
facilement à Spring MVC et permet de manipuler des modèles HTML de manière plus lisible.

Exemple d'une vue Thymeleaf (home.html) :

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>Page d'accueil</title>
</head>
<body>
<h1 th:text="${message}"></h1>
</body>
</html>

Ici, l'attribut th:text remplace le contenu de l'élément avec la variable message provenant du
modèle.

4.3. Configuration de Thymeleaf dans Spring

Pour utiliser Thymeleaf dans Spring, il est nécessaire de l’ajouter en tant que dépendance
dans le projet et de configurer un résolveur de vues.

Dépendance Maven pour Thymeleaf :

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

5. Exemple complet : formulaire de contact avec Spring MVC

Voici un exemple simple d’application Spring MVC qui gère un formulaire de contact.
L’utilisateur peut soumettre ses informations, et le contrôleur les traite.

5.1. Classe Contact

public class Contact {

private String nom;
private String email;

// Getters et setters
}
5.2. Contrôleur de formulaire de contact

@Controller
@RequestMapping("/contact")
public class ContactController {

@GetMapping
public String showContactForm(Model model) {
model.addAttribute("contact", new Contact());
return "contact-form";
}

@PostMapping
public String submitContactForm(@ModelAttribute("contact") Contact contact, Model
model) {
// Traitement du formulaire (sauvegarde, validation, etc.)
model.addAttribute("message", "Merci " + contact.getNom() + ", votre formulaire
a été soumis.");
return "contact-result";
}
}

5.3. Formulaire JSP pour le contact (contact-form.jsp)

<form action="#" th:action="@{/contact}" th:object="${contact}" method="post">

<label for="nom">Nom :</label>
<input type="text" id="nom" th:field="*{nom}" />

<label for="email">Email :</label>

<input type="email" id="email" th:field="*{email}" />

<button type="submit">Envoyer</button>
</form>

5.4. Vue de confirmation (contact-result.jsp)

<h2>${message}</h2>

6. Conclusion

Le framework Spring MVC fournit une architecture robuste et flexible pour le développement
d’applications web. En gérant les requêtes HTTP et en intégrant des moteurs de template comme
JSP ou Thymeleaf, Spring permet de créer des applications web dynamiques et maintenables.
L'utilisation de contrôleurs et de la gestion des modèles et vues simplifie considérablement la
structuration des applications web complexes.

Résumé des points clés :

 Spring MVC implémente l'architecture MVC pour séparer la logique métier, l'affichage,
et le contrôle des interactions utilisateur.
 Les contrôleurs Spring gèrent les requêtes HTTP et permettent de lier des modèles à des
vues.
 JSP et Thymeleaf sont des moteurs de template couramment utilisés pour la création de
vues dynamiques.
Activité 5: Bases de données avec Spring Data JPA

Objectifs de l’activité :

 Découvrir les concepts de JPA (Java Persistence API) dans le contexte de Spring.
 Apprendre à créer des entités et à les mapper aux tables d'une base de données.
 Comprendre comment utiliser Spring Data JPA pour interagir avec une base de données
via les repositories et les query methods.
 Configurer une connexion à une base de données MySQL ou PostgreSQL.

1. Concepts de JPA dans Spring

1.1. Qu'est-ce que JPA ?

JPA (Java Persistence API) est une spécification Java pour la gestion des données
relationnelles dans les applications. Elle définit une manière standard d’interagir avec une base de
données à travers des objets Java appelés entités. Le but de JPA est de permettre une abstraction
du langage SQL sous-jacent, en manipulant les données directement sous forme d'objets.

Spring utilise Hibernate, l'une des implémentations les plus populaires de JPA, pour
fournir cette couche d'abstraction.

1.2. JPA et Spring Data JPA

Spring Data JPA est un module de Spring qui simplifie l'utilisation de JPA. Il fournit une
infrastructure complète pour gérer les interactions avec les bases de données via des interfaces
appelées repositories, et offre un support pour des requêtes automatiques via des méthodes de
requête (query methods).
2. Création d'entités et mapping avec des tables de bases de données

2.1. Qu'est-ce qu'une entité ?

Une entité en JPA est une classe Java qui représente une table dans une base de données
relationnelle. Chaque instance de cette classe correspond à une ligne dans la table, et chaque attribut
de la classe est mappé à une colonne de la table.

Les entités sont généralement annotées avec @Entity, et chaque attribut est annoté avec
@Column. L'annotation @Id est utilisée pour désigner la clé primaire.

2.2. Exemple d’entité simple

Voici un exemple d’une classe Product qui représente une table products dans la base de
données :

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Product {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private String name;

private Double price;

// Getters et setters
}

 @Entity : Indique que la classe Product est une entité JPA.

 @Id : Indique que l’attribut id est la clé primaire de l'entité.
 @GeneratedValue : Spécifie la génération automatique des valeurs pour la clé primaire.

Cette classe sera mappée à une table product dans la base de données, avec des colonnes pour
id, name, et price.
3. Spring Data JPA : Repositories, Query Methods

3.1. Introduction aux Repositories

Spring Data JPA simplifie la manipulation des entités en introduisant le concept de

repositories, des interfaces qui fournissent des méthodes prêtes à l'emploi pour les opérations de
base comme l'insertion, la suppression, la mise à jour, et la récupération des données.

Spring Data JPA propose un repository de base appelé CrudRepository, et un autre plus
riche appelé JpaRepository.

Exemple d’un repository pour l’entité Product :

import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {

}

Dans cet exemple, ProductRepository étend JpaRepository et hérite de méthodes

comme save(), findById(), delete(), etc.

3.2. Query Methods (Méthodes de requête)

Les query methods permettent d'exécuter des requêtes SQL complexes simplement en
définissant des méthodes dans les interfaces repository. Spring génère automatiquement les
requêtes en fonction du nom des méthodes.

Exemple de query method :

List<Product> findByName(String name);

Ici, Spring générera automatiquement une requête qui recherche les produits en fonction de
leur nom.

Exemple d'utilisation :

List<Product> products = productRepository.findByName("Ordinateur");

3.3. Requêtes personnalisées avec @Query

Pour des requêtes plus complexes qui ne peuvent pas être générées automatiquement, on
peut utiliser l'annotation @Query pour écrire des requêtes JPQL (Java Persistence Query Language).

Exemple de requête JPQL :

@Query("SELECT p FROM Product p WHERE p.price > :price")

List<Product> findProductsExpensiveThan(@Param("price") Double price);

Cette méthode récupérera tous les produits dont le prix est supérieur à une certaine valeur.

4. Connexion à une base de données MySQL/PostgreSQL

4.1. Configuration de la base de données

Spring Boot facilite la connexion à des bases de données comme MySQL ou PostgreSQL
via le fichier application.properties ou application.yml. Il suffit de spécifier les détails de
la connexion et Spring s'occupe du reste.

4.2. Exemple de configuration pour MySQL

Pour se connecter à une base de données MySQL, ajoutez les informations suivantes dans
application.properties :

spring.datasource.url=jdbc:mysql://localhost:3306/nom_de_la_base
spring.datasource.username=root
spring.datasource.password=mot_de_passe
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

 spring.datasource.url : L'URL de connexion à la base de données MySQL.

 spring.datasource.username : Le nom d'utilisateur pour se connecter à la base de données.
 spring.datasource.password : Le mot de passe pour l'utilisateur de la base de données.
  spring.jpa.hibernate.ddl-auto : Détermine si Hibernate doit créer, mettre à jour ou valider
le schéma de la base de données. Ici, update permet de synchroniser automatiquement la
structure des tables.
 spring.jpa.show-sql : Permet d'afficher les requêtes SQL générées dans la console.

4.3. Exemple de configuration pour PostgreSQL

Pour une base de données PostgreSQL, utilisez cette configuration :

spring.datasource.url=jdbc:postgresql://localhost:5432/nom_de_la_base
spring.datasource.username=postgres
spring.datasource.password=mot_de_passe
spring.datasource.driver-class-name=org.postgresql.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

4.4. Ajouter les dépendances JDBC

N'oubliez pas d'ajouter la dépendance appropriée dans le fichier pom.xml de votre projet
Maven pour connecter Spring à la base de données choisie.

Exemple pour MySQL :

<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>

Exemple pour PostgreSQL :

<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<scope>runtime</scope>
</dependency>
5. Exemple complet : Gestion de produits avec Spring Data JPA

Dans cet exemple, nous allons créer une simple application qui gère une liste de produits et
les stocke dans une base de données MySQL ou PostgreSQL.

5.1. Entité Product

@Entity
public class Product {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

private String name;

private Double price;

// Getters et setters
}

5.2. Repository pour l’entité Product

import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {

List<Product> findByName(String name);
}

5.3. Contrôleur pour gérer les produits

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/products")
public class ProductController {

@Autowired
private ProductRepository productRepository;

@GetMapping
public List<Product> getAllProducts() {
return productRepository.findAll();
}
 @PostMapping
public Product createProduct(@RequestBody Product product) {
return productRepository.save(product);
}

@GetMapping("/{id}")
public Product getProductById(@PathVariable Long id) {
return productRepository.findById(id).orElseThrow(() -> new
RuntimeException("Produit non trouvé"));
}
}

5.4. Configuration de la base de données dans application.properties

Pour MySQL :

spring.datasource.url=jdbc:mysql://localhost:3306/products_db
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

6. Conclusion

L’intégration de Spring Data JPA avec JPA permet de simplifier la gestion des données
persistantes dans une application Spring. En utilisant les entités pour mapper les objets Java aux
tables de la base de données, et en manipulant les données via les repositories et les query methods,
Spring offre une solution robuste et flexible pour interagir avec les bases de données relationnelles
comme MySQL ou PostgreSQL.
Activité 6: Introduction à Spring Boot

Objectifs de l’activité :

 Comprendre les différences entre Spring et Spring Boot.

 Explorer la configuration simplifiée offerte par Spring Boot.
 Connaître la structure d’un projet Spring Boot.
 Développer une application simple avec Spring Boot.

1. Différences entre Spring et Spring Boot

Spring est un framework Java complet qui offre un large éventail de fonctionnalités pour le
développement d’applications Java, notamment la gestion de la configuration, l'injection de
dépendances, et le développement d'applications web. Cependant, il nécessite souvent une
configuration manuelle et peut être complexe à mettre en place.

Spring Boot, en revanche, est un projet dérivé de Spring qui vise à simplifier le processus de
développement en fournissant des conventions par défaut et en minimisant la configuration
nécessaire. Voici quelques différences clés :

 Configuration : Spring nécessite souvent beaucoup de configuration XML ou Java, tandis

que Spring Boot adopte la convention par rapport à la configuration et utilise des fichiers
application.properties ou application.yml pour les réglages.
 Démarrage rapide : Spring Boot inclut des starters, qui sont des ensembles de dépendances
préconfigurées, permettant de démarrer rapidement le développement d'une application.
 Serveur intégré : Spring Boot permet de créer des applications autonomes avec un serveur
intégré (comme Tomcat ou Jetty), ce qui évite la nécessité de déployer sur un serveur
externe.
 Actuateurs : Spring Boot fournit des fonctionnalités de monitoring et de gestion via les
actuateurs, qui permettent d'exposer des informations sur l'état de l'application.
2. Configuration simplifiée avec Spring Boot

2.1. Démarrer avec Spring Boot

Pour commencer un projet Spring Boot, il est courant d'utiliser Spring Initializr, un outil en
ligne qui génère une structure de projet de base. Il permet de sélectionner les dépendances
souhaitées et de télécharger un projet prêt à être utilisé.

1. Accéder à Spring Initializr : start.spring.io

2. Choisir les options : Sélectionner les dépendances (ex. Spring Web, Spring Data JPA, etc.), le
langage (Java), la version de Spring Boot, et les informations sur le projet (nom, groupe, artefact).
3. Générer le projet : Télécharger le projet généré et l'ouvrir dans votre IDE préféré.

2.2. Fichier application.properties

Le fichier application.properties est utilisé pour configurer divers aspects de

l'application, comme la connexion à la base de données ou le port du serveur.

Exemple de configuration pour une base de données MySQL :

spring.datasource.url=jdbc:mysql://localhost:3306/nom_de_la_base
spring.datasource.username=root
spring.datasource.password=mot_de_passe
spring.jpa.hibernate.ddl-auto=update

3. Structure d’un projet Spring Boot

Un projet Spring Boot typique a une structure de répertoire standard :

- src
- main
- java
- com
- exemple
- monapplication
- MonApplication.java
- controller
- model
- repository
- resources
- application.properties
 - static
- templates
- test
- java
- com
- exemple
- monapplication

 src/main/java : Contient le code source Java.

 src/main/resources : Contient les fichiers de configuration, les templates (ex. Thymeleaf)
et les ressources statiques (ex. CSS, JavaScript).
 src/test/java : Contient les tests unitaires et d'intégration.

Le fichier principal de l'application (généralement MonApplication.java) est annoté avec

@SpringBootApplication, qui englobe les annotations @Configuration,

@EnableAutoConfiguration, et @ComponentScan.

4. Développement d’une application Spring Boot

4.1. Création d'une application simple

Pour illustrer la création d'une application Spring Boot, nous allons développer une simple
API REST pour gérer des produits.

4.1.1. Étape 1 : Créer l'entité Product

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
private Double price;

// Getters et setters
}
4.1.2. Étape 2 : Créer le repository

import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {

}

4.1.3. Étape 3 : Créer le contrôleur

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/products")
public class ProductController {

@Autowired
private ProductRepository productRepository;

@GetMapping
public List<Product> getAllProducts() {
return productRepository.findAll();
}

@PostMapping
public Product createProduct(@RequestBody Product product) {
return productRepository.save(product);
}

@GetMapping("/{id}")
public Product getProductById(@PathVariable Long id) {
return productRepository.findById(id).orElseThrow(() -> new
RuntimeException("Produit non trouvé"));
}
}

4.1.4. Étape 4 : Configuration de la base de données dans application.properties

Pour une base de données MySQL :

spring.datasource.url=jdbc:mysql://localhost:3306/products_db
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
4.1.5. Étape 5: Lancer l'application

Pour lancer l'application, exécutez la méthode main dans le fichier MonApplication.java :

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MonApplication {
public static void main(String[] args) {
SpringApplication.run(MonApplication.class, args);
}
}

Une fois l'application lancée, vous pouvez accéder à l'API REST à l'adresse
http://localhost:8080/products.

5. Conclusion

Spring Boot simplifie le processus de développement d’applications en fournissant une

configuration automatique, une structure de projet standard et une gestion simplifiée des
dépendances. Grâce à ses fonctionnalités, les développeurs peuvent se concentrer sur la logique
métier de leur application sans se soucier des détails de la configuration.
Activité 7: Création d’API RESTful avec Spring Boot

Objectifs de l’activité :

 Comprendre le concept d'API RESTful et comment Spring Boot facilite leur création.
 Explorer l'utilisation de Spring MVC pour développer des services REST.
 Apprendre à gérer les formats de réponse, notamment JSON.
 Mettre en œuvre la validation des données d’entrée avec Bean Validation.

1. Introduction aux API RESTful avec Spring

Les API RESTful (Representational State Transfer) sont un ensemble de conventions pour
la création de services web qui permettent aux applications de communiquer entre elles via le
protocole HTTP. Les API RESTful utilisent des méthodes HTTP (GET, POST, PUT, DELETE)
pour effectuer des opérations sur des ressources identifiées par des URI.

Principes fondamentaux des API RESTful :

 Stateless : Chaque requête du client au serveur doit contenir toutes les informations nécessaires
pour traiter la requête.
 Identifiable par URI : Chaque ressource doit être accessible via une URI unique.
 Utilisation des méthodes HTTP : Chaque méthode HTTP correspond à une opération CRUD
(Create, Read, Update, Delete).

2. Spring Boot et Spring MVC pour les services REST

2.1. Créer un service REST avec Spring Boot

Pour créer un service REST avec Spring Boot, on utilise les annotations de Spring MVC.
Voici les étapes :
Étape 1 : Créer une entité

Prenons l’exemple de l’entité Product que nous avons déjà vue dans les activités précédentes.

Étape 2 : Créer un repository

Le repository pour l’entité Product :

import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {

}

Étape 3 : Créer un contrôleur REST

Voici un exemple de contrôleur REST pour gérer les produits :

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/api/products")
public class ProductController {

@Autowired
private ProductRepository productRepository;

@GetMapping
public List<Product> getAllProducts() {
return productRepository.findAll();
}

@GetMapping("/{id}")
public Product getProductById(@PathVariable Long id) {
return productRepository.findById(id).orElseThrow(() -> new
RuntimeException("Produit non trouvé"));
}

@PostMapping
public Product createProduct(@RequestBody Product product) {
return productRepository.save(product);
}

@PutMapping("/{id}")
public Product updateProduct(@PathVariable Long id, @RequestBody Product
productDetails) {
 Product product = productRepository.findById(id).orElseThrow(() -> new
RuntimeException("Produit non trouvé"));
product.setName(productDetails.getName());
product.setPrice(productDetails.getPrice());
return productRepository.save(product);
}

@DeleteMapping("/{id}")
public void deleteProduct(@PathVariable Long id) {
productRepository.deleteById(id);
}
}

Dans cet exemple, nous avons utilisé les annotations @GetMapping, @PostMapping,
@PutMapping, et @DeleteMapping pour définir les opérations REST sur l'entité Product.

3. Gestion des formats de réponse (JSON)

Spring Boot supporte nativement le format JSON grâce à la bibliothèque Jackson, qui est
incluse par défaut. Cela signifie que lorsque vous retournez des objets à partir de votre contrôleur,
Spring Boot les sérialise automatiquement en JSON.

Exemple de réponse JSON

Si vous effectuez une requête GET sur /api/products, la réponse pourrait ressembler à ceci :

[
{
"id": 1,
"name": "Ordinateur",
"price": 1200.00
},
{
"id": 2,
"name": "Imprimante",
"price": 150.00
}
]
Configurer Jackson

Il est possible de configurer les comportements de Jackson, comme le format des dates ou
le style de sérialisation, en ajoutant des propriétés dans application.properties :

spring.jackson.date-format=yyyy-MM-dd
spring.jackson.serialization.indent_output=true

4. Validation des données d’entrée avec Bean Validation

4.1. Introduction à Bean Validation

Bean Validation est un framework qui permet de valider les objets Java via des
annotations. Avec Spring Boot, vous pouvez facilement intégrer cette validation pour garantir que
les données entrantes sont conformes à des règles définies.

4.2. Ajouter des dépendances

Pour utiliser Bean Validation, vous n'avez généralement pas besoin d'ajouter des
dépendances supplémentaires, car Hibernate Validator est inclus par défaut avec Spring Boot.

4.3. Annoter l'entité avec des contraintes

Voici comment vous pouvez annoter l’entité Product pour appliquer des règles de validation :

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotBlank;

@Entity
public class Product {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@NotBlank(message = "Le nom du produit ne peut pas être vide")

private String name;
 @Min(value = 0, message = "Le prix doit être supérieur ou égal à zéro")
private Double price;

// Getters et setters
}

 @NotBlank : Vérifie que le champ n'est pas vide.

 @Min : Vérifie que le prix est supérieur ou égal à zéro.

4.4. Gérer les erreurs de validation dans le contrôleur

Vous pouvez gérer les erreurs de validation dans votre contrôleur en utilisant l'objet
BindingResult :

import org.springframework.validation.BindingResult;

@PostMapping
public ResponseEntity<Product> createProduct(@Valid @RequestBody Product product,
BindingResult result) {
if (result.hasErrors()) {
// Gérer les erreurs de validation
return ResponseEntity.badRequest().body(null);
}
return ResponseEntity.ok(productRepository.save(product));
}

L’annotation @Valid déclenche la validation et si des erreurs sont présentes, elles peuvent être
gérées de manière appropriée.

5. Conclusion

Cette activité a couvert les concepts fondamentaux pour créer des API RESTful avec
Spring Boot. Vous avez appris à définir des contrôleurs REST, à gérer les réponses au format
JSON, et à appliquer des validations sur les données d'entrée via Bean Validation.
Activité 8: Sécurité avec Spring Security

Objectifs de l’activité :

 Comprendre les concepts de base de Spring Security.

 Explorer les mécanismes d'authentification et d'autorisation avec Spring Security.
 Apprendre à intégrer OAuth2 et JWT pour sécuriser les API.
 Mettre en place un exemple de configuration de sécurité dans une application Spring Boot.

1. Introduction à Spring Security

Spring Security est un framework puissant et personnalisable qui fournit des

fonctionnalités de sécurité pour les applications Java. Il permet de protéger les applications contre
diverses menaces, telles que l'accès non autorisé, les attaques CSRF, et l'injection de code.

Principales fonctionnalités de Spring Security :

 Authentification : Vérifie l'identité de l'utilisateur (login).

 Autorisation : Contrôle l'accès aux ressources en fonction des rôles de l'utilisateur.
 Protection contre les attaques courantes : Telles que CSRF (Cross-Site Request Forgery)
et XSS (Cross-Site Scripting).

2. Authentification et autorisation avec Spring Security

2.1. Authentification

L'authentification consiste à vérifier l'identité d'un utilisateur. Avec Spring Security, cela
se fait généralement en configurant un UserDetailsService, qui charge les détails de l'utilisateur
depuis une base de données ou un autre service.
Exemple de UserDetailsService :

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class CustomUserDetailsService implements UserDetailsService {

@Autowired
private UserRepository userRepository; // Repository pour accéder aux utilisateurs

@Override
public UserDetails loadUserByUsername(String username) throws
UsernameNotFoundException {
User user = userRepository.findByUsername(username);
if (user == null) {
throw new UsernameNotFoundException("Utilisateur non trouvé : " +
username);
}
return new
org.springframework.security.core.userdetails.User(user.getUsername(),
user.getPassword(), new ArrayList<>());
}
}

2.2. Autorisation

L'autorisation détermine si un utilisateur a le droit d'accéder à une ressource ou de réaliser

une action. Spring Security permet de configurer des règles d'accès basées sur les rôles de
l'utilisateur.

Exemple de configuration des rôles :

import
org.springframework.security.config.annotation.authentication.builders.AuthenticationMa
nagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import
org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import
org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerA
dapter;

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.inMemoryAuthentication()
.withUser("user").password("{noop}password").roles("USER")
.and()
.withUser("admin").password("{noop}admin").roles("ADMIN");
}

@Override
protected void configure(HttpSecurity http) throws Exception {
http.authorizeRequests()
.antMatchers("/api/admin/**").hasRole("ADMIN")
.antMatchers("/api/user/**").hasAnyRole("USER", "ADMIN")
.anyRequest().authenticated()
.and()
.formLogin()
.and()
.httpBasic(); // Authentification de base
}
}

Dans cet exemple, seuls les utilisateurs avec le rôle ADMIN peuvent accéder aux routes
commençant par /api/admin, tandis que les utilisateurs avec les rôles USER et ADMIN peuvent
accéder à celles commençant par /api/user.

3. Intégration OAuth2 et JWT pour la sécurisation des API

3.1. OAuth2

OAuth2 est un protocole d'autorisation qui permet aux applications tierces d'accéder à des
ressources sans partager les identifiants des utilisateurs. Spring Security facilite l'intégration
d'OAuth2 pour protéger vos API.

3.2. JWT (JSON Web Token)

JWT est un standard ouvert pour partager des informations de manière sécurisée entre deux parties.
Les tokens JWT peuvent être utilisés pour représenter des informations d'identité et des droits
d'accès.
3.3. Configuration de Spring Security pour utiliser OAuth2 et JWT

Pour configurer votre application Spring Boot pour utiliser OAuth2 et JWT, vous devrez ajouter
les dépendances suivantes dans votre fichier pom.xml :

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-oauth2-client</artifactId>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>

Exemple d'implémentation JWT

1. Créer un service pour générer le JWT :

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service
public class JwtUtil {

private final String SECRET_KEY = "secret"; // Clé secrète pour signer le token

public String generateToken(String username) {

return Jwts.builder()
.setSubject(username)
.setIssuedAt(new Date(System.currentTimeMillis()))
.setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60
* 10)) // Validité de 10 heures
.signWith(SignatureAlgorithm.HS256, SECRET_KEY)
.compact();
}

public boolean validateToken(String token, String username) {

final String extractedUsername = extractUsername(token);
 return (extractedUsername.equals(username) && !isTokenExpired(token));
}

public String extractUsername(String token) {

return extractAllClaims(token).getSubject();
}

private Claims extractAllClaims(String token) {

return
Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody();
}

private boolean isTokenExpired(String token) {

return extractAllClaims(token).getExpiration().before(new Date());
}
}

2. Configurer la sécurité pour utiliser JWT : Vous devez modifier la configuration de

sécurité pour accepter le token JWT dans les requêtes entrantes.

@Override
protected void configure(HttpSecurity http) throws Exception {
http.csrf().disable()
.authorizeRequests()
.antMatchers("/api/auth/**").permitAll() // Autoriser l'accès aux
endpoints d'authentification
.anyRequest().authenticated()
.and()
.addFilter(new JwtAuthenticationFilter(authenticationManager()));
}

4. Exemple de configuration de sécurité dans une application Spring Boot

Pour mettre en place une sécurité complète dans une application Spring Boot, voici un exemple :

1. Créer une classe de configuration de sécurité :

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import
org.springframework.security.config.annotation.authentication.builders.Authentic
ationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import
org.springframework.security.config.annotation.web.configuration.EnableWebSecuri
 ty;
import
org.springframework.security.config.annotation.web.configuration.WebSecurityConf
igurerAdapter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

@Autowired
private CustomUserDetailsService userDetailsService;

@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception
{
auth.userDetailsService(userDetailsService).passwordEncoder(new
BCryptPasswordEncoder());
}

@Override
protected void configure(HttpSecurity http) throws Exception {
http.csrf().disable()
.authorizeRequests()
.antMatchers("/api/auth/**").permitAll() // Autoriser l'accès
aux endpoints d'authentification
.anyRequest().authenticated()
.and()
.addFilter(new
JwtAuthenticationFilter(authenticationManager()));
}

// Configuration pour JWT et autres filtres

}

2. Créer le filtre d'authentification JWT :

import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class JwtAuthenticationFilter extends WebAuthenticationFilter {

@Override
protected void doFilterInternal(HttpServletRequest request,
HttpServletResponse response, FilterChain chain)
throws ServletException, IOException {
 String token = request.getHeader("Authorization");

// Si le token est valide, configurez le contexte de sécurité

if (token != null && token.startsWith("Bearer ")) {
token = token.substring(7);
String username = jwtUtil.extractUsername(token);
// Vérifiez l'authentification et configurez le contexte de sécurité
}

chain.doFilter(request, response);
}
}

5. Conclusion

Cette activité a couvert les bases de la sécurité des applications Spring avec Spring Security. Vous
avez appris à gérer l'authentification et l'autorisation, à intégrer OAuth2 et JWT, et à mettre en
place une configuration de sécurité dans une application Spring Boot.
Activité 9: Transactions et Gestion des Transactions avec Spring

Objectifs de l’activité :

 Comprendre les concepts fondamentaux des transactions, y compris le modèle ACID.

 Explorer les approches de gestion des transactions dans Spring : déclarative et programmatique.
 Intégrer JPA avec Spring pour la gestion des transactions.
 Mettre en œuvre des exemples pratiques de gestion des transactions.

1. Concepts des transactions (ACID)

Les transactions sont des unités de travail qui doivent être exécutées de manière atomique. Le
modèle ACID définit les propriétés essentielles qu'une transaction doit respecter pour garantir
l'intégrité des données :

 Atomicité : Une transaction est atomique, ce qui signifie qu'elle est soit entièrement
exécutée, soit pas du tout. Si une partie de la transaction échoue, tous les changements
effectués sont annulés.
 Cohérence : Les transactions doivent amener la base de données d'un état valide à un autre
état valide. Cela garantit que toutes les contraintes de la base de données sont respectées
avant et après la transaction.
 Isolation : Les transactions concurrentes doivent être isolées les unes des autres. Les
modifications apportées par une transaction ne doivent pas être visibles par d'autres
transactions tant qu'elles ne sont pas validées.
 Durabilité : Une fois qu'une transaction est validée, ses modifications sont permanentes,
même en cas de défaillance du système.

2. Gestion déclarative vs programmatique des transactions dans Spring

Spring propose deux approches pour gérer les transactions :

2.1. Gestion déclarative des transactions

Cette approche utilise les annotations ou XML pour définir les transactions. Spring gère
automatiquement les transactions en fonction de la configuration.

Exemple d'utilisation de l'annotation @Transactional :

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class ProductService {

@Autowired
private ProductRepository productRepository;

@Transactional
public void createProduct(Product product) {
productRepository.save(product);
// D'autres opérations peuvent être ajoutées ici
}
}

Dans cet exemple, la méthode createProduct est annotée avec @Transactional. Cela signifie
que Spring gérera automatiquement la transaction pour cette méthode.

2.2. Gestion programmatique des transactions

Cette approche permet aux développeurs de gérer manuellement les transactions. Cela offre plus
de contrôle, mais cela nécessite également plus de code.

Exemple de gestion programmatique des transactions :

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

@Service
public class ProductService {

@Autowired
private ProductRepository productRepository;
 @Autowired
private PlatformTransactionManager transactionManager;

public void createProduct(Product product) {

TransactionStatus status = transactionManager.getTransaction(new
DefaultTransactionDefinition());
try {
productRepository.save(product);
// D'autres opérations peuvent être ajoutées ici
transactionManager.commit(status); // Valider la transaction
} catch (Exception e) {
transactionManager.rollback(status); // Annuler la transaction en cas
d'erreur
throw e;
}
}
}

Dans cet exemple, nous avons utilisé PlatformTransactionManager pour gérer manuellement la
transaction.

3. Intégration de JPA avec Spring pour la gestion des transactions

Spring intègre parfaitement JPA pour la gestion des transactions. Lorsque vous utilisez
@Transactional, Spring gère les transactions en fonction de la configuration de JPA.

Exemple d'intégration JPA et Spring avec @Transactional :

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class OrderService {

@Autowired
private OrderRepository orderRepository;

@Transactional
public void placeOrder(Order order) {
orderRepository.save(order);
// D'autres opérations, comme mettre à jour le stock, peuvent être effectuées
ici
 }

@Transactional(readOnly = true)
public List<Order> getAllOrders() {
return orderRepository.findAll();
}
}

Dans cet exemple, nous avons une méthode placeOrder qui enregistre une commande et une
méthode getAllOrders qui récupère toutes les commandes sans modifier l'état de la base de
données.

4. Exemples pratiques

Exemple 1 : Gestion des transactions avec plusieurs opérations

Imaginons une méthode qui effectue une opération de transfert d'argent entre deux comptes
bancaires. Cela nécessite que deux opérations soient effectuées avec succès ou que les deux soient
annulées.

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class BankService {

@Autowired
private AccountRepository accountRepository;

@Transactional
public void transferMoney(Long fromAccountId, Long toAccountId, double amount) {
Account fromAccount = accountRepository.findById(fromAccountId).orElseThrow(()
-> new RuntimeException("Compte non trouvé"));
Account toAccount = accountRepository.findById(toAccountId).orElseThrow(() ->
new RuntimeException("Compte non trouvé"));

fromAccount.setBalance(fromAccount.getBalance() - amount);
toAccount.setBalance(toAccount.getBalance() + amount);

accountRepository.save(fromAccount);
accountRepository.save(toAccount);
}
}
Exemple 2 : Gestion des transactions avec des erreurs

Lorsque vous traitez des opérations qui peuvent échouer, il est essentiel de gérer les exceptions
pour annuler la transaction.

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class PaymentService {

@Autowired
private PaymentRepository paymentRepository;

@Autowired
private OrderRepository orderRepository;

@Transactional
public void processPayment(Payment payment) {
orderRepository.findById(payment.getOrderId())
.orElseThrow(() -> new RuntimeException("Commande non trouvée"));

// Logique de traitement de paiement

paymentRepository.save(payment);

if (paymentFailed) { // Exemple de condition d'échec

throw new RuntimeException("Échec du traitement du paiement");
}
}
}

Dans cet exemple, si le traitement du paiement échoue, la transaction sera annulée et toutes les
modifications précédentes seront également annulées.

5. Conclusion

Cette activité a exploré la gestion des transactions dans Spring, y compris les concepts ACID, les
approches déclaratives et programmatiques de gestion des transactions, et l'intégration de JPA.
Vous avez également examiné des exemples pratiques pour mieux comprendre comment gérer
efficacement les transactions dans une application Spring Boot.
Activité 10: Messaging et Intégration avec JMS et RabbitMQ

Objectifs de l’activité :

 Comprendre les concepts fondamentaux de Java Messaging Service (JMS).

 Apprendre à utiliser RabbitMQ avec Spring Boot pour la gestion des messages.
 Explorer l’envoi et la réception de messages asynchrones.
 Mettre en œuvre des exemples pratiques d’intégration avec RabbitMQ.

1. Introduction à Java Messaging Service (JMS)

Java Messaging Service (JMS) est une API Java qui permet à des applications Java de
communiquer entre elles en utilisant des messages. JMS permet une communication asynchrone,
ce qui signifie que les expéditeurs et les récepteurs de messages peuvent fonctionner
indépendamment les uns des autres.

Principes clés de JMS :

 Asynchrone : Les messages peuvent être envoyés et reçus à des moments différents.
 Découplage : Les producteurs et les consommateurs de messages ne doivent pas être en ligne en
même temps.
 Fiabilité : JMS garantit la livraison des messages et peut gérer les pannes de manière efficace.

Types de modèles de messagerie :

 Queue (file d'attente) : Utilisé pour une communication point à point. Un message est consommé
par un seul consommateur.
 Topic (sujet) : Utilisé pour une communication de publication/abonnement. Un message est diffusé
à tous les abonnés.
2. Utilisation de RabbitMQ avec Spring Boot

RabbitMQ est un système de messagerie open-source qui implémente le modèle de messages

asynchrones. Avec Spring Boot, il est facile d'intégrer RabbitMQ pour envoyer et recevoir des
messages.

Configuration de RabbitMQ dans une application Spring Boot :

Pour commencer, vous devez ajouter les dépendances RabbitMQ à votre projet. Voici un exemple
de configuration avec Maven :

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

Configuration des paramètres RabbitMQ :

Ajoutez les paramètres de connexion à votre fichier application.properties :

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

3. Envoi et réception de messages asynchrones

3.1. Envoi de messages

Pour envoyer des messages à RabbitMQ, nous pouvons utiliser la classe RabbitTemplate.

Exemple d’envoi de messages :

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MessageProducer {
 @Autowired
private RabbitTemplate rabbitTemplate;

private final String QUEUE_NAME = "myQueue";

public void sendMessage(String message) {

rabbitTemplate.convertAndSend(QUEUE_NAME, message);
System.out.println("Message envoyé : " + message);
}
}

3.2. Réception de messages

Pour recevoir des messages, nous devons créer un MessageListener qui écoutera les messages
arrivant sur la queue.

Exemple de réception de messages :

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class MessageListener {

@RabbitListener(queues = "myQueue")
public void receiveMessage(String message) {
System.out.println("Message reçu : " + message);
}
}

4. Exemples pratiques d’intégration avec RabbitMQ

Exemple 1 : Envoi de messages en réponse à une action utilisateur

Imaginons une application qui envoie un message chaque fois qu'un utilisateur s'inscrit.

Service d'inscription d'utilisateur :

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class UserService {

@Autowired
private MessageProducer messageProducer;

public void registerUser(User user) {

// Logique d'inscription
// ...

// Envoi d'un message après l'inscription

messageProducer.sendMessage("Nouvel utilisateur inscrit : " +
user.getUsername());
}
}

Exemple 2 : Traitement des messages dans un service de fond

Nous pouvons traiter les messages reçus dans un service de fond.

Service de traitement des commandes :

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

@Service
public class OrderProcessingService {

@RabbitListener(queues = "orderQueue")
public void processOrder(Order order) {
// Logique de traitement de commande
System.out.println("Traitement de la commande : " + order.getId());
// ...
}
}

5. Conclusion

Cette activité a exploré les concepts fondamentaux de Java Messaging Service (JMS) et comment
utiliser RabbitMQ avec Spring Boot pour gérer des messages asynchrones. Vous avez appris à
envoyer et recevoir des messages et à intégrer RabbitMQ dans vos applications Spring.
Activité 11: Tests et Déploiement des Applications Spring Boot

Objectifs de l’activité :

 Comprendre l'importance des tests unitaires et d’intégration dans le développement d'applications

Spring Boot.
 Apprendre à utiliser JUnit et Mockito pour écrire des tests.
 Tester les couches web et de services dans une application Spring Boot.
 Explorer les méthodes de déploiement d’une application Spring Boot sur des plateformes comme
Heroku, AWS ou OVH.

1. Introduction aux tests unitaires et d’intégration avec Spring Boot

Les tests sont essentiels pour garantir que les applications fonctionnent comme prévu. Dans Spring
Boot, deux types de tests sont couramment utilisés :

 Tests unitaires : Vérifient des unités de code isolées (par exemple, des méthodes individuelles)
pour s'assurer qu'elles se comportent comme prévu.
 Tests d'intégration : Vérifient que différentes parties de l'application fonctionnent correctement
ensemble.

Avantages des tests :

 Détection précoce des bugs.

 Amélioration de la qualité du code.
 Facilitation de la maintenance et des mises à jour.

2. Utilisation de JUnit et Mockito

JUnit est un cadre de test populaire pour Java, tandis que Mockito est une bibliothèque de
simulation qui permet de créer des objets fictifs (mock objects) pour les tests unitaires.
2.1. JUnit

Pour ajouter JUnit à votre projet, vous pouvez utiliser la dépendance suivante dans votre fichier
pom.xml :

<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.8.1</version>
<scope>test</scope>
</dependency>

Exemple de test unitaire avec JUnit :

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;

public class CalculatorTest {

@Test
public void testAddition() {
Calculator calculator = new Calculator();
assertEquals(5, calculator.add(2, 3));
}
}

2.2. Mockito

Pour ajouter Mockito, vous pouvez ajouter la dépendance suivante :

<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>3.12.4</version>
<scope>test</scope>
</dependency>

Exemple de test unitaire avec Mockito :

import static org.mockito.Mockito.*;

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;
public class UserServiceTest {

@Test
public void testGetUser() {
UserRepository userRepository = mock(UserRepository.class);
UserService userService = new UserService(userRepository);
User user = new User("John");

when(userRepository.findById(1L)).thenReturn(Optional.of(user));

assertEquals("John", userService.getUser(1L).getName());
}
}

3. Tests des couches web et de services

Spring Boot fournit des annotations pour faciliter les tests des contrôleurs et des services.

3.1. Tests des contrôleurs web

Utilisez l’annotation @WebMvcTest pour tester les contrôleurs web.

Exemple de test de contrôleur :

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;

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;

@WebMvcTest(UserController.class)
public class UserControllerTest {

@Autowired
private MockMvc mockMvc;

@Test
public void testGetUser() throws Exception {
mockMvc.perform(get("/users/1"))
.andExpect(status().isOk())
.andExpect(content().string("User details for id: 1"));
}
}
3.2. Tests de services

Utilisez l’annotation @SpringBootTest pour tester les services avec toute l'application chargée.

Exemple de test de service :

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserServiceIntegrationTest {

@Autowired
private UserService userService;

@Test
public void testGetAllUsers() {
assertEquals(3, userService.getAllUsers().size());
}
}

4. Déploiement d’une application Spring Boot sur Heroku/AWS/OVH

Le déploiement d’une application Spring Boot peut être réalisé sur plusieurs plateformes. Voici un
aperçu des étapes de déploiement sur Heroku, AWS, et OVH.

4.1. Déploiement sur Heroku

1. Créer un compte Heroku et installer la CLI Heroku.

2. Configurer le fichier system.properties pour spécifier la version de Java :

java.runtime.version=17

3. Créer un fichier Procfile pour définir le type d'application :

web: java -jar target/your-app.jar

4. Déployer l’application :
 heroku create your-app-name
git push heroku main

4.2. Déploiement sur AWS

1. Créer un compte AWS et un service Elastic Beanstalk.

2. Installer AWS CLI et configurer vos informations d'identification.
3. Emballer l'application en un fichier JAR.
4. Déployer via la CLI :

eb init -p java-17 your-app-name

eb create your-env-name
eb deploy

4.3. Déploiement sur OVH

1. Créer un compte OVH et sélectionner un hébergement compatible Java.

2. Configurer le serveur pour qu'il exécute Java.
3. Téléverser le fichier JAR de votre application sur le serveur.
4. Lancer l’application en utilisant une commande comme :

java -jar your-app.jar

5. Conclusion

Cette activité a couvert les tests unitaires et d’intégration dans une application Spring Boot à l'aide
de JUnit et Mockito, ainsi que le test des couches web et de services. Vous avez également exploré
le déploiement d'applications Spring Boot sur des plateformes comme Heroku, AWS et OVH.

Cette dernière activité conclut notre cours sur le développement avec Java EE, Spring et Spring
Boot. Vous êtes désormais équipés pour développer, tester et déployer des applications robustes et
évolutives.
Activité 12: Projet Final

Objectifs de l’activité :

 Concevoir et développer une application complète en utilisant Spring Boot.

 Intégrer les concepts étudiés tout au long du cours, notamment REST, Spring Data JPA, Spring
Security, et la gestion des transactions.
 Déployer l’application sur une plateforme cloud choisie (Heroku, AWS, OVH).
 Présenter le projet et partager les expériences d’apprentissage.

1. Conception de l'application

1.1. Choix du sujet de projet

Les étudiants doivent choisir un sujet d'application qui les intéresse. Quelques idées peuvent inclure
:

 Application de gestion de bibliothèque : Permettre aux utilisateurs d'emprunter, de rendre et de

réserver des livres.
 Application de gestion de tâches : Offrir une interface pour créer, modifier et suivre des tâches ou
des projets.
 Application de gestion de portefeuille d'investissement : Suivre les investissements et fournir des
analyses financières.
 Plateforme de e-commerce : Permettre aux utilisateurs d'acheter et de vendre des produits en ligne.

1.2. Architecture de l'application

Les étudiants doivent définir une architecture pour leur application, en considérant :

 Couches : Contrôleur, Service, DAO (Data Access Object), et modèles.

 Base de données : Choisir un SGBD (MySQL, PostgreSQL, etc.) et définir le schéma des données.
 Sécurité : Mettre en place l'authentification et l'autorisation des utilisateurs.
2. Développement de l'application

2.1. Configuration de Spring Boot

Créer un projet Spring Boot à l'aide de Spring Initializr, en incluant les dépendances nécessaires :

 Spring Web : Pour développer des APIs REST.

 Spring Data JPA : Pour l'accès aux données.
 Spring Security : Pour sécuriser l'application.
 H2 Database (ou autre) : Pour une base de données de développement.

2.2. Développement des fonctionnalités

Les étudiants doivent implémenter les fonctionnalités suivantes :

 API REST : Créer des endpoints pour gérer les opérations CRUD (Create, Read, Update, Delete).
 Accès aux données : Utiliser Spring Data JPA pour interagir avec la base de données.
 Gestion de la sécurité : Implémenter l'authentification des utilisateurs à l'aide de Spring Security
(par exemple, en utilisant JWT).
 Gestion des transactions : S'assurer que les opérations critiques sont gérées transactionnellement.

Exemple d’API REST :

@RestController
@RequestMapping("/api/books")
public class BookController {

@Autowired
private BookService bookService;

@GetMapping
public List<Book> getAllBooks() {
return bookService.findAll();
}

@PostMapping
public Book createBook(@RequestBody Book book) {
return bookService.save(book);
}
}
3. Déploiement de l'application

3.1. Préparation au déploiement

Avant de déployer, les étudiants doivent s’assurer que :

 L'application est correctement configurée pour l'environnement de production.

 Les fichiers de configuration (comme application.properties) sont adaptés pour la base de
données de production.

3.2. Déploiement sur une plateforme cloud

Les étudiants peuvent choisir une des plateformes suivantes pour déployer leur application :

 Heroku : Suivre les étapes de déploiement déjà abordées.

 AWS : Utiliser Elastic Beanstalk pour déployer l'application.
 OVH : Téléverser le JAR et le configurer sur le serveur.

4. Présentation du projet

4.1. Structure de la présentation

Les étudiants doivent préparer une présentation de leur projet qui inclut :

 Vue d'ensemble de l'application : Expliquer le problème résolu par l'application et son public
cible.
 Démo en direct : Montrer les fonctionnalités de l'application.
 Techniques utilisées : Discuter des technologies et des concepts Spring appliqués.
 Défis rencontrés : Partager les obstacles et les solutions trouvées pendant le développement.
 Leçons apprises : Réfléchir sur ce qu'ils ont appris tout au long du processus.
4.2. Feedback

Après la présentation, il est essentiel d'organiser une session de questions-réponses et de feedback,

permettant aux étudiants de partager leurs expériences et d'obtenir des conseils pour améliorer leur
travail.

5. Conclusion

Cette activité finale permet aux étudiants de synthétiser tout ce qu'ils ont appris pendant le cours et
d'appliquer ces connaissances dans un projet concret. En intégrant Spring Boot, Spring Data JPA,
Spring Security, et d'autres concepts, les étudiants auront l'opportunité de démontrer leurs
compétences et leur compréhension du développement d'applications Java modernes. Cela
constitue également une excellente expérience pour leur future carrière dans le développement
logiciel.