Spring Boot com Java — Material de Aula
SPRING BOOT COM JAVA
Material Completo de Aula
Do Zero ao CRUD em duas aulas
AULA 1 AULA 2
Introdução e primeiros Spring Data JPA e
endpoints REST CRUD completo
Atributo Detalhe
Nível dos alunos Intermediário (POO, coleções, interfaces)
Duração por aula Mais de 2 horas
Ambiente IntelliJ IDEA
Banco de dados H2 (memória) — nenhuma instalação necessária
Java 17 ou 21 (LTS)
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
AULA 1 — Introdução ao Spring Boot
Duração estimada: 2h30 | Ambiente: IntelliJ IDEA | Java 17+
Objetivos da Aula 1
Compreender o que é Spring Boot e por que ele domina o mercado Java
Criar e executar um projeto Spring Boot no IntelliJ IDEA
Criar os primeiros endpoints REST (GET com e sem parâmetros)
Entender os conceitos de IoC e Injeção de Dependência na prática
Retornar objetos Java automaticamente como JSON
SEÇÃO 1 — Contexto e Motivação (30 min)
1.1 O que é o Spring Framework?
Spring é um ecossistema de frameworks para Java criado em 2003 como alternativa ao EJB
(Enterprise JavaBeans), que era extremamente complexo na época. Seu objetivo principal é
simplificar o desenvolvimento de aplicações Java empresariais.
O Spring possui vários módulos especializados:
• Spring Core — Container IoC (núcleo de tudo)
• Spring MVC — desenvolvimento Web e APIs REST
• Spring Data — acesso a bancos de dados
• Spring Security — autenticação e autorização
• Spring Boot — autoconfiguração e produtividade
1.2 O que é Spring Boot e por que ele existe?
Spring Boot foi lançado em 2014 para resolver um problema clássico do Spring puro: a quantidade
absurda de configuração necessária.
Com Spring puro, você precisava:
• Escrever arquivos XML de configuração enormes (ou classes Java com centenas de linhas)
• Configurar manualmente o servidor de aplicação (Tomcat, Jetty, JBoss)
• Resolver manualmente conflitos de versão entre dependências
• Escrever muito código boilerplate repetitivo
O Spring Boot resolve isso com 4 pilares:
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
Pilar O que significa na prática
Auto-configuração O Spring Boot detecta suas dependências e configura
automaticamente. Adicionou JPA? Ele já configura o EntityManager.
Servidor embutido O Tomcat já vem DENTRO do JAR. Basta executar java -jar [Link]
Starters Pacotes de dependências pré-curados e com versões compatíveis
garantidas
Opinativo Já escolhe as melhores configurações padrão. Você só muda o que
precisa.
1.3 IoC (Inversão de Controle) e Injeção de Dependência
Esses são os conceitos mais importantes para entender o Spring. Vale dedicar tempo aqui.
Sem IoC — você cria e gerencia os objetos manualmente:
// Você é responsável por criar CADA objeto
public class PedidoService {
private EmailService emailService = new EmailService(); //
acoplamento forte
private EstoqueService estoqueService = new EstoqueService(); //
difícil de testar
}
Com IoC — o Spring cria e injeta os objetos para você:
// O Spring cria e injeta os objetos automaticamente
@Service
public class PedidoService {
private final EmailService emailService; // o Spring injeta isso
private final EstoqueService estoqueService;
// Injeção via construtor (forma recomendada)
public PedidoService(EmailService emailService,
EstoqueService estoqueService) {
[Link] = emailService;
[Link] = estoqueService;
}
}
Por que IoC é importante?
Menos acoplamento: PedidoService não sabe como EmailService é criado
Facilita testes: você pode trocar EmailService por uma versão fake (mock)
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
O Spring gerencia o ciclo de vida: cria, reutiliza e destrói os objetos
Bean = objeto gerenciado pelo Spring Container
SEÇÃO 2 — Criando o Primeiro Projeto (40 min)
2.1 Spring Initializr — Gerando o Projeto
Acesse: [Link]
Campo Valor
Project Maven
Language Java
Spring Boot 3.2.x (ou última versão estável)
Group [Link]
Artifact springboot-intro
Name springboot-intro
Packaging Jar
Java 17 ou 21
Dependências Spring Web (adicionar clicando em ADD DEPENDENCIES)
Clique em GENERATE, extraia o ZIP em uma pasta de sua preferência.
2.2 Abrindo no IntelliJ IDEA
1. File → Open → selecione a pasta extraída
2. Aguarde o IntelliJ baixar as dependências via Maven (barra de progresso no canto)
3. Verifique o JDK: File → Project Structure → SDK → selecione Java 17 ou 21
4. Se o Maven não disparar, clique com botão direito no [Link] → Maven → Reload Project
2.3 Entendendo a Estrutura do Projeto
springboot-intro/
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/aula/springbootintro/
│ │ │ └── [Link] ← ponto de entrada
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
│ │ └── resources/
│ │ └── [Link] ← configurações
│ └── test/
│ └── java/...
├── [Link] ← dependências
Maven
└── mvnw ← Maven Wrapper
2.4 Entendendo o [Link]
<!-- Parent do Spring Boot — gerencia versões automaticamente -->
<parent>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.0</version>
</parent>
<!-- Spring Web — inclui Tomcat embutido + Spring MVC + Jackson (JSON)
-->
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<!-- sem <version>: o parent gerencia automaticamente -->
</dependency>
O spring-boot-starter-web inclui automaticamente:
• spring-webmvc — framework MVC
• spring-boot-starter-tomcat — servidor embutido
• jackson-databind — conversão Java ↔ JSON automática
2.5 A Classe Principal
@SpringBootApplication // combinação de 3 anotações fundamentais
public class SpringbootIntroApplication {
public static void main(String[] args) {
[Link]([Link], args);
}
}
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
@SpringBootApplication equivale a... O que faz
@Configuration Esta classe pode definir Beans (objetos gerenciados)
@EnableAutoConfiguration Liga a mágica: Spring configura tudo automaticamente
@ComponentScan Varre o pacote em busca de @Controller, @Service,
@Repository etc.
Para executar: clique no botão ▶ verde ao lado do método main ou Shift+F10.
Saída esperada no console:
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v3.2.0)
Tomcat started on port(s): 8080 (http)
Started SpringbootIntroApplication in 2.3 seconds
Teste no navegador
Acesse: [Link]
Aparecerá uma página de erro 404 — isso é NORMAL e significa que a aplicação está
rodando!
O 404 significa apenas que não existe nenhum endpoint mapeado para '/' ainda.
SEÇÃO 3 — Primeiro Controller REST (35 min)
3.1 O que é uma API REST?
REST (Representational State Transfer) é um estilo arquitetural para APIs web. Usa os métodos
HTTP como verbos de ação sobre recursos:
Método HTTP Significado Exemplo
GET Buscar/Ler dados GET /produtos → lista produtos
POST Criar novo dado POST /produtos → cria produto
PUT Atualizar dado PUT /produtos/1 → atualiza produto 1
DELETE Remover dado DELETE /produtos/1 → deleta produto 1
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
APIs REST retornam dados (geralmente JSON) em vez de páginas HTML. Clientes podem ser apps
mobile, frontends React/Angular, Postman, etc.
3.2 Criando o Primeiro Controller
Crie a classe [Link] no pacote [Link]:
package [Link];
import [Link];
import [Link];
@RestController // diz ao Spring que esta classe responde requisições
HTTP como REST
public class OlaController {
@GetMapping("/ola") // responde a GET [Link]
public String ola() {
return "Olá, Spring Boot!";
}
}
5. Reinicie a aplicação (Ctrl+F5 no IntelliJ)
6. Acesse: [Link]
7. Resultado: texto simples na tela
O que @RestController faz?
@RestController = @Controller + @ResponseBody
@Controller: registra a classe como um controller MVC
@ResponseBody: serializa o retorno do método direto no corpo HTTP (não busca uma
view HTML)
Com @RestController, qualquer objeto retornado é convertido para JSON
automaticamente
3.3 Retornando Objetos Java como JSON
Crie a classe [Link] no pacote [Link]:
package [Link];
public class Produto {
private Long id;
private String nome;
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
private Double preco;
// Construtor
public Produto(Long id, String nome, Double preco) {
[Link] = id;
[Link] = nome;
[Link] = preco;
}
// Getters (obrigatórios para Jackson serializar o JSON)
public Long getId() { return id; }
public String getNome() { return nome; }
public Double getPreco() { return preco; }
// Setters
public void setId(Long id) { [Link] = id; }
public void setNome(String nome) { [Link] = nome; }
public void setPreco(Double preco) { [Link] = preco; }
}
Agora crie o [Link]:
package [Link];
import [Link];
import [Link].*;
import [Link];
@RestController
@RequestMapping("/produtos") // prefixo base para todos os endpoints
desta classe
public class ProdutoController {
// GET /produtos → retorna lista de produtos em JSON
@GetMapping
public List<Produto> listar() {
return [Link](
new Produto(1L, "Teclado", 150.0),
new Produto(2L, "Mouse", 80.0),
new Produto(3L, "Monitor", 1200.0)
);
}
// GET /produtos/2 → retorna produto com id 2
@GetMapping("/{id}")
public Produto buscarPorId(@PathVariable Long id) {
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
// simulação — na Aula 2 usaremos banco de dados real
return new Produto(id, "Produto " + id, 100.0 * id);
}
}
Reinicie e acesse:
• [Link] → retorna array JSON com 3 produtos
• [Link] → retorna apenas o produto de id 2
Magia do Jackson!
O Spring Boot já incluiu a biblioteca Jackson (via spring-boot-starter-web)
Jackson converte automaticamente objetos Java → JSON (serialização)
E JSON → objetos Java (deserialização, que veremos no POST da Aula 2)
Único requisito: a classe precisa ter getters públicos
3.4 PathVariable e RequestParam
@PathVariable — captura parte da URL:
// URL: GET /produtos/42
@GetMapping("/{id}")
public Produto buscar(@PathVariable Long id) {
// id = 42
}
@RequestParam — captura query parameters (após o ?):
// URL: GET /produtos/buscar?nome=teclado
@GetMapping("/buscar")
public String buscar(@RequestParam String nome) {
return "Buscando: " + nome;
}
// @RequestParam com valor padrão (não obrigatório)
@GetMapping("/buscar")
public String buscar(@RequestParam(defaultValue = "") String nome) {
return "Buscando: " + nome;
}
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
SEÇÃO 4 — Exercício Prático da Aula 1 (30 min)
Exercício: API de Alunos
Crie uma API REST que exponha os seguintes endpoints:
GET /alunos → retorna lista com pelo menos 3 alunos
GET /alunos/{id} → retorna um aluno pelo id
GET /alunos/aprovados → retorna apenas alunos com nota >= 7.0
Classe Aluno (modelo):
public class Aluno {
private Long id;
private String nome;
private String curso;
private Double nota;
public Aluno(Long id, String nome, String curso, Double nota) {
[Link] = id;
[Link] = nome;
[Link] = curso;
[Link] = nota;
}
// getters e setters...
}
Dica — lista estática como banco de dados temporário:
private List<Aluno> alunos = new ArrayList<>([Link](
new Aluno(1L, "Ana", "ADS", 8.5),
new Aluno(2L, "Carlos", "ADS", 6.0),
new Aluno(3L, "Maria", "ADS", 9.2),
new Aluno(4L, "Pedro", "ADS", 5.5)
));
Dica — filtrar aprovados com Stream:
[Link]()
.filter(a -> [Link]() >= 7.0)
.collect([Link]());
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
Desafio extra (para quem terminar cedo)
GET /alunos?curso=ADS → filtra por curso via @RequestParam
GET /alunos/top → retorna o aluno com maior nota
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
AULA 2 — Spring Data JPA e CRUD Completo
Duração estimada: 2h30 | Banco: H2 (memória) | Projeto novo do zero
Objetivos da Aula 2
Compreender a arquitetura em camadas (Controller → Service → Repository)
Criar entidades JPA e mapeá-las automaticamente para tabelas
Usar Spring Data JPA para fazer CRUD sem escrever SQL
Implementar os 4 métodos HTTP: GET, POST, PUT, DELETE
Usar ResponseEntity para controlar status HTTP nas respostas
Testar a API completa com o HTTP Client do IntelliJ
SEÇÃO 1 — Revisão e Arquitetura em Camadas (20 min)
1.1 Recapitulando a Aula 1
O que aprendemos Conceito central
Spring Boot Framework que auto-configura e simplifica Java
@RestController Marca classe como controller REST
@GetMapping Mapeia requisições GET para um método
@PathVariable Captura parâmetro da URL: /produtos/{id}
@RequestParam Captura query string: /buscar?nome=x
Jackson Converte Java → JSON automaticamente (via getters)
1.2 O Problema da Aula 1
Na Aula 1, os dados eram fixos no código (hardcoded). Isso funciona para aprender, mas em
aplicações reais os dados precisam ser:
• Persistidos: devem sobreviver ao reinício da aplicação
• Consultáveis: filtros, buscas, paginação
• Modificáveis: criar, atualizar, deletar
Para isso, usaremos um banco de dados. E para comunicar com o banco de forma elegante em
Java, usaremos JPA.
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
1.3 Arquitetura em Camadas
HTTP Request (Postman, navegador, app mobile...)
|
v
┌─────────────┐
│ Controller │ ← recebe a requisição, delega ao Service, retorna
resposta
└──────┬───────┘
|
v
┌─────────────┐
│ Service │ ← regras de negócio (validações, cálculos, etc.)
└──────┬───────┘
|
v
┌─────────────┐
│ Repository │ ← acesso ao banco de dados (queries)
└──────┬───────┘
|
v
┌─────────────┐
│ Banco de │
│ Dados │
└─────────────┘
Por que separar em camadas?
Controller não tem lógica de negócio — fácil de trocar (REST, GraphQL, gRPC...)
Service concentra as regras — fácil de testar isoladamente
Repository só acessa dados — fácil de trocar o banco de dados
Princípio da Responsabilidade Única (SOLID): cada camada tem um único motivo para
mudar
SEÇÃO 2 — Criando Novo Projeto com JPA (20 min)
2.1 Spring Initializr — Novo Projeto
Acesse [Link] com as mesmas configurações da Aula 1, mas agora com 3
dependências:
Dependência Para que serve
Spring Web Criar APIs REST (igual Aula 1)
Spring Data JPA ORM: mapeamento Java ↔ banco de dados
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
Dependência Para que serve
H2 Database Banco em memória — sem instalação, perfeito para aprender
Artifact: springboot-crud. Abra no IntelliJ da mesma forma.
2.2 O que é JPA e H2?
JPA (Java Persistence API) é uma especificação Java para ORM (Object-Relational Mapping).
Permite trabalhar com banco de dados usando objetos Java, sem escrever SQL manualmente.
Hibernate é a implementação padrão de JPA e já vem configurado automaticamente pelo Spring
Data JPA.
H2 é um banco de dados escrito em Java que roda inteiramente na memória RAM. Os dados
somem ao reiniciar a aplicação — perfeito para aprender, protótipos e testes automatizados.
2.3 Configurando o [Link]
# ── H2 Console (interface web para ver o banco) ──────────────────
[Link]=true
[Link]=/h2-console
# ── Datasource (conexão com o banco) ─────────────────────────────
[Link]=jdbc:h2:mem:auladb
[Link]-class-name=[Link]
[Link]=sa
[Link]=
# ── JPA / Hibernate ───────────────────────────────────────────────
[Link]-platform=[Link].H2Dialect
[Link]-sql=true # exibe SQL gerado no console
[Link]-auto=update # cria/atualiza tabelas
automaticamente
Acessando o H2 Console (banco visual)
Com a aplicação rodando, acesse: [Link]
JDBC URL: jdbc:h2:mem:auladb
Username: sa
Password: (deixar vazio)
Aqui você pode executar SQL e ver as tabelas criadas pelo Spring!
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
SEÇÃO 3 — Criando a Entidade (Entity) (20 min)
Uma entidade JPA é uma classe Java anotada com @Entity que representa uma tabela no banco
de dados. Cada instância = uma linha da tabela.
Crie [Link] no pacote [Link]:
package [Link];
import [Link].*;
@Entity // marca como entidade JPA → cria tabela
@Table(name = "produtos") // nome da tabela (opcional)
public class Produto {
@Id // chave
primária
@GeneratedValue(strategy = [Link]) // auto
incremento (1, 2, 3...)
private Long id;
@Column(nullable = false) // NOT NULL no banco
private String nome;
@Column(nullable = false)
private Double preco;
@Column(length = 500) // VARCHAR(500)
private String descricao;
// Construtor padrão — OBRIGATÓRIO para JPA
public Produto() {}
// Construtor de conveniência
public Produto(String nome, Double preco, String descricao) {
[Link] = nome;
[Link] = preco;
[Link] = descricao;
}
// Getters e Setters (todos necessários)
public Long getId() { return id; }
public String getNome() { return nome; }
public Double getPreco() { return preco; }
public String getDescricao() { return descricao; }
public void setId(Long id) { [Link] = id;
}
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
public void setNome(String nome) { [Link] = nome;
}
public void setPreco(Double preco) { [Link] = preco;
}
public void setDescricao(String desc) { [Link] = desc;
}
}
Anotação Equivalente SQL
@Entity CREATE TABLE
@Table(name = "produtos") ... CREATE TABLE produtos
@Id PRIMARY KEY
@GeneratedValue(IDENTITY) AUTO_INCREMENT
@Column(nullable = false) NOT NULL
@Column(length = 500) VARCHAR(500)
SEÇÃO 4 — Repository (15 min)
O Repository é a camada responsável por acessar o banco. Com Spring Data JPA, basta declarar
uma interface — a implementação é gerada automaticamente.
Crie [Link] no pacote [Link]:
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
@Repository
public interface ProdutoRepository extends JpaRepository<Produto, Long>
{
// ^ ^
// Entidade Tipo do
ID
// JpaRepository já implementa automaticamente:
// save(produto) → INSERT ou UPDATE
// findById(id) → SELECT ... WHERE id = ?
// findAll() → SELECT * FROM produtos
// deleteById(id) → DELETE WHERE id = ?
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
// existsById(id) → SELECT COUNT(*) WHERE id = ?
// count() → SELECT COUNT(*)
// Métodos personalizados: Spring Data gera automaticamente pelo
nome!
List<Produto> findByNomeContaining(String nome); // LIKE
'%nome%'
List<Produto> findByPrecoBetween(Double min, Double max); // BETWEEN
List<Produto> findByNomeContainingIgnoreCase(String nome); // case-
insensitive
}
Query Methods — o poder do Spring Data JPA
O Spring Data JPA interpreta o nome do método e gera o SQL automaticamente!
findBy{Campo} → WHERE campo = ?
findBy{Campo}Containing → WHERE campo LIKE '%valor%'
findBy{Campo}GreaterThan → WHERE campo > ?
findBy{Campo}Between → WHERE campo BETWEEN ? AND ?
Nenhuma linha de SQL foi escrita — o Spring gerou tudo!
SEÇÃO 5 — Service (20 min)
O Service é a camada de negócio. Aqui ficam validações, transformações e orquestração de
operações.
Crie [Link] no pacote [Link]:
package [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
@Service // registra como bean gerenciado pelo Spring
public class ProdutoService {
private final ProdutoRepository repository;
// Injeção de dependência via construtor (recomendada)
public ProdutoService(ProdutoRepository repository) {
[Link] = repository;
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
public List<Produto> listarTodos() {
return [Link]();
}
public Optional<Produto> buscarPorId(Long id) {
return [Link](id);
// Optional evita NullPointerException: pode ou não ter valor
}
public Produto salvar(Produto produto) {
return [Link](produto); // INSERT (se id nulo) ou
UPDATE
}
public Produto atualizar(Long id, Produto dadosNovos) {
Produto produto = [Link](id)
.orElseThrow(() -> new RuntimeException("Produto não
encontrado: " + id));
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
return [Link](produto); // UPDATE
}
public void deletar(Long id) {
[Link](id);
}
public List<Produto> buscarPorNome(String nome) {
return [Link](nome);
}
}
SEÇÃO 6 — Controller com CRUD Completo (25 min)
Crie [Link] no pacote [Link]:
package [Link];
import [Link];
import [Link];
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
import [Link];
import [Link];
import [Link].*;
import [Link];
@RestController
@RequestMapping("/api/produtos")
public class ProdutoController {
private final ProdutoService service;
public ProdutoController(ProdutoService service) {
[Link] = service;
}
// ── GET /api/produtos ──────────────────────────────────────
@GetMapping
public List<Produto> listar() {
return [Link]();
}
// ── GET /api/produtos/1 ────────────────────────────────────
@GetMapping("/{id}")
public ResponseEntity<Produto> buscarPorId(@PathVariable Long id) {
return [Link](id)
.map(ResponseEntity::ok) // 200 OK
.orElse([Link]().build()); // 404 Not Found
}
// ── POST /api/produtos ─────────────────────────────────────
@PostMapping
public ResponseEntity<Produto> criar(@RequestBody Produto produto) {
Produto salvo = [Link](produto);
return ResponseEntity
.status([Link]) // 201 Created
.body(salvo);
}
// ── PUT /api/produtos/1 ────────────────────────────────────
@PutMapping("/{id}")
public ResponseEntity<Produto> atualizar(@PathVariable Long id,
@RequestBody Produto
produto) {
try {
return [Link]([Link](id, produto)); //
200 OK
} catch (RuntimeException e) {
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
return
[Link]().build(); // 404
}
}
// ── DELETE /api/produtos/1 ─────────────────────────────────
@DeleteMapping("/{id}")
public ResponseEntity<Void> deletar(@PathVariable Long id) {
[Link](id);
return [Link]().build(); // 204 No Content
}
// ── GET /api/produtos/buscar?nome=teclado ──────────────────
@GetMapping("/buscar")
public List<Produto> buscar(@RequestParam String nome) {
return [Link](nome);
}
}
Códigos de Status HTTP
Código Nome Quando usar
200 OK GET, PUT retornando dados com sucesso
201 Created POST: recurso criado com sucesso
204 No Content DELETE: operação realizada, sem dados para retornar
400 Bad Request Dados inválidos na requisição
404 Not Found Recurso não existe no banco
500 Server Error Exceção não tratada no servidor
SEÇÃO 7 — Testando a API com IntelliJ HTTP Client (15 min)
Crie o arquivo [Link] na raiz do projeto (o IntelliJ o reconhece automaticamente):
### 1. Criar produto
POST [Link]
Content-Type: application/json
{
"nome": "Teclado Mecânico",
"preco": 299.90,
"descricao": "Cherry MX Red, ABNT2"
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
### 2. Criar outro produto
POST [Link]
Content-Type: application/json
{
"nome": "Mouse Gamer",
"preco": 159.90,
"descricao": "16000 DPI, RGB"
}
### 3. Listar todos
GET [Link]
### 4. Buscar por ID
GET [Link]
### 5. Atualizar
PUT [Link]
Content-Type: application/json
{
"nome": "Teclado Mecânico RGB",
"preco": 349.90,
"descricao": "Cherry MX Red, iluminação RGB, ABNT2"
}
### 6. Buscar por nome
GET [Link]
### 7. Deletar
DELETE [Link]
### 8. Confirmar deleção (deve retornar 404)
GET [Link]
Para executar: clique no ▶ verde que aparece ao lado de cada ### no arquivo .http . O IntelliJ
mostrará o resultado na aba Response.
Verificando no H2 Console
Após criar produtos, acesse: [Link]
Execute o SQL: SELECT * FROM PRODUTOS
Você verá as linhas criadas pelas requisições POST!
Isso confirma que os dados estão realmente sendo persistidos no banco.
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
SEÇÃO 8 — Projeto Final: API de Biblioteca (30 min)
Desafio: implemente uma API REST completa para uma Biblioteca
Sem consultar o código da aula — use o que você aprendeu!
Trabalhem em duplas ou individualmente.
Você tem a estrutura de arquivos e os endpoints como guia.
Entidade Livro:
// Campos obrigatórios da entidade:
Long id // @Id, @GeneratedValue
String titulo // @Column(nullable = false)
String autor // @Column(nullable = false)
Integer anoPublicacao
Boolean disponivel // padrão: true
Endpoints a implementar:
Método Endpoint O que faz
GET /api/livros Lista todos os livros
GET /api/livros/{id} Busca livro por id (404 se não existir)
GET /api/livros/disponiveis Lista apenas livros com disponivel = true
POST /api/livros Cadastra novo livro (retorna 201)
PUT /api/livros/{id} Atualiza livro completo
DELETE /api/livros/{id} Remove livro (retorna 204)
PATCH /api/livros/{id}/emprestar Muda disponivel para false
PATCH /api/livros/{id}/devolver Muda disponivel para true
Estrutura de arquivos esperada:
[Link]/
├── model/
│ └── [Link]
├── repository/
│ └── [Link]
├── service/
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
│ └── [Link]
└── controller/
└── [Link]
Desafio extra (bônus)
GET /api/livros/autor?nome=Tolkien → buscar por autor (use @RequestParam)
GET /api/livros/ano?inicio=2000&fim=2020 → buscar por intervalo de ano
GET /api/livros/count → retorna o total de livros cadastrados
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
APÊNDICE — Referência Rápida
Tabela de Anotações Mais Usadas
Anotação Camada O que faz
@SpringBootApplication Principal Liga auto-configuração + scan + configuração
@RestController Controller Classe que responde requisições REST
@RequestMapping Controller Prefixo base da URL da classe ou método
@GetMapping Controller Mapeia GET requests
@PostMapping Controller Mapeia POST requests
@PutMapping Controller Mapeia PUT requests
@DeleteMapping Controller Mapeia DELETE requests
@PatchMapping Controller Mapeia PATCH requests
@PathVariable Parâmetro Extrai valor da URL: /produtos/{id}
@RequestParam Parâmetro Extrai query param: ?nome=x
@RequestBody Parâmetro Lê JSON do corpo da requisição
@Service Service Marca como serviço gerenciado pelo Spring
@Repository Repository Marca como repositório de dados
@Entity Model Classe = tabela no banco
@Table(name=) Model Nome personalizado da tabela
@Id Model Campo = chave primária
@GeneratedValue Model Valor gerado automaticamente (auto
increment)
@Column Model Configuração da coluna (nullable, length...)
Estrutura de Pacotes Recomendada
[Link]/
├── [Link] ← classe principal
├── controller/ ← @RestController
├── service/ ← @Service
├── repository/ ← interface extends JpaRepository
└── model/ ← @Entity (ou domain/, entity/)
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
[Link] para H2 (copie e cole)
[Link]=true
[Link]=/h2-console
[Link]=jdbc:h2:mem:auladb
[Link]-class-name=[Link]
[Link]=sa
[Link]=
[Link]-platform=[Link].H2Dialect
[Link]-sql=true
[Link]-auto=update
Links Úteis
• Spring Initializr: [Link]
• Documentação Spring Boot: [Link]
• Spring Data Query Methods:
[Link]
• H2 Console: [Link] (enquanto a app estiver rodando)
Dicas para o Professor
Sugestões para conduzir as aulas
Live coding: escreva o código ao vivo, não apenas exiba. Os alunos aprendem mais
vendo o processo.
Erros são oportunidades: se algo der errado ao vivo, use para ensinar como depurar.
H2 Console: mostre o banco visual sempre após criar/alterar dados. Torna concreto o
que o JPA faz.
[Link]-sql=true: aponte o SQL gerado no console a cada operação. Conecta o
abstrato ao real.
Comparação com JDBC puro: se a turma já viu JDBC, mostre quantas linhas seriam
necessárias sem Spring Data.
Pausa entre seções: reserve 2-3 min para perguntas ao fim de cada seção.
Possíveis perguntas dos alunos
"Por que usar H2 e não MySQL?" → H2 é para aprendizado. Em produção, troca só o
driver e a URL no properties.
"O que é Optional?" → Evita NullPointerException. Se o findById não achar, retorna
[Link]().
Material didático — Spring Boot Introdução Página
Spring Boot com Java — Material de Aula
"Por que @RequestBody?" → O Spring precisa saber que o JSON está no corpo HTTP,
não na URL.
"Como trocar para MySQL?" → Adicionar dependência mysql-connector-j, ajustar
url/user/password no properties.
"O que é ORM?" → Mapeia objetos Java para tabelas relacionais. Você escreve Java, o
ORM gera SQL.
Material didático — Spring Boot Introdução Página