COURS DE

PROGRAMMATION EN JAVA
L1 RTM

Ir Concepteur MUKHUT MVOUL Jean-Paul

Année Académique 2025-2026

 Page |1

Cours de Programmation en Java

Objectif Général
L’objectif général de ce cours est de permettre aux apprenants d’acquérir les
compétences nécessaires pour développer des applications web robustes, évolutives
et sécurisées en utilisant java et le Framework Spring boot.

Objectifs Spécifiques
• Maitriser la syntaxe et les concepts fondamentaux de Java ;
• Maitriser la programmation orientée objet (POO) ;
• Gérer les exceptions et les erreurs ;
• Lire et écriture dans le fichier ;
• Créer les interfaces graphiques simples ;
• Comprendre l’architecture de Spring et Spring Boot ;
• Utiliser les outils modernes de développement.
 Page |2

MODULE 1 : Fondamentaux de java

I.1. Introduction à java

Java est un langage de programmation et une plateforme informatique polyvalente,
orientée objet, créée par Sun Microsystems (aujourd'hui propriété d'Oracle) en 1995.
Sa principale caractéristique est son indépendance vis-à-vis de la plateforme grâce à
la machine virtuelle Java (JVM) qui exécute le bytecode, permettant d'écrire le code
une fois et de l'exécuter partout. Java est utilisé pour développer une vaste gamme
d'applications, notamment des applications mobiles, des logiciels d'entreprise, des
applications web, des jeux, et pour le Big Data.
Caractéristiques principales de Java

• Indépendance de la plateforme (Write Once, Run Anywhere)

Un programme Java compilé en bytecode peut être exécuté sur n'importe quel
système qui dispose d'une JVM, sans nécessiter de recompilation.

• Langage orienté objet

Le code Java est structuré en classes et objets, ce qui favorise la réutilisation du code
et la modularité.
• Polyvalence

Java est utilisé pour créer différents types d'applications, allant des petites applications
embarquées aux systèmes distribués complexes.

• Vaste écosystème
Le langage bénéficie d'un grand nombre de bibliothèques (API), d'outils de
développement (JDK) et d'une communauté de développeurs active.

Comment Java fonctionne

1. Compilation
Le code source Java est écrit par le développeur, puis compilé en un format
intermédiaire appelé bytecode.

2. Exécution
Ce bytecode est ensuite exécuté par la JVM, qui le traduit en instructions natives pour
la machine sur laquelle il s'exécute.
Exemple de code simple (programme "Hello, World!")
 Page |3

• public class HelloWorld : déclare une classe nommée HelloWorld.

• public static void main(String[] args) : c'est la méthode principale, le point
d'entrée de l'exécution du programme.

• [Link]("Hello, World!"); : cette instruction affiche le texte "Hello,

World!" sur la console.

Environnements Java
• JRE (Java Runtime Environment)

Il fournit les outils nécessaires pour exécuter des applications Java, y compris la JVM.

• JDK (Java Development Kit)

Il inclut tout le nécessaire pour l'exécution (JRE) et le développement de programmes
Java, comme le compilateur.

1.1.1. INSTALLATION JDK ET IDE VS CODE

Pour développer en Java avec Visual Studio Code, vous devez installer des
extensions qui transforment VS Code en un IDE Java complet, car le support de Java
n'est pas intégré par défaut. Il est recommandé d'installer le Coding Pack for
Java de Visual Studio Code, qui inclut le JDK, VS Code, et des extensions essentielles
pour Java, comme le support du langage et la gestion des projets Maven ou Gradle.

1. Installer les Outils Essentiels

• JDK (Java Development Kit)

VS Code ne fournit pas le JDK, vous devez l'installer séparément ou utiliser le Coding
Pack, qui l'inclut.
• Extension Pack for Java

Installez l'Extension Pack for Java dans VS Code, qui regroupe les outils nécessaires
:

• Language Support for Java™ by Red Hat : pour le support du langage Java.
 Page |4

• Debugger for Java et Test Runner for Java : pour le débogage et

l'exécution des tests.

• Maven for Java et Project Manager for Java : pour la gestion des projets
Java, y compris la génération de projets à partir d'archétypes Maven et
la gestion des dépendances, explique Visual Studio Code.
2. Configuration et Utilisation
• Démarrer un projet
Vous pouvez créer des projets Java grâce à l'extension Project Manager for Java ou
utiliser des outils comme Maven pour générer des projets existants.

• Fonctionnalités intégrées

: Une fois configuré, VS Code offre des fonctionnalités avancées telles que :
• IntelliSense : auto-complétion intelligente du code, mise en surbrillance
syntaxique et pliage de code.

• Débogage : points d'arrêt, piles d'appels et console interactive pour le

débogage de votre code.

• Contrôle de version : support intégré de Git.

• Terminal intégré : vous pouvez ouvrir un terminal directement dans VS
Code pour exécuter des commandes.

3. Différence avec les IDE Dédiés

• Contrairement à des IDE comme IntelliJ IDEA ou Eclipse, qui ont un support
natif et centralisé pour les projets Java, VS Code s'appuie sur un écosystème
d'extensions pour fournir ces fonctionnalités.

• Cela rend VS Code très polyvalent, car il peut être transformé en un IDE Java
puissant en ajoutant les extensions nécessaires, tout en conservant sa légèreté
et sa rapidité.
 Page |5

1.1.2. Structure d’un programme java

Un programme Java est structuré autour de classes, qui contiennent des méthodes
(des blocs de code nommés) et des attributs. La structure de base d'une classe inclut
des modificateurs, un nom, et des accolades { } pour délimiter son corps. Les
programmes utilisent des instructions terminées par un point-virgule (;) pour effectuer
des opérations, et des blocs de code { } pour organiser les instructions. L'exécution
commence par la méthode main, et les commentaires (// ou /* */) sont utilisés pour
expliquer le code.
Voici les éléments clés de la structure d'un programme Java :

• Classes

• Les classes sont les blocs de construction fondamentaux de Java.

• Elles regroupent des méthodes et des attributs liés à un concept
particulier.

• La définition d'une classe commence par le mot-clé class.

• Méthodes
• Ce sont des séquences d'instructions nommées qui effectuent une tâche
spécifique.

• Elles peuvent avoir un type de retour, un nom, des paramètres (entrées)

et un corps de méthode.

• La méthode main est le point d'entrée principal de l'exécution d'un

programme Java.
• Instructions et Points-virgules

• Les instructions sont des déclarations qui spécifient une opération à

exécuter.

• Chaque instruction se termine par un point-virgule (;).

• Blocs de code

• Ils sont délimités par des accolades { } et permettent de regrouper des

instructions.
• Les blocs sont utilisés pour les structures de contrôle comme les if ou
les boucles.

• Commentaires

• Ils sont utilisés pour annoter le code et fournir des explications.

• Ils commencent par // pour les commentaires sur une seule ligne, ou
par /* et se terminent par */ pour les commentaires sur plusieurs lignes.
 Page |6

1.1.3. Types de données, variables, opérateurs

Les types de données définissent la nature d'une valeur (ex: entier, chaîne de
caractères, booléen), les variables sont des espaces de stockage nommés pour ces
valeurs, et les opérateurs sont des symboles qui effectuent des actions sur les
données, telles que l'addition, la multiplication ou la comparaison.
Types de données

Les types de données indiquent le genre de valeur qu'une variable peut contenir. Les
principaux types sont :
• Types numériques : pour les nombres, comme les entiers (int) pour les
nombres entiers (ex: 5, -10) et les nombres flottants (float) pour les nombres à
virgule flottante (ex: 3.14, -0.5).
• Types de chaîne de caractères : pour les textes, comme "New York City".

• Types booléens : pour des valeurs de vérité, comme true (vrai)

ou false (faux).

Variables
• Une variable est un identifiant (un nom) qui représente un espace mémoire
pour stocker une donnée.

• Lors de la création d'une variable (souvent avec des mots-clés comme var), on
spécifie généralement le type de données qu'elle contiendra et on lui assigne
une valeur.

• Exemple : nom = "Alice" (une variable nom de type chaîne de caractères).

Opérateurs

Les opérateurs permettent de manipuler les variables et les valeurs.

• Opérateurs arithmétiques : pour les calculs.

o + : addition

o - : soustraction
o * : multiplication

o / : division

• Opérateurs d'assignation : pour attribuer une valeur à une variable (ex: =).
• Opérateurs de comparaison et logiques : pour comparer des valeurs et
prendre des décisions dans un programme.
 Page |7

1.2. Contrôle de flux

1.2.1. Conditions(If,switch)
En Java, if et switch sont des structures conditionnelles permettant d'exécuter du
code différemment selon une condition. Le if teste des expressions booléennes
complexes et permet une logique "si ... sinon si ... sinon". Le switch est plus adapté
pour tester une seule valeur (entier, énumération, ou chaîne) contre plusieurs cas
possibles, offrant une syntaxe plus condensée et souvent plus optimisée pour de
multiples conditions exactes, contrairement au if qui est plus flexible pour des plages
de valeurs.

L'instruction if

• Usage : Permet de tester des conditions complexes basées sur des

comparaisons (>, <, ==, etc.) et d'exécuter du code si la condition est vraie.
• Syntaxe :

• Quand l'utiliser : Idéal pour des conditions booléennes complexes, des tests
sur des valeurs flottantes, ou lorsqu'il y a une relation entre différentes
conditions.

L'instruction switch
• Usage : Permet de sélectionner une des nombreuses instructions à exécuter,
en fonction de la valeur d'une expression.

• Syntaxe :
 Page |8

• Quand l'utiliser :
Idéal pour choisir parmi plusieurs valeurs exactes et éviter une longue chaîne de if-
else if.

• Points importants :

• L'expression du switch doit être de type int, char, String, ou enum.

• Chaque case doit se terminer par break; pour éviter le "fall-
through" (l'exécution du code du cas suivant sans le vouloir).

• Le default est facultatif et s'exécute si aucune valeur ne correspond.

1.2.2. Boucles (for,while,do-while)

En Java, les boucles for, while et do-while permettent de répéter des instructions. La
boucle for est idéale lorsque le nombre d'itérations est connu à l'avance. La
boucle while exécute des instructions tant qu'une condition est vraie, mais peut ne
jamais s'exécuter si la condition est fausse dès le départ. La boucle do-while est une
variante de while qui garantit au moins une exécution du corps de la boucle, car la
condition est vérifiée après le bloc d'instructions.

La boucle for

La boucle for est utilisée pour exécuter un bloc de code un nombre défini de fois. Elle
inclut généralement l'initialisation d'une variable, une condition de test et une
expression d'incrémentation ou de décrémentation.
 Page |9

La boucle while

Cette boucle exécute un bloc d'instructions tant qu'une condition logique est vraie. Si
la condition est fausse au départ, le corps de la boucle ne sera jamais exécuté.

La boucle do-while

La principale différence avec la boucle while est que le bloc d'instructions est exécuté
au moins une fois avant que la condition ne soit évaluée. Le point-virgule après la
condition est une exigence de syntaxe de la boucle do-while.

1.2.3. Le tableau
En Java, un tableau est une structure de données fondamentale qui permet de stocker
un nombre fixe d'éléments du même type, accessibles par un index numérique
commençant à zéro. Pour déclarer et créer un tableau, on spécifie le type des
éléments et sa taille, puis on l'instancie avec new ou on l'initialise directement avec
 P a g e | 10

des valeurs. Les tableaux possèdent une propriété length pour connaître leur taille et
sont accessibles via des boucles, notamment la boucle for.

Création et Déclaration
Pour utiliser un tableau, il faut le déclarer et l'instancier.

• Déclaration : type[] nomTableau; ou type nomTableau[];.

• Instanciation : nomTableau = new type[taille]; où type est le type des

éléments (ex: int, String) et taille est le nombre d'éléments.
Exemple de création et d'initialisation

Accès aux éléments

Les éléments d'un tableau sont accessibles par leur indice, qui commence toujours à
0.
• nomTableau[indice] permet d'accéder à un élément.

Exemple d'accès

Opérations courantes
• Obtenir la taille : La propriété length donne le nombre d'éléments du tableau.
 P a g e | 11

• Tableaux multidimensionnels : On peut utiliser plusieurs paires de

crochets [] pour créer des tableaux en deux dimensions ou plus, formant une
grille de valeurs.

Tableaux multidimensionnels (Exemple)

1.3. Programmation orientée objet (POO)

La Programmation Orientée Objet (POO) en Java est un paradigme qui organise les
programmes autour des objets (des entités concrètes ou abstraites du monde réel)
plutôt qu'autour des actions logiques. Java est un langage intrinsèquement orienté
objet, utilisant des concepts clés comme les classes (des modèles pour créer des
objets), l'encapsulation (lier données et méthodes), l'héritage (réutiliser le code), et
le polymorphisme (polyvalence des objets) pour créer des applications modulaires,
réutilisables et faciles à maintenir.
1.3.1. Classes et objets
En Java, une classe est un plan ou un modèle définissant les caractéristiques
(attributs) et les comportements (méthodes) d'objets. Un objet est une instance
concrète de cette classe, c'est une réalisation unique du modèle. Par exemple, la
classe Voiture peut avoir les attributs couleur et marque, et une
méthode demarrer(). Vous pouvez créer plusieurs objets Voiture (une Voiture rouge,
 P a g e | 12

une Voiture bleue), chacun ayant sa propre couleur et marque, et chacun pouvant
appeler la méthode demarrer().

Qu'est-ce qu'une classe ?

• C'est un modèle ou un moule utilisé pour créer des objets.

• Elle spécifie les propriétés (attributs) et les actions (méthodes) que les objets
de ce type pourront avoir.

• Elle est définie en Java à l'aide du mot-clé class.

Qu'est-ce qu'un objet ?

• C'est une instance d'une classe, une réalisation concrète du modèle.

• Chaque objet possède sa propre copie des attributs définis dans la classe.

• On accède aux attributs et aux méthodes d'un objet en utilisant

l'opérateur . (point), comme [Link] ou [Link]().
Comment créer des objets (instancier une classe) ?
• L'opérateur new est utilisé pour créer une nouvelle instance d'une classe.

• La syntaxe est : nomClasse nomObjet = new nomClasse(paramètres);.

Exemple concret : Une classe Chien

 P a g e | 13

1.3.1. Encapsulation
L'encapsulation en Java est un mécanisme qui regroupe les données (attributs) et les
méthodes qui les manipulent au sein d'une seule classe, en cachant les détails
d'implémentation et en restreignant l'accès direct aux attributs privés via des
 P a g e | 14

méthodes publiques appelées getters et setters. Cela permet de protéger les

données, de garantir leur intégrité grâce à des validations, et de simplifier l'utilisation
de la classe en exposant une interface publique claire.

Exemple d'encapsulation
Prenons une classe Voiture pour illustrer ce principe :

Dans cet exemple, les variables marque et vitesse sont publiques et peuvent être
modifiées directement depuis n'importe quelle autre classe, ce qui peut mener à des
incohérences.

2. La Classe Voiture (avec Encapsulation)

Pour appliquer l'encapsulation, nous rendons les attributs private et ajoutons des
méthodes public pour y accéder et les modifier :
P a g e | 15
 P a g e | 16

Explication de l'Encapsulation dans cet exemple :

1. Attributs private
marque et vitesse sont private. Cela signifie qu'elles ne peuvent pas être accédées ou
modifiées directement depuis une autre classe.
2. Méthodes public (Getters)

Les méthodes getMarque() et getVitesse() permettent de lire les valeurs des attributs,
mais pas de les modifier directement.
3. Méthodes public (Setters)
 P a g e | 17

Les méthodes comme accelerer() et freiner() permettent de modifier la valeur

de vitesse, mais elles incluent des logiques de contrôle (par exemple, une vitesse ne
peut pas être négative). C'est la protection de l'intégrité des données.

1.2.2. Héritage, polymorphisme

L'héritage en Java est un mécanisme POO qui permet à une classe (sous-classe)
d'hériter des attributs et méthodes d'une autre classe (super-classe) en utilisant le
mot-clé extends. Un exemple classique est la classe Animal (mère) et des classes
comme Chien et Chat (filles) qui héritent de Animal, partageant des caractéristiques
comme manger ou dormir tout en ajoutant leur comportement spécifique.

Exemple de code Java

1. Classe mère (Super-classe) : Définition d'une classe générale, par

exemple Animal.

1. Classe fille (Sous-classe) : Création d'une classe qui étend Animal, par
exemple Chien.
 P a g e | 18

1. Exemple d'utilisation : Création d'objets et appel de méthodes.

Explication

• extends : La classe Chien utilise extends Animal pour hériter de Animal.

• super() : Le mot-clé super() dans le constructeur de Chien appelle le
constructeur de la classe parente Animal pour initialiser l'attribut nom.

• Héritage des membres : Chien hérite

de nom, manger() et dormir() de Animal.

• Comportement spécifique : Chien ajoute sa propre méthode aboyer() et son

propre attribut race.
 P a g e | 19

• Relation "est un" : L'héritage établit une relation "est un", où un Chien est
un Animal.

Cet exemple montre comment l'héritage permet de réutiliser le code et de créer des
hiérarchies de classes, rendant le code plus organisé et maintenable.
 P a g e | 20

1.2.3. Interface et abstraction

En Java, une interface est un type abstrait qui définit un contrat de méthodes (sans
implémentation) que les classes doivent respecter, ce qui permet d'atteindre
l'abstraction en n'exposant que les fonctionnalités. Par exemple, une
interface Motorise peut spécifier une méthode fais Le Plein(), et diverses classes
comme Voiture et Avion peuvent l'implémenter, chacune avec sa propre manière de
faire le plein, tout en permettant une gestion unifiée par une
classe StationService recevant des objets Motorise.
Qu'est-ce que l'abstraction en Java ?

L'abstraction consiste à masquer les détails d'implémentation complexes d'un objet

pour ne montrer que les fonctionnalités nécessaires. Une interface est un outil pour
réaliser cette abstraction en Java.

Rôle de l'interface
• Contrat d'implémentation :

L'interface définit un ensemble de méthodes (sans corps) que toute classe

l'implémentant doit impérativement fournir.

• Définit le comportement :
Elle spécifie ce qu'une classe doit faire, mais pas comment elle doit le faire.

• Supporte l'abstraction :

En ne révélant que les méthodes, elle cache les détails internes d'une fonctionnalité,
permettant une approche plus simple de la conception logicielle.
Exemple d'interface et d'abstraction

Imaginons un système pour gérer des véhicules :

1. Définir l'interface: Motorise :

Cette interface établit le contrat que tout type de véhicule motorisé doit pouvoir faire
le plein.

1. Créer des classes qui implémentent : l'interface :

 P a g e | 21

Chaque classe implémente Motorise à sa manière.

1. Utiliser l'interface pour la gestion abstraite :
P a g e | 22
 P a g e | 23

1.4. Concepts avancés

1.4.1. Exceptions & gestion des erreurs

En Java, la gestion des exceptions permet d'intercepter et de traiter les erreurs lors
de l'exécution d'un programme en utilisant les mots-clés try, catch, et finally. Un
bloc try contient le code qui pourrait générer une erreur, tandis que le bloc catch traite
l'exception si elle se produit. Le bloc finally, toujours exécuté, est utilisé pour le
nettoyage des ressources. Pour lever une exception, on utilise throw,
et throws indique qu'une méthode peut en propager une.

Mécanisme de gestion des exceptions

1. Levée de l'exception
Lorsqu'une erreur survient (par exemple, division par zéro), un objet d'exception est
créé et « levé ».

2. Transfert du contrôle
Le flux d'exécution du programme est interrompu et le contrôle est transféré à un «
gestionnaire d'exception » (handler) approprié.
3. Propriété de la pile d'appels

Si le bloc de code actuel ne gère pas l'exception, celle-ci est propagée à la méthode
appelante, et ainsi de suite à travers la pile d'appels jusqu'à être traitée ou que le
programme s'arrête.

Mots-clés et structures
• try

: Le bloc try est utilisé pour encadrer le code susceptible de lancer une exception.
• catch

: Le bloc catch est exécuté si une exception du type spécifié (ou un de ses sous-types)
est levée dans le bloc try.

• finally
: Le bloc finally est un bloc de code qui sera toujours exécuté, qu'une exception soit
levée ou non. Il est souvent utilisé pour libérer des ressources (comme fermer des
fichiers).

• throw

: Le mot-clé throw est utilisé pour générer explicitement une exception à partir d'un
objet.
• throws
 P a g e | 24

Dans la signature d'une méthode, throws indique que la méthode peut potentiellement
lever des exceptions de certains types, signalant ainsi à l'appelant qu'il doit les gérer.

Types d'exceptions
• Error

Représente des erreurs graves et critiques qui surviennent au niveau de la machine

virtuelle Java ou du système. Ces erreurs entraînent généralement l'arrêt du
programme.

• Exception
Représente des problèmes moins graves, souvent récupérables, tels
que ArithmeticException (division par zéro), NullPointerException,
ou FileNotFoundException.

• RuntimeException

Une classe d'exceptions qui ne sont pas obligatoires à intercepter avec un bloc try-
catch.
En Java, la gestion des exceptions permet d'intercepter et de traiter les erreurs lors
de l'exécution d'un programme en utilisant les mots-clés try, catch, et finally. Un
bloc try contient le code qui pourrait générer une erreur, tandis que le bloc catch traite
l'exception si elle se produit. Le bloc finally, toujours exécuté, est utilisé pour le
nettoyage des ressources. Pour lever une exception, on utilise throw,
et throws indique qu'une méthode peut en propager une.
Mécanisme de gestion des exceptions

1. Levée de l'exception

Lorsqu'une erreur survient (par exemple, division par zéro), un objet d'exception est
créé et « levé ».
2. Transfert du contrôle

Le flux d'exécution du programme est interrompu et le contrôle est transféré à un «

gestionnaire d'exception » (handler) approprié.

3. Propriété de la pile d'appels

Si le bloc de code actuel ne gère pas l'exception, celle-ci est propagée à la méthode
appelante, et ainsi de suite à travers la pile d'appels jusqu'à être traitée ou que le
programme s'arrête.

Mots-clés et structures

• try
Le bloc try est utilisé pour encadrer le code susceptible de lancer une exception.
 P a g e | 25

• catch

Le bloc catch est exécuté si une exception du type spécifié (ou un de ses sous-types)
est levée dans le bloc try.
• finally

Le bloc finally est un bloc de code qui sera toujours exécuté, qu'une exception soit
levée ou non. Il est souvent utilisé pour libérer des ressources (comme fermer des
fichiers).

• throw
Le mot-clé throw est utilisé pour générer explicitement une exception à partir d'un
objet.

• throws

Dans la signature d'une méthode, throws indique que la méthode peut potentiellement
lever des exceptions de certains types, signalant ainsi à l'appelant qu'il doit les gérer.
Types d'exceptions

• Error

Représente des erreurs graves et critiques qui surviennent au niveau de la machine

virtuelle Java ou du système. Ces erreurs entraînent généralement l'arrêt du
programme.
• Exception

: Représente des problèmes moins graves, souvent récupérables, tels

que ArithmeticException (division par zéro), NullPointerException,
ou FileNotFoundException.

• RuntimeException : Une classe d'exceptions qui ne sont pas obligatoires à

intercepter avec un bloc try-catch.
1.4.2. Collections (List,Set,Map)
En Java, List, Set et Map sont des interfaces clés de l'API Collections pour organiser
des objets. List stocke des éléments ordonnés et autorise les doublons, tandis
que Set stocke des éléments uniques sans ordre garanti. Map stocke des paires clé-
valeur, où les clés sont uniques, et est utilisée pour associer des données de manière
efficace.

1. List (Liste)
• Description : Une collection ordonnée qui peut contenir des éléments
dupliqués. L'ordre des éléments est préservé, et on peut y accéder par un
index.
 P a g e | 26

• Utilisation : Idéale lorsque l'ordre des éléments est important, comme dans
l'affichage d'une liste d'éléments dans une interface utilisateur ou pour des
algorithmes nécessitant une séquence.

• Implémentation courante : ArrayList (un tableau redimensionnable).

• Exemple :

2. Set (Ensemble)

• Description : Une collection qui ne permet pas les doublons. Les éléments ne
sont pas nécessairement ordonnés.

• Utilisation : Parfait pour stocker des données uniques, comme une liste
d'adresses e-mail pour éviter les doublons, ou pour des opérations qui
nécessitent des éléments uniques.
• Implémentation courante : HashSet.

• Exemple :
 P a g e | 27

3. Map (Carte)
En Java, une Map est une structure de données qui stocke des éléments sous forme
de paires clé-valeur, où chaque clé est unique et permet de retrouver une valeur
associée. Elle fait partie du framework Java Collections et est implémentée par des
classes comme HashMap. Pour l'utiliser, vous instanciez une classe Map (par
exemple, new HashMap<>()), ajoutez des paires avec put(clé, valeur), puis récupérez
des valeurs avec get(clé).

Qu'est-ce qu'une Map ?

• Paires clé-valeur

: La Map stocke des données sous forme de paires où chaque valeur est associée à
une clé unique.

• Clés uniques
: Il ne peut y avoir qu'une seule instance de chaque clé dans une Map.

• Valeurs répétées
: Les valeurs ne sont pas obligées d'être uniques et peuvent apparaître plusieurs fois.

• Interface de collection

: La Map est une interface du framework [Link] qui n'est pas un sous-type de
l'interface Collection.
 P a g e | 28

Exemple d'utilisation

Voici un exemple simple pour créer une Map de noms d'étudiants et leur âge, et pour
y accéder :
Exemple :

1.4.3. Generics
Les génériques Java sont un mécanisme permettant de définir des classes, des
interfaces et des méthodes qui peuvent fonctionner avec différents types de données,
 P a g e | 29

spécifiés au moment de la création d'une instance ou de l'appel d'une méthode. Ils

améliorent la sécurité des types en effectuant des vérifications au moment de la
compilation, réduisent le besoin de conversions de types manuelles et augmentent la
lisibilité du code, notamment en renforçant les collections. L'utilisation de l'opérateur
diamant <> permet de spécifier un type, par exemple ArrayList<Integer>, créant un
type paramétré.

Pourquoi utiliser les génériques ?

• Sécurité des types

: Le compilateur vérifie que vous utilisez le bon type de données, ce qui évite les
erreurs au moment de l'exécution.

• Lisibilité du code
: Le code est plus clair car les types sont explicitement définis.

• Flexibilité
: Vous pouvez écrire des classes ou des méthodes réutilisables pour différents types
de données sans avoir à les dupliquer.
• Réduction des conversions

: Vous n'avez plus besoin de convertir manuellement les types (comme caster
des Object en String ou Integer).

Comment ça marche ?
• Paramètres de type

: Ce sont des symboles, souvent des lettres comme T, qui servent de placeholders
pour les types.

• Opérateur diamant (<>)

: Il est utilisé pour spécifier l'argument de type réel. Par
exemple, ArrayList<String> spécifie que la liste doit contenir des String.

• Types paramétrés

: Une fois le type précisé avec l'opérateur diamant, le type générique devient un type
paramétré, comme ArrayList<String>.
• Effacement de type (Type Erasure)

: Pendant la compilation, les informations sur les génériques sont supprimées pour
garantir la rétrocompatibilité avec les anciennes versions de Java. Cela signifie que
l'information sur le type n'est pas disponible à l'exécution.

Exemple
 P a g e | 30

Voici un exemple de classe Box générique :

1.4.4. Input/Ouput (Fichier)

En Java, l'entrée/sortie (E/S) des fichiers permet de lire et d'écrire des données dans
des fichiers en utilisant des classes comme File, Scanner, FileWriter, et les méthodes
de [Link]. Pour lire, on crée un Scanner ou un BufferedReader, puis on lit
ligne par ligne avec hasNextLine() et nextLine(). Pour écrire, on
utilise FileWriter ou BufferedWriter avec write(), et il faut toujours fermer les flux
avec close() pour libérer les ressources.
1. Lire un fichier

Pour lire le contenu d'un fichier, vous pouvez utiliser la

classe Scanner ou BufferedReader.
 P a g e | 31

• Explication :
o File file = new File("[Link]"); crée un objet File représentant le
fichier à lire.
o Scanner scanner = new Scanner(file); initialise un objet Scanner pour
lire à partir de ce fichier.

o while ([Link]()) { ... } est une boucle qui continue tant qu'il
y a des lignes à lire dans le fichier.

o String ligne = [Link](); lit la ligne suivante.

o [Link](); ferme le flux pour libérer les ressources.
2. Écrire dans un fichier
Pour écrire des données dans un fichier, vous pouvez
utiliser FileWriter ou BufferedWrite
 P a g e | 32

• Explication :
o FileWriter writer = new FileWriter("[Link]"); crée un
objet FileWriter. Si [Link] existe, son contenu sera remplacé.

o [Link]("..."); écrit le texte spécifié dans le fichier.

o [Link](); ferme le flux d'écriture.

Bonnes pratiques

• Fermez toujours les flux

Après avoir fini de lire ou d'écrire, utilisez close() pour fermer les flux et libérer les
ressources système. L'utilisation de blocs try-with-resources (non montrée ici pour
simplifier) est une meilleure pratique pour garantir que les flux sont automatiquement
fermés.

• Gérez les exceptions

Les opérations de fichier peuvent échouer, il est donc essentiel de les entourer de
blocs try-catch pour gérer les exceptions
comme FileNotFoundException ou IOException.
 P a g e | 33

Module 2 : Introduction à Spring

2.1. Qu’est-ce que Spring
Spring est un framework (cadriciel) Java open source qui fournit une infrastructure
complète et des outils pour développer des applications Java, en particulier des
applications d'entreprise, web et microservices. Il se base sur la gestion de la création
et des relations entre les objets via l'injection de dépendances et un conteneur
léger, ce qui simplifie le développement, réduit la complexité et améliore la
maintenabilité des applications.

Fonctionnalités et principes clés

• Injection de dépendances (DI)
: Spring gère le cycle de vie des objets et leurs dépendances. Au lieu qu'un objet crée
lui-même ses dépendances, Spring les lui fournit, ce qui rend le code plus modulaire
et plus facile à tester.

• Conteneur léger

: Le cœur de Spring est un conteneur qui gère les "Beans" (objets) et leurs relations,
instanciant les objets nécessaires et les rendant disponibles à l'application.
• Modularité

: Les développeurs peuvent choisir les modules Spring dont ils ont besoin, comme
Spring Security pour la sécurité ou Spring Data pour l'accès aux données, ce qui offre
une grande flexibilité.

• Simplification
: Spring automatise de nombreuses tâches répétitives, comme la gestion des bases
de données ou la sécurité, et simplifie la création d'applications complexes.

Pourquoi utiliser Spring ?

• Développement simplifié
: Spring réduit la complexité de la création d'applications Java.

• Flexibilité et modularité
: Il permet aux développeurs de n'utiliser que les composants dont ils ont besoin.

• Applications robustes et maintenables

: L'utilisation des principes de Spring favorise de bonnes pratiques de développement,

rendant le code plus propre, plus testable et plus facile à maintenir.
• Écosystème étendu
: Spring est une plateforme complète avec de nombreux projets et intégrations, ce qui
en fait une pièce maîtresse dans le développement Java.
 P a g e | 34

2.1.1. Inversion de contrôle (loC)

L'Inversion de Contrôle (IoC) dans Spring est un principe de conception qui délègue
la création et la gestion des objets (beans) et de leurs dépendances à un conteneur
IoC externe, plutôt qu'à la logique métier de l'application elle-même. Cela permet aux
développeurs de se concentrer sur le code métier en utilisant l'Injection de
Dépendances (DI), où le conteneur Spring fournit automatiquement les objets et leurs
configurations au lieu que l'application n'ait à les instancier.

Comment l'IoC fonctionne dans Spring

1. Le Conteneur IoC
: Le cœur du Spring Framework est le conteneur IoC, qui gère le cycle de vie des
objets (beans).

2. Configuration
: Le conteneur est configuré via des fichiers XML, des classes Java annotées
avec @Configuration et @Bean, ou en utilisant le composant scanning
avec @ComponentScan.
3. Injection de Dépendances (DI)

: Une fois la configuration lue, le conteneur crée les instances des classes (beans) et
injecte automatiquement les dépendances nécessaires.

4. Gestion des dépendances

: Le conteneur s'assure que les objets ont toutes les ressources dont ils ont besoin
pour fonctionner, en les leur fournissant de manière passive, à l'inverse d'une
recherche active par l'objet lui-même.

Exemple simple d'IoC (analogie du restaurant)

• Sans IoC (Cuisiner à la maison)

: Vous contrôlez tous les aspects, du choix des ingrédients à la préparation des plats.

• Avec IoC (Aller au restaurant)

: Vous déléguez l'ensemble du processus à un restaurant (le conteneur IoC), et vous
recevez simplement vos plats (les objets et leurs dépendances).

Avantages de l'IoC avec Spring

• Développement plus rapide

: Les développeurs peuvent se concentrer sur la logique métier plutôt que sur la
gestion des dépendances.

• Meilleure modularité
 P a g e | 35

: Le code est plus faiblement couplé, ce qui le rend plus facile à maintenir et à faire
évoluer.

• Conformité aux bonnes pratiques

: Favorise l'adoption des principes SOLID, notamment le principe d'injection des
dépendances (DIP).

2.1.2. Injection de dépendance(DI)

L'injection de dépendances (DI) dans Spring est un modèle de conception où des

classes reçoivent leurs dépendances (objets dont elles ont besoin) d'une source
externe, plutôt que de les créer elles-mêmes, favorisant ainsi un couplage faible. Dans
un exemple simple, si une classe Voiture a besoin d'un Moteur, Spring peut injecter
une instance de Moteur dans Voiture via un constructeur, un setter, ou un champ.
Le principe de l'Injection de Dépendances (DI)

• Dépendances :
Une classe a besoin d'une référence à une autre classe (ou une interface) pour
fonctionner.
• Injection :

Au lieu que la classe instancie directement sa dépendance avec new, un framework

comme Spring fournit l'instance de la dépendance à la classe.

• Avantages :
• Couplage faible : La classe n'est plus liée à l'implémentation concrète
de sa dépendance.

• Tests facilités : Il est possible d'injecter des objets mocks pour les tests
unitaires.

• Maintenabilité : Facilite les modifications et les remplacements de

dépendances.
Exemple avec l'injection par constructeur

1. Créez la dépendance (Interface et implémentation):

o [Link] (Interface) :
 P a g e | 36

1. Créez un fichier de configuration (ou utilisez les annotations):

o Si vous n'utilisez que des annotations @Component (comme dans
l'exemple ci-dessus), Spring peut automatiquement scanner ces
composants et créer les Beans.
 P a g e | 37

2. Lancez l'application:

o Dans votre classe principale ([Link]) :

Explication du fonctionnement

• Le conteneur Spring démarre et scanne votre projet à la recherche

d'annotations comme @Component.
• Il crée une instance de MoteurEssence car c'est une classe
annotée @Component.

• Lorsque le conteneur crée une instance de Voiture, il reconnaît que le

constructeur a besoin d'un objet de type Moteur.

• Il injecte l'instance de MoteurEssence dans le constructeur de Voiture.

• Ainsi, Voiture n'a pas besoin de créer elle-même son Moteur ; elle le reçoit tout
prêt.

2.2. Spring Boot

Spring Boot est un framework Java open source basé sur l'infrastructure Spring
Framework qui simplifie la création d'applications web et de microservices autonomes
et prêts pour le cloud. Il automatise la configuration, gère les dépendances et intègre
des serveurs web, rendant le développement plus rapide et plus simple que l'utilisation
de Spring Framework seul.

Pourquoi utiliser Spring Boot ?

• Développement accéléré
 P a g e | 38

Il réduit la configuration et la configuration XML, permettant de créer des applications

fonctionnelles plus rapidement.

• Applications autonomes
Vous pouvez construire des applications qui s'exécutent immédiatement avec un
serveur web intégré, sans avoir besoin de dépendances externes.

• Configuration automatique

Spring Boot configure automatiquement l'application en fonction des bibliothèques

présentes, simplifiant le processus.
• Microservices

Sa légèreté et sa capacité à créer des applications autonomes le rendent idéal pour

les architectures de microservices.

• Gestion simplifiée des dépendances

Il fournit un système de gestion des dépendances avancé pour intégrer et gérer
facilement les bibliothèques externes.

Fonctionnalités clés

• Configuration automatique
Les configurations sont déduites des dépendances ajoutées au projet.

• Annotations
Utilise des annotations comme @SpringBootApplication pour configurer et démarrer
l'application de manière concise.

• Serveur web intégré

Des serveurs comme Tomcat peuvent être intégrés directement dans l'application,
évitant le besoin d'un serveur externe.
• Projets prêts à l'emploi

Vous pouvez utiliser le service en ligne Spring Initializr pour générer un modèle de
projet avec les dépendances nécessaires.
2.2.1. Spring Initializr
Spring Initializr est un outil web qui permet de créer rapidement le squelette d'un projet
Spring Boot. Il génère la structure de base de l'application, sélectionne le langage
(Java, Kotlin, Groovy), l'outil de build (Maven ou Gradle), et permet d'ajouter des
dépendances sous forme de « starters » (des ensembles de bibliothèques) pour les
besoins de l'application, comme le web ou l'accès aux bases de données.
Comment ça marche ?
 P a g e | 39

1. Accéder à l'outil

Vous vous rendez sur l'interface web de Spring Initializr, généralement accessible
via [Link].
2. Configurer le projet

Vous spécifiez les détails de votre projet, tels que le langage, le type de projet (Maven
ou Gradle), la version de Spring Boot, et les métadonnées du projet (nom du groupe,
nom de l'artefact).

3. Ajouter des dépendances

Vous sélectionnez les bibliothèques nécessaires à votre application, comme « Spring
Web » pour une API REST ou « Spring Data JPA » pour les bases de données. Ces
bibliothèques sont regroupées en « starters », qui sont des dépendances uniques.

4. Générer le projet

Une fois configuré, l'outil génère un fichier ZIP contenant la structure du projet, les
fichiers de configuration ([Link] pour Maven, [Link] pour Gradle) et les
dépendances sélectionnées.
Avantages

• Gain de temps

Il automatise la configuration initiale du projet, vous évitant de le faire manuellement.

• Simplicité

Il fournit une interface conviviale pour configurer les éléments nécessaires à une
application.

• Flexibilité
Vous pouvez choisir parmi différentes options de langage, d'outils de build et de
dépendances.

• Intégration

De nombreux environnements de développement intégrés (IDE) intègrent Spring

Initializr pour une création de projet encore plus rapide.
2.2.2. Structure d’un projet Sprng boot
La structure d'un projet Spring Boot suit le modèle MVC, organisant le code en
couches (contrôleur, service, repository) et en paquets pour une bonne séparation des
responsabilités. Un projet commence via Spring Initializr, générant les fichiers
nécessaires, dont la classe d'application principale dans src/main/java et les
ressources dans src/main/resources.
Structure du Projet
 P a g e | 40

• src/main/java

: Contient le code source Java de l'application.

• [Link] : Le paquet principal de votre application.

• <NomApplication>[Link] : La classe principale avec la

méthode main() et l'annotation @SpringBootApplication.

• controller : Contient les classes des contrôleurs qui gèrent les

requêtes HTTP.
• service : Contient la logique métier de l'application.

• repository : Contient les classes qui interagissent avec la base de

données.

• model (ou entity) : Contient les classes qui modélisent les

données de l'application, souvent des entités JPA.
• src/main/resources
: Contient les fichiers de configuration et les ressources statiques de l'application.
• [Link] (ou [Link]) : Fichier de configuration
principal pour les propriétés de l'application, comme les connexions à la
base de données.
• [Link] (ou [Link])

: Le fichier de configuration du projet, listant les dépendances, notamment les starters

Spring Boot.

• src/test
: Contient les tests unitaires et d'intégration de l'application.

Comment créer un projet

1. Utiliser Spring Initializr

: Allez sur le site, sélectionnez le système de build (Maven ou Gradle), le langage

(Java), la version de Spring Boot, et ajoutez les dépendances nécessaires comme
"Spring Web".

2. Générer le projet
Remplissez les métadonnées du projet et cliquez sur "Generate". Téléchargez le
fichier ZIP.

3. Décompresser et ouvrir

: Décompressez le fichier et ouvrez le projet dans votre IDE (comme IntelliJ IDEA).
 P a g e | 41

Comment capturer des données dans Spring Boot

Pour récupérer des données d'une requête HTTP, vous pouvez utiliser des
annotations sur les méthodes de vos contrôleurs :
• @PathVariable : Capture des variables d'URL, par exemple /utilisateurs/{id}.

• @RequestParam : Capture des paramètres de requête, tels que ?page=2.

• @RequestBody : Mappe le corps de la requête HTTP (souvent JSON) dans un

objet Java.
2.2.3. Configuration automatique
La configuration automatique d'un projet Spring Boot consiste à activer le mécanisme
d'autoconfiguration via une annotation
comme @SpringBootApplication ou @EnableAutoConfiguration pour que Spring
Boot configure les composants de l'application de manière intelligente, en fonction des
bibliothèques et des dépendances présentes dans le projet. Cela simplifie
grandement le développement en fournissant des valeurs par défaut et des
configurations pour de nombreux scénarios courants, comme l'utilisation de bases de
données, de serveurs web ou de sécurité.

Comment cela fonctionne :

1. Analyse des dépendances :

Spring Boot examine le classpath et les dépendances de votre projet pour identifier
les bibliothèques installées (comme celles des "starters").

2. Conditions d'application :
Pour chaque dépendance détectée, Spring Boot vérifie si des conditions spécifiques
sont remplies en utilisant des annotations conditionnelles (par
exemple, @ConditionalOnClass, @ConditionalOnBean).

3. Configuration des beans :

Si les conditions sont réunies, Spring Boot configure automatiquement les beans et
les composants Spring nécessaires, comme un DataSource pour une base de
données ou un serveur web embarqué (Tomcat par défaut).
Comment activer l'autoconfiguration :

• Utilisez l'annotation `@SpringBootApplication

C'est l'annotation recommandée, car elle englobe @EnableAutoConfiguration,

l'analyse des composants et la configuration de base. Ajoutez-la à votre classe
principale de l'application.
• Utilisez l'annotation @EnableAutoConfiguration
 P a g e | 42

Si vous préférez, vous pouvez utiliser cette annotation directement sur une de vos
classes @Configuration pour activer spécifiquement la configuration automatique.

Avantages de l'autoconfiguration :
• Développement accéléré :

Vous n'avez pas à configurer manuellement de nombreux cas d'utilisation courants.

• Réduction des erreurs :

Elle prévient les erreurs humaines en appliquant des configurations sensées par
défaut.

• Simplification des dépendances :

Les "starter projects" regroupent les dépendances courantes, simplifiant encore plus
la configuration.
• Flexibilité :
Vous pouvez facilement personnaliser ces configurations automatiques si nécessaire,
en utilisant des fichiers de propriétés ([Link] ou [Link]) ou
des variables d'environnement.

2.2.4. Fichiers [Link] ou [Link]

Dans une application Spring Boot, les
fichiers [Link] et [Link] sont utilisés pour la configuration
externe, mais [Link] est préférable pour les configurations complexes en
raison de sa lisibilité et de sa structure hiérarchique. Ces fichiers se placent dans le
dossier src/main/resources et sont chargés automatiquement, permettant d'injecter
les propriétés dans le code Java via l'annotation @Value.

Contexte
Les fichiers [Link] et [Link] servent à définir des paramètres
pour votre application Spring Boot. Le cadre Spring Boot charge automatiquement ces
fichiers à partir du répertoire src/main/resources.
Différences entre [Link] et [Link]

• [Link]
Un format simple de paires clé-valeur, idéal pour des configurations courtes et
simples.

• [Link]

Un format basé sur l'indentation (YAML) qui est plus lisible et structuré,
particulièrement adapté aux configurations complexes avec des propriétés
imbriquées.
 P a g e | 43

Exemples de configuration

[Link]

2.2.3. Entité
Pour créer une entité Java en utilisant JPA (Java Persistence API), vous créez une
classe Java classique, y ajoutez l'annotation @Entity au niveau de la classe pour
indiquer qu'elle représente une table de base de données, puis vous définissez les
champs de la classe qui correspondent aux colonnes de la table, en utilisant @Id pour
 P a g e | 44

la clé primaire et @Column pour les autres champs. Des constructeurs, des getters et
des setters sont également requis pour la classe d'entité.

1. Créer une nouvelle classe Java

• Créez une nouvelle classe Java (par exemple, [Link]) dans votre
projet. Cette classe sera votre entité.

2. Ajouter l'annotation @Entity

• Ajoutez l'annotation @Entity (depuis [Link] ou [Link])
au-dessus de la déclaration de la classe pour indiquer qu'il s'agit d'une entité
JPA.

3. Définir un constructeur vide

• Chaque classe d'entité doit posséder un constructeur vide, public ou

protected. Il est souvent généré automatiquement par l'IDE.
 P a g e | 45

4. Définir la clé primaire (@Id)

• Déclarez un champ pour la clé primaire (par exemple, id) et anotez-le

avec @Id pour indiquer qu'il s'agit de la clé primaire de l'entité.
• Vous pouvez utiliser @GeneratedValue avec [Link] pour
une clé auto-incrémentée en base de données.

5. Définir les autres champs et colonne (@Column)

• Ajoutez d'autres variables membres pour représenter les colonnes de la table

(par exemple, nom, description).
• Utilisez l'annotation @Column pour spécifier le nom de la colonne dans la table
si celui-ci diffère du nom du champ, ou pour définir d'autres propriétés de la
colonne.
 P a g e | 46

6. Ajouter les Getters et Setters

• Pour chaque champ, générez des méthodes getter et setter.
 P a g e | 47

2.2.4. Repository
Pour créer un « repository » en Java, notamment avec le framework Spring Data
JPA, vous devez créer une interface Java qui étend une interface de Spring Data
comme JpaRepository ou CrudRepository. Cette interface définit les opérations de
base de données (CRUD), et Spring s'occupe de l'implémentation, vous offrant des
méthodes pour interagir avec votre base de données sans écrire de code d'accès aux
données manuel. Vous pouvez ensuite utiliser l'annotation @Repository sur des
classes spécifiques si vous avez besoin d'une logique personnalisée, ou vous fier à
l'implémentation automatique de Spring.
Voici les étapes détaillées pour créer un repository en utilisant Spring Data JPA :
1. Créez une classe d'entité
 P a g e | 48

Cette classe représente votre objet de données (par exemple, Produit) et est
généralement annotée avec @Entity pour indiquer qu'elle est mappée à une table de
base de données.

2. Créez une interface de repository

• Définissez une interface (par exemple, ProduitRepository) dans votre
projet.

• Faites-lui étendre une interface de Spring Data, comme JpaRepository.

• Passez l'entité (Produit) et le type de son identifiant (Long, par exemple)

en tant qu'arguments génériques à l'interface JpaRepository, comme
suit :
Java

public interface ProduitRepository extends JpaRepository<Produit, Long> {}

1. Injectez et utilisez votre repository :

o Une fois l'interface définie, Spring Data JPA la fournit avec une
implémentation et un bean Spring.

o Vous pouvez injecter ce repository dans vos services ou contrôleurs

pour effectuer des opérations sur la base de données.

Pourquoi utiliser Spring Data JPA ?

• Génération automatique des méthodes

: Spring Data JPA fournit automatiquement des méthodes pour les opérations CRUD
(Create, Read, Update, Delete).

• Réduction du code boilerplate

: Vous n'avez pas besoin d'écrire l'implémentation de ces méthodes, ce qui réduit la
quantité de code répétitif.

• Personnalisation facile

: Vous pouvez ajouter des méthodes personnalisées à votre interface de repository

pour des requêtes spécifiques, et Spring peut générer l'implémentation pour vous, ou
vous pouvez la fournir manuellement.
En résumé, la création d'un repository en Java avec Spring Data est simplifiée par
l'utilisation d'interfaces qui étendent les interfaces de Spring, ce qui vous permet de
vous concentrer sur la logique métier de haut niveau.

2.2.5. Contrôleur

Pour créer un contrôleur dans Java avec Spring, créez une classe Java et ajoutez-y
l'annotation @Controller ou @RestController. Utilisez ensuite
 P a g e | 49

l'annotation @RequestMapping sur les méthodes pour ** mapper les URL spécifiques
aux méthodes** qui traiteront les requêtes HTTP. L'annotation @Controller est utilisée
pour les applications MVC où le contrôleur renvoie des vues (fichiers HTML), tandis
que @RestController est utilisée pour créer des API REST qui renvoient directement
des données (souvent au format JSON).

Étapes pour créer un contrôleur Spring Boot

1. Créez un projet Spring Boot

:

• Allez sur le site Spring Initializr et configurez votre projet avec les
dépendances nécessaires, comme "Spring Web".
• Téléchargez et importez le projet dans votre IDE (comme IntelliJ IDEA
ou Eclipse).

2. Créez une classe de contrôleur

:
• Dans le dossier src/main/java, créez un nouveau package, par
exemple [Link].

• Ajoutez-y une nouvelle classe Java, par exemple MonController.

3. Ajoutez l'annotation de contrôleur

:

• Ajoutez l'annotation @Controller pour un contrôleur MVC

ou @RestController pour une API REST au-dessus de la déclaration de
classe.
 P a g e | 50

1. Définissez des méthodes de gestion de requêtes :

o Ajoutez des méthodes publiques dans la classe du contrôleur.

o Utilisez
l'annotation @RequestMapping, @GetMapping, @PostMapping, etc.,
pour spécifier le chemin de l'URL et la méthode HTTP que la méthode
doit gérer.
 P a g e | 51

1. Exécutez et testez :

o Exécutez votre application Spring Boot.

o Accédez aux URL définies (par
exemple, [Link] ou [Link]
dans votre navigateur ou avec un outil comme Postman.

2.2.5. DTO
Pour créer un DTO (Data Transfer Object) en Java avec Spring Boot, vous définissez
une classe (ou un Java Record) qui contient uniquement les champs nécessaires à
l'exportation des données, puis vous mappez vos objets d'entité vers ce DTO, souvent
à l'aide d'une bibliothèque comme MapStruct ou manuellement via la couche
service. Ce processus permet de contrôler les données exposées, d'améliorer la
sécurité, et de découpler les couches de l'application pour plus de maintenabilité et
de flexibilité.
Voici les étapes pour créer et utiliser des DTOs en Spring Boot :

1. Créer la classe DTO

• Définir le DTO : Créez une classe simple qui représente les données que vous
souhaitez transférer. Elle peut être une classe Java classique avec des getters
et des setters, ou, de manière plus moderne, un Java Record pour une
concision accrue.
• Exemple de classe DTO :

2.3. Création projet avec VS CODE

Pour créer un projet Java Spring avec Visual Studio Code, installez le JDK, l'Extension
Pack for Java et le Spring Boot Extension Pack dans VS Code. Ensuite, ouvrez la
palette de commandes (Ctrl+Maj+P), tapez Spring Initializr et suivez l'assistant pour
configurer et générer votre projet Spring Boot, en spécifiant les détails du projet, les
dépendances comme Spring Web, et la localisation. Enfin, ouvrez le projet généré
dans VS Code.

Étapes détaillées :

1. Vérifier ou installer le JDK

 P a g e | 52

• Assurez-vous que le Java Development Kit (JDK) est installé sur votre
système. Vous pouvez vérifier avec la commande java -version dans
votre terminal.

2. Installer les extensions dans VS Code

• Ouvrez VS Code et accédez à la vue des extensions (Ctrl+Maj+X).

• Recherchez et installez :

• Extension Pack for Java

• Spring Boot Extension Pack (Ce pack inclut les outils nécessaires
comme Spring Initializr et Spring Boot Dashboard).

3. Générer le projet via Spring Initializr

• Ouvrez la palette de commandes dans VS Code en appuyant

sur Ctrl+Maj+P.
• Saisissez Spring Initializr dans la barre de recherche et sélectionnez
l'option pour générer un projet.

• Suivez l'assistant pour configurer votre projet :

• Choisissez le type de projet (Maven ou Gradle).

• Sélectionnez la version de Spring Boot.

• Entrez les métadonnées de votre projet, comme le groupe

(Group), l'artefact (Artifact) et le nom.
• Choisissez les dépendances nécessaires, par exemple Spring
Web pour créer des API web.
• Sélectionnez le dossier où le projet sera généré.

4. Ouvrir le projet dans VS Code

• Une fois le projet généré, ouvrez le dossier de votre projet dans VS
Code.

5. Lancer l'application
• Vous pouvez maintenant commencer à développer votre application
Spring Boot. Pour exécuter l'application, utilisez l'icône ou la commande
appropriée, souvent le tableau de bord Spring Boot ou une option « Run
Java » dans VS Code.
 P a g e | 53

2.6. Cas Pratique avec une application Spring Boot

1. Interface D’accuel

2. Liste des clients

3. Formulaire d’ajout des clients

 P a g e | 54

3. Formulaire de modification d’un client

 P a g e | 55

4. Code Sources

• Entité Client
• package [Link];
• import [Link];
• import [Link].*;
• import lombok.*;
•

• @Entity
• @Table(name = "clients")
• @Getter
• @Setter
• @ToString
• public class Client {
•
• @Id @GeneratedValue(strategy = [Link])
• private int id;
•
• private String firstName;
• private String lastName;
•
• @Column(nullable = false, unique = true)
• private String email;
•
• private String phone;
•
• private String adresse;
• private String status;
• private Date createdAt;
•
• }
•
 P a g e | 56

• Client DTO
• package [Link];
•
• import [Link].*;
• import [Link];
• import [Link];
•
• @Getter
• @Setter
• public class ClientDto {
•
• @NotEmpty(message = "The First Nme is required")
• private String firstName;
•
• @NotEmpty(message ="The last name is required")
• private String lastName;
•
• @NotEmpty(message ="The email name is required")
• @Email
• private String email;
•
• private String phone;
• private String adresse;
•
• @NotEmpty(message ="The last name is required")
• private String status;
•
• }
•

• Client Repository
• package [Link];
•
• import [Link];
•
• import [Link];
•

• public interface ClientRepository extends JpaRepository<Client,Integer> {

•
• public Client findByEmail(String email);
• }
•

• Client Contrôleur
 P a g e | 57

• package [Link];
•
• import [Link];
•
• import [Link];
• import [Link];
• import [Link];
• import [Link];
• import [Link];
• import [Link];
• import [Link];
•
• import [Link];
• import [Link];
• import [Link];
•
• import [Link];
•
• import [Link].*;
•

• @Controller
• @RequestMapping("/clients")
• public class ClientController {
•
• @Autowired
• private ClientRepository clientRepository;
•
• @GetMapping({"","/"})
• public String getClients(Model model) {
• var clients =[Link]([Link]([Link],"id"));
• [Link]("clients", clients);
• return "clients/index";
• }
•
• @GetMapping("/create")
• public String createClient(Model model){
• ClientDto clientDto = new ClientDto();
•
• [Link]("clientDto", clientDto);
•
• return "clients/create";
• }
•
• @PostMapping("/create")
• public String createClient(
• @Valid @ModelAttribute ClientDto clientDto,
 P a g e | 58

• BindingResult result
• ){
•
• if([Link]([Link]()) != null){
• [Link](new FieldError("clientDto","email",
[Link](),
• false, null,null, "Email adresse is already used")
• );
• }
•
• if([Link]()){
• return "clients/create";
• }
•
• Client client = new Client();
•
• [Link]([Link]());
• [Link]([Link]());
• [Link]([Link]());
• [Link]([Link]());
• [Link]([Link]());
• [Link]([Link]());
• [Link](new Date());
•
• [Link](client);
•
• return "redirect:/clients";
• }
•
• @GetMapping("/edit")
• public String editClient(Model model,@RequestParam int id){
• Client client = [Link](id).orElse(null);
•
• if(client == null) {
• return "redirect:/clients";
• }
•
• ClientDto clientDto = new ClientDto();
•
• [Link]([Link]());
• [Link]([Link]());
• [Link]([Link]());
• [Link]([Link]());
• [Link]([Link]());
• [Link]([Link]());
•
• [Link]("client", client);
 P a g e | 59

• [Link]("clientDto", clientDto);
•
• return "clients/edit";
•
• }
•
• @PostMapping("/edit")
• public String editClient(
• Model model,
• @RequestParam int id,
• @Valid @ModelAttribute ClientDto clientDto,
• BindingResult result
• ){
•
• Client client = [Link](id).orElse(null);
•
• if(client == null) {
• return "redirect:/clients";
• }
•
• [Link]("client", client);
•
• if([Link]()){
• return "clients/create";
• }
•
• //update
•
• [Link]([Link]());
• [Link]([Link]());
• [Link]([Link]());
• [Link]([Link]());
• [Link]([Link]());
• [Link]([Link]());
•
• try{
• [Link](client);
•
• }catch(Exception e){
•
• [Link](
• new FieldError("clientDto","email", [Link]()
• ,false,null,null,"Email Adresse is already used")
• );
•
• return "client/edit";
•
 P a g e | 60

• }
• return "redirect:/clients";
• }
•
• @GetMapping("/delete")
• public String deleteClient(@RequestParam int id){
• Client client = [Link](id).orElse(null);
•
• if(client != null) {
• [Link](client);
• }
•
• return "redirect:/clients";
• }
•
• }
•

• Home Contrôleur
• package [Link];
•
• import [Link];
• import [Link];
•
• @Controller
• public class HomeController {
•
• @GetMapping("/")
• public String home() {
• return "home/index"; // Renvoie le nom de la vue ([Link])
• }
•
• }
•

• Formulaire de création client

• <!doctype html>
• <html lang="en">
• <head>
• <meta charset="utf-8">
• <meta name="viewport" content="width=device-width, initial-scale=1">
• <title>Client Manager</title>
• <link rel="stylesheet" th:href="@{/bootstrap/css/[Link]}">
• </head>
• <body>
•
 P a g e | 61

• <div class="container my-4">

•
• <div class="col-md-8 mx-auto rounded border p-4">
• <h2 class="text-center mb-5">New client</h2>
•
•
• <form method="post" th:object="${clientDto}">
•
• <div class="row mb-3">
• <label class="col-sm-4 col-form-label">First Name</label>
• <div class="col-sm-8">
• <input class="form-control" th:field="${[Link]}"/>
• <p th:if="${#[Link]('firstName')}"
• th:errorclass="text-danger"
• th:errors="${[Link]}"></p>
• </div>
• </div>
•
• <div class="row mb-3">
• <label class="col-sm-4 col-form-label">Last Name</label>
• <div class="col-sm-8">
• <input class="form-control" th:field="${[Link]}"/>
• <p th:if="${#[Link]('lastName')}"
• th:errorclass="text-danger"
• th:errors="${[Link]}"></p>
• </div>
• </div>
•
• <div class="row mb-3">
• <label class="col-sm-4 col-form-label">Email</label>
• <div class="col-sm-8">
• <input class="form-control" th:field="${[Link]}"/>
• <p th:if="${#[Link]('email')}"
• th:errorclass="text-danger"
• th:errors="${[Link]}"></p>
• </div>
• </div>
•
• <div class="row mb-3">
• <label class="col-sm-4 col-form-label">Phone Number</label>
• <div class="col-sm-8">
• <input class="form-control" th:field="${[Link]}"/>
• <p th:if="${#[Link]('phone')}"
• th:errorclass="text-danger"
• th:errors="${[Link]}"></p>
•
• </div>
 P a g e | 62

• </div>
•
• <div class="row mb-3">
• <label class="col-sm-4 col-form-label">Adresse</label>
• <div class="col-sm-8">
• <input class="form-control" th:field="${[Link]}"/>
• <p th:if="${#[Link]('adresse')}"
• th:errorclass="text-danger"
• th:errors="${[Link]}"></p>
•
• </div>
• </div>
•
• <div class="row mb-3">
• <label class="col-sm-4 col-form-label">Status</label>
• <div class="col-sm-8">
• <select class="form-control" th:field="${[Link]}">
•
• <option value='New'>New</option>
• <option value='Permanent'>Permanent</option>
• <option value='Lead'>Lead</option>
• <option value='Occasional'>Occasional</option>
•
• <option value='nactiv'>Inactive</option>
• </select>
•
• <p th:if="${#[Link]('status')}"
• th:errorclass="text-danger"
• th:errors="${[Link] }"></p>
• </div>
• </div>
•
• <div class="row">
• <div class="offset-sm-4 col-sm-4 d-grid">
• <button type="submit" class="btn btn-primary">Save</button>
• </div>
•
• <div class="col-sm-4 d-grid">
• <a class="btn btn-outline-primary"
href="/clients">Cancel</button>
• </div>
•
• </div>
•
• </form>
•
• </div>
 P a g e | 63

•
• </div>
•
• <script rel="stylesheet"
th:src="@{/bootstrap/js/[Link]}"></script>
• </body>
• </html>
 P a g e | 64

• Formulaire de modification Client

<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Client Manager</title>
<link rel="stylesheet" th:href="@{/bootstrap/css/[Link]}">
</head>
<body>

<div class="container my-4">

<div class="col-md-8 mx-auto rounded border p-4">
<h2 class="text-center mb-5">Edit client</h2>

<form method="post" th:object="${clientDto}">

<div class="row mb-3">

<label class="col-sm-4 col-form-label">Client ID</label>
<div class="col-sm-8">
<input class="form-control-plaintext" readonly
th:value="${[Link]}"/>
</div>
</div>

<div class="row mb-3">

<label class="col-sm-4 col-form-label">First Name</label>
<div class="col-sm-8">
<input class="form-control" th:field="${[Link]}"/>
<p th:if="${#[Link]('firstName')}"
th:errorclass="text-danger"
th:errors="${[Link]}"></p>
</div>
</div>

<div class="row mb-3">

<label class="col-sm-4 col-form-label">Last Name</label>
<div class="col-sm-8">
<input class="form-control" th:field="${[Link]}"/>
<p th:if="${#[Link]('lastName')}"
th:errorclass="text-danger"
th:errors="${[Link]}"></p>
 P a g e | 65

</div>
</div>

<div class="row mb-3">

<label class="col-sm-4 col-form-label">Email</label>
<div class="col-sm-8">
<input class="form-control" th:field="${[Link]}"/>
<p th:if="${#[Link]('email')}"
th:errorclass="text-danger"
th:errors="${[Link]}"></p>
</div>
</div>

<div class="row mb-3">

<label class="col-sm-4 col-form-label">Phone Number</label>
<div class="col-sm-8">
<input class="form-control" th:field="${[Link]}"/>
<p th:if="${#[Link]('phone')}"
th:errorclass="text-danger"
th:errors="${[Link]}"></p>
</div>
</div>

<div class="row mb-3">

<label class="col-sm-4 col-form-label">Adresse</label>
<div class="col-sm-8">
<input class="form-control" th:field="${[Link]}"/>
<p th:if="${#[Link]('adresse')}"
th:errorclass="text-danger"
th:errors="${[Link]}"></p>
</div>
</div>

<div class="row mb-3">

<label class="col-sm-4 col-form-label">Adresse</label>
<div class="col-sm-8">
<select class="form-control" th:field="${[Link]}">

<option value='New'>New</option>
<option value='Permanent'>Permanent</option>
<option value='Lead'>Lead</option>
<option value='Occasional'>Occasional</option>
 P a g e | 66

<option value='nactiv'>Inactive</option>
</select>
<p th:if="${#[Link]('status')}"
th:errorclass="text-danger"
th:errors="${[Link] }"></p>
</div>
</div>
<div class="row mb-3">
<label class="col-sm-4 col-form-label">Created at</label>
<div class="col-sm-8">
<input class="form-control-plaintext" readonly
th:value="${[Link]}"/>
</div>
</div>
<div class="row">
<div class="offset-sm-4 col-sm-4 d-grid">
<button type="submit" class="btn btn-primary">Save</button>
</div>
<div class="col-sm-4 d-grid">
<a class="btn btn-ouline-primary" href="/clients">Cancel</button>
</div>
</div>
</form>
</div>
</div>
<script rel="stylesheet"
th:src="@{/bootstrap/js/[Link]}"></script>
</body>
</html>
 P a g e | 67

• Tableau Client
• <!doctype html>
• <html lang="en" xmlns:th="[Link]
• <head>
• <meta charset="utf-8">
• <meta name="viewport" content="width=device-width, initial-scale=1">
• <title>Client Manager</title>
• <link rel="stylesheet" th:href="@{/bootstrap/css/[Link]}">
• </head>
• <body>
•
• <div class="container my-3">
• <h1 class="text-center mb-3">Liste des clients</h1>
• <a class="btn btn-primary" href="/clients/create">Nouveau Client</a>
•
• <table class="table">
• <thead>
• <tr>
• <th>ID</th>
• <th>Name</th>
• <th>Email</th>
• <th>Phone</th>
• <th>Adresse</th>
• <th>Status</th>
• <th>Created At</th>
• <th>Actions</th>
• </tr>
• </thead>
• <tbody class="table-group-divider">
• <tr th:each="client: ${clients}">
• <td th:text="${[Link]}"></td>
• <td th:text="${[Link]} +' '+ ${[Link]}"></td>
• <td th:text="${[Link]}"></td>
• <td th:text="${[Link]}"></td>
• <td th:text="${[Link]}"></td>
• <td th:text="${[Link]}"></td>
• <td th:text="${[Link]().substring(0,10)}"></td>
• <td style="white-space:nowrap">
• <a class="btn btn-primary btn-sm"
th:href="@{/clients/edit(id=${[Link]})}">
• Edit
• </a>
•
• <a class="btn btn-danger btn-sm"
th:href="@{/clients/delete(id=${[Link]})}"
• onclick ="return confirm('are you sure?')">
• Delete
 P a g e | 68

• </a>
•
• </td>
•
• </tr>
• </tbody>
• </table>
•
• </div>
•

• <script rel="stylesheet"
th:src="@{/bootstrap/js/[Link]}"></script>
• </body>
• </html>

• Connexion à la base de données

[Link]=jdbc:mysql://localhost:3306/db6
[Link]=root
[Link]=
[Link]-class-name=[Link]
[Link]-platform=[Link].MySQL8Dialect
[Link]-auto=update
[Link]-sql= true
 P a g e | 69

Table des matières

Objectif Général ............................................................................................................. 1
Objectifs Spécifiques ....................................................................................................... 1
MODULE 1 : Fondamentaux de java ............................................................................. 2
I.1. Introduction à java ..................................................................................................... 2
1.1.1. INSTALLATION JDK ET IDE VS CODE .......................................................... 3
1. Installer les Outils Essentiels .............................................................................. 3
2. Configuration et Utilisation .................................................................................. 4
3. Différence avec les IDE Dédiés .......................................................................... 4
1.1.2. Structure d’un programme java ........................................................................ 5
1.1.3. Types de données, variables, opérateurs .................................................... 6
1.2. Contrôle de flux..................................................................................................... 7
1.2.1. Conditions(If,switch) ...................................................................................... 7
1.2.2. Boucles (for,while,do-while) ...................................................................... 8
1.3. Programmation orientée objet (POO).............................................................11
1.3.1. Classes et objets ........................................................................................11
1.3.1. Encapsulation ...............................................................................................13
1.2.2. Héritage, polymorphisme .............................................................................17
1.2.3. Interface et abstraction .................................................................................20
1.4. Concepts avancés .............................................................................................23
1.4.1. Exceptions & gestion des erreurs ...........................................................23
1.4.2. Collections (List,Set,Map) .........................................................................25
1.4.3. Generics .......................................................................................................28
1.4.4. Input/Ouput (Fichier) ..................................................................................30
Module 2 : Introduction à Spring ...............................................................................33
2.1. Qu’est-ce que Spring ........................................................................................33
2.1.1. Inversion de contrôle (loC) .......................................................................34
2.2. Spring Boot ........................................................................................................37
2.2.1. Spring Initializr ............................................................................................38
2.2.2. Structure d’un projet Sprng boot .............................................................39
2.2.3. Configuration automatique .......................................................................41
2.2.4. Fichiers [Link] ou [Link] ..............................42
 P a g e | 70

2.2.3. Entité.............................................................................................................43
2.2.4. Repository ..................................................................................................47
2.2.5. DTO ...............................................................................................................51
2.3. Création projet avec VS CODE ........................................................................51
2.6. Cas Pratique avec une application Spring Boot .........................................53