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 60 atividades. Gostou? Conheça nossos outros cursos de Java em Back-end, ou leia nossos artigos de Back-end.

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