Criar uma Aplicação REST com Spring Boot e Gradle

Tutoriais

Gradle

Neste tutorial, criaremos um simples serviço web RESTful usando Spring Boot e Gradle. O Spring Boot facilita a criação de aplicações autônomas, de produção, baseadas no Spring, e Gradle é uma poderosa ferramenta de build que simplifica o processo de build.

O que é REST?

REST, Transferência de Estado Representacional, é um conjunto de princípios arquiteturais que garantem que suas APIs sejam interoperáveis, escaláveis e fáceis de manter. Imagine construir com blocos de Lego — diferentes aplicações podem interagir perfeitamente com sua API, contanto que sigam as diretrizes RESTful, assim como os Legos se encaixam independentemente do conjunto.

O que é Spring Boot?

Spring Boot é um framework poderoso que simplifica o processo de desenvolvimento. Pense nele como uma caixa de ferramentas pré-montada, abastecida com componentes e recursos, economizando seu tempo e esforço na configuração da infraestrutura de sua aplicação. Você pode se concentrar na criação da lógica central de sua API sem ser atolado em código repetitivo.

Prontos para liberar seu desenvolvedor de API interno? Este guia o capacitará a criar sua primeira aplicação REST do Spring Boot usando Gradle, uma ferramenta de build popular. Seja você um programador Java experiente ou apenas começando sua exploração, esta jornada passo a passo o equipará com o conhecimento essencial para construir serviços web dinâmicos e interativos.

Principais Aprendizados

Criar APIs RESTful usando o Spring Boot: O Spring Boot é um framework Java popular que simplifica o processo de desenvolvimento de APIs RESTful. Ele oferece uma ampla gama de recursos prontos para uso, como configuração automática e injeção de dependências, o que pode economizar tempo e esforço.
Compreender os conceitos centrais das APIs RESTful: REST significa Transferência de Estado Representacional. É um conjunto de princípios arquiteturais que garantem que suas APIs sejam interoperáveis, escaláveis e fáceis de manter. Alguns dos conceitos chave das APIs RESTful incluem representação de recursos, métodos HTTP e códigos de status.
Implementar operações básicas CRUD: CRUD significa Criar, Ler, Atualizar e Excluir. Estas são as operações básicas que você precisará implementar em seus endpoints da API para permitir que os usuários interajam com seus dados.
Testar sua API minuciosamente: É importante testar sua API minuciosamente antes de implantá-la em produção. Isso ajudará a garantir que ela esteja funcionando conforme o esperado e que não haja erros.
Explorar funcionalidades avançadas: À medida que você se familiariza mais com o Spring Boot e as APIs RESTful, pode explorar funcionalidades mais avançadas, como gerenciamento de dados, segurança e autenticação.

Ao combinar o poder do REST com a abordagem enxuta do Spring Boot, você será capaz de criar APIs eficientes e amigáveis que podem se integrar perfeitamente a outras aplicações. Então, está pronto para desbloquear o potencial das APIs RESTful com o Spring Boot e o Gradle? Vamos começar!

Pré-requisitos

JDK 11 instalado
Versão mais recente do Gradle instalada
Compreensão básica de conceitos Java e Spring

Passo 1: Configurar o Projeto

Para começar com o projeto, precisamos iniciar os seguintes 3 passos.

Abra um terminal ou prompt de comando
Crie um novo diretório para o seu projeto
Navegue até o diretório do projeto
Inicie uma estrutura básica de projeto Spring Boot

Shell

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

Passo 2: Criar um Projeto Spring Boot

Por favor, edite o arquivo build.gradle existente no diretório com o seguinte conteúdo.

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

Isso configura um projeto Spring Boot básico com as dependências necessárias.

Passo 3: Criar um Controlador REST

Crie um novo arquivo chamado HelloController.java no diretório src/main/java/com/example com o seguinte conteúdo:

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

Isso define um controlador REST com endpoints para operações GET, POST, PUT e DELETE em uma simples lista de mensagens.

Passo 4: Executar a Aplicação

Abra um terminal ou prompt de comando e execute o seguinte comando:

Java

./gradlew bootRun

Visite http://localhost:8080/api/hello no seu navegador para verificar o endpoint inicial. Você pode usar ferramentas como curl, Postman ou qualquer cliente REST para testar os outros endpoints.

Passo 5: Escrever Casos de Teste

Crie um novo arquivo chamado HelloControllerTest.java na pasta src/test/java/com/example com o seguinte conteúdo:

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() {
        // Limpar mensagens antes de cada teste
        // Isso garante um estado limpo para cada teste
        // Alternativamente, você poderia usar um banco de dados de teste ou dados simulados
        // dependendo dos seus 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"));
    }
}

Esses casos de teste usam recursos de teste do Spring Boot para simular solicitações HTTP e verificar o comportamento do controlador REST.

Passo 6: Executar Testes

Abra um terminal ou prompt de comando e execute o seguinte comando para executar os testes:

Java

./gradlew test

Revise os resultados dos testes para garantir que todos os testes passem com sucesso.

Conclusão

Parabéns! Você criou com sucesso um serviço web REST básico com operações CRUD usando Spring Boot e Gradle. Este tutorial cobriu a implementação de endpoints para operações GET, POST, PUT e DELETE, juntamente com os casos de teste correspondentes.

Notas Adicionais:

Este é um exemplo muito básico. Você pode expandi-lo criando mais endpoints, lidando com diferentes métodos HTTP (POST, PUT, DELETE) e adicionando funcionalidades como gerenciamento de dados.
Considere adicionar testes unitários para seu controlador usando frameworks como JUnit.
Você pode usar o Spring Initializr (https://start.spring.io/) para gerar rapidamente um projeto com dependências e configurações adicionais.

Para aprender mais, confira esses recursos:

Guia de Introdução ao Spring Boot: https://spring.io/guides/gs/spring-boot/
Tutorial de Serviços REST do Spring: https://spring.io/guides/gs/rest-service/
Criando um Serviço Web RESTful com o Spring Boot Actuator: https://spring.io/guides/gs/actuator-service/

Lembre-se, isso é apenas o começo de sua jornada com o Spring Boot! Continue explorando e construindo aplicativos incríveis.

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