On a des projets de type spring et spring boot
Pour pouvoir appeler la base de données on a besoin d’appeler d’une dépendance qui fait appel à sql
dans [Link]
A travers dependence starter on peut appeler des dependences qui s’accorde avec la version du
spring utilisé -> la gestion dépendance avec starter
Avant on utilise spring avec l’installation de tomcat et déployer le projet avec le serveur
Now avec spring boot le tomcat est embarqué avec lui auto
L’url de la datasource yethat f application propities qui contient les configurations du projet
Meaven est déjà installer avec notre ide
On le cherche comme ca
Release donné au clt -> version stable
Snapchot en train de dev -> version en cours de dev
Artifactid le nom de notre livrable
Template fyh les fichies de ressource kima tswr
Pour la classe soit exécuté, elle doit être dans le même package que la classe main
Pour spécifier le primary key il faut l’indiquer par @id
Enum howa les type mtae classe expl enum howa type contrat par expl cloud res
En bleu is the same juste la première est générique avec toute les versions de java
Pour qu’elle soit une entité JPA IL FAUT UNE annotation entity
Generatedvalue permet de gérer un id automatiquement
Les entités JPA
JPA permet de définir des entités (entities). Une entité est simplement une
instance d’une classe qui sera persistante (que l’on pourra sauvegarder
dans / charger depuis une base de données relationnelle). Une entité est
signalée par l’annotation @Entity sur la classe. De plus, une entité
JPA doit disposer d’un ou plusieurs attributs définissant un
identifiant grâce à l’annotation @Id. Cet identifiant correspondra à la clé
primaire dans la table associée.
Entity instance de classe peut être charger une base de
->
données et doit êtres signalé la classe par @enitity et doit
être disposé par @id qui correspond à une clé primaire de la
table
Une interface doit être hérité par une interface
Une interface ne peut pas être hérité d’une interface
Many to one = classe mère qui possède la grande cardinalité donc c la classe responsable à
l’affectation exp etudiant
One toMany= classe fille puisque elle possède la cardinalité la plus faible et qui doit être lié par la
classe mère donc mapped by nom(de l’object effecte dans sa classe mère) et qui a une liste d ses
affectations à la classe mère exp departement
Relation 1 à 1 : on choisi une classe fille quelconque et on le met mapped by
Relation * à * : une autre table se génère car des plusieurs foregein key (seul mapped by)
Relation Unidirectionnelle : une table associative qui sera crée ( la table departement ne voit
pas université) on va mettre la relation que dans l’université
@OneToMany
private Set<Departement> listedep;
cascade = [Link] permet de créer un contrat lors de la création d’etudiant et vise versa
ios container (conteneur permet de stocker les instanances créé -> espace mémoire locale et pas
au niveau de serveur) -> repository permet de créer l instance au niveau de ios container
on créer une interface qui contient que les signatures des méthodes pour éviter le couplage fort
Icontratservice
injection des bean -> @autowired pour chaque repository ajouté dans contratserviceimpl ou
@allargconstructor
pour ajouter des dependence, il faut l installer (on le trouve dans maven install )
pour accéder au swagger il faut ajouter sa dépendance dans prop puiq pour l’acceder
[Link]
dans notre cas : http:// leport /[Link]
serveur : Le nom ou l’IP du serveur
port : Le port du serveur
context-path : Le chemin du contexte de l’application
IL faut Ajouter @JsonIgnore avant la relation pour ignorer les relations entre 2 classe et ne teste
que ses attribus
il faut ajouter @JsonIgnore
pour * à * : la classe responsable à laffectation est la classe qui na apas de mapped by
put update
post add
get affichage
requestbody pour les objets (classe)
pathvariable pour les variables (id)
mapped by se met dans la classe fille eli feha cardinalité 1 car ca la fille q on va lier a sa mère
donc pour une cardinalité 1 à * : donc la classe mère qui porte la cardinalité la plus forte voit un
object puisque c 1 pour la fille donc : mè[Link](idfille)
[Link](setEtud)
pour 1 à * : la classe responsable a l affectation est * , puisque elle porte la cardinalité la plus forte
donc c la classe mère qui va donner un bebe (fille) -> cllasse mère(*) reponsable à l’affectation
pour * à * : on met l’affectation dans la classe qui ne porte pas la mapped by puisque la classe
mère voit beaucoup * donc c une liste donc l’affectation est mè[Link](listefille).add(idfille)
[Link](listeC).add(idContrat)
Il faut ajouter l’annotation des getters et setters et les constructeurs au noveau des entités pour
pouvoir les récupérer dans les autres services des classes
Repository contient les crud predinifie et on peut ajouter d autre crud personnalisé comme
public Etudiant findByNomLikeAndPrenomLike(String nom, String prenom);
entity(@entity implements Serializable) -> repository (interface @repository
extnds repo)->Interface(seul qui import tous les entities)-> service(@service seul
qui implémente l interface) -> controller (seul@RestController)
[Link]=jdbc:mysql://localhost:3306/springdb?useUnicode=true&use
JDBCCompliantTimezoneShift=true&createDatabaseIfNotExist=true&useLegacyDatetim
eCode=false&serverTimezone=UTC
[Link]=root
[Link]=
### JPA / HIBERNATE ###
[Link]-sql=true
[Link]-auto=update
[Link]=[Link].MySQL5Dialect
me
[Link]=jdbc:mysql://localhost:3306/ExamenBlanc2?
createDatabaseIfNotExist=true&useUnicode=true
[Link]=root
[Link]=
[Link]-sql=true
#systeme conx
[Link]-auto=update
#systeme generation db
[Link]=[Link].MySQL5Dialect
[Link]=8075
@EnableScheduling
Dans app
1. @Scheduled(cron = "15 * * * * *") 2. @Scheduled(cron = "*/15 * * * * *") 3.
@Scheduled(cron = "0/15 * * * * *") 4. @Scheduled(cron = "0 0/30 11 * * *")
ChatGPT
1. L'expression cron 15 * * * * * planifie la méthode pour s'exécuter toutes les
minutes à la 15ème seconde, par exemple 10:05:15, 10:06:15, 10:07:15, etc.
2. L'expression cron */15 * * * * * planifie la méthode pour s'exécuter toutes les
15 secondes, par exemple à 10:05:00, 10:05:15, 10:05:30, 10:05:45, etc.
3. L'expression cron 0/15 * * * * * planifie la méthode pour s'exécuter toutes les
15 secondes à partir de la 0ème seconde, par exemple à 10:05:00, 10:05:15,
10:05:30, 10:05:45, etc.
4. L'expression cron 0 0/30 11 * * * planifie la méthode pour s'exécuter toutes les
30 minutes à partir de 11h00, par exemple à 11:00:00, 11:30:00, 12:00:00,
12:30:00, etc. Les champs sont définis comme suit:
Université 1 departement *
Relation Unidirectionnelle : une table associative qui sera crée ( la table departement ne voit
pas université) on va mettre la relation que dans l’université
@OneToMany(cascade = [Link])
//@JsonIgnore
@[Link]
private Set<Departement> departements;
Formation * formateur 1
formation
@JsonIgnore
@[Link]
@ManyToOne
private Formateur formateur;
Formateur
@JsonIgnore
@[Link]
@OneToMany(mappedBy = "formateur")
private List<Formation> formationList;
Formation * Apprenant *
formation
@JsonIgnore
@[Link]
@ManyToMany(fetch = [Link])
private List<Apprenant> apprenantList;
Apprenant
@JsonIgnore
@[Link]
@ManyToMany(mappedBy = "apprenantList")
private List<Formation> formationList;
@Temporal([Link])
private Date dateMatch;
Date de type Localdate (ca)
private LocalDate dateDebut;
Boolean
Integer
@EnableScheduling