Crear una Aplicación REST de Spring Boot Con Gradle

Tutoriales

Gradle

En este tutorial, crearemos un simple servicio web RESTful utilizando Spring Boot y Gradle. Spring Boot facilita la creación de aplicaciones independientes y de nivel de producción basadas en Spring, y Gradle es una poderosa herramienta de compilación que simplifica el proceso de compilación.

¿Qué es REST?

REST, Representational State Transfer, es un conjunto de principios arquitectónicos que garantizan que sus API sean interoperables, escalables y fácilmente mantenibles. Imagina construir bloques de Lego: diferentes aplicaciones pueden interactuar de manera transparente con tu API siempre que sigan las pautas RESTful, al igual que los Lego se enganchan sin importar su conjunto.

¿Qué es Spring Boot?

Spring Boot es un potente marco que simplifica el proceso de desarrollo. Piénsalo como un kit preconstruido repleto de componentes y características, ahorrándote tiempo y esfuerzo en la configuración de la infraestructura de tu aplicación. Puedes centrarte en diseñar la lógica central de tu API sin atascarte en código repetitivo.

¿Listo para desatar tu interior de desarrollador de API? Esta guía te empoderará para crear tu primera aplicación REST de Spring Boot utilizando Gradle, una herramienta de compilación popular. Ya seas un programador Java experimentado o estés comenzando tu exploración, este viaje paso a paso te proporcionará el conocimiento esencial para construir servicios web dinámicos e interactivos.

Puntos clave

Crear API RESTful utilizando Spring Boot: Spring Boot es un popular framework de Java que simplifica el proceso de desarrollo de API RESTful. Proporciona una amplia gama de características listas para usar, como la configuración automática y la inyección de dependencias, lo que puede ahorrarte tiempo y esfuerzo.
Comprender los conceptos centrales de las API RESTful: REST significa Transferência de Estado Representacional. Es un conjunto de principios arquitectónicos que garantizan que sus API sean interoperables, escalables y fácilmente mantenibles. Algunos de los conceptos clave de las API RESTful incluyen la representación de recursos, los métodos HTTP y los códigos de estado.
Implementar operaciones básicas CRUD: CRUD significa Crear, Leer, Actualizar y Borrar. Estas son las operaciones básicas que necesitará implementar en los puntos finales de su API para permitir que los usuarios interactúen con sus datos.
Probar su API a fondo: Es importante probar su API a fondo antes de implementarla en producción. Esto le ayudará a asegurarse de que funcione como se espera y de que no haya errores.
Explorar funcionalidades avanzadas: A medida que se familiarice más con Spring Boot y las API RESTful, puede explorar funcionalidades más avanzadas, como la gestión de datos, la seguridad y la autenticación.

Al combinar el poder de REST con el enfoque simplificado de Spring Boot, podrá crear API eficientes y fáciles de usar que se integren sin problemas con otras aplicaciones. ¿Estás listo para desbloquear el potencial de las API RESTful con Spring Boot y Gradle? ¡Empecemos!

Requisitos previos

JDK 11 instalado
Versión más reciente de Gradle instalada
Comprensión básica de conceptos de Java y Spring

Paso 1: Configurar el Proyecto

Para comenzar con el proyecto, necesitamos iniciar los siguientes 3 pasos.

Abra un terminal o una ventana de comandos
Cree un nuevo directorio para su proyecto
Navegue hasta el directorio del proyecto
Inicie una estructura básica de proyecto Spring Boot

Shell

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

Paso 2: Crear un Proyecto Spring Boot

Por favor, edite el archivo build.gradle existente presente en el directorio con el contenido a continuación.

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

Esto configura un proyecto Spring Boot básico con las dependencias necesarias.

Paso 3: Crear un Controlador REST

Cree un nuevo archivo llamado HelloController.java en el directorio src/main/java/com/example con el siguiente contenido:

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

Esto define un controlador REST con puntos finales para operaciones GET, POST, PUT y DELETE en una simple lista de mensajes.

Paso 4: Ejecutar la Aplicación

Abra un terminal o una ventana de comandos y ejecute el siguiente comando:

Java

./gradlew bootRun

Visite http://localhost:8080/api/hello en su navegador para verificar el punto final inicial. Puede utilizar herramientas como curl, Postman o cualquier cliente REST para probar los otros puntos finales.

Paso 5: Escribir Casos de Prueba

Crea un archivo nuevo llamado HelloControllerTest.java en el directorio src/test/java/com/example con el siguiente contenido:

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() {
        // Borrar mensajes antes de cada prueba
        // Esto asegura un estado limpio para cada prueba
        // Alternativamente, podrías usar una base de datos de prueba o datos simulados
        // dependiendo de tus requisitos
        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"));
    }
}

Estos casos de prueba utilizan las características de prueba de Spring Boot para simular solicitudes HTTP y verificar el comportamiento del controlador REST.

Paso 6: Ejecutar Pruebas

Abre un terminal o línea de comandos y ejecuta el siguiente comando para realizar las pruebas:

Java

./gradlew test

Revisa los resultados de las pruebas para asegurarte de que todas las pruebas pasen exitosamente.

Conclusión

¡Felicidades! Has creado con éxito un servicio web RESTful básico con operaciones CRUD utilizando Spring Boot y Gradle. Este tutorial cubrió la implementación de puntos finales para operaciones GET, POST, PUT y DELETE junto con casos de prueba correspondientes.

Notas Adicionales:

Este es un ejemplo muy básico. Puedes expandirlo creando más puntos finales, manejando diferentes métodos HTTP (POST, PUT, DELETE) y agregando funcionalidad como administración de datos.
Considera agregar pruebas unitarias para tu controlador utilizando frameworks como JUnit.
Puedes utilizar el Spring Initializr (https://start.spring.io/) para generar rápidamente un proyecto con dependencias y configuraciones adicionales.

Para seguir aprendiendo, consulta estos recursos:

Guía de Introducción a Spring Boot: https://spring.io/guides/gs/spring-boot/
Tutorial de Servicios REST de Spring: https://spring.io/guides/gs/rest-service/
Construyendo un Servicio Web RESTful con Spring Boot Actuator: https://spring.io/guides/gs/actuator-service/

Recuerda, ¡esto es solo el comienzo de tu viaje con Spring Boot! Sigue explorando y construyendo aplicaciones increíbles.

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