Différences entre Spring et Microservices
Transféré par
hezoubeke18Différences entre Spring et Microservices
Transféré par
hezoubeke18Note du 01/01/2024
1- difference entre spring et spring boot
spring boot est un module de spring qui permet de creer grance a l'IOC une
application autonome sans configuration
package-----> jar : java archive
war : web application archive
2 DIFFERENCE ENTRE UNE ARCHITECTURE MONOLITHIC ET MICROSERVICES
-----MONOLITHIC--------
* Toutes les fonctionnalités de notre application se trouve en un seul endroit
DATA ACCESS LAYER : permet de communiquer avec la base de donneés et pour les
services
le BUIZNESS LOGIC( logique metier : fait référence à la partie du code qui gère
la fonctionnalité principale et
le traitement des données au sein de l'application. ) et le UI (User Interface)
communique grace au controller
* Inconvenient :
-lorsque il y a un probleme au niveau d'une partie de l'architecture (UI, DATA
ACCESS , etc) , l'application ne fonctionne plus
- ne peut etre maintenue dans le cas d'une grande application
------- MICROSERVICES-----------
* permet de diviser une grande application en pluisieurs micro services qui
communiquent entre
elle via le protocole HTTP et qui execute chacune un processus metier specifique
de l'application
* chaque microservice dispose de sa base de donneés
* on peut coder chaque microservice peut etre coder avec different framework
3- difference entre les controllers et les services:
En Spring Boot, les services sont des composants qui encapsulent la logique métier
de votre application.
Ils sont utilisés par les contrôleurs pour effectuer des opérations spécifiques et
abstraire la logique métier du contrôleur.
Les services peuvent être injectés dans les contrôleurs et d'autres composants,
favorisant la modularité et la réutilisabilité du code.
En résumé, les services sont responsables de la logique métier, tandis que les
contrôleurs gèrent l'interaction avec les clients HTTP
4- l'annotation @Autowired
Brièvement, l'annotation @Autowired sert à indiquer à Spring d'injecter
automatiquement les dépendances requises dans une classe.
Cela facilite la gestion des dépendances sans avoir à créer manuellement les
instances des dépendances.
Vous pouvez utiliser @Autowired pour injecter des dépendances dans des champs, des
constructeurs ou
des méthodes dans les composants gérés par Spring, tels que les contrôleurs, les
services, etc.
5- Qu’est-ce qu’un spring bean ?
Bean est un concept clé du framework spring. Il est donc important de comprendre
cette notion pour comprendre le framework et l’utiliser de manière efficace.
Un bean est un objet (classe) java dont le cycle de vie est géré par le conteneur
spring (IoC).
6- JPA (Java Persistence API (JPA) )
ava Persistence API (JPA) est une spécification Java qui fournit une interface de
programmation pour la gestion des données dans une base
de données relationnelle.
Elle simplifie le développement des applications Java qui interagissent avec des
bases de données relationnelles en permettant la
création, la mise à jour, la suppression et la récupération des objets Java
directement depuis la base de données, sans écrire de requêtes SQL
7 - CONFIGURATION DE LA BASE DE DONNEES h2
# Configuration de la base de données H2
[Link]=jdbc:h2:mem:testdb
[Link]=[Link]
[Link]=sa
[Link]=password
# Console H2 (facultatif, pour accéder à la console H2)
[Link]=true
[Link]=/h2-console
8- repository
*Accès aux données avec Spring Data JPA :
Spring Data JPA est une extension de Spring Data qui simplifie considérablement
l'implémentation de la couche d'accès aux données en utilisant Java Persistence API
(JPA).
Le "repository" dans ce contexte est une interface qui étend JpaRepository ou une
interface similaire fournie par Spring Data JPA.
*Définition des méthodes de requête :
Les méthodes définies dans le "repository" peuvent être simples (telles que
findById, findAll, save, delete, etc.) ou peuvent définir des requêtes
personnalisées basées sur la convention de nommage.
Par exemple, si vous avez une entité User, vous pouvez définir une méthode
findByUsername(String username) dans votre "repository" pour rechercher un
utilisateur par son nom d'utilisateur.
9-les methodes du repository avec leur role :
Dans une interface de "repository" Spring Data JPA, vous pouvez définir différentes
méthodes déclaratives basées sur la convention de nommage. Voici quelques-unes des
méthodes couramment utilisées et leurs rôles :
1. **`findById` :**
- **Rôle :** Recherche une entité par son identifiant.
- **Exemple :** `Optional<User> findById(Long id);`
2. **`findAll` :**
- **Rôle :** Récupère toutes les entités de la table.
- **Exemple :** `List<User> findAll();`
3. **`save` :**
- **Rôle :** Enregistre une entité dans la base de données.
- **Exemple :** `User save(User user);`
4. **`deleteById` :**
- **Rôle :** Supprime une entité par son identifiant.
- **Exemple :** `void deleteById(Long id);`
5. **`findBy...` :**
- **Rôle :** Recherche une entité en fonction d'un critère spécifique, basé sur
la convention de nommage.
- **Exemple :** `List<User> findByLastName(String lastName);`
6. **`count` :**
- **Rôle :** Compte le nombre total d'entités dans la table.
- **Exemple :** `long count();`
7. **`existsById` :**
- **Rôle :** Vérifie si une entité avec l'identifiant donné existe.
- **Exemple :** `boolean existsById(Long id);`
8. **`delete` :**
- **Rôle :** Supprime une entité de la base de données.
- **Exemple :** `void delete(User user);`
9. **`findBy...And...` :**
- **Rôle :** Recherche une entité en utilisant plusieurs critères.
- **Exemple :** `List<User> findByFirstNameAndLastName(String firstName, String
lastName);`
10. **`findFirstBy...` :**
- **Rôle :** Recherche la première entité selon un critère spécifié.
- **Exemple :** `Optional<User> findFirstByOrderByCreationDateDesc();`
Ces méthodes sont générées automatiquement par Spring Data JPA en fonction des noms
des méthodes dans votre interface de "repository".
Elles permettent de créer des requêtes SQL en fonction des noms des méthodes,
ce qui simplifie grandement le code nécessaire pour effectuer des opérations de
base sur la base de données.
Si ces méthodes conventionnelles ne suffisent pas, vous pouvez également définir
des requêtes personnalisées en utilisant l'annotation `@Query`.
11- la classe configuration
Dans un projet Spring Boot, la classe configuration est généralement utilisée pour
définir et configurer des beans,
des composants et d'autres éléments de configuration nécessaires au bon
fonctionnement de l'application.
Une classe de configuration peut être annotée avec @Configuration pour indiquer à
Spring qu'elle contient des configurations spécifiques.
En ce qui concerne une classe Student dans un projet Spring Boot,
une classe de configuration pourrait être utilisée pour définir des instances de la
classe Student en tant que beans Spring.
Cela pourrait être utile si vous souhaitez définir des configurations particulières
pour les instances de la classe Student
ou si vous avez besoin de gérer l'injection de dépendances pour cette classe.
12 - JPA REPOSITORY :
Le rôle de l'interface JpaRepository dans Spring Boot est de fournir un ensemble de
méthodes prêtes à l'emploi pour effectuer des opérations courantes
de manipulation des données dans une base de données en utilisant JPA.
- ici on definit les reférentiel avec lequel on veut travailler , dans notre cas
ici c'est Student avec biensur son ID
13 - Sauvegardons Student
- pour ce faire nous allons creer une classe configuration qui nous permettra de
definir des enregistrement specifique que nous allons sauvegarder dans la base de
donneés