O Spring Boot é uma ferramenta que visa facilitar o processo de configuração e publicação de aplicações que utilizem o ecossistema Spring.
O Spring Boot fornece a maioria dos componentes baseados no Spring, necessários em aplicações de maneira pré-configurada, tornando possível termos uma aplicação rodando em produção rapidamente e com o esforço mínimo de configuração e implantação.
Para facilitar ainda mais, o Spring disponibiliza a página Spring Initializr. Nesta página, com alguns poucos cliques, você pode criar um projeto inteiro.
No final, a página irá gerar um projeto Maven ou Gradle, que são gerenciadores de dependências da linguagem Java (semelhante ao NPM do JavaScript/Typescript), pré-configurado e com todos os componentes solicitados especificados.
O Gradle é mais recente e usa uma abordagem baseada em scripts Groovy ou Kotlin. Embora mais flexível, o Maven ainda é mais utilizado em projetos Spring por sua simplicidade e estrutura padronizada.
Nossos projetos Spring Boot utilizarão o Maven como Gerenciador Dependências.
A palavra Maven significa acumulador de conhecimento. No Universo Java, o Maven é uma ferramenta usada para construir e gerenciar qualquer projeto Java, tornando o trabalho diário dos desenvolvedores mais fácil, além de simplificar a compreensão de qualquer projeto baseado na linguagem Java.
Entre as principais características do Maven, destaca-se:
O Maven é responsável por fazer o download das bibliotecas que você vai precisar no seu projeto. Para efetuar esta tarefa, o Maven utiliza o arquivo pom.xml, onde você precisa declarar todas as dependências necessárias para o seu projeto.
Todas as ferramentas e bibliotecas utilizadas nos projetos Spring Boot estão disponíveis em um único servidor na nuvem chamado Maven Central Repository. O Maven Repository facilita e centraliza o download de todas as dependências independentemente de serem as oficiais do Spring ou Desenvolvidas por outras empresas ou pessoas desenvolvedoras (Lombok, Flyway, Mockito, entre outras), dispensando a necessidade de procurar as dependências no Google, por exemplo.
Um projeto que possui muitas bibliotecas e muitas dependências gera alguns problemas no dia a dia, tais como: manter todas atualizadas, fazer o build da sua aplicação, realizar alguns testes e etc. O MAVEN auxilia nestes e outros processos através dos seus scripts prontos que automatizam todas estas tarefas.
 |
DICA: Além do Maven, existe um outro Gerenciador de Dependências para projetos Spring Boot chamado Gradle. Para conhecer o Gradle, acesse: https://gradle.org/ |
|---|
- A Classe Principal, que possui o Método main, inicia um servidor WEB (TOMCAT), que vai gerenciar todas as URL's (Endpoints) disponíveis na API.
- Cada URL deve ser mapeada para um determinado Método de uma Classe.
- A execução desse Método retornará uma resposta quando acionamos a URL.
- A partir daí, criamos nossos objetos que implementarão todas as lógicas necessárias.
O Apache Tomcat é um servidor web e contêiner de servlets Java de código aberto, amplamente utilizado para executar aplicações Java baseadas em tecnologias como Servlets, JSP (JavaServer Pages) e Spring Framework.
Um Servlet é um componente Java do lado do servidor, utilizado para processar requisições HTTP e gerar respostas dinâmicas, geralmente em aplicações web. Ele funciona como uma ponte entre o cliente (navegador ou ferramenta como o Insomnia) e o servidor de aplicações (como o Tomcat). Em outras palavras, um servlet é como um programa Java que roda dentro de um servidor e responde a requisições da web.
O Spring Boot utiliza o Apache Tomcat embutido como servidor padrão, eliminando a necessidade de instalação externa. Também é possível configurar Jetty ou Undertow caso necessário.
Quais ENDPOINTS vamos oferecer? (Um endpoint é uma URL associada a um Método do protocolo HTTP: GET, POST, PUT, DELETE).
Em geral, temos um endpoint para cada Método HTTP (podemos ter mais de um desde que os endereços sejam diferentes), em cada objeto do nosso modelo de negócios:
Objeto de Negócios: POSTAGEM
- URL para recuperar dados das postagens ( Método GET)
- URL para recuperar dados de uma postagem específica ( Método GET)
- URL para recuperar dados de várias postagens de acordo com um critério específico ( Método GET)
- URL para inserir uma nova postagem (Método POST)
- URL para atualizar os dados de uma postagem (Método PUT)
- URL para apagar uma postagem (Método DELETE)
Como estes endpoints estarão estruturados no nosso sistema?
Vamos discutir isto mais adiante...
- Abra o Navegador de sua preferência e acesse o Spring Initializr, através do endereço: https://start.spring.io
Vamos configurar o template inicial do nosso projeto conforme a figura abaixo:
| Item | Descrição |
|---|---|
| Project | Define o Gerenciador de Dependências (Maven Project). |
| Language | Define a Linguagem (Java). |
| Spring Boot | Define a versão do Spring Boot, que será utilizada. Mantenha a versão indicada pelo Spring Initializr. |
| Group | O Domínio Reverso da sua Empresa ou Organização. Exemplo: generation.com 🡪 com.generation |
| Artifact | O artefato a ser gerado, ou seja, o mesmo nome do projeto. |
| Name | Nome do Projeto (letras minúsculas, sem acentos ou espaços). |
| Description | Breve descrição do projeto. |
| Package Name | Estrutura do pacote inicial da aplicação (Group + Artifact). Exemplo: com.generation.helloworld |
| Packaging | Define como a aplicação será empacotada (JAR). |
| Java Version | Versão do Java (a versão da imagem pode ser diferente da sua tela). |
 |
ATENÇÃO: Na época em que este material foi escrito, a versão atual do Spring Boot era 3.0.4. Como o Spring Boot atualiza a sua versão com frequência, a versão atual do Spring Boot pode ser outra. Em caso de dúvidas, verifique com o seu instrutor. |
|---|
No projeto Hello World! vamos adicionar 2 dependências: Spring Web e Spring Boot Dev Tools.
-
Na página do Spring Initializr, clique no botão ADD DEPENDENCIES... CTRL + B
-
Na caixa de pesquisa (indicada na figura com uma seta amarela), digite o nome da dependência que você deseja adicionar e clique sobre o nome da Dependência para adicionar (indicada na figura com um retângulo vermelho)
-
Repita os itens 2 e 3 para adicionar a segunda Dependência (Spring Boot Dev Tools)
|
DICA: Mantenha a tecla CTRL pressionada ao clicar sobre a Dependência que será adicionada ao projeto. Desta forma, a janela se manterá aberta e você conseguirá selecionar todas Dependências do projeto de uma só vez. |
|---|
- Após adicionar as duas Dependências, o item Dependencies do Spring Intializr estará igual a figura abaixo:
| Dependência | Descrição |
|---|---|
| Spring Web | Fornece todas as Bibliotecas necessárias para trabalhar com o protocolo HTTP. |
| Spring Boot Dev Tools | Permite a atualização do projeto em tempo real durante o processo de Desenvolvimento da aplicação. |
- O seu projeto deverá estar semelhante a figura abaixo:
-
Clique no botão
-
Faça o Download do Projeto
Para desenvolver os nossos projetos Spring utilizaremos a IDE Spring Tools Suite (STS). O STS é baseado no Eclipse e já está totalmente configurada para executar o Spring, sem a necessidade de instalar outros aplicativos. A única exigência do STS é que você possua o Java Development Kit - JDK instalado no seu computador (mínimo versão 17).
|
DICA: Caso você tenha alguma dúvida quanto a instalação do STS, consulte o Guia de Instalação do STS . |
|---|
- Extraia o arquivo zip, contendo o projeto Spring Boot, dentro da pasta Workspace do STS
|
ATENÇÃO: A pasta Workspace do STS geralmente está localizada em: C:\Users\seu usuario\Documents\workspace-spring-tool-suite-4-4.17.2.RELEASE, onde: 4.17.2 é a versão do STS no momento em que este conteúdo foi escrito. |
|---|
- Abra o STS
- Importe o projeto no STS através da opção File 🡪 Import
- Na janela Import, clique na pasta Maven, na opção Existing Maven Projects
- No item Root Directory, clique no botão Browse e selecione a pasta do projeto (indicado em azul na imagem abaixo).
- No item Projects, selecione o arquivo pom.xml e clique no botão Finish para concluir a importação
- A estrutura do nosso projeto importado para o STS ficará de acordo com a imagem abaixo:
-
As pastas cujo nome iniciam com src são chamadas de Source Folder.
-
As estruturas que estão contidas dentro das pastas src/main/java e src/test/java são chamadas de Package (Pacote).
-
Na pasta src/main/java está localizado o pacote principal da aplicação. Todas as Camadas da aplicação são desenvolvidas dentro deste pacote.
-
Na pasta src/test/java está localizado o pacote de testes da aplicação. Todas as Camadas de teste da aplicação são desenvolvidas dentro deste pacote.
| Item | Descrição |
|---|---|
| src/main/java | Source Folder mais importante da aplicação, onde será desenvolvido todo o código da nossa aplicação dentro do pacote principal (em nosso exemplo: com.helloworld.helloworld). Dentro deste pacote existe um arquivo com o nome do projeto + a palavra Application (em nosso exemplo: HelloworldApplication.java), que é responsável por inicializar a aplicação (Classe Main). Não apague este arquivo ou altere a estrutura de pastas do projeto. |
| src/main/resources | Source Folder responsável por manter os recursos da aplicação, ou seja, os arquivos de configuração do projeto. O mais importante deles é o application.properties, que é o responsável por manter as configurações de Data, Hora, Fuso-horário, Banco de Dados, entre outras. |
| src/test/java | Source Folder onde serão desenvolvidas as Classes de Teste da aplicação, dentro do pacote de testes. Observe que o nome do pacote é o mesmo do pacote da Source Folder Principal. |
| JRE System Library | Neste pacote, o Maven faz o download do Compilador Java (JDK) durante a importação do projeto para o STS |
| Maven Dependencies | Neste pacote, o Maven faz o download de todas as Dependências inseridas no projeto (ver arquivo pom.xml) durante a importação do projeto para o STS |
| pom.xml | O Project Object Model (POM) é o arquivo principal de configuração do Maven. É um arquivo XML que contém informações sobre o projeto e detalhes de configuração usados pelo Maven para construir o projeto. Não apague este arquivo e ao fazer alterações tenha muito cuidado para manter a estrutura do arquivo. |
A Classe principal do projeto (Main), é responsável por inicializar o nosso projeto. Esta Classe é gerada automaticamente pelo Spring Boot durante a criação do projeto e raramente precisaremos fazer alterações nela. Vamos abrir a Classe HelloworldApplication.java (Classe principal do nosso projeto) e conhecer o seu conteúdo.
- No STS, na Package Explorer, clique na pasta src/main/java e na sequência clique no pacote principal com.helloworld.helloworld.
- Clique duas vezes sobre o arquivo HelloworldApplication.java.
- Será aberto o código abaixo:
Linha 06: Foi invocada a anotação @SpringBootApplication que indica que o nosso projeto é do tipo Spring Boot Application. Esta anotação inicializa uma série de configurações padrão em projetos Spring Boot, além de analisar os pacotes em busca das Classes que compõem a aplicação, inicializando as configurações especificas de cada uma.
Uma anotação (ou annotation) em Java é um recurso da linguagem que permite adicionar metadados (informações extras) ao código. Essas informações não afetam diretamente a lógica do programa, mas são interpretadas pelo compilador, frameworks ou ferramentas durante a execução ou compilação.
Pense em uma anotação como uma etiqueta colada sobre um pedaço do código (Classe, Método ou Objeto), dizendo: "Ei, ferramenta, aqui tem algo especial. Faça algo com isso."
Linha 10: O Método run da Classe SpringApplication inicializa a aplicação executando a Classe Principal da aplicação (em nosso exemplo: HelloworldApplication.java). A Classe SpringApplication fornece uma maneira simples de inicializar um aplicativo Spring que é iniciado a partir de um Método main() (Semelhante ao do Java), onde é indicada a Classe principal da Aplicação.
 |
ALERTA DE BSM: Mantenha a Atenção aos Detalhes ao criar as Classes do projeto. As Classes devem ser criadas no Pacote main, dentro da Source Folder src/main/java. Crie as Classes com calma e não altere a estrutura de pastas e pacotes do projeto. |
|---|
Primeiro vamos criar o pacote Controller, onde será criada a nossa Classe controladora.
- Clique com o botão direito do mouse sobre o pacote principal da aplicação (em nosso exemplo: com.helloworld.helloworld).
- Na sequência, clique na opção New 🡪 Package
- Na janela New Java Package, no item Name, acrescente no final do nome do pacote .controller, como mostra a figura abaixo:
- Clique no botão Finish para concluir.
Na sequência, vamos criar a Classe Controladora que chamaremos de HelloWorldController.
-
Clique com o botão direito do mouse sobre o pacote controller da aplicação (em nosso exemplo: com.helloworld.helloworld.controller).
-
Na sequência, clique na opção New 🡪 Class
- Na janela New Java Class, no item Name, digite o nome da Classe (em nosso exemplo: HelloWorldController), como mostra a figura abaixo:
- Clique no botão Finish para concluir.
Agora vamos criar o código da Classe Controladora HelloWorldController, igual a figura abaixo:
linha 07: A anotação @RestController define que a Classe é do tipo controladora rest, que receberá requisições que serão compostas por:
- URL: Endereço da requisição (/hello-world)
- Verbo: Define qual Método HTTP será acionado na Classe controladora.
- Corpo da requisição (Request Body): Objeto que contém os dados que serão criados ou atualizados.
Após receber e processar a requisição, a Classe Controladora Responderá a estas requisições com:
- Um Código de Status HTTP pertinente a operação que está sendo realizada
- O resultado do processamento (Dados de uma consulta, por exemplo) inserido diretamente no corpo da resposta (Response Body)
linha 08: A anotação @RequestMapping é usada para mapear solicitações para os Métodos da Classe controladora HelloWorldController, ou seja, definir a URL (endereço) padrão do recurso (em nosso exemplo: /hello-world). Ao digitar a url do servidor seguida da url do recurso, o Spring envia a requisição para a Classe responsável pelo recurso com este endereço.
Exemplo: http://localhost:8080/hello-world é o endereço do recurso hello-world da Classe Controladora HelloWorldController.
linha 11: A anotação @GetMapping mapeia solicitações HTTP GET para Métodos de tratamento específicos, ou seja, indica que o Método helloWorld() responderá a todas as requisições do tipo HTTP GET, enviadas no endereço http://localhost:8080/hello-world, do recurso hello-world.
linhas 12-14: O Método helloWorld() retorna uma mensagem de boas vindas, ou seja, quando o endereço for enviado via Postman ou via Browser (Navegador), será exibida a mensagem de boas vindas Hello World!!!
Para concluir, não esqueça de Salvar o código (File 🡪 Save All)
- No STS, na Package Explorer, clique na pasta src/main/java e na sequência clique no pacote principal com.helloworld.helloworld.
- Clique com o botão direito do mouse sobre o arquivo HelloworldApplication.java.
- No menu que será aberto, clique na opção Run AS 🡪 Spring Boot App como mostra a figura abaixo:
-
Observe que será aberta a janela Console com o log da execução do código.
-
Neste momento o STS varre todo o seu projeto procurando por TODAS as Classes que contenham Métodos main e checará se o código está correto ou se falta alguma Dependência.
- Caso esteja tudo certo, o Console exibirá ao final do processamento a mensagem: Started Helloworld1Application in 4.302 seconds (JVM running for 6.036), como mostra a figura abaixo:
Para testar a aplicação, utilizaremos o aplicativo Insomnia.
|
DICA: Caso você tenha alguma dúvida quanto a instalação do Insomnia, consulte o Guia de Instalação do Insomnia. |
|---|
O Insomnia é um API Client que simplifica o processo de desenvolvimento do Backend de uma aplicação WEB. O Insomnia permite criar, compartilhar e testar aplicações WEB de forma simples e prática. O Insomnia permite aos usuários criar e salvar requisições HTTP e HTTPS (Request) desde as mais simples até as mais complexas, bem como ler as suas respostas HTTP (Response).
Para testar a nossa API, vamos criar uma requisição do tipo GET, onde iremos indicar o servidor (localhost), a porta padrão do Spring (8080) e o endereço do recurso (/hello-world).
- Na janela principal do Insomnia, clique no botão Create e clique na opção Request Collection.
- Na janela que será aberta, informe o nome da Collection (Hello World) e clique no botão Create para concluir.
- Na Collection Hello World, clique no botão
. No menu que será aberto, clique na opção New HTTP Request.
- Será criada uma nova Requisição (New Request) dentro da collection Hello World.
- Dê um duplo clique sobre a nova requisição (New Request), informe o nome da requisição (indicado na imagem abaixo na cor amarela) e pressione a tecla enter do seu teclado.
- Selecione o Método HTTP que será utilizado (GET) na requisição, indicado na imagem abaixo na cor verde.
- Configure a requisição conforme a imagem abaixo:
- No item marcado em amarelo na imagem acima, informe o endereço da Requisição. A requisição Hello World foi configurada da seguinte maneira:
- A primeira parte (http://localhost:8080) é o endereço do servidor local.
- A segunda parte é o endereço do endpoint configurado na anotação @RequestMapping (/hello-world).
-
Para testar a requisição, com a aplicação rodando, clique no botão
.
-
O resultado da requisição você confere na imagem abaixo:
- Se a mensagem de boas vindas: Hello World !!! for exibida, a aplicação está funcionando corretamente.
Voltar