■ FICHE DE RÉVISION

Langage & Architecture Java

Jakarta EE • JPA • REST • POO • Collections

M1IA – FPC | 2025-2026

■■ Architectures 1-tier / n-tiers ■ Java & JVM Bytecode & JIT ■■ JPA / ORM Entités & Requêtes

■ Jakarta REST Annotations &

déploiement ■ Maven GAV & Cycle de vie ■ POO Héritage & Polymorphisme
 ■ SOMMAIRE
1. Architectures logicielles
■ 1.1 Niveaux d'abstraction (Contexte → Code)
■ 1.2 Architecture 1-tier, 2-tiers, n-tiers
■ 1.3 Architectures applicative, logique et physique

2. Java – Le langage et la plateforme

■ 2.1 JVM, JRE, JDK
■ 2.2 Bytecode, JIT et évolution des versions
■ 2.3 JSE / JME / JEE / Jakarta EE

3. Les bases du langage Java

■ 3.1 Structure d'une classe
■ 3.2 Types primitifs et objets (Stack / Heap)
■ 3.3 Opérateurs et structures de contrôle
■ 3.4 Tableaux, attributs et méthodes
■ 3.5 Cycle de vie d'un objet

4. Programmation Orientée Objet (POO)

■ 4.1 Encapsulation
■ 4.2 Héritage et composition
■ 4.3 Polymorphisme (statique & dynamique)
■ 4.4 Constructeurs et surcharge
■ 4.5 Interfaces

5. Fonctionnalités avancées du langage

■ 5.1 Exceptions (hiérarchie, try-catch-finally)
■ 5.2 Énumérations
■ 5.3 Collections (List, Set, Queue, Map)
■ 5.4 Dates ([Link])

6. Jakarta EE & Outils

■ 6.1 Maven (POM, GAV, cycle de vie)
■ 6.2 Serveurs d'application (WildFly, GlassFish…)

7. Jakarta Persistence (JPA)

■ 7.1 Entités JPA et annotations
■ 7.2 Identifiants simples et composés
■ 7.3 Héritage JPA (Single Table, Joined…)
■ 7.4 EntityManager et cycle de vie
■ 7.5 Associations (1:1, 1:N, N:1, M:N)

8. Jakarta RESTful Web Services

■ 8.1 Concepts REST et annotations
■ 8.2 Configuration et déploiement (WAR / JAR)

9. Révision finale
■ 9.1 Résumé des points clés
■ 9.2 QCM d'entraînement (20 questions)
 1. ARCHITECTURES LOGICIELLES
1.1 Les niveaux d'abstraction
Un logiciel peut être décrit à différents niveaux de détail. On part d'une vue très globale vers une vue très
technique. Voici les 4 niveaux :

Niveau Nom Ce qu'on voit Objectif

1 Contexte (Vue système) Le système dans son Comprendre ce que fait

environnement, acteurs le système
externes

2 Conteneurs Applications, services, Décrire les grandes

bases de données briques techniques

3 Composants Modules internes d'un Comprendre la structure

conteneur interne

4 Code Classes, méthodes, Décrire l'implémentation

attributs précise

Imaginez une ville : niveau 1 = vue satellite, niveau 2 = les bâtiments, niv
meubles dans chaque pièce.

1.2 Évolution des architectures physiques

Architecture 1-tier
Toutes les couches (présentation, traitement, données) sont sur la même machine. C'est l'informatique
centralisée.

Couplage fort : si on change la présentation, on risque de casser le métie

Architecture 2-tiers (client-serveur)

Le client gère la présentation ET le traitement métier. Un serveur séparé gère uniquement les données.

Toujours un manque de séparation. Rigide et difficile à faire évoluer.

Architecture n-tiers
La logique métier est découpée en composants spécialisés indépendants, pouvant tourner sur des
machines distinctes. On peut ajouter autant de niveaux que nécessaire.

Distribution libre de la logique applicative. Facilite la répartition de charge

modèle utilisé par Jakarta EE.

1.3 Architectures applicative, logique et physique

Type Définition Niveau

Applicative Structure le SI en blocs applicatifs Macro

communicants. Décrit les
applications, flux et messages.

Logique Décrit la répartition des tâches au Moyen

sein d'une application (couches :
présentation, métier, données).

Physique Décrit les composants matériels : Micro

serveurs, postes, réseau, stockage.
 2. JAVA – LE LANGAGE ET LA PLATEFORME
2.1 JVM, JRE, JDK
Java résout le problème de portabilité grâce à la Java Virtual Machine (JVM). Voici la hiérarchie :

Composant Contenu Rôle

JVM Machine virtuelle Interprète le bytecode. Abstrait

l'OS. Gère la mémoire (Garbage
Collector).

JRE JVM + APIs Java Environnement d'exécution pour

lancer des programmes Java.

JDK JRE + compilateur (javac) + outils Kit complet pour développer ET

exécuter des programmes Java.

"Write Once, Run Everywhere" : on compile une seule fois en bytecode (

d'exploitation l'exécute.

2.2 Bytecode, JIT et compilation

Contrairement au C/C++ qui produit un binaire dépendant de l'OS, Java produit du bytecode, un format
intermédiaire universel.

Étape Commande Résultat

Compilation javac [Link] Produit [Link]

(bytecode)

Exécution java HelloWorld La JVM interprète le bytecode

Le JIT (Just-In-Time compiler) améliore les performances en compilant dynamiquement les portions de
bytecode fréquemment utilisées en code machine natif.

2.3 JSE / JME / JEE / Jakarta EE

Plateforme Cible Description

Java SE Applications Desktop La base : types, collections, I/O,

concurrence…

Java ME Mobile / embarqué Sous-ensemble de Java SE adapté

aux petits appareils

Java EE / Jakarta EE Entreprise / Web Ajoute JPA, Servlets, EJB,

JAX-RS, CDI… pour apps
distribuées

Java Card Cartes à puce / SIM Version ultra-allégée de Java

Java EE a été cédé par Oracle à la Eclipse Foundation en 2017. Le nom

javax.* est devenu jakarta.*). Jakarta EE 10 est la version actuelle.
 3. LES BASES DU LANGAGE JAVA
3.1 Structure d'une classe
En Java, tout le code est organisé en classes. Une classe est déclarée dans un fichier portant
exactement le même nom avec l'extension .java.

public class Voiture {

// Constantes
public static final int VITESSE_MAX = 250;

// Attributs (état interne)

private double vitesse;
private String marque;

// Constructeur
public Voiture(String marque) {
[Link] = marque;
[Link] = 0;
}

// Méthode
public double getVitesse() {
return vitesse;
}

// Point d'entrée du programme

public static void main(String[] args) {
Voiture v = new Voiture("Toyota"); // mot-clé new
[Link]([Link]()); // affiche 0.0
}
}

Élément Description

Attribut Variable stockant l'état d'un objet (ex: vitesse, marque)

Méthode Fonction définissant le comportement d'un objet

Constructeur Méthode spéciale (même nom que la classe, sans

return) appelée à la création

main() Point d'entrée du programme, signature obligatoire :

public static void main(String[] args)

new Mot-clé pour créer une instance (objet) d'une classe

3.2 Types primitifs et types objets

Java est un langage fortement typé. Il distingue deux catégories de types :

Type primitif Taille Valeur par défaut Classe Wrapper

byte 8 bits 0 Byte

 Type primitif Taille Valeur par défaut Classe Wrapper

short 16 bits 0 Short

int 32 bits 0 Integer

long 64 bits 0L Long

float 32 bits 0.0f Float

double 64 bits 0.0d Double

char 16 bits '\u0000' Character

boolean 1 bit false Boolean

Autoboxing : Java convertit automatiquement un primitif en objet wrapper (int → Integer) et inversement
(unboxing).

int x = 5;
Integer obj = x; // autoboxing : int -> Integer
int y = obj; // unboxing : Integer -> int

Stack (pile) : stocke les variables locales et références. Rapide, géré aut
objets créés avec new. Plus grand, géré par le Garbage Collector. Un ob
supprimé par le GC.

3.3 Opérateurs
Catégorie Opérateurs Exemple

Affectation = int a = 5;

Arithmétiques +-*/% int r = 10 % 3; // r = 1

Unaires ++ -- - a++; // équivalent à a = a+1

Relationnels == != < > <= >= if (a > 0) { ... }

Logiques && || ! if (a>0 && b>0) { ... }

Concaténation + "Bonjour " + nom

Ternaire cond ? val1 : val2 String s = (x>0)?"pos":"neg";

Ne pas confondre == (comparaison de valeur/référence) et .equals() (com

utilisez TOUJOURS .equals() : "hello".equals(s)

3.4 Structures de contrôle

 // --- if / else if / else ---
if (note >= 16) {
[Link]("Très bien");
} else if (note >= 12) {
[Link]("Bien");
} else {
[Link]("Insuffisant");
}

// --- switch ---

switch (jour) {
case "Lundi": [Link]("Début de semaine"); break;
case "Vendredi": [Link]("TGIF"); break;
default: [Link]("Jour normal");
}

// --- for classique ---

for (int i = 0; i < 5; i++) {
[Link](i);
}

// --- while ---

while (compteur > 0) { compteur--; }

// --- do-while (exécuté au moins une fois) ---

do { lireSaisie(); } while (!saisieValide);

3.5 Tableaux, attributs et méthodes

// Déclaration + création
int[] notes = new int[5];

// Initialisation directe
String[] fruits = {"pomme", "banane", "mangue"};

// Accès et modification
fruits[0] = "orange";
[Link]([Link]); // 3

// Parcours avec for-each

for (String f : fruits) {
[Link](f);
}

Portée des attributs : public = visible partout ; private = visible uniquement dans la classe. Un attribut
final ne peut être initialisé qu'une seule fois.

Signature d'une méthode : [portée] [type_retour] nomMéthode(paramètres). Si la méthode ne retourne

rien, on utilise void. Un paramètre final ne peut pas être réaffecté.
 4. PROGRAMMATION ORIENTÉE OBJET (POO)
4.1 Encapsulation
Définition : L'encapsulation consiste à cacher les données internes d'un objet et à ne les exposer qu'au
travers de méthodes contrôlées.

Mise en œuvre en 2 étapes :

• ① Déclarer les attributs private
• ② Fournir des getters (lecture) et setters (écriture avec validation)

public class CompteBancaire {

private double solde; // inaccessible directement depuis l'extérieur

public double getSolde() { // getter

return solde;
}

public void setSolde(double s) { // setter avec validation

if (s >= 0) {
[Link] = s;
} else {
[Link]("Solde invalide !");
}
}
}

• Intégrité des données (on ne peut pas mettre un solde négatif par erreu
interne sans modifier l'interface publique. • Découplage : chaque classe e
données.

4.2 Héritage et Composition

L'héritage permet à une classe fille d'hériter des attributs et méthodes d'une classe mère. Relation "est
un" (is-a). Mot-clé : extends.
 public class Vehicule {
protected String marque;
protected int vitesseMax;

public Vehicule(String marque, int vitesseMax) {

[Link] = marque;
[Link] = vitesseMax;
}
public void afficher() {
[Link](marque + " - vmax: " + vitesseMax);
}
}

public class Voiture extends Vehicule {

private int nbPortes;

public Voiture(String marque, int vitesseMax, int nbPortes) {

super(marque, vitesseMax); // appel du constructeur parent
[Link] = nbPortes;
}
}

Visibilité Même classe Sous-classe Autre package

private ■ ■ ■

protected ■ ■ ■

public ■ ■ ■

(défaut) ■ ■ (même pkg) ■

Java ne supporte que l'héritage SIMPLE (une seule classe mère). Une c
mot-clé super permet d'accéder aux membres de la classe mère.

La Composition : relation "a un" (has-a). Une classe contient une instance d'une autre classe comme
attribut.

// Agrégation faible : Bibliothèque a des Livres (ils peuvent exister sans elle)
public class Bibliotheque {
private List livres;
}

// Composition forte : Voiture a un Moteur (le moteur n'existe pas sans la voiture)
public class Voiture {
private Moteur moteur;
public Voiture() {
[Link] = new Moteur(); // créé dans le constructeur
}
}

4.3 Polymorphisme
Type Nom Mécanisme Résolu à

Statique Surcharge (Overloading) Même nom, paramètres Compilation

différents dans la MÊME
classe

Dynamique Redéfinition (Overriding) Même signature dans la Exécution (liaison

classe FILLE dynamique)

// SURCHARGE (Overloading) - même classe, paramètres différents

public class Calculatrice {
public int additionner(int a, int b) { return a + b; }
public double additionner(double a, double b) { return a + b; } // surchargé
}

// REDÉFINITION (Overriding) - héritage requis

public class Animal {
public String parler() { return "..."; }
}
public class Chien extends Animal {
@Override // bonne pratique : annotation obligatoire recommandée
public String parler() { return "Woof!"; }
}

// Liaison dynamique en action

Animal a = new Chien(); // type référence = Animal, type réel = Chien
[Link]([Link]()); // affiche "Woof!" (méthode du type RÉEL)

4.4 Constructeurs et surcharge

public class Etudiant {

private String nom;
private int age;
private String filiere;

// Constructeur par défaut (sans paramètres)

public Etudiant() {
this("Inconnu", 0, "Non définie"); // appel d'un autre constructeur
}

// Constructeur avec nom seulement

public Etudiant(String nom) {
this(nom, 0, "Non définie");
}

// Constructeur complet (le plus "riche")

public Etudiant(String nom, int age, String filiere) {
[Link] = nom;
[Link] = age;
[Link] = filiere;
}
}
 • Même nom que la classe, aucun type de retour (même pas void). • Si v
paramètres, le constructeur sans argument par défaut N'EST PLUS géné
un autre constructeur de la même classe (doit être en 1ère ligne). • supe
mère (doit être en 1ère ligne).

4.5 Interfaces
Une interface est un contrat : elle déclare des méthodes que les classes qui l'implémentent doivent
fournir. Mot-clé : implements. Une classe peut implémenter plusieurs interfaces (héritage multiple de
comportement).

public interface Volable {

void decoller(); // implicitement public abstract
void atterrir();
default void planer() { // méthode par défaut (Java 8+)
[Link]("Je plane...");
}
}

public interface Nageble {

void nager();
}

// Une classe peut implémenter plusieurs interfaces

public class Canard extends Animal implements Volable, Nageble {
@Override public void decoller() { [Link]("Envol du canard"); }
@Override public void atterrir() { [Link]("Atterrissage"); }
@Override public void nager() { [Link]("Coin coin..."); }
}
 5. FONCTIONNALITÉS AVANCÉES DU LANGAGE
5.1 Exceptions
Une exception est un événement anormal survenant à l'exécution. Java les gère avec le mécanisme
try-catch-finally.

Catégorie Hérite de Obligatoire à gérer? Exemples

Checked Exception Exception Oui (catch ou throws) IOException,

FileNotFoundException

Unchecked Exception RuntimeException Non NullPointerException, Arr

ayIndexOutOfBoundsExc
eption

Error Error Non (irrécupérable) OutOfMemoryError,

StackOverflowError

public void lireFichier(String chemin) throws IOException {

try {
// Code risqué
FileReader fr = new FileReader(chemin);
int c = [Link]();
} catch (FileNotFoundException e) { // plus spécifique en PREMIER
[Link]("Fichier non trouvé : " + [Link]());
} catch (IOException e) { // plus général ensuite
[Link]("Erreur I/O : " + [Link]());
} finally {
[Link]("Toujours exécuté (fermeture ressources)");
}
}

// Lever une exception personnalisée

if (age < 0) throw new IllegalArgumentException("Age invalide : " + age);

// Créer une exception personnalisée

public class SoldeInsuffisantException extends RuntimeException {
public SoldeInsuffisantException(String msg) { super(msg); }
}

5.2 Énumérations
public enum JourSemaine {
LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI, DIMANCHE;

public boolean estWeekEnd() {

return this == SAMEDI || this == DIMANCHE;
}
}

// Utilisation
JourSemaine j = [Link];
[Link]([Link]()); // false

Type-safe : impossible d'assigner une valeur invalide. Les enums sont de

avoir des attributs, constructeurs et méthodes.

5.3 Collections (Java Collections Framework)

Interface Caractéristiques Implémentations courantes

List Ordonnée, indexée, doublons ArrayList (accès rapide), LinkedList

autorisés (insertion rapide)

Set Sans doublons, ordre non garanti HashSet (O(1)), LinkedHashSet

(ordre insertion), TreeSet (trié)

Queue FIFO (premier entré, premier sorti) LinkedList, PriorityQueue

Map Paires clé-valeur, clés uniques HashMap, LinkedHashMap,

TreeMap

// List - ArrayList
List liste = new ArrayList<>();
[Link]("Alice"); [Link]("Bob"); [Link]("Alice"); // doublons OK
[Link]([Link](0)); // "Alice"

// Set - HashSet
Set ensemble = new HashSet<>();
[Link]("pomme"); [Link]("pomme"); // doublon ignoré
[Link]([Link]()); // 1

// Map - HashMap
Map scores = new HashMap<>();
[Link]("Alice", 95); [Link]("Bob", 87);
[Link]([Link]("Alice")); // 95

// Parcours avec for-each (toutes les collections)

for (String nom : liste) { [Link](nom); }

5.4 Gestion des dates ([Link] – Java 8+)

Classe Contient Exemple

LocalDate Date seulement (année, mois, jour) 2025-10-07

Classe Contient Exemple

LocalTime Heure seulement 10:30:00

LocalDateTime Date + heure (sans fuseau) 2025-10-07T10:30:00

ZonedDateTime Date + heure + fuseau horaire 2025-10-07T10:30:00+01:00[Africa

/Abidjan]

import [Link].*;

LocalDate auj = [Link]();

LocalDate noel = [Link](2025, 12, 25);

// Les objets sont IMMUABLES : chaque opération retourne un nouvel objet

LocalDate demain = [Link](1);
LocalDate anneeProch = [Link](1);

[Link]([Link](auj)); // true

// Fuseau horaire
ZoneId zone = [Link]("Africa/Abidjan");
ZonedDateTime maintenant = [Link](zone);
 6. JAKARTA EE & OUTILS
6.1 Maven – Gestionnaire de projet
Maven est un outil de build et gestion de projet. Son coeur est le fichier [Link] (Project Object Model).

Concept Description

GAV Identifiant unique : groupId:artifactId:version (ex:

[Link]:monapp:1.0.0)

[Link] Fichier XML décrivant le projet : dépendances, plugins,

version Java…

Dépendance Bibliothèque externe déclarée dans [Link],

téléchargée depuis Maven Central

Packaging Type d'archive produite : jar, war, ear (war =

application web)

Cycle de vie Maven (dans l'ordre) :

validate → compile → test → package → verify → install → deploy

↑
mvn package (produit le .war ou .jar)

[Link]
monapp
1.0.0
war

[Link]
[Link]-api
10.0.0
provided

compile (défaut) = embarqué dans le .war. provided = fourni par le serve

= uniquement pendant les tests.

6.2 Serveurs d'application Jakarta EE

Serveur Type Particularité

WildFly Open source (Red Hat) Léger, rapide, modulaire.

Recommandé pour dev/test/prod.

GlassFish Open source (Eclipse) Serveur de référence Jakarta EE

officiel.
Serveur Type Particularité

Payara Open source / Commercial Dérivé de GlassFish, support actif.

Open Liberty Open source (IBM) Très performant, cloud-native.

TomEE Open source (Apache) Apache Tomcat + extensions

Jakarta EE.
 7. JAKARTA PERSISTENCE (JPA)
JPA (Jakarta Persistence API) est la couche standard Java pour faire le lien entre les objets Java et les
tables d'une base de données relationnelle (ORM : Object-Relational Mapping). L'implémentation la plus
connue est Hibernate.

7.1 Entités JPA et annotations de base

Une entité JPA doit respecter ces règles :
• • Annotée @Entity
• • Avoir au moins un attribut annoté @Id
• • Avoir un constructeur sans argument
• • Implémenter [Link]
• • Tous les attributs privés avec getters/setters

@Entity
@Table(name = "employes") // nom personnalisé de la table
public class Employe implements Serializable {

@Id
@GeneratedValue(strategy = [Link])
private Long id;

@Column(name = "nom_complet", nullable = false, length = 100)

private String nom;

@Enumerated([Link]) // stocké comme "ACTIF" ou "INACTIF"

private Statut statut;

@Temporal([Link]) // pour [Link]

private Date dateEmbauche;

// constructeur sans argument obligatoire

public Employe() {}
// ... getters et setters
}

Annotation Rôle

@Entity Déclare la classe comme entité persistante

@Table(name="...") Personnalise le nom de la table (défaut = nom de la

classe)

@Id Définit la clé primaire

@GeneratedValue Stratégie de génération : IDENTITY, SEQUENCE,

TABLE, AUTO

@Column Personnalise le nom, la taille, nullabilité de la colonne

@Enumerated Stockage d'un enum (STRING ou ORDINAL)

Annotation Rôle

@Temporal Type temporel pour [Link] (DATE,

TIMESTAMP, TIME)

7.2 Stratégies d'identifiant (@GeneratedValue)

Stratégie Description

IDENTITY Utilise l'auto-incrément natif du SGBD

(AUTO_INCREMENT MySQL, SERIAL PostgreSQL)

SEQUENCE Utilise une séquence gérée par Hibernate (table

hibernate_sequence)

TABLE Utilise une table dédiée pour les séquences (portable

mais lent)

AUTO Hibernate choisit la meilleure stratégie selon le SGBD

7.3 Héritage JPA

Stratégie Mapping DB Avantage Inconvénient

SINGLE_TABLE (défaut) Une seule table pour Simple, pas de jointure Beaucoup de NULL si
toute la hiérarchie hiérarchie complexe

TABLE_PER_CLASS Une table par classe Aucun NULL Pas supporté par tous les
concrète providers

JOINED Une table par classe, Propre, normalisé Requêtes plus lentes
jointures pour (jointures)
reconstituer

7.4 EntityManager et cycle de vie

État Description

NEW Objet créé avec new, pas encore géré par JPA

MANAGED Associé au contexte de persistance (après persist() ou

find())

DETACHED N'est plus géré (contexte fermé ou clear())

REMOVED Marqué pour suppression de la DB (après remove())

// Configuration : [Link] (dans src/main/resources/META-INF/)

// Utilisation complète de l'EntityManager

EntityManagerFactory emf = [Link]("monPU");
EntityManager em = [Link]();

[Link]().begin();

// CREATE
Employe emp = new Employe(); // état: NEW
[Link]("Koné Moussa");
[Link](emp); // état: MANAGED → INSERT dans la DB au commit

// READ
Employe trouve = [Link]([Link], 1L); // SELECT par clé primaire

// UPDATE (automatique si MANAGED)

[Link]("Koné Moussa Diallo"); // modif auto détectée

// DELETE
[Link](trouve); // état: REMOVED → DELETE au commit

[Link]().commit();
[Link]();
[Link]();

7.5 Associations entre entités

Annotation Type Table générée Exemple

@OneToOne 1:1 Colonne FK dans l'entité Employé ↔ Contact

maître

@OneToMany 1:N Table associative (si Laboratoire → List

unidirectionnel)

@ManyToOne N:1 Colonne FK dans la table Employe → Laboratoire

"many"

@ManyToMany M:N Table associative avec 2 Technicien ↔

FK Competence
// Bidirectionnel 1:N - le "mappedBy" définit le côté esclave
@Entity public class Laboratoire {
@Id @GeneratedValue private Long id;

@OneToMany(mappedBy = "laboratoire") // côté maître

private List employes;
}

@Entity public class Employe {

@Id @GeneratedValue private Long id;

@ManyToOne // côté esclave (porte la FK)

@JoinColumn(name = "labo_id")
private Laboratoire laboratoire;
}
 8. JAKARTA RESTFUL WEB SERVICES (JAX-RS)
JAX-RS est l'API Jakarta EE pour créer des services web REST. REST (Representational State Transfer)
utilise les méthodes HTTP standard (GET, POST, PUT, DELETE) et identifie les ressources par des URI.

8.1 Annotations principales

Annotation Rôle Exemple

@Path Chemin de la ressource @Path("/produits")

@GET / @POST / @PUT / Méthode HTTP @GET → lecture

@DELETE

@Produces Type de réponse retournée @Produces("application/json")

@Consumes Type de contenu reçu @Consumes("application/json")

@PathParam Paramètre dans l'URL @PathParam("id") int id

@QueryParam Paramètre de requête (?nom=val) @QueryParam("page") int p

@ApplicationPath Préfixe de toutes les URLs REST @ApplicationPath("/api")

// Configuration de l'application REST
@ApplicationPath("/api")
public class MyRestApp extends Application { }

// Ressource REST pour les produits

@Path("/produits")
public class ProduitResource {

// GET /api/produits → liste tous les produits

@GET
@Produces("application/json")
public List listerTous() {
return [Link]();
}

// GET /api/produits/5 → produit par ID

@GET
@Path("/{id}")
@Produces("application/json")
public Produit trouverParId(@PathParam("id") int id) {
return [Link](id);
}

// POST /api/produits → créer un nouveau produit

@POST
@Consumes("application/json")
@Produces("application/json")
public Response creer(Produit p) {
[Link](p);
return [Link](201).entity(p).build();
}
}

8.2 Déploiement (WAR vs JAR bootable)

Critère WAR classique JAR bootable (Galleon)

Nécessite WildFly installé Oui Non (serveur embarqué)

Format .war .jar

Lancement Via WildFly [Link] java -jar [Link]

Usage recommandé Déploiement classique / CI-CD Microservices, cloud

# Construction
mvn clean package

# WAR : copier dans le répertoire de déploiement WildFly

cp target/[Link] /opt/wildfly/standalone/deployments/
/opt/wildfly/bin/[Link]

# JAR bootable : lancement direct

java -jar target/[Link]
 9. RÉVISION FINALE
9.1 Résumé des points clés

Architecture • 1-tier : tout sur une machine (rigide). 2-tiers : client lourd + serveur données. n-tiers :
composants métier indépendants distribués.
• Architecture physique (matériel) ≠ logique (couches) ≠ applicative (blocs applicatifs).

JVM / Java • JVM = machine abstraite exécutant le bytecode. JDK = JVM + JRE + outils dev.
• "Write Once, Run Everywhere" : le bytecode est universel. Le JIT optimise l'exécution.
• Jakarta EE étend Java SE pour les applications d'entreprise (JPA, REST, CDI, Servlets…).

Bases Java • 8 types primitifs (int, double, boolean…) + classes wrappers (Integer, Double, Boolean…).
• Autoboxing : conversion automatique primitif ↔ objet.
• Stack = variables locales / références. Heap = objets (gérés par le GC).

POO • Encapsulation : attributs private + getters/setters → contrôle des données.

• Héritage (extends) : relation "est un". Java = héritage SIMPLE uniquement.
• Polymorphisme : surcharge (overloading) = même nom, params différents, même classe.
Redéfinition (overriding) = même signature, classe fille.
• Interface (implements) : contrat de comportement. Héritage MULTIPLE d'interfaces autorisé.
• Constructeur : même nom que la classe, sans type de retour, appelé par new.

Avancé • Exceptions : Checked (obligatoire à gérer), Unchecked (RuntimeException), Error.

• Enums : type sûr pour des constantes nommées. Vraies classes en Java.
• Collections : List (ordonné, doublons), Set (unique), Map (clé-valeur), Queue (FIFO).
• [Link] : LocalDate, LocalTime, LocalDateTime, ZonedDateTime. Objets IMMUABLES.

JPA • @Entity + @Id + constructeur vide + Serializable = entité valide.

• Stratégies ID : IDENTITY (auto-increment), SEQUENCE, TABLE, AUTO.
• EntityManager : persist(), find(), remove(), merge(). Toujours dans une transaction.
• Associations : @OneToOne, @OneToMany, @ManyToOne, @ManyToMany. mappedBy =
côté bidirectionnel esclave.
• Héritage : SINGLE_TABLE (défaut), JOINED (normalisé), TABLE_PER_CLASS.

REST / Maven • REST : ressources identifiées par URI, méthodes HTTP (GET/POST/PUT/DELETE).
• @Path, @GET, @POST, @Produces, @Consumes, @PathParam, @QueryParam.
• Maven : [Link], GAV (groupId:artifactId:version), cycle de vie (compile → package →
deploy).
 9.2 QCM d'entraînement (20 questions)

Pour chaque question, choisissez la meilleure réponse. Les corrections s

Q1. Que signifie 'Write Once, Run Everywhere' en Java ?

A) Le code source est identique sur tous les OS
■ B) Le bytecode Java est exécutable sur toute JVM, quel que soit l'OS
C) On ne peut compiler qu'une seule fois par machine
D) Java est le seul langage portable

Q2. Quelle commande compile un fichier Java ?

A) java [Link]
■ B) javac [Link]
C) compile [Link]
D) run [Link]

Q3. Parmi ces types, lequel est un type PRIMITIF en Java ?

A) String
B) Integer
■ C) boolean
D) Object

Q4. Quelle est la différence entre Stack et Heap ?

A) La Stack stocke les objets, le Heap les primitifs
■ B) La Stack stocke les variables locales/références, le Heap stocke les objets
C) Il n'y a pas de différence en Java
D) La Stack est gérée par le développeur, le Heap par la JVM

Q5. Quel mot-clé est utilisé pour créer un objet en Java ?

A) create
B) make
■ C) new
D) object

Q6. L'encapsulation consiste à :

A) Hériter d'une classe mère
■ B) Cacher les attributs et contrôler l'accès via des getters/setters
C) Implémenter plusieurs interfaces
D) Surcharger les méthodes

Q7. En Java, l'héritage de classes est :

A) Multiple : une classe peut étendre plusieurs classes
■ B) Simple : une classe ne peut étendre qu'une seule classe
C) Interdit en Java
D) Optionnel selon la JVM

Q8. Quelle annotation est recommandée lors de la redéfinition d'une méthode ?

■ A) @Override
B) @Redefine
C) @Overload
 D) @Inherit

Q9. La surcharge (Overloading) est résolue à :

A) L'exécution
■ B) La compilation
C) Le déploiement
D) L'installation

Q10. Un constructeur en Java :

A) A un type de retour void
■ B) N'a aucun type de retour et porte le même nom que la classe
C) Est optionnel même si on déclare d'autres constructeurs
D) Peut être appelé plusieurs fois sur un même objet

Q11. Quelle exception est une Unchecked Exception ?

A) IOException
B) FileNotFoundException
■ C) NullPointerException
D) SQLException

Q12. Le bloc finally est exécuté :

A) Uniquement si une exception est levée
B) Uniquement si aucune exception n'est levée
■ C) Toujours, qu'une exception soit levée ou non
D) Uniquement si on retourne une valeur dans le try

Q13. Quelle collection n'autorise pas les doublons ?

A) ArrayList
B) LinkedList
■ C) HashSet
D) Stack

Q14. Quelle affirmation est vraie sur les objets [Link] ?

A) Ils sont mutables
■ B) Ils sont immuables (chaque opération retourne un nouvel objet)
C) On les crée toujours avec new
D) Ils remplacent les int pour les calculs

Q15. En JPA, quelle annotation déclare une classe comme entité persistante ?
A) @Table
B) @Persistent
■ C) @Entity
D) @Model

Q16. Dans le cycle de vie JPA, après [Link](obj), l'entité est dans l'état :
A) NEW
■ B) MANAGED
C) DETACHED
D) REMOVED

Q17. Quelle stratégie de génération d'ID utilise l'AUTO_INCREMENT MySQL ?

 A) SEQUENCE
B) TABLE
C) AUTO
■ D) IDENTITY

Q18. Dans une relation bidirectionnelle JPA, l'attribut mappedBy est placé :
A) Sur le côté maître (celui qui possède la FK)
■ B) Sur le côté esclave (celui qui ne possède pas la FK)
C) Sur les deux côtés à la fois
D) N'importe où

Q19. En JAX-RS, l'annotation @PathParam sert à :

A) Lire un paramètre de formulaire HTML
B) Lire un paramètre de requête HTTP (?param=val)
■ C) Lire une valeur intégrée dans l'URL (/produits/{id})
D) Définir le chemin de la ressource

Q20. Dans Maven, que signifie GAV ?

■ A) GroupId, ArtifactId, Version
B) GlobalAccess, Visibility, Type
C) GenerateAll, Validate, Verify
D) GroupAccess, AppId, View

Bonne chance pour ton devoir ! ■ – M1IA/FPC 2025-2026