Créer une Application REST Spring Boot Avec Gradle

Tutoriels

Gradle

Dans ce tutoriel, nous allons créer un simple service web RESTful à l’aide de Spring Boot et de Gradle. Spring Boot facilite la création d’applications autonomes et de qualité production basées sur Spring, et Gradle est un puissant outil de construction qui simplifie le processus de construction.

Qu’est-ce que REST?

REST, Transfer State Representational, est un ensemble de principes architecturaux garantissant que vos API sont interopérables, évolutives et maintenables. Imaginez construire des blocs Lego — différentes applications peuvent interagir en toute transparence avec votre API tant qu’elles respectent les directives RESTful, tout comme les Legos s’emboîtent indépendamment de leur ensemble.

Qu’est-ce que Spring Boot?

Spring Boot est un framework puissant qui simplifie le processus de développement. Pensez-y comme à un kit pré-construit approvisionné en composants et fonctionnalités, vous épargnant du temps et de l’effort pour mettre en place l’infrastructure de votre application. Vous pouvez vous concentrer sur la logique centrale de votre API sans être submergé par le code de base.

Prêt à libérer votre développeur API intérieur? Ce guide vous donnera les moyens de créer votre première application REST Spring Boot à l’aide de Gradle, un outil de construction populaire. Que vous soyez programmeur Java expérimenté ou que vous commenciez simplement votre exploration, ce parcours étape par étape vous équipera des connaissances essentielles pour construire des services web dynamiques et interactifs.

Points clés à retenir

Créer des API RESTful à l’aide de Spring Boot : Spring Boot est un cadre Java populaire qui simplifie le processus de développement des API RESTful. Il offre un large éventail de fonctionnalités prêtes à l’emploi, telles que la configuration automatique et l’injection de dépendances, qui peuvent vous faire gagner du temps et des efforts.
Comprendre les concepts clés des API RESTful : REST signifie Transfer d’État Représentatif. Il s’agit d’un ensemble de principes architecturaux qui garantissent que vos API sont interopérables, évolutives et maintenables. Certains des concepts clés des API RESTful incluent la représentation des ressources, les méthodes HTTP et les codes d’état.
Mettre en œuvre les opérations de base CRUD : CRUD signifie Créer, Lire, Mettre à jour et Supprimer. Il s’agit des opérations de base que vous devrez mettre en œuvre dans vos points de terminaison API afin de permettre aux utilisateurs d’interagir avec vos données.
Tester votre API en profondeur : Il est important de tester votre API en profondeur avant de la déployer en production. Cela vous aidera à vous assurer qu’elle fonctionne comme prévu et qu’il n’y a pas de bogues.
Explorer des fonctionnalités avancées : À mesure que vous vous familiarisez davantage avec Spring Boot et les API RESTful, vous pouvez explorer des fonctionnalités plus avancées, telles que la gestion des données, la sécurité et l’authentification.

En combinant la puissance de REST avec l’approche simplifiée de Spring Boot, vous serez en mesure de créer des API efficaces et conviviales qui peuvent s’intégrer en douceur avec d’autres applications. Alors, êtes-vous prêt à débloquer le potentiel des API RESTful avec Spring Boot et Gradle ? Commençons !

Prérequis

Kit de développement Java (JDK) 11 installé
Dernière version de Gradle installée
Compréhension de base des concepts Java et Spring

Étape 1 : Configurer le projet

Pour commencer le projet, nous devons suivre les 3 étapes ci-dessous.

Ouvrir un terminal ou une invite de commande
Créer un nouveau répertoire pour votre projet
Se diriger vers le répertoire du projet
Initialiser une structure de base de projet Spring Boot

Shell

mkdir spring-boot-rest-gradle
cd spring-boot-rest-gradle
gradle init --type spring-boot

Étape 2 : Créer un projet Spring Boot

Veuillez modifier le fichier build.gradle existant présent dans le répertoire avec le contenu ci-dessous.

Groovy

plugins {
    id 'org.springframework.boot' version '2.6.3'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

group = 'com.example'
version = '1.0-SNAPSHOT'
sourceCompatibility = '11'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

test {
    useJUnitPlatform()
}

Cela configure un projet Spring Boot de base avec les dépendances nécessaires.

Étape 3 : Créer un contrôleur REST

Créer un nouveau fichier nommé HelloController.java dans le répertoire src/main/java/com/example avec le contenu suivant:

Java

import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/api")
public class HelloController {

    private final List<String> messages = new ArrayList<>();

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, Spring Boot!";
    }

    @GetMapping("/messages")
    public List<String> getMessages() {
        return messages;
    }

    @PostMapping("/messages")
    public String addMessage(@RequestBody String message) {
        messages.add(message);
        return "Message added: " + message;
    }

    @PutMapping("/messages/{index}")
    public String updateMessage(@PathVariable int index, @RequestBody String updatedMessage) {
        if (index < messages.size()) {
            messages.set(index, updatedMessage);
            return "Message updated at index " + index + ": " + updatedMessage;
        } else {
            return "Invalid index";
        }
    }

    @DeleteMapping("/messages/{index}")
    public String deleteMessage(@PathVariable int index) {
        if (index < messages.size()) {
            String removedMessage = messages.remove(index);
            return "Message removed at index " + index + ": " + removedMessage;
        } else {
            return "Invalid index";
        }
    }
}

Cela définit un contrôleur REST avec des points de terminaison pour les opérations GET, POST, PUT et DELETE sur une simple liste de messages.

Étape 4 : Exécuter l’application

Ouvrir un terminal ou une invite de commande et exécuter la commande suivante:

Java

./gradlew bootRun

Visiter http://localhost:8080/api/hello dans votre navigateur pour vérifier le point de terminaison initial. Vous pouvez utiliser des outils comme curl, Postman ou tout client REST pour tester les autres points de terminaison.

Étape 5 : Écrire des cas de test

Créez un nouveau fichier nommé HelloControllerTest.java dans le répertoire src/test/java/com/example avec le contenu suivant:

Java

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.is;

@SpringBootTest
@AutoConfigureMockMvc
public class HelloControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @BeforeEach
    public void setUp() {
        // Effacer les messages avant chaque test
        // Cela garantit un état propre pour chaque test
        // Sinon, vous pourriez utiliser une base de données de test ou des données simulées
        // selon vos besoins
        HelloController messagesController = new HelloController();
        messagesController.getMessages().clear();
    }

    @Test
    public void testSayHello() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/api/hello"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.content().string("Hello, Spring Boot!"));
    }

    @Test
    public void testGetMessages() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/api/messages"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.jsonPath("$", hasSize(0)));
    }

    @Test
    public void testAddMessage() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.post("/api/messages")
                .contentType(MediaType.APPLICATION_JSON)
                .content("\"Test Message\""))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.content().string("Message added: Test Message"));
    }

    @Test
    public void testUpdateMessage() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.post("/api/messages")
                .contentType(MediaType.APPLICATION_JSON)
                .content("\"Initial Message\""));

        mockMvc.perform(MockMvcRequestBuilders.put("/api/messages/0")
                .contentType(MediaType.APPLICATION_JSON)
                .content("\"Updated Message\""))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.content().string("Message updated at index 0: Updated Message"));
    }

    @Test
    public void testDeleteMessage() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.post("/api/messages")
                .contentType(MediaType.APPLICATION_JSON)
                .content("\"Message to Delete\""));

        mockMvc.perform(MockMvcRequestBuilders.delete("/api/messages/0"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.content().string("Message removed at index 0: Message to Delete"));
    }
}

Ces cas de test utilisent les fonctionnalités de test de Spring Boot pour simuler des requêtes HTTP et vérifier le comportement du contrôleur REST.

Étape 6: Exécuter les Tests

Ouvrez un terminal ou un invite de commande et exécutez la commande suivante pour exécuter les tests:

Java

./gradlew test

Examinez les résultats des tests pour vous assurer que tous les tests passent avec succès.

Conclusion

Félicitations! Vous avez réussi à créer un service web REST de base avec des opérations CRUD en utilisant Spring Boot et Gradle. Ce tutoriel a couvert la mise en œuvre des points de terminaison pour les opérations GET, POST, PUT et DELETE, ainsi que les cas de test correspondants.

Notes supplémentaires:

Ceci est un exemple très basique. Vous pouvez l’étendre en créant plus de points de terminaison, en gérant différentes méthodes HTTP (POST, PUT, DELETE), et en ajoutant des fonctionnalités comme la gestion des données.
Pensez à ajouter des tests unitaires pour votre contrôleur en utilisant des frameworks comme JUnit.
Vous pouvez utiliser le Spring Initializr (https://start.spring.io/) pour générer rapidement un projet avec des dépendances et configurations supplémentaires.

Pour approfondir vos connaissances, consultez ces ressources:

Guide de démarrage Spring Boot: https://spring.io/guides/gs/spring-boot/
Tutoriel sur les services REST Spring: https://spring.io/guides/gs/rest-service/
Création d’un service Web RESTful avec Spring Boot Actuator: https://spring.io/guides/gs/actuator-service/

N’oubliez pas, c’est juste le début de votre voyage avec Spring Boot ! Continuez à explorer et à construire des applications incroyables.

Source:
https://dzone.com/articles/build-your-first-spring-boot-rest-application-with