TP2.1 - Aplicação "Greeting" com Spring Boot

Objetivos

Este exercício prático permitirá que você:

• Crie seu primeiro projeto Spring Boot com o Spring Initializr
• Configure o Visual Studio Code para desenvolvimento com Spring Boot
• Crie um controlador REST simples
• Compreenda a estrutura de um projeto Spring Boot
• Resolva problemas comuns de inicialização

Pré-requisitos

Antes de começar, certifique-se de ter instalado:

• JDK 17 ou superior
• Visual Studio Code
• Extensões VS Code necessárias:
  • Extension Pack for Java
  • Spring Boot Extension Pack
  • Maven for Java
• Maven 3.9+ (recomendado para estabilidade)

Verificação dos Pré-requisitos

# Verificar Java
java -version

# Verificar Maven
mvn -version

---

Parte 1: Criação do Projeto com Spring Initializr

Etapa 1.1: Acessar o Spring Initializr

Abra seu navegador e acesse: https://start.spring.io/

Etapa 1.2: Configuração do Projeto

Configure seu projeto com os seguintes parâmetros:

Parâmetro	Valor
Project	Maven
Language	Java
Spring Boot	3.2.0 (ou versão estável mais recente)
Group	com.example
Artifact	greeting
Name	greeting
Package name	com.example.demo
Packaging	Jar
Java	17

Etapa 1.3: Adição de Dependências

Clique em "Add Dependencies" e adicione:

• Spring Web - Para criar aplicações web REST

Importante: Para este exercício, adicionamos APENAS Spring Web. Não adicione:

• Spring Data JPA
• PostgreSQL Driver
• Lombok

(Veremos essas dependências nos próximos exercícios)

Etapa 1.4: Geração do Projeto

1. Clique no botão Generate
2. Um arquivo ZIP será baixado: greeting.zip
3. Extraia este arquivo no seu workspace (por exemplo: C:\workspace\greeting)

---

Parte 2: Abrindo o Projeto no VS Code

Etapa 2.1: Abrir o Projeto

1. Inicie o Visual Studio Code
2. Menu: File → Open Folder
3. Selecione a pasta greeting extraída
4. O VS Code irá detectar automaticamente o projeto Maven

Etapa 2.2: Aguarde a Inicialização

O VS Code irá:

• Baixar as dependências do Maven
• Configurar o projeto Java
• Indexar os arquivos

Nota: A primeira vez pode levar alguns minutos.

Etapa 2.3: Estrutura do Projeto

Você deve ver a seguinte estrutura:

greeting/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demo/
│   │   │       └── GreetingApplication.java
│   │   └── resources/
│   │       └── application.properties
│   └── test/
├── pom.xml
└── README.md

---

Parte 3: Criação das Classes

Etapa 3.1: Criar a Classe Greeting

1. No VS Code, clique com o botão direito em src/main/java/com/example/demo
2. Selecione New File
3. Nomeie o arquivo: Greeting.java

Código da classe Greeting:

package com.example.demo;

public class Greeting {

    private Long id;
    private String content;
    
    public Greeting(Long id, String content) {
        super();
        this.id = id;
        this.content = content;
    }
    
    public Long getId() {
        return id;
    }
    
    public String getContent() {
        return content;
    }
    
    public void setId(Long id) {
        this.id = id;
    }
    
    public void setContent(String content) {
        this.content = content;
    }
}

Etapa 3.2: Criar a Classe GreetingController

1. Na mesma pasta, crie um novo arquivo: GreetingController.java

Código do controlador:

package com.example.demo;

import java.util.concurrent.atomic.AtomicLong;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    private static final String template = "Hello, %s!";
    private final AtomicLong counter = new AtomicLong();
    
    @GetMapping("/greeting")
    public Greeting greeting(@RequestParam(value="name") String name) {
        return new Greeting(counter.incrementAndGet(), String.format(template, name));
    }
}

---

Parte 4: Verificação do pom.xml

Etapa 4.1: Abrir pom.xml

Abra o arquivo pom.xml e verifique as dependências.

Dependências esperadas (apenas 2):

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

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Etapa 4.2: Explicação das Dependências

Dependência	Função
spring-boot-starter-web	Fornece tudo o necessário para criar aplicações web REST (Tomcat, Spring MVC, Jackson)
spring-boot-starter-test	Fornece ferramentas de teste (JUnit, Mockito, etc.)

Etapa 4.3: Se Você Tiver Dependências Adicionais

Se você adicionou por engano:

• spring-boot-starter-data-jpa
• postgresql
• lombok

REMOVA-OS do pom.xml para evitar erros.

Por quê? Essas dependências exigem configuração adicional (banco de dados, etc.) que não será feita neste exercício.

---

Parte 5: Compilação e Execução

Etapa 5.1: Limpar e Compilar com Maven

Opção A: Via Terminal Integrado do VS Code

1. Abra o terminal: Terminal → New Terminal
2. Execute os comandos:

mvn clean
mvn install

Opção B: Via Extensão Maven

1. Abra a visualização Maven (ícone Maven na barra lateral)
2. Expanda seu projeto
3. Clique com o botão direito em clean → Run
4. Clique com o botão direito em install → Run

Etapa 5.2: Executar a Aplicação

Opção A: Via Terminal

mvn spring-boot:run

Opção B: Via VS Code

1. Abra GreetingApplication.java
2. Clique em Run acima do método main
3. Ou pressione F5

Etapa 5.3: Verificar a Inicialização

Você deve ver no console:

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::

...
Started GreetingApplication in X.XXX seconds

O servidor inicia na porta 8080 por padrão.

---

Parte 6: Teste da Aplicação

Etapa 6.1: Teste no Navegador

Abra seu navegador e teste as seguintes URLs:

Teste 1:

http://localhost:8080/greeting?name=Armstrong

Resultado esperado:

{
  "id": 1,
  "content": "Hello, Armstrong!"
}

Teste 2:

http://localhost:8080/greeting?name=François

Resultado esperado:

{
  "id": 2,
  "content": "Hello, François!"
}

Teste 3:

http://localhost:8080/greeting?name=Patrick

Resultado esperado:

{
  "id": 3,
  "content": "Hello, Patrick!"
}

Etapa 6.2: Observar o Contador

Atualize a página várias vezes e observe:

• O ID é incrementado a cada chamada
• O contador é mantido em memória enquanto a aplicação está em execução

Etapa 6.3: Teste com Postman (Opcional)

Se você tiver o Postman instalado:

1. Crie uma nova requisição GET
2. URL: http://localhost:8080/greeting?name=SeuNome
3. Clique em Send

---

Parte 7: Resolução de Problemas

Problema 1: Erro de Inicialização - Dependências Ausentes

Sintoma:

Failed to configure a DataSource: 'url' attribute is not specified

Causa: Provavelmente você tem spring-boot-starter-data-jpa no seu pom.xml

Solução:

Abra o pom.xml e remova estas dependências se estiverem presentes:

<!-- REMOVER -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

Depois, execute novamente:

mvn clean install
mvn spring-boot:run

Problema 2: Porta 8080 Já Está em Uso

Sintoma:

Port 8080 was already in use.

Causa: Outro aplicativo já está usando a porta 8080.

Solução 1: Alterar a Porta

Abra src/main/resources/application.properties e adicione:

server.port=8081

Ou se você usa application.yml:

server:
  port: 8081

Depois, teste com: http://localhost:8081/greeting?name=Test

Solução 2: Finalizar o Processo que Usa a Porta 8080

No Windows:

1. Encontrar o processo:

netstat -ano | findstr :8080

2. Anote o PID (Process ID) na última coluna

3. Finalize o processo (como administrador):

taskkill /F /PID <número_do_PID>

No macOS/Linux:

1. Encontrar o processo:

lsof -i :8080

2. Finalize o processo:

kill -9 <PID>

Problema 3: Extensões VS Code Ausentes

Sintoma: O VS Code não detecta o projeto Java

Solução:

1. Abra a aba de Extensões (Ctrl + Shift + X)
2. Instale estas extensões:
   • Extension Pack for Java (Microsoft)
   • Spring Boot Extension Pack (VMware)
   • Maven for Java (Microsoft)
3. Reinicie o VS Code

Problema 4: Maven Não Reconhecido

Sintoma:

'mvn' is not recognized as an internal or external command

Solução:

1. Baixe o Maven: https://maven.apache.org/download.cgi
2. Adicione o Maven ao seu PATH do sistema
3. Reinicie o terminal
4. Verifique: mvn -version

---

Parte 8: Perguntas de Compreensão

Perguntas

1. O que faz a anotação @RestController?

2. Qual a diferença entre @RestController e @Controller?

3. O que significa @GetMapping("/greeting")?

4. Por que usamos AtomicLong em vez de um simples Long?

5. O que faz @RequestParam(value="name")?

6. Por que a aplicação responde automaticamente em JSON?

7. Em qual porta a aplicação inicia por padrão?

8. O que acontece se esquecermos o parâmetro ?name= na URL?

Respostas Esperadas

(A ser preenchido pelo estudante)

---

Parte 9: Exercícios Adicionais

Exercício 1: Adicionar um Parâmetro Opcional

Altere o controlador para que o parâmetro name seja opcional com valor padrão "World".

Dica: Use defaultValue em @RequestParam

Exercício 2: Adicionar um Novo Método

Crie um novo método no controlador:

• URL: /greeting/time
• Retorno: Um greeting com a hora atual

Exercício 3: Alterar o Template

Altere o template para retornar "Bonjour, %s!" em vez de "Hello, %s!"

Exercício 4: Adicionar um Endpoint de Saúde

Crie um endpoint /health que retorne simplesmente "OK"

---

Entregáveis

A entregar (conforme instruções do seu professor):

1. Código fonte completo (projeto ZIP)
2. Capturas de tela mostrando:
   • A aplicação em execução no VS Code
   • Os testes no navegador com diferentes nomes
   • O contador sendo incrementado
   • Referência: Veja exemplos de capturas de tela
3. Documento de respostas às perguntas de compreensão
4. Exercícios concluídos (se solicitado)

---

Critérios de Avaliação

Critério	Pontos
Projeto criado corretamente com Spring Initializr	10%
Classes Greeting e GreetingController completas e funcionais	30%
Aplicação inicia sem erro	20%
Testes bem-sucedidos no navegador	20%
Perguntas de compreensão respondidas	10%
Exercícios adicionais (bônus)	10%
Total	100%

---

Recursos Adicionais

Documentação

• Spring Initializr
• Spring Boot Reference Documentation
• Building a RESTful Web Service

Tutoriais em Vídeo

• Spring Boot Tutorial for Beginners
• VS Code Java Setup

Ferramentas

• Postman - Para testar APIs
• JSON Formatter - Para formatar JSON

Capturas de Tela de Referência

Documentos com capturas de tela detalhadas:

Consulte a seguinte pasta do Google Drive para ver capturas de tela completas de cada etapa do exercício:

📸 Capturas de tela do Projeto Greeting

Conteúdo disponível:

• Documento PDF com capturas de tela anotadas
• Documento Word com instruções visuais
• Exemplos de resultados esperados

Nota: Essas capturas de tela usam STS (Spring Tool Suite), mas os conceitos e resultados são idênticos no VS Code.

---

Próximos Passos

Após concluir este exercício, você estará pronto para:

• TP2: Conexão com banco de dados usando JPA
• TP3: Criação de uma API CRUD completa
• TP4: Segurança com Spring Security

---

Notas Importantes

Boas Práticas:

• Sempre execute mvn clean antes de mvn install
• Pare a aplicação (Ctrl + C) antes de reiniciar
• Verifique se a porta está livre antes de iniciar
• Salve seu trabalho regularmente

Ajuda:

Se você encontrar problemas:

1. Consulte a seção "Resolução de Problemas"
2. Verifique os logs no console
3. Pesquise o erro no Stack Overflow
4. Entre em contato com seu professor

---

Bom trabalho e boa codificação!

---

Voltar ao Módulo 2