Contenu du cours

Backend Spring Boot

1. Notions de Base du Développement Backend

Introduction au Backend Comment Fonctionne HTTP HTTP/HTTPS Code de Statut Formats de Données : JSON et XML

2. Notions de Base de Spring Boot

Introduction à Spring Structure du Projet Spring MVC IoC et DI Architecture à Trois Niveaux Tâche de Printemps

3. API RESTful

Qu'est-ce Que REST?Principes de Base de REST Écrire Votre Propre API REST Travailler avec DTO Gestion des Exceptions Swagger Tester l'API RESTful

4. Travailler avec des Bases de Données

Introduction aux Bases de Données Relationnelles Connexion à une Base de Données MySQL Migrations de Base de Données Travailler avec ORM : JPA et Hibernate Ajouter la Base de Données à Notre Application Transactions

5. Tester les Applications Backend

Fondamentaux des Tests des Applications Backend Tests Modulaires avec JUnit Mockito Défi : Test Unitaire Résumé du Cours

IoC et DI

Le conteneur Spring est le composant central du Spring Framework qui gère la création, la configuration et le cycle de vie des beans (objets) au sein d'une application. Le conteneur Spring est également connu sous le nom de conteneur IoC.

Une dépendance fait référence à toute classe qui nécessite que d'autres objets soient injectés pour fonctionner correctement, et cette chaîne de dépendances peut se poursuivre indéfiniment. Normalement, pour créer un objet avec des dépendances, nous devons l'initialiser explicitement en utilisant l'opérateur new et spécifier la classe.

Mais c'est là que Spring intervient avec Inversion of Control et Dependency Injection. L'idée est que Spring prend en charge la responsabilité de créer et de gérer les dépendances. Au lieu de gérer manuellement la configuration, nous annotons simplement les classes nécessaires, et Spring les crée automatiquement et gère leur cycle de vie dans son contexte.

L'une de ces annotations est @Component, que nous plaçons au-dessus de la classe.

BeanExample


              123
            
@Component
public class BeanExample {
}

Cette approche déplace l'attention de la gestion manuelle des dépendances, permettant aux développeurs de se concentrer sur la logique métier tandis que Spring gère les tâches d'infrastructure liées à la création d'objets et à la gestion des dépendances.

Comment fonctionne le conteneur Spring ?

Lorsque l'application démarre, le conteneur Spring est initialisé. Il commence par scanner les classes pour les annotations comme @Component, @Service, @Repository, et @Configuration.

@Component est une annotation générale qui rend une classe gérée par Spring, lui permettant d'être enregistrée en tant que bean.

@Service, @Repository, et @Controller sont des versions plus spécialisées de @Component. Ils servent le même but mais indiquent le rôle spécifique de la classe : @Service pour la logique métier, @Repository pour l'accès aux données, et @Controller pour la gestion des requêtes web.

@Configuration est utilisé pour les classes qui contiennent des définitions de bean et la configuration de l'application.

En marquant une classe avec l'une de ces annotations, vous assurez qu'elle devienne un bean dans le contexte Spring.

Une fois que les classes sont identifiées, le conteneur procède à créer des instances de ces classes annotées, les transformant effectivement en beans que le contexte Spring gère tout au long du cycle de vie de l'application.

Au fur et à mesure que ces beans sont créés, le conteneur gère automatiquement leurs dépendances grâce à l'Injection de Dépendances. Ce processus permet aux classes de recevoir les dépendances nécessaires sans avoir besoin de les créer ou de les localiser explicitement, simplifiant ainsi le processus de développement.

Injection de Dépendances (DI)

Tout d'abord, le conteneur Spring ajoute à son contexte les beans (classes) marqués avec les annotations @Component, @Service, @Repository, et @Configuration. Après cela, il fournit ces beans à tout objet qui les demande.

Exemple de la vie réelle

Imaginez que vous développez une boutique en ligne. Vous avez une classe OrderService qui gère les commandes et une classe PaymentService qui gère les paiements. Au lieu de créer manuellement une instance de PaymentService à l'intérieur de OrderService, vous pouvez laisser le Spring Container créer et injecter PaymentService dans OrderService.

OrderService

PaymentService


              1234567891011121314
            
@Service
public class OrderService {

    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

Dans la classe OrderService, nous aurons un champ paymentService qui est initialisé avec le type exact dont nous avons besoin (PaymentService). Remarquez que nous n'avons pas explicitement initialisé cet objet, Spring l'a fait pour nous!

Si nous n'avions pas annoté PaymentService avec @Service, ce bean n'aurait pas été ajouté au contexte Spring, et nous aurions rencontré une erreur indiquant que Spring ne pouvait pas trouver un tel bean.

@Autowired

Vous pouvez également utiliser l'annotation @Autowired, qui indique au conteneur Spring d'injecter l'objet approprié dans le champ.

OrderService


              123456789101112131415
            
@Service
public class OrderService {

    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void placeOrder() {
        System.out.println("Placing order...");
        paymentService.processPayment();
    }
}

Dans Spring, à partir de la version 4.3, l'utilisation de l'annotation @Autowired n'est plus nécessaire lors de l'injection de dépendances via un constructeur s'il n'y a qu'un seul constructeur dans la classe. Spring détermine automatiquement que ce constructeur doit être utilisé pour l'injection de dépendances.

Quels sont les différents types de Bean ?

Imaginez que vous avez une seule machine à café dans un café. Chaque fois qu'un client commande un café, le barista utilise cette même machine à café pour préparer chaque tasse. La machine à café est toujours la même, pas une nouvelle pour chaque commande.

De même, dans Spring, lorsque vous injectez un bean depuis le contexte Spring, Spring vous fournit la même instance de ce bean à chaque fois. C'est ce qu'on appelle le singleton scope. Tout comme la machine à café du café, Spring s'assure que vous obtenez toujours le même objet plutôt que d'en créer un nouveau à chaque fois.

Singleton

Nous pouvons définir le type en utilisant l'annotation @Scope et spécifier singleton dans les attributs.

SingletonService


              12345
            
@Service
@Scope("singleton")
public class SingletonService {
    // Class for handling business logic
}

Prototype

PrototypeService


              12345
            
@Service
@Scope("prototype")
public class PrototypeService {
    // Class for handling business logic
}

Nous faisons la même chose, mais spécifions prototype dans les attributs. Cela garantit que chaque fois que nous injectons ce bean, il retournera un nouvel objet.

Résumé

Dans ce chapitre sur IoC (Inversion de Contrôle) et DI (Injection de Dépendances), nous avons exploré comment Spring gère la création et le cycle de vie des beans à travers son conteneur, permettant l'injection automatique de dépendances.

Nous avons discuté de la portée par défaut singleton, où une instance unique d'un bean est réutilisée, et de la portée prototype, qui crée une nouvelle instance pour chaque requête, soulignant comment ces portées impactent la gestion des objets et la conception des applications.