Introdução
Aprender Java continua sendo uma das melhores decisões para quem deseja entrar no mundo do desenvolvimento backend, sistemas corporativos, APIs, microsserviços e aplicações robustas. Porém, quem começa a estudar Java muitas vezes percebe que a linguagem sozinha não resolve tudo. Depois dos primeiros programas com public static void main, classes, objetos, listas e herança, surge uma pergunta natural: “Como eu crio uma aplicação real para web?”
É nesse ponto que entra o Spring Boot.
O Spring Boot é uma ferramenta do ecossistema Spring criada para facilitar o desenvolvimento de aplicações Java. Ele reduz configurações manuais, já traz padrões prontos, integra servidor web embutido, facilita conexão com banco de dados e permite criar APIs REST de forma muito mais rápida. A própria página oficial do projeto define o Spring Boot como uma forma simples de criar aplicações Spring independentes e prontas para produção, que podem ser executadas diretamente.
Este guia foi criado para iniciantes. A ideia não é apenas mostrar comandos, mas explicar o raciocínio por trás de cada parte. Você vai entender o que é Java, o que é Spring, o que é Spring Boot, como criar um projeto, como organizar as classes, como criar endpoints REST, como conectar com banco de dados e quais são os próximos passos para evoluir.
1. O que é Java?
Java é uma linguagem de programação orientada a objetos, muito usada em empresas, bancos, sistemas de gestão, aplicações web, sistemas Android, APIs, microsserviços e plataformas de grande porte. Uma das razões para sua popularidade é a estabilidade. Java existe há décadas, tem uma comunidade enorme, uma vasta quantidade de bibliotecas e é muito presente no mercado corporativo.
Quando você programa em Java, normalmente escreve arquivos com extensão .java. Esses arquivos são compilados para bytecode, que é executado pela JVM, a Máquina Virtual Java. A grande vantagem desse modelo é que o mesmo programa pode rodar em diferentes sistemas operacionais, desde que exista uma JVM compatível instalada.
Em um curso de Java com Spring Boot, você não precisa dominar todos os detalhes avançados da linguagem logo no começo. Mas precisa entender alguns fundamentos:
- classes;
- objetos;
- métodos;
- atributos;
- encapsulamento;
- interfaces;
- herança;
- exceções;
- coleções;
- generics;
- anotações;
- pacotes;
- Maven ou Gradle.
Esses conceitos aparecem o tempo todo no Spring Boot. Por exemplo, quando você cria um controller, você está criando uma classe Java. Quando injeta um service dentro de um controller, você está usando orientação a objetos e inversão de controle. Quando cria um repository, você geralmente trabalha com interfaces. Quando usa @RestController, @Service ou @Entity, está usando anotações.
2. O que é Spring?
Antes de entender Spring Boot, é importante entender o Spring.
O Spring Framework é um framework Java criado para facilitar o desenvolvimento de aplicações. Ele fornece recursos para injeção de dependência, configuração de objetos, acesso a banco de dados, criação de aplicações web, segurança, transações, mensageria e muitos outros recursos usados em sistemas profissionais.
Um dos conceitos centrais do Spring é o IoC, ou Inversão de Controle. Em vez de você criar manualmente todos os objetos da aplicação com new, o Spring gerencia esses objetos para você. Esses objetos gerenciados pelo Spring são chamados de beans.
Imagine que você tem uma classe ProdutoController que precisa usar uma classe ProdutoService. Sem Spring, você poderia fazer algo assim:
ProdutoService service = new ProdutoService();Com Spring, você deixa o framework cuidar disso:
@RestController
public class ProdutoController {
private final ProdutoService service;
public ProdutoController(ProdutoService service) {
this.service = service;
}
}O Spring percebe que ProdutoController precisa de ProdutoService e injeta essa dependência automaticamente. Isso torna o código mais organizado, testável e profissional.
3. O que é Spring Boot?
O Spring Boot é uma camada sobre o Spring que simplifica a criação de aplicações. Ele não substitui o Spring. Na verdade, ele usa o Spring por baixo, mas adiciona configurações automáticas e convenções que deixam o desenvolvimento mais rápido.
Antes do Spring Boot, criar um projeto Spring exigia muitas configurações manuais. Era comum configurar arquivos XML, servidor externo, dependências, contexto da aplicação e várias integrações. O Spring Boot mudou essa experiência. Com ele, você consegue iniciar uma aplicação web com poucas classes e poucas dependências.
A documentação atual do Spring Boot lista recursos como criação de aplicações independentes, servidor embutido, dependências “starter”, configuração automática, métricas, health checks e configuração externa.
Na prática, Spring Boot ajuda você a:
criar uma API REST rapidamente;
subir um servidor embutido, como Tomcat;
conectar com banco de dados;
usar JPA e Hibernate;
validar dados de entrada;
criar testes;
expor métricas da aplicação;
configurar ambientes diferentes;
empacotar a aplicação como .jar;
preparar a aplicação para nuvem e containers.
Para iniciantes, o maior benefício é sair rapidamente do estudo teórico e construir algo real.
4. Qual versão do Java usar?
Para estudar Spring Boot, use uma versão moderna do Java. A documentação atual do Spring Boot 4.0.6 informa que ele requer pelo menos Java 17 e é compatível até Java 26. Também informa suporte explícito a Maven 3.6.3 ou superior.
A Oracle informa que o JDK 25 é a versão LTS mais recente da plataforma Java SE, enquanto o JDK 26 é a versão mais recente disponível.
Para iniciantes, uma escolha segura é:
Java 17 ou superior para compatibilidade com Spring Boot moderno;
Java 21 ou Java 25 LTS para projetos novos;
Maven como ferramenta inicial de build, porque é muito usado no mercado e aparece em muitos tutoriais.
5. Ferramentas necessárias
Para acompanhar um curso de Java com Spring Boot, você precisa instalar algumas ferramentas.
A primeira é o JDK, que é o kit de desenvolvimento Java. Ele permite compilar e executar aplicações Java. Não confunda JDK com JRE. O JRE serve para executar programas Java; o JDK serve para desenvolver.
A segunda ferramenta é uma IDE. As opções mais usadas são IntelliJ IDEA, Eclipse, Spring Tools ou VS Code. Para iniciantes, IntelliJ IDEA Community ou Spring Tools são boas opções.
A terceira ferramenta é o Maven. Ele gerencia dependências, compila o projeto, executa testes e empacota a aplicação. Quando você cria um projeto Spring Boot com Maven, o arquivo principal de configuração é o pom.xml.
Também é recomendável instalar o Postman, Insomnia ou usar o próprio terminal com curl para testar APIs REST.
6. Criando o primeiro projeto com Spring Initializr
A forma mais simples de criar um projeto Spring Boot é usando o Spring Initializr. Ele gera a estrutura inicial do projeto, com Maven ou Gradle, linguagem Java, versão do Spring Boot e dependências escolhidas. A documentação do Spring Initializr explica que ele gera projetos JVM e permite inspecionar metadados como dependências e versões disponíveis.
Para criar o projeto, configure assim:
Project: Maven
Language: Java
Spring Boot: versão estável atual
Group: com.exemplo
Artifact: cursojava
Name: cursojava
Packaging: Jar
Java: 17 ou superior
Dependências iniciais:
Spring Web
Spring Data JPA
H2 Database
Validation
Spring Boot DevTools
O guia oficial de REST com Spring também orienta o uso do Spring Initializr com dependências como Spring Web, Spring Data JPA e H2 Database para iniciar um projeto de API.
Depois de gerar o projeto, extraia o arquivo .zip e abra a pasta na sua IDE.
7. Entendendo a estrutura do projeto
Um projeto Spring Boot geralmente vem com uma estrutura parecida com esta:
cursojava
├── src
│ ├── main
│ │ ├── java
│ │ │ └── com
│ │ │ └── exemplo
│ │ │ └── cursojava
│ │ │ └── CursojavaApplication.java
│ │ └── resources
│ │ ├── application.properties
│ │ ├── static
│ │ └── templates
│ └── test
│ └── java
└── pom.xmlA pasta src/main/java guarda o código Java principal.
A pasta src/main/resources guarda configurações, arquivos estáticos e templates.
A pasta src/test/java guarda os testes.
O arquivo pom.xml contém dependências e configurações do Maven.
A classe principal costuma ser parecida com esta:
package com.exemplo.cursojava;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class CursojavaApplication {
public static void main(String[] args) {
SpringApplication.run(CursojavaApplication.class, args);
}
}A anotação @SpringBootApplication é muito importante. Ela combina configurações essenciais do Spring Boot e indica o ponto inicial da aplicação. Quando você executa essa classe, a aplicação sobe, o Spring cria o contexto, carrega os beans e inicia o servidor web embutido.
8. Criando o primeiro Controller
Um controller é a classe responsável por receber requisições HTTP. Em uma API REST, o controller recebe chamadas como GET, POST, PUT e DELETE.
Crie uma classe chamada HelloController:
package com.exemplo.cursojava;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@GetMapping("/")
public String inicio() {
return "Curso de Java com Spring Boot iniciado com sucesso!";
}
}Agora execute a aplicação e acesse:
http://localhost:8080/Você verá a mensagem retornada pelo método inicio.
Aqui entram dois conceitos importantes.
A anotação @RestController informa ao Spring que essa classe responde requisições REST.
A anotação @GetMapping("/") informa que o método será chamado quando alguém acessar a raiz da aplicação usando HTTP GET.
A documentação oficial de introdução ao Spring Boot mostra um exemplo semelhante de controller simples usando @RestController e @GetMapping.
9. O que é uma API REST?
API significa Interface de Programação de Aplicações. Em termos simples, uma API permite que sistemas conversem entre si.
REST é um estilo arquitetural muito usado na criação de APIs web. Em uma API REST, você geralmente trabalha com recursos. Por exemplo, em uma loja virtual, os recursos poderiam ser:
/produtos
/clientes
/pedidos
/categoriasCada recurso pode aceitar operações HTTP:
GET /produtos -> listar produtos
GET /produtos/1 -> buscar produto por ID
POST /produtos -> cadastrar produto
PUT /produtos/1 -> atualizar produto
DELETE /produtos/1 -> remover produtoO Spring Boot facilita a criação desse tipo de API porque fornece anotações prontas para mapear métodos Java para endpoints HTTP.
10. Criando uma pequena API de produtos
Agora vamos criar um exemplo mais real: uma API de produtos.
Um produto terá:
id
nome
precoComece criando uma entidade chamada Produto.
package com.exemplo.cursojava.produto;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
@Entity
public class Produto {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String nome;
private Double preco;
protected Produto() {
}
public Produto(String nome, Double preco) {
this.nome = nome;
this.preco = preco;
}
public Long getId() {
return id;
}
public String getNome() {
return nome;
}
public Double getPreco() {
return preco;
}
public void alterar(String nome, Double preco) {
this.nome = nome;
this.preco = preco;
}
}A anotação @Entity indica que essa classe representa uma tabela no banco de dados. A anotação @Id indica a chave primária. A anotação @GeneratedValue informa que o valor do ID será gerado automaticamente.
11. Criando o Repository
O repository é a camada responsável por acessar o banco de dados. Com Spring Data JPA, você não precisa escrever todas as operações básicas manualmente.
Crie a interface:
package com.exemplo.cursojava.produto;
import org.springframework.data.jpa.repository.JpaRepository;
public interface ProdutoRepository extends JpaRepository<Produto, Long> {
}Essa pequena interface já oferece métodos como:
findAll()
findById()
save()
deleteById()
existsById()Esse é um dos motivos pelos quais Spring Boot com Spring Data JPA é tão poderoso. Você escreve pouco código repetitivo e consegue focar mais na regra de negócio.
12. Criando DTOs para entrada e saída
Um erro comum de iniciante é receber e devolver diretamente a entidade em todos os endpoints. Para projetos pequenos isso até funciona, mas não é uma boa prática para aplicações maiores.
DTO significa Data Transfer Object. Ele serve para transportar dados entre camadas ou entre cliente e servidor.
Crie um DTO de entrada:
package com.exemplo.cursojava.produto;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Positive;
public record ProdutoRequest(
@NotBlank(message = "O nome é obrigatório")
String nome,
@NotNull(message = "O preço é obrigatório")
@Positive(message = "O preço deve ser maior que zero")
Double preco
) {
}Agora crie um DTO de saída:
package com.exemplo.cursojava.produto;
public record ProdutoResponse(
Long id,
String nome,
Double preco
) {
public static ProdutoResponse from(Produto produto) {
return new ProdutoResponse(
produto.getId(),
produto.getNome(),
produto.getPreco()
);
}
}Usar DTO deixa sua API mais controlada. Você decide exatamente o que entra e o que sai. Também evita expor detalhes internos da entidade.
13. Criando a camada Service
A camada service concentra a regra de negócio. O controller não deve decidir tudo. Ele deve receber a requisição, chamar o service e devolver a resposta.
Crie a classe ProdutoService:
package com.exemplo.cursojava.produto;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class ProdutoService {
private final ProdutoRepository repository;
public ProdutoService(ProdutoRepository repository) {
this.repository = repository;
}
public List<ProdutoResponse> listar() {
return repository.findAll()
.stream()
.map(ProdutoResponse::from)
.toList();
}
public ProdutoResponse buscarPorId(Long id) {
Produto produto = repository.findById(id)
.orElseThrow(() -> new RuntimeException("Produto não encontrado"));
return ProdutoResponse.from(produto);
}
public ProdutoResponse cadastrar(ProdutoRequest request) {
Produto produto = new Produto(request.nome(), request.preco());
Produto salvo = repository.save(produto);
return ProdutoResponse.from(salvo);
}
public ProdutoResponse atualizar(Long id, ProdutoRequest request) {
Produto produto = repository.findById(id)
.orElseThrow(() -> new RuntimeException("Produto não encontrado"));
produto.alterar(request.nome(), request.preco());
Produto salvo = repository.save(produto);
return ProdutoResponse.from(salvo);
}
public void remover(Long id) {
if (!repository.existsById(id)) {
throw new RuntimeException("Produto não encontrado");
}
repository.deleteById(id);
}
}A anotação @Service informa ao Spring que essa classe é um componente de serviço. O Spring cria e gerencia essa classe automaticamente. Depois, ela pode ser injetada no controller.
14. Criando o Controller de Produto
Agora vamos criar os endpoints da API.
package com.exemplo.cursojava.produto;
import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/produtos")
public class ProdutoController {
private final ProdutoService service;
public ProdutoController(ProdutoService service) {
this.service = service;
}
@GetMapping
public List<ProdutoResponse> listar() {
return service.listar();
}
@GetMapping("/{id}")
public ProdutoResponse buscarPorId(@PathVariable Long id) {
return service.buscarPorId(id);
}
@PostMapping
@ResponseStatus(HttpStatus.CREATED)
public ProdutoResponse cadastrar(@RequestBody @Valid ProdutoRequest request) {
return service.cadastrar(request);
}
@PutMapping("/{id}")
public ProdutoResponse atualizar(
@PathVariable Long id,
@RequestBody @Valid ProdutoRequest request
) {
return service.atualizar(id, request);
}
@DeleteMapping("/{id}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public void remover(@PathVariable Long id) {
service.remover(id);
}
}Agora sua aplicação já tem uma API básica com operações de CRUD.
CRUD significa:
Create -> criar
Read -> ler
Update -> atualizar
Delete -> removerEsse é um dos primeiros projetos que todo iniciante deve construir com Spring Boot.
15. Configurando o banco H2
O H2 é um banco de dados em memória muito usado para estudos e testes. Ele permite testar a aplicação sem instalar PostgreSQL, MySQL ou outro banco externo.
No arquivo application.properties, adicione:
spring.datasource.url=jdbc:h2:mem:cursojava
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.h2.console.enabled=true
spring.h2.console.path=/h2-consoleCom essa configuração, o Spring Boot cria uma base em memória chamada cursojava. O Hibernate cria ou atualiza as tabelas conforme suas entidades. O console do H2 fica disponível em:
http://localhost:8080/h2-consoleUse a JDBC URL:
jdbc:h2:mem:cursojavaPara estudo, o H2 é excelente. Para produção, você usaria um banco real como PostgreSQL, MySQL, Oracle ou SQL Server.
16. Testando a API
Com a aplicação rodando, você pode testar os endpoints no Postman, Insomnia ou terminal.
Cadastrar produto:
POST http://localhost:8080/produtos
Content-Type: application/json
{
"nome": "Notebook",
"preco": 3500.00
}Listar produtos:
GET http://localhost:8080/produtosBuscar produto por ID:
GET http://localhost:8080/produtos/1Atualizar produto:
PUT http://localhost:8080/produtos/1
Content-Type: application/json
{
"nome": "Notebook Gamer",
"preco": 5200.00
}Remover produto:
DELETE http://localhost:8080/produtos/1Quando você entende esse fluxo, começa a enxergar como aplicações reais funcionam. Uma tela web, um aplicativo mobile ou outro sistema pode chamar esses endpoints para cadastrar, consultar, alterar ou remover informações.
17. Entendendo as camadas da aplicação
Uma aplicação Spring Boot bem organizada costuma ter camadas. Isso ajuda a separar responsabilidades.
A camada Controller recebe a requisição HTTP. Ela não deve concentrar regra de negócio pesada.
A camada Service contém a regra de negócio. É nela que você valida decisões, calcula valores, aplica regras e coordena operações.
A camada Repository acessa o banco de dados. Ela conversa com JPA, Hibernate e SQL indiretamente.
A camada Entity representa os dados persistidos no banco.
A camada DTO representa os dados que entram e saem da API.
Essa separação evita bagunça. Sem camadas, o iniciante costuma colocar tudo no controller: consulta banco, valida dados, calcula regra, trata erro e monta resposta. Isso funciona por alguns dias, mas rapidamente vira um problema.
Uma estrutura melhor seria:
com.exemplo.cursojava
├── produto
│ ├── Produto.java
│ ├── ProdutoController.java
│ ├── ProdutoService.java
│ ├── ProdutoRepository.java
│ ├── ProdutoRequest.java
│ └── ProdutoResponse.java
└── erro
└── ApiExceptionHandler.javaOrganizar por domínio, como produto, cliente e pedido, costuma ser melhor do que organizar apenas por tipo técnico, como controller, service e repository.
18. Tratando erros corretamente
No exemplo anterior, usamos RuntimeException. Para um projeto real, isso é fraco. O ideal é criar exceções específicas e um tratamento global.
Crie uma exceção:
package com.exemplo.cursojava.produto;
public class ProdutoNaoEncontradoException extends RuntimeException {
public ProdutoNaoEncontradoException(Long id) {
super("Produto não encontrado com ID: " + id);
}
}Altere o service:
public ProdutoResponse buscarPorId(Long id) {
Produto produto = repository.findById(id)
.orElseThrow(() -> new ProdutoNaoEncontradoException(id));
return ProdutoResponse.from(produto);
}Agora crie um handler global:
package com.exemplo.cursojava.erro;
import com.exemplo.cursojava.produto.ProdutoNaoEncontradoException;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestControllerAdvice
public class ApiExceptionHandler {
@ExceptionHandler(ProdutoNaoEncontradoException.class)
@ResponseStatus(HttpStatus.NOT_FOUND)
public ErroResponse tratarProdutoNaoEncontrado(ProdutoNaoEncontradoException ex) {
return new ErroResponse("PRODUTO_NAO_ENCONTRADO", ex.getMessage());
}
@ExceptionHandler(MethodArgumentNotValidException.class)
@ResponseStatus(HttpStatus.BAD_REQUEST)
public List<ErroResponse> tratarErroValidacao(MethodArgumentNotValidException ex) {
return ex.getFieldErrors()
.stream()
.map(erro -> new ErroResponse(
"CAMPO_INVALIDO",
erro.getField() + ": " + erro.getDefaultMessage()
))
.toList();
}
}E o record de erro:
package com.exemplo.cursojava.erro;
public record ErroResponse(
String codigo,
String mensagem
) {
}Agora, quando um produto não for encontrado, a API retorna HTTP 404. Quando um campo inválido for enviado, retorna HTTP 400. Isso torna a API mais clara para quem consome.
19. Validação de dados
Validação é essencial. Não confie que o cliente da API sempre enviará dados corretos.
No DTO ProdutoRequest, usamos:
@NotBlank
@NotNull
@PositiveEssas anotações impedem que um produto seja cadastrado sem nome ou com preço inválido. Para que elas funcionem, o controller precisa usar @Valid:
public ProdutoResponse cadastrar(@RequestBody @Valid ProdutoRequest request)Esse pequeno detalhe evita muitos bugs. Em aplicações reais, validações podem ser mais complexas: CPF válido, e-mail válido, data futura, valor máximo, relacionamento existente, status permitido e assim por diante.
20. O papel do Maven
O Maven é uma ferramenta de build e gerenciamento de dependências. O arquivo principal é o pom.xml.
Um trecho típico de dependências poderia ser:
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
</dependencies>Quando você adiciona uma dependência, o Maven baixa as bibliotecas necessárias. Quando você executa:
mvn spring-boot:runA aplicação sobe.
Quando executa:
mvn clean packageO Maven compila, testa e empacota a aplicação.
21. O que são starters?
Starters são dependências prontas do Spring Boot que agrupam bibliotecas comuns para determinada finalidade.
Por exemplo, ao adicionar um starter web, você recebe as principais dependências para criar uma aplicação web com Spring MVC, JSON e servidor embutido. Ao adicionar o starter data JPA, recebe suporte para JPA, Hibernate e integração com banco de dados.
Isso evita que o iniciante precise descobrir manualmente todas as bibliotecas necessárias e suas versões compatíveis. O Spring Boot assume opiniões sensatas e configura muita coisa automaticamente.
A documentação oficial destaca que o Spring Boot fornece dependências starter para simplificar a configuração do build.
22. O que é configuração automática?
Configuração automática é um dos recursos mais importantes do Spring Boot.
Imagine que sua aplicação tem a dependência do H2 no projeto. O Spring Boot percebe isso e consegue configurar um banco em memória automaticamente, desde que você informe ou aceite as propriedades necessárias.
Imagine que sua aplicação tem Spring Web. O Spring Boot entende que você provavelmente quer uma aplicação web e configura um servidor embutido.
O guia oficial explica que o Spring Boot observa os módulos adicionados e os beans configurados, faz suposições razoáveis sobre o que está faltando e adiciona esses elementos. Também informa que ele não gera código nem edita seus arquivos, mas conecta beans e configurações ao iniciar a aplicação.
Para o iniciante, isso parece mágica. Para o desenvolvedor experiente, é produtividade.
23. Testes em Spring Boot
Testes são fundamentais para evoluir como desenvolvedor Java. No começo, muitos ignoram testes porque querem apenas “ver funcionando”. Mas projetos profissionais precisam de segurança para mudar código sem quebrar funcionalidades existentes.
Um teste simples de service poderia ser feito com JUnit e Mockito. Um teste de controller pode usar MockMvc. Um teste de integração pode subir o contexto do Spring e validar a aplicação de ponta a ponta.
Exemplo simples de teste de contexto:
package com.exemplo.cursojava;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class CursojavaApplicationTests {
@Test
void contextLoads() {
}
}Esse teste verifica se o contexto do Spring consegue subir. Parece simples, mas já detecta erros de configuração, injeção de dependência e problemas de inicialização.
Depois, você pode evoluir para testar regras de negócio:
@Test
void deveCadastrarProdutoComSucesso() {
// organizar dados
// executar ação
// verificar resultado
}A mentalidade é: todo comportamento importante deve ter algum teste protegendo.
24. Segurança: quando aprender Spring Security?
Spring Security é poderoso, mas pode assustar no início. Para quem está começando, o ideal é primeiro aprender:
Java básico;
orientação a objetos;
HTTP;
API REST;
Spring Web;
Spring Data JPA;
validação;
tratamento de erros;
testes básicos.
Depois disso, comece com autenticação e autorização.
Autenticação responde: “Quem é você?”
Autorização responde: “O que você pode acessar?”
Em aplicações modernas, é comum usar JWT, OAuth2, login com provedor externo, roles e permissões. Porém, não pule etapas. Spring Security faz mais sentido quando você já entende bem controllers, services e fluxo HTTP.
25. Perfis e configuração por ambiente
Uma aplicação real geralmente possui ambientes diferentes:
desenvolvimento;
teste;
homologação;
produção.
Cada ambiente pode ter banco de dados, usuário, senha, URL e configurações diferentes. O Spring Boot permite trabalhar com profiles.
Exemplo:
spring.profiles.active=devVocê pode ter arquivos:
application-dev.properties
application-prod.propertiesNo ambiente de desenvolvimento, você usa H2. Em produção, PostgreSQL. O código Java não precisa mudar. Apenas a configuração muda.
Isso é uma prática essencial para aplicações profissionais.
26. Actuator e monitoramento
Quando sua aplicação vai para produção, não basta ela funcionar. Você precisa saber se ela está saudável.
O Spring Boot Actuator fornece endpoints de monitoramento, como health check, informações da aplicação, métricas e outros dados úteis. A documentação do Spring Boot lista recursos de produção como endpoints de gerenciamento, monitoramento, métricas, tracing e auditoria.
Um endpoint comum é:
/actuator/healthEle pode indicar se a aplicação está UP ou DOWN. Em ambientes com Docker, Kubernetes ou plataformas de nuvem, health checks são muito importantes.
Para usar Actuator, você adiciona a dependência:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>Depois configura quais endpoints serão expostos.
27. Empacotando a aplicação
Depois de desenvolver, você pode empacotar a aplicação como .jar.
Execute:
mvn clean packageDepois rode:
java -jar target/cursojava-0.0.1-SNAPSHOT.jarEssa é uma grande vantagem do Spring Boot: a aplicação pode ser executada diretamente, com servidor embutido. Você não precisa obrigatoriamente instalar um servidor externo e fazer deploy manual de WAR, embora isso ainda seja possível em alguns cenários.
Para iniciantes, o .jar executável simplifica muito o entendimento.
28. Principais erros de iniciantes
Um erro comum é tentar aprender Spring Boot sem saber Java básico. Isso gera confusão, porque o aluno não sabe se o problema está na linguagem ou no framework. Antes de avançar muito, domine classes, objetos, métodos, listas, exceções e interfaces.
Outro erro é colocar regra de negócio no controller. O controller deve ser fino. Regra de negócio deve ir para o service.
Também é comum retornar entidade diretamente em todos os endpoints. DTOs ajudam a proteger a API e deixam o contrato mais claro.
Outro problema é ignorar tratamento de erros. Uma API que retorna erro genérico para tudo é difícil de consumir.
Também é erro não testar. Mesmo testes simples ajudam a evitar regressões.
Por fim, muitos iniciantes copiam código sem entender. Copiar pode ajudar no começo, mas o objetivo é compreender o fluxo: requisição chega no controller, controller chama service, service usa repository, repository acessa banco, resposta volta para o cliente.
29. Plano de estudos recomendado
Para aprender Java com Spring Boot de forma organizada, siga esta ordem.
Primeiro, estude Java básico: variáveis, tipos, operadores, condicionais, laços, métodos e arrays.
Depois, avance para orientação a objetos: classes, objetos, atributos, métodos, construtores, encapsulamento, herança, interfaces e polimorfismo.
Em seguida, aprenda coleções: List, Set, Map, generics, streams e Optional.
Depois, estude exceções, arquivos, datas e boas práticas.
Quando estiver confortável, entre em Maven, dependências e estrutura de projeto.
Só então comece Spring Boot com Spring Web. Crie controllers simples, entenda rotas, parâmetros, JSON e status HTTP.
Depois aprenda Spring Data JPA, entidades, repositories, relacionamentos e consultas.
Em seguida, estude validação, tratamento de erros, DTOs e testes.
Depois avance para Spring Security, autenticação JWT, Docker, deploy, microsserviços e mensageria.
Essa ordem evita frustração. Você constrói uma base sólida antes de entrar nos temas mais complexos.
30. Projeto prático para consolidar
Depois de criar a API de produtos, evolua para um pequeno sistema de pedidos.
Entidades:
Cliente
Produto
Pedido
ItemPedidoFuncionalidades:
Cadastrar cliente
Listar clientes
Cadastrar produto
Listar produtos
Criar pedido
Adicionar itens ao pedido
Calcular total do pedido
Consultar pedido por ID
Cancelar pedidoRegras de negócio:
O pedido não pode ser criado sem cliente.
O item não pode ter quantidade menor que 1.
O produto precisa existir.
O total do pedido deve ser calculado com base nos itens.
Pedido cancelado não pode receber novos itens.
Esse projeto obriga você a praticar entidades, relacionamentos, services, repositories, DTOs, validações e tratamento de erros.
Conclusão
Um curso de Java com Spring Boot é um caminho excelente para quem deseja se tornar desenvolvedor backend. Java oferece uma base sólida, muito usada no mercado. Spring Boot acelera a criação de aplicações reais, reduz configuração manual e fornece recursos prontos para web, banco de dados, validação, testes, monitoramento e produção.
O segredo para aprender bem não é decorar anotações. O segredo é entender o fluxo da aplicação. Uma requisição chega pelo controller, passa pelo service, acessa o repository, conversa com o banco e retorna uma resposta. Quando esse ciclo fica claro, o Spring Boot deixa de parecer mágico e começa a se tornar uma ferramenta poderosa nas suas mãos.
Comece pequeno. Crie uma API simples. Depois adicione banco de dados. Depois validação. Depois tratamento de erros. Depois testes. Depois segurança. Esse processo gradual transforma conhecimento solto em habilidade real.
Quem domina Java com Spring Boot consegue criar APIs, sistemas corporativos, microsserviços e aplicações escaláveis. Para iniciantes, esse é um dos caminhos mais fortes para entrar no desenvolvimento profissional.
Deixe um comentário