Cest quoi un framework
=> Un cadre de travail:
Ensemble d’outils
Ensemble de biblios
Ensemble de bonnes pratique
Objectif : Faciliter le dev Rendre le code organisé +
Architecture Structurée +Gain de temps
FrontEnd: BackEnd:
Traitement de la partie visible au client C’est la ou la logique et les règles de notre
programme.
Exemple Facebook:Les pages,les boutons ,les
couleurs Exemple Facebook : Les méthodes , Les API ...
FrontOffice: BackOffice
Résultat final : Ce que voit le client
Résultat final : Ce que voit l’Admin : Celui qui
gère l’application
Exemple e-commerce : Panier , Produit
Exemple e-commerce : Dashboard ...
Le fichier [Link] – C’est quoi ?
✔ Déclarer les dépendances
Ce sont les librairies dont ton projet a besoin (Spring Web, Log4J, MySQL
driver, etc.)
✔ Définir l’identité du projet
Étapes de construction du projet Maven
Vérifier que les tables ont été créées dans
la base de données
[Link]:
🔥 [Link]-auto=create
➡️ À chaque démarrage de l'application :
Hibernate supprime toute la base (toutes les tables)
Puis la recrée à partir des entités
Toutes les données sont perdues à chaque redémarrage
🛠️ [Link]-auto=update
➡️ À chaque démarrage :
Hibernate met à jour la structure des tables si nécessaire (ajout de colonne,
changement de type…)
Les données existantes sont conservées
🌱 Sérialisation / Désérialisation
Ce sont deux opérations automatiques que Spring Boot fait tout le temps dans les API
REST.
Imagine que ton application :
reçoit des données en JSON depuis Postman → elle doit créer un objet Java
envoie un objet Java comme réponse →elle doit produire du JSON
🔵 1. Sérialisation
👉 Définition simple :
Transformer un objet Java en JSON
Spring Boot utilise Jackson pour faire ça automatiquement.
🔵 2. Désérialisation
👉 Définition simple :
Transformer un JSON reçu → en objet Java
Qu’est-ce que le logging ?
[Link]("Foyer ajouté avec succès");
=>Les logs peuvent apparaître dans la console ou dans un fichier externe.
=>Si tu écris beaucoup de logs dans un fichier, il peut devenir très gros.
=>Spring Boot te permet de limiter la taille avec :
[Link]-file-size=10KB
Ici, chaque fichier ne peut pas dépasser 10 KB.
Si la taille est dépassée, Spring Boot crée un nouveau fichier automatiquement.
Si tu ne mets rien, la taille par défaut = 10 MB.
=>Tu peux choisir ce que tu veux afficher, par classe ou pour tout le projet.
🔹 Exemple pour une seule classe :
[Link] = WARN
→ Seuls les logs WARN et ERROR s’affichent pour cette classe.
→ INFO et DEBUG sont ignorés.
Lombok et Logger
Lombok est une librairie qui écrit automatiquement du code répétitif.
@Getter →Génère automatiquement tous les getters
@Setter →Génère automatiquement tous les setters
@NoArgsConstructor →Génère un constructeur vide
@AllArgsConstructor →Génère un constructeur avec tous les attributs
@ToString →Génère la méthode toString()
@Slf4j →Génère un logger automatique
Cascade
le cascade permet de propager une opération d’une entité parent vers les entités enfants.
Type de cascadeEffet
[Link] =>Tous les types (PERSIST, REMOVE, MERGE…)
[Link] =>Si on ajoute l’entité parent, les enfants sont ajoutés
automatiquement
[Link] =>Si on supprime l’entité parent, les enfants sont supprimés
automatiquement
Exemple pratique :
@ManyToMany(cascade = {[Link], [Link]})private
Set<Projet> projets;
Quand tu ajoutes une Équipe avec des Projets →tout est ajouté dans la DB
Quand tu supprimes l’Équipe →les Projets liés sont supprimés pour éviter les
orphelins
Fetch (EAGER vs LAZY)
[Link]
Les projets liés sont chargés immédiatement quand on récupère l’équipe
[Link]
Les projets liés ne sont pas chargés tant qu’on ne les demande pas explicitement
([Link]())
Règles par défaut :
OneToMany, ManyToMany →
LAZY (car beaucoup d’éléments “many”)
OneToOne, ManyToOne →
EAGER (car peu de données associées)
Exemple :
@ManyToMany(fetch=[Link])private Set<Projet> projets;
Tous les projets liés seront chargés automatiquement avec l’équipe.
Unidirectionnelle (uni)
Sens unique : seule une entité “connaît” l’autre.
L’autre entité ne sait pas qu’elle est liée.
Exemple concret :
Un Foyer a plusieurs Chambres, mais la Chambre ne sait pas à quel Foyer elle
appartient.
@Entitypublic class Foyer {
@OneToManyprivate List<Chambre> chambres; // Foyer connaît les chambres
}
@Entitypublic class Chambre {
// Pas de référence vers Foyer
}
✅ Utilité : simple, moins de code, mais tu ne peux pas naviguer depuis la chambre vers le
foyer.
Bidirectionnelle (bi)
Sens double : les deux entités se connaissent.
Tu peux naviguer dans les deux sens : A→ →
B et B A.
Exemple concret :
Un Foyer a plusieurs Chambres, et chaque Chambre sait à quel Foyer elle appartient.
@Entitypublic class Foyer {
@OneToMany(mappedBy="foyer")private List<Chambre> chambres; // Foyer connaît les
chambres
}
@Entitypublic class Chambre {
@ManyToOne@JoinColumn(name="foyer_id")private Foyer foyer; // Chambre connaît
son foyer
}
✅ Utilité : plus flexible pour les requêtes et manipulations, mais plus de code et
complexité.
WS REST avec Spring
WS REST = Web Services REST.
Spring Boot te permet de créer facilement des services web qui exposent tes données (par exemple,
les chambres) via HTTP.
Ces services peuvent être appelés depuis un navigateur, Postman ou une autre application.
Exemple de service REST pour l’entité Chambre :
/chambres → endpoint pour accéder aux chambres.
@RestController@RequestMapping("/chambres")public class ChambreController {
@Autowiredprivate ChambreRepository chambreRepository;
@GetMapping →
pour récupérer la liste des chambres.
@GetMappingpublic List<Chambre> getAllChambres() {
return [Link]();
}
@PostMapping →pour créer une nouvelle chambre
@PostMappingpublic Chambre createChambre(@RequestBody Chambre chambre) {
return [Link](chambre);
}
Le cycle de vie de maven:
MVN Package:creation de livrable Jar (sous/target)
MVN clean:vider le contenu du dossier targert
MVN Compile:compiler le prj
MVN Test:Executer les tests unitaires
Injection de Dépendances (DI)
Imagine que tu as une classe Voiture et qu’elle a besoin d’un moteur (Moteur) pour fonctionner.
Sans DI :public class Voiture { private Moteur moteur = new Moteur();}
Avec DI:public class Voiture { @Autowiredprivate Moteur moteur;}
Problème :Supposons que tu as deux moteurs : MoteurEssence et MoteurElectrique, les deux
implémentent l’interface Moteur
Solution 1 : @Qualifier
@Autowired@Qualifier("moteurEssence")private Moteur moteur;
Spring va injecter le moteur essence, pas l’autre.
Solution 2 : @Primary
Tu peux définir un moteur par défaut avec @Primary :
@Service@Primarypublic class MoteurEssence implements Moteur { ... }
@Servicepublic class MoteurElectrique implements Moteur { ... }
Maintenant, si tu fais juste @Autowired sans @Qualifier, Spring prend automatiquement
MoteurEssence
Spring Data JPA – Keywords
REMARQUE:LocalDate
JPQL
@Query("SELECT COUNT(j) FROM Joueur j JOIN [Link] e JOIN [Link] m " +
"WHERE [Link] = :idMatch AND [Link] = true AND [Link] = :idEquipe")
long countJoueursBlessesDansEquipe(@Param("idMatch") Integer idMatch,
@Param("idEquipe") Integer idEquipe);
Schedular
@Component
public class ExempleSchedulerService {
// Cette méthode s'exécute toutes les 60 secondes
@Scheduled(fixedRate = 60000) // en millisecondes
public void afficherMessage() {
[Link]("Scheduler déclenché : " + [Link]());
}
// Autre exemple : avec un délai initial
@Scheduled(initialDelay = 5000, fixedRate = 60000)
public void afficherMessageAvecDelai() {
[Link]("Scheduler avec délai initial déclenché : " + [Link]());
}
@Component
@Aspect
public class LoggingAspect {
AOP
@Before("execution(*[Link].adoption_animal.[Link]
ur(..))")
public void logMethodEntry(JoinPoint joinPoint) {
String name = [Link]().getName();
[Link]("Bienvenue dans le service " + name);
}
@After("execution(* [Link].*(..))")
public void logMethodExit(JoinPoint joinPoint) {
String name = [Link]().getName();
[Link]("Exiting method: " + name);
}
} main:@EnableAspectJAutoProxy
AOP
@Before("execution(* [Link]..add*(..))")
=>methode dajout
public void beforeAddMethods() {
[Link]("Méthode d'ajout appelée");
}
REMARQUE
Dans matchFotball:
Dans equipe:
Dans equipe:
Dans joueur: