Costruire un’applicazione REST Spring Boot con Gradle

Tutorial

Gradle

In questo tutorial, creeremo un semplice servizio web RESTful utilizzando Spring Boot e Gradle. Spring Boot semplifica la creazione di applicazioni basate su Spring auto-contenute e di livello di produzione, e Gradle è uno strumento di compilazione potente che semplifica il processo di compilazione.

Che cos’è REST?

REST, Transfer State Representational, è un insieme di principi architetturali che garantiscono che le tue API siano interoperabili, scalabili e mantenibili. Immagina di costruire blocchi Lego — differenti applicazioni possono interagire senza soluzione di continuità con la tua API fintanto che seguono le linee guida RESTful, proprio come i Lego si incastrano indipendentemente dal loro set.

Che cos’è Spring Boot?

Spring Boot è un potente framework che semplifica il processo di sviluppo. Pensa ad esso come a un kit pre-costruito fornito di componenti e funzionalità, risparmiandoti tempo ed energie nell’impostare l’infrastruttura della tua applicazione. Puoi concentrarti sulla logica principale della tua API senza essere intrappolato nel codice di template.

Pronto a liberare il tuo sviluppatore API interno? Questa guida ti darà il potere di creare la tua prima applicazione REST di Spring Boot utilizzando Gradle, uno strumento di compilazione popolare. Che tu sia un programmatore Java esperto o che tu stia appena iniziando la tua esplorazione, questo viaggio passo-passo ti fornirà le conoscenze essenziali per costruire servizi web dinamici e interattivi.

Punti chiave

Creare API RESTful utilizzando Spring Boot: Spring Boot è un popolare framework Java che semplifica il processo di sviluppo di API RESTful. Offre una vasta gamma di funzionalità pronte all’uso, come la configurazione automatica e l’iniezione di dipendenze, che possono farti risparmiare tempo e fatica.
Comprendere i concetti chiave delle API RESTful: REST sta per Representational State Transfer. Si tratta di un insieme di principi architetturali che garantiscono che le tue API siano interoperabili, scalabili e mantenibili. Alcuni dei concetti chiave delle API RESTful includono la rappresentazione delle risorse, i metodi HTTP e i codici di stato.
Implementare le operazioni di base CRUD: CRUD sta per Create, Read, Update e Delete. Queste sono le operazioni di base che dovrai implementare nei tuoi endpoint API per consentire agli utenti di interagire con i tuoi dati.
Testare accuratamente la tua API: È importante testare accuratamente la tua API prima di distribuirla in produzione. Questo ti aiuterà a garantire che funzioni come previsto e che non ci siano bug.
Esplorare funzionalità avanzate: Man mano che diventi più familiare con Spring Boot e API RESTful, puoi esplorare funzionalità più avanzate, come la gestione dei dati, la sicurezza e l’autenticazione.

Combinando il potere di REST con l’approccio semplificato di Spring Boot, sarai in grado di creare API efficienti e user-friendly che possono integrarsi perfettamente con altri applicativi. Quindi, sei pronto per sbloccare il potenziale delle API RESTful con Spring Boot e Gradle? Iniziamo!

Prerequisiti

JDK 11 installato
Ultima versione di Gradle installata
Comprensione di base dei concetti di Java e Spring

Passo 1: Configurare il Progetto

Per iniziare con il progetto, dobbiamo seguire i seguenti 3 passaggi.

Aprire un terminale o un prompt dei comandi
Creare una nuova directory per il progetto
Navigare nella directory del progetto
Iniziare una struttura di base per un progetto Spring Boot

Shell

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

Passo 2: Creare un Progetto Spring Boot

Modificare il file build.gradle esistente presente nella directory con il contenuto seguente.

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()
}

Questo configura un progetto Spring Boot di base con le dipendenze necessarie.

Passo 3: Creare un Controller REST

Creare un nuovo file chiamato HelloController.java nella directory src/main/java/com/example con il seguente contenuto:

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";
        }
    }
}

Questo definisce un controller REST con endpoint per operazioni GET, POST, PUT e DELETE su una semplice lista di messaggi.

Passo 4: Eseguire l’Applicazione

Aprire un terminale o un prompt dei comandi ed eseguire il seguente comando:

Java

./gradlew bootRun

Visitare http://localhost:8080/api/hello nel browser per verificare l’endpoint iniziale. È possibile utilizzare strumenti come curl, Postman o qualsiasi client REST per testare gli altri endpoint.

Passo 5: Scrivere Casi di Test

Creare un nuovo file chiamato HelloControllerTest.java nella directory src/test/java/com/example con il seguente contenuto:

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() {
        // Cancella i messaggi prima di ogni test
        // Questo garantisce uno stato pulito per ogni test
        // In alternativa, potresti usare un database di test o dati mock
        // a seconda dei tuoi requisiti
        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"));
    }
}

Questi casi di test utilizzano le funzionalità di test di Spring Boot per simulare richieste HTTP e verificare il comportamento del controller REST.

Passo 6: Esegui i Test

Apri un terminale o un prompt dei comandi ed esegui il seguente comando per eseguire i test:

Java

./gradlew test

Rivedi i risultati dei test per assicurarti che tutti i test passino con successo.

Conclusione

Congratulazioni! Hai creato con successo un semplice servizio web RESTful con operazioni CRUD utilizzando Spring Boot e Gradle. Questa guida ha coperto l’implementazione di endpoint per operazioni GET, POST, PUT e DELETE insieme a casi di test corrispondenti.

Note aggiuntive:

Questo è un esempio molto basilare. Puoi ampliarlo creando più endpoint, gestendo diversi metodi HTTP (POST, PUT, DELETE) e aggiungendo funzionalità come la gestione dei dati.
Considera l’aggiunta di test unitari per il tuo controller utilizzando framework come JUnit.
Puoi utilizzare il Spring Initializr (https://start.spring.io/) per generare rapidamente un progetto con dipendenze e configurazioni aggiuntive.

Per ulteriori informazioni, consulta questi risorse:

Guida introduttiva a Spring Boot: https://spring.io/guides/gs/spring-boot/
Esercitazione sui servizi REST di Spring: https://spring.io/guides/gs/rest-service/
Creazione di un servizio Web RESTful con Spring Boot Actuator: https://spring.io/guides/gs/actuator-service/

Ricorda, questo è solo l’inizio del tuo viaggio con Spring Boot! Continua ad esplorare e costruire applicazioni fantastiche.

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