Spring Boot 3: desenvolva uma API Rest em Java

Criação do projeto - Apresentação

Boas-vindas ao curso de Spring Boot 3: desenvolva uma API Rest em Java!

Me chamo Rodrigo Ferreira e serei o seu instrutor ao longo deste curso, em que vamos aprender como usar o Spring Boot na versão 3.

Rodrigo Ferreira é uma pessoa de pele clara, com olhos castanhos e cabelos castanhos e curto. Veste camiseta preta lisa, tem um microfone de lapela na gola da camiseta, e está sentado em uma cadeira preta. Ao fundo, há uma parede lisa com iluminação azul gradiente.

Objetivos

Desenvolvimento de uma API Rest
CRUD (Create, Read, Update e Delete)
Validações
Paginação e ordenação

O objetivo neste curso é usarmos o Spring Boot para desenvolvermos uma API Rest, com algumas funcionalidades. A ideia é desenvolver um CRUD, sendo as quatro operações fundamentais das aplicações: cadastro, listagem, atualização e exclusão de informações.

Isto é, aprenderemos a desenvolver um CRUD de uma API Rest usando o Spring Boot.

Vamos ver também como aplicar validações das informações que chegam na nossa API, usando o Bean Validation. Depois, vamos aprender a utilizar o conceito de paginação e ordenação das informações que a nossa API vai devolver.

Tecnologias

Spring Boot 3
Java 17
Lombok
MySQL/ Flyway
JPA/Hibernate
Maven
Insomnia

Faremos tudo isso usando algumas tecnologias, como Spring Boot 3, sendo a última versão disponibilizada pelo framework. Usaremos, também, o Java 17 sendo a última versão LTS (Long-term support, em português "Suporte de longo prazo") que possui maior tempo de suporte disponível para o Java.

Aprenderemos a usar alguns recursos das últimas versões do Java para deixarmos o nosso código mais simples. Utilizaremos em conjunto com o projeto o Lombok, responsável por fazer a geração de códigos repetitivos, como getters, setters, toString, entre outros. Tudo via anotações para o código ficar menos verboso.

Usaremos o banco de dados MySQL para armazenar as informações da API e junto com ele utilizaremos a biblioteca Flyway. Isso para termos o controle do histórico de evolução do banco de dados, um conceito que chamamos de Migration.

A camada de persistência da nossa aplicação será feita com a JPA (Java Persistence API), com o Hibernate como implementação dessa especificação e usando os módulos do Spring Boot, para tornar esse processo o mais simples possível.

Usaremos o Maven para gerenciar as dependências do projeto, e também para gerar o build da nossa aplicação. Por último, como focaremos na API Rest (apenas no Back-end), não teremos interface gráfica, como páginas HTML e nem Front-end e aplicativo mobile.

Mas para testarmos a API, usaremos o Insomnia, sendo uma ferramenta usada para testes em API. Com ela, conseguimos simular a requisição para a API e verificar se as funcionalidades implementadas estão funcionando.

Essas são as tecnologias que usaremos ao longo deste curso.

Qual é o nosso projeto?

Trabalharemos em um projeto de uma clínica médica fictícia. Temos uma empresa chamada Voll Med, que possui uma clínica que precisa de um aplicativo para monitorar o cadastro de médicos, pacientes e agendamento de consultas.

Será um aplicativo com algumas opções, em que a pessoa que for usar pode fazer o CRUD, tanto de médicos quanto de pacientes e o agendamento e cancelamento das consultas.

Vamos disponibilizar esse protótipo, mas lembrando que é somente para consultas, para visualizarmos como seria o Front-end. Isso porque o foco deste curso é o Back-end.

A documentação das funcionalidades do projeto ficará em um quadro do Trello com cada uma das funcionalidades. Em cada cartão teremos a descrição de cada funcionalidade, com as regras e validações que vamos implementar ao longo do projeto.

Esse é o nosso objetivo neste curso, aprender a usar o Spring Boot na versão 3 para desenvolvermos o projeto dessa clínica médica, utilizando as tecnologias mencionadas anteriormente.

Vamos lá?

Até a próxima aula!

Criação do projeto - Spring Initializr

O primeiro passo para iniciarmos o nosso projeto é criá-lo, já que neste curso iniciaremos do zero. No caso do Spring Boot, usaremos o Spring Initializr para isso, sendo uma ferramenta disponibilizada pela equipe do Spring Boot para criarmos o projeto com toda estrutura inicial necessária.

Acessaremos o Spring Initializr pelo site https://start.spring.io/. Nele, será exibido alguns campos para preenchermos sobre o projeto e na parte inferior da tela, temos três botões, sendo o primeiro "Generate" para gerar o projeto.

Como o projeto vai usar o Maven como ferramenta de gestão de dependências e de build, deixaremos marcado a opção "Maven Project". Em "Language" deixaremos marcada a opção "Java", que será a linguagem que usaremos.

Na parte "Spring Boot", vamos selecionar a versão do Spring Boot que desejamos gerar o projeto. No momento da gravação deste curso, a mais atual é a versão 2.7.4, mas temos a versão 3.0.0 que não está liberada ainda, porém, é a que iremos selecionar.

Provavelmente no momento em que estiver assistindo a este curso, essa versão já estará liberada, sem ser a versão beta.

Project

Maven Project: selecionado

Language

Java: selecionado

Spring Boot

3.0.0: selecionado

Em "Project Metadata" são solicitadas informações para o Maven configurar o projeto. No campo "Group" colocaremos "med.voll" por ser o nome da empresa, e em "Artifact" e "Name" colocaremos o nome do projeto, "api".

Na descrição, podemos colocar "API Rest da aplicação Voll.med" e em "Package name" (pacote principal da aplicação) ele já pega o group e o artifact, deixaremos como med.voll.api.

No campo "Packaging" é para escolhermos como o projeto será empacotado, que vamos deixar a opção Jar selecionada. Usaremos a versão 17 do Java, sendo a última versão LTS - long term support, que possui maior tempo de suporte.

Project Metadata

Group: med.voll
Artifact: api
Name: api
Description: API Rest da aplicação Voll.med
Package name: med.voll.api
Packaging: Jar
Java: 17

Agora, à direita da tela temos a seção "Dependencies" e um botão "Add dependencies" (com o atalho "Ctrl + B"). Nela, adicionaremos as dependências do Spring que desejamos incluir no projeto. Para isso, vamos clicar no botão "Add dependencies".

Será aberta uma pop-up com diversas dependências do Spring Boot, e do Spring para selecionarmos. Vamos apertar a tecla "Ctrl" do teclado e clicar em cada uma das dependências que desejamos adicionar, sendo elas:

Spring Boot DevTools
Lombok
Spring Web

O Spring Boot DevTools é um módulo do Spring Boot que serve para não precisarmos reiniciar a aplicação a cada alteração feita no código. Isto é, toda vez que salvarmos as modificações feitas no código, ele subirá automaticamente.

Já o Lombok não é do Spring, é uma ferramenta para gerar códigos, como esses códigos verbosos do Java, de getter e setter, baseado em anotações. Usaremos o Lombok para deixarmos o código mais simples e menos verboso.

A próxima dependência é a Spring Web, dado que vamos trabalhar com uma API Rest e precisamos do módulo web. A princípio deixaremos somente essas três dependências, sem incluir as de banco de dados, de migration e de segurança. Mas conforme formos desenvolvendo o projeto, podemos ir adicionando de forma manual.

Após isso, apertaremos a tecla "Esc" para fechar a pop-up. À direita, em "Dependencies", perceba que temos as três listadas.

Depois de preenchermos todas as informações e adicionarmos as dependências, podemos selecionar o botão "Generate" na parte inferior da página.

Dessa forma, vamos gerar o projeto e teremos um arquivo .zip com o projeto compactado. Após finalizado o download, clicaremos no arquivo api.zip para abrir.

Perceba que ele possui uma pasta chamada api, o mesmo nome do projeto que digitamos na tela do Spring Initializr. Clicaremos na pasta api e depois no botão "Extract", para extrair. Você pode usar a ferramenta que achar necessária para descompactar o arquivo .zip.

Criamos o projeto, baixamos o arquivo zip e o descompactamos. O diretório api, é o nosso projeto. Agora, podemos importar na IDE e começar a trabalhar no código.

Na próxima aula, vamos entender como funciona a estrutura de diretórios e como esse projeto já foi criado para nós pelo site do Spring Initializr.

Vamos lá?

Criação do projeto - Estrutura do projeto

Após descompactarmos o projeto, no Desktop teremos uma pasta chamada api, sendo a pasta do nosso projeto e podemos importá-la na IDE.

Neste curso usaremos o Intellij, o ideal é você também usar essa IDE para não termos nenhum problema de configuração ao longo do caminho.

Com o Intellij aberto, na página inicial temos a mensagem "Welcome to intellij IDEA", abaixo três botões na cor azul, sendo eles: New Project, Open e Get from VCS. Clicaremos no segundo botão "Open", para abrirmos o projeto.

Será exibida um pop-up com o título "Open File or Project" (em português, "Abrir arquivo ou projeto"), em que vamos até o local que descompactamos o projeto, "Desktop > api". Após selecionar a pasta api, basta clicar no botão "Ok", na parte inferior direita.

Com isso, o projeto é importado no Intellij. E a primeira coisa que precisamos fazer ao importar um projeto usando o Maven é verificar se ele baixou as dependências corretamente.

Para fazer essa verificação, na lateral direita do Intellij, escrito da vertical, temos a opção "Maven". Clicaremos nela, será mostrado o projeto api com uma seta do lado esquerdo para expandir, vamos selecioná-la.

Temos a pasta Lifecycle, mas percebemos que ele ainda está realizando as configurações. Na parte inferior esquerda temos a mensagem: "Resolving dependencies of api". Isto é, ele está baixando as dependências do projeto para o computador.

Após aguardar um pouco, no painel do Maven (no canto direito), temos as pastas: Lifecycle, Plugins e Dependencies. Clicaremos na seta à esquerda da pasta Dependencies, para expandir.

Perceba que são as dependências que instalamos anteriormente, a do Web, DevTools e Lombox, e também, foi baixado uma starter-test. Esta dependência é o Spring que instala de forma automática, usada para testes automatizados.

Caso uma das dependências não aparece, podemos selecionar o botão "Reload All Maven Projects" ("Recarregar todos os projetos Maven"), no ícone do canto superior esquerdo do painel do Maven. Assim, o projeto será recarregado e será feita uma nova tentativa para baixar as dependências.

Podemos minimizar o painel do Maven, clicando no ícone "-" na parte superior direita.

No painel à esquerda do Intellij, temos a estrutura de diretórios do projeto. Como foi o Spring Initializr que criou essa estrutura de diretórios e arquivos de uma aplicação com Spring Boot para nós, vamos entendê-la.

É um projeto que usa Maven, logo está seguinte a estrutura de diretórios do Maven. Note que temos a pasta src, com os arquivos main e test dentro. Na pasta main, temos o arquivo resources e dentro de test temos o java. E no diretório raiz, temos o projeto pom.xml.

Até agora, nada muito diferente do esperado da estrutura de projetos Maven. Vamos clicar em pom.xml para visualizarmos o xml do Maven para projetos com Spring Boot.

Perceba que as informações que preenchemos no site constam neste arquivo, a partir da linha 11.

pom.xml

//código omitido

<groupId>med.voll</groupId>
<artifactId>api</artifactId>
<version>0.0.1</version>
<name>api</name>
<description>API Rest da aplicação Voll.med</description>
<properties>
    <java.version>17</java.version>
</properties>

//código omitido

Neste trecho temos o artefato, o nome, a descrição e a versão do Java. Mais para baixo, temos a tag <dependencies> com as dependências que incluímos anteriormente também.

Descendo mais o código, temos a tag <build> com um plugin do Maven para fazer o build do projeto. Em <exclude> ele aplica uma configuração devido ao Lombok.

//código omitido

<exclude>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</exclude>

//código omitido

Abaixo, há as tags repositories e pluginRepositories por estarmos usando uma versão não finalizada, que ainda está em beta.

Porém, onde está o Spring Boot? Ele não está declarado como uma dependência neste arquivo. Essa é a primeira diferença em relação à aplicação com Spring tradicional.

O Spring Boot não vem como uma dependência, dentro da tag dependencies. Se subirmos o código do arquivo pom.xml, temos uma tag chamada parent:

//código omitido

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.0.0-M5</version>
    <relativePath/> <!--lookup parent from repository -->
</parent>

//código omitido

A tag parent é como uma herança da orientação a objetos. É como se o pom.xml estivesse herdando de outro pom.xml e dentro dessa tag vem de onde ele vai herdar - sendo o pom.xml do Spring Boot.

O Spring Boot vem dentro da tag parent, em que declaramos para o projeto herdar do arquivo pom.xml do Spring Boot. Nela, passamos a versão, o group Id e o artifact Id do Spring Boot. Isso foi feito de forma automática pelo site do Spring Initializr.

As dependências são os módulos do Spring Boot, ou outras bibliotecas e frameworks que desejarmos usar. Note que nas bibliotecas do Spring Boot não especificamos as versões, colocamos somente o GroupId e o ArtifactId, como em:

//código omitido

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web
</dependency>

//código omitido

Isso acontece porque ele já sabe qual a versão correta de cada dependência, baseada na versão do Spring Boot. Logo, precisamos especificar somente a versão do Spring Boot e não de cada dependência, é uma facilidade que temos.

Assim que funciona o arquivo pom.xml no caso do Maven para um projeto usando o Spring Boot.

Vamos fechar o arquivo pom.xml e expandir o menu da pasta Project, à esquerda do Intellij. Temos a estrutura de diretórios do Maven, mas em "src > main java", perceba que já foi criado o pacote raiz do projeto, o med.voll.api.

Dentro da pasta med.voll.api, temos uma classe java chamada ApiApplication, selecionaremos ela. Por padrão, ele criou essa classe com o nome Api (nome do projeto), Application.

ApiApplication

package med.voll.api;

//código omitido

@SpringBootApplication
public class ApiApplication {

        public static void main(String[] args) {
            SpringApplication.run(ApiApplication.class, args);
        }

}

Note que foi gerada uma classe com o método main, logo, essa é a classe que rodará o projeto. Isso foi criado de forma automática para nós.

À esquerda, em "src > main > resources" (diretório do Maven que ficam os arquivos e as configurações do projeto), temos três pastas: static, templates e application.properties.

No arquivo static é onde ficam as configurações estáticas da aplicação web, como arquivos de csv, JavaScript e imagens. Não usaremos essa pasta, dado que não desenvolveremos uma aplicação web tradicional e sim uma API Rest.

Na pasta templates, estão os templates HTML, as páginas do projeto. Não usaremos essa pasta, também, porque essas páginas não ficarão na API Back-end e sim em outra aplicação Front-end.

Por último, na pasta resources, temos o arquivo application.properties. Clicando nele, note que ele está vazio. Esse é a pasta de configurações do projeto com Spring Boot, usaremos bastante esse arquivo.

Além disso, em "src > test > java", foi criado um pacote com uma classe chamada ApiApplicationTests, de exemplos com testes automatizados. Clicando nela, perceba que é um teste que está vazio.

Posteriormente, vamos aprender mais sobre essa parte de testes automatizados e entenderemos como realizá-los em um projeto com Spring Boot.

Essa é a estrutura de diretórios de um projeto com Spring Boot. No caso, estamos usando o Maven e, por isso, a estrutura de diretórios está estruturada dessa forma.

Criando o projeto no site do Spring Boot, o arquivo pom.xml é configurado corretamente, com as dependências que escolhemos. Gera as configurações do projeto, como vimos em resources e já cria a classe main ApiApplication, com a estrutura inicial para rodarmos a nossa aplicação.

O objetivo deste vídeo era importarmos o projeto na IDE e explorar os diretórios e arquivos criados. Agora, podemos rodar esse projeto e inicializá-lo fazendo um "Hello, world".

Veremos como fazer isso no próximo vídeo. Até lá!

Sobre o curso Spring Boot 3: desenvolva uma API Rest em Java

O curso Spring Boot 3: desenvolva uma API Rest em Java possui 225 minutos de vídeos, em um total de 59 atividades. Gostou? Conheça nossos outros cursos de Java em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

Criação do projeto
Requisições POST
Spring Data JPA
Requisições GET
Requisições PUT e DELETE