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 aplicativos autônomos e de produção baseados em Spring, e o 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 arquitetônicos que garantem que suas APIs sejam interoperáveis, escaláveis e fáceis de manter. Imagine construir blocos de Lego — diferentes aplicativos podem interagir perfeitamente com sua API desde que sigam as diretrizes RESTful, assim como os Legos se encaixam independentemente do seu conjunto.

O que é Spring Boot?

Spring Boot é um framework poderoso que simplifica o processo de desenvolvimento. Pense nele como um kit pré-construído com componentes e recursos, economizando seu tempo e esforço na configuração da infraestrutura do seu aplicativo. Você pode se concentrar na criação da lógica central da sua API sem ficar preso em código repetitivo.

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

Dicas Importantes

Criar APIs RESTful usando 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.
Entenda os conceitos centrais das APIs RESTful: REST significa Transferência de Estado Representacional. É um conjunto de princípios arquitetônicos que garantem que suas APIs sejam interoperáveis, escaloná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 nos endpoints de sua API para permitir que os usuários interajam com seus dados.
Teste sua API minuciosamente: É importante testar sua API minuciosamente antes de implantá-la em produção. Isso ajudará a garantir que esteja funcionando conforme o esperado e que não haja erros.
Explore 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.

Combinando o poder do REST com a abordagem simplificada 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 do 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 o Aplicativo

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 RESTful básico com operações CRUD usando o Spring Boot e o Gradle. Este tutorial cobriu a implementação de endpoints para operações GET, POST, PUT e DELETE, juntamente com os casos de teste correspondentes.

Observações 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 o seu controlador usando frameworks como o 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 aplicações incríveis.

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