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

Spring MVC

Pourquoi vous avez besoin de Spring MVC

Spring MVC aide à organiser une application web en suivant le principe de la séparation des préoccupations, ce qui facilite le développement, le test et la maintenance du code. Il fournit un cadre pour créer des pages web et gérer les requêtes des utilisateurs, ainsi que pour s'intégrer à la logique métier et aux bases de données.

Dans notre application, nous utilisons une architecture à trois niveaux pour séparer la logique en modules distincts. Nous avons les couches repository, service et controller. Cette séparation facilite la maintenance et le test de l'application.

Annotations Clés et Leur Rôle

Pour chaque couche, nous avons des annotations spécifiques, qui sont essentielles pour que Spring reconnaisse et enregistre automatiquement les composants dans le contexte de l'application (nous discuterons de ce que cela signifie plus tard). Cela aide à maintenir une architecture plus propre et améliore la lisibilité du code.

Annotation de la couche Repository

L'annotation @Repository est utilisée pour indiquer une classe qui interagit avec la base de données. Ces classes contiennent généralement des méthodes pour effectuer des opérations CRUD (Create, Read, Update, Delete).

UserRepository


              1234567
            
@Repository
public class UserRepository {
    // Method to find a user by their ID
    public User findById(Long id) {
        // Logic to retrieve the user from the database
    }
}

Dans cet exemple, UserRepository est marqué comme un repository, permettant à Spring de gérer les exceptions liées à l'accès aux données et de l'intégrer automatiquement dans l'application.

Annotation de la couche de service

L'annotation @Service est utilisée pour désigner une classe comme un composant de la logique métier. Ces classes contiennent des méthodes qui implémentent les règles et opérations métier de l'application.

UserService


              1234567
            
@Service
public class UserService {
    // Method to retrieve a user by their ID
    public User getUserById(Long id) {
        // Logic to get the user by ID
    }
}

L'annotation @Service indique que cette classe contient la logique métier de l'application, facilitant son utilisation dans d'autres parties de l'application. Cela simplifie le développement car vous n'avez pas à créer manuellement des instances de cette classe — Spring s'en charge pour vous.

Annotation de la couche contrôleur

Puisque la couche contrôleur sert de point d'interaction entre le client et notre application, nous devons établir des points de terminaison pour que les clients puissent y accéder. Cela implique d'associer des URLs spécifiques à chaque méthode, permettant ainsi aux clients d'interagir directement avec ces méthodes.

Pour y parvenir, nous devons annoter la classe en tant que @Controller et définir une méthode qui agira comme le gestionnaire de requêtes.

Main


              12345678
            
@Controller
public class HomeController {

    @RequestMapping(value = "/", method = RequestMethod.GET)
    public String home() {
        // code
    }
}

L'annotation @RequestMapping est utilisée pour lier les requêtes HTTP à des méthodes spécifiques dans le contrôleur. Elle aide à spécifier quels modèles d'URL et types de requêtes (comme GET ou POST) une méthode doit répondre. Par exemple, dans ce cas, la méthode home() répondra aux requêtes GET faites à l'URL racine.

Lorsqu'un utilisateur visite example.com/, son navigateur envoie une requête HTTP GET au serveur, qui atteint l'application Spring. Le framework Spring trouve le @RequestMapping correspondant dans le HomeController, appelle la méthode home() pour traiter la requête, puis renvoie la réponse appropriée au navigateur de l'utilisateur.

Il existe des annotations qui fournissent un mapping plus précis pour le type de méthode de requête, telles que @GetMapping, @PostMapping, @DeleteMapping, etc. Dans leurs attributs, vous spécifiez simplement l'URL qui peut être utilisée pour y accéder.

Main


              12345678
            
@Controller
public class HomeController {

    @GetMapping("/home")
    public String home() {
        // code 
    }
}

Dans cet exemple, si nous accédons à l'URL /home, nous serons dirigés vers la méthode home() UNIQUEMENT si c'était une requête GET. Si un type de méthode de requête différent est utilisé, le serveur répondra avec une erreur 404 Not Found pour cette URL.

@RequestParam

Quels sont les paramètres de requête URL ? Ce sont les paramètres qui apparaissent après le point d'interrogation dans l'URL. Par exemple, si nous avons l'adresse -> example.com/home?name=Alex (clé = name, valeur = Alex), nous pouvons directement récupérer le paramètre (name) dans la méthode welcomeUser().

Main


              12345678
            
@Controller
public class WelcomeController {

    @GetMapping("/home")
    public String welcomeUser(@RequestParam(name = "name") String name) {
        // code
    }
}

Ici, le paramètre name est extrait de l'URL (/home?name=Alex) et passé à la méthode welcomeUser().

Vous pouvez également extraire plus d'un paramètre, pas seulement un seul. Tous les paramètres dans l'URL doivent être séparés par le symbole &. Par exemple : example.com/home?name=Alex&age=20.

Main


              12345
            
@GetMapping("/home")
public String getUserInfo(@RequestParam String name, @RequestParam int age) {
    // Logic to handle the request using 'name' and 'age' parameters
    return "User Name: " + name + ", Age: " + age;
}

Dans cet exemple, le point de terminaison /home peut être accédé avec une URL comme example.com/home?name=Alex&age=20, où name et age sont les paramètres passés à la méthode.

@PathVariable

Dans Spring MVC, l'annotation @PathVariable est utilisée pour lier une variable dans l'URL directement à un paramètre de méthode. Elle vous permet de capturer des valeurs dynamiques à partir de l'URL et de les utiliser dans la méthode.

Si vous avez besoin de définir dynamiquement une URL, c'est-à-dire que vous passez une valeur directement dans l'URL elle-même, vous pouvez utiliser l'annotation @PathVariable.

Par exemple, si vous avez un modèle d'URL comme /users/{id}, vous pouvez utiliser @PathVariable pour accéder à la partie {id} de l'URL et la passer comme un paramètre à votre méthode.

Main


              12345678
            
@Controller
public class UserController {

    @GetMapping("/user/{id}")
    public String getUser(@PathVariable("id") Long userId) {
        // code
    }
}

Dans cet exemple, id est extrait de l'URL (/user/123) et passé à la méthode getUser(), où la valeur 123 est assignée au paramètre userId.

Ces annotations aident les développeurs à configurer facilement la gestion des requêtes HTTP, à lier les données aux objets, et à gérer les réponses, améliorant ainsi la lisibilité et la maintenabilité du code.

Résumé

Spring MVC simplifie le développement d'applications web en séparant la gestion des requêtes, la logique applicative, et le rendu des vues. Les contrôleurs, marqués avec l'annotation @Controller ou @RestController, gèrent les requêtes et retournent les données à afficher.