Aprender Spring do Zero: roteiro, fundamentos e primeira API

Aprender Spring é um dos passos mais importantes para quem deseja trabalhar profissionalmente com Java no desenvolvimento de aplicações web, APIs REST, sistemas corporativos e microsserviços.

Entretanto, o ecossistema Spring pode parecer enorme para quem está começando. Spring Framework, Spring Boot, Spring MVC, Spring Data, Spring Security e Spring Cloud são apenas alguns dos nomes encontrados durante os estudos.

A boa notícia é que você não precisa dominar todo o ecossistema de uma só vez.

O caminho mais eficiente é compreender os fundamentos, criar uma aplicação pequena, observar como seus componentes se relacionam e evoluir gradualmente para projetos mais completos.

Neste guia, você aprenderá:

• o que são Spring Framework e Spring Boot;
• quais conhecimentos de Java são necessários;
• como funciona a inversão de controle;
• o que são beans e injeção de dependências;
• como criar um projeto pelo Spring Initializr;
• como desenvolver sua primeira API REST;
• como executar e testar a aplicação;
• quais assuntos estudar depois;
• como organizar um roteiro para aprender Spring do zero.

Ao final, você terá uma aplicação funcional e uma visão clara do caminho necessário para continuar evoluindo.

Table of Contents

Toggle

Desenvolvimento de API Restful com Java Spring Framework

⭐ 5.0/5

Desenvolvimento de API Restful com Java Spring Framework. Produto recomendado para estudos, programação e produtividade.

R$ 14,90

Ver na Amazon Como afiliado, posso receber comissão por compras qualificadas.

O que é Spring?

Spring é um ecossistema de projetos criado para facilitar o desenvolvimento de aplicações Java.

Seu núcleo é o Spring Framework, responsável por oferecer recursos como:

• inversão de controle;
• injeção de dependências;
• gerenciamento de objetos;
• programação orientada a aspectos;
• suporte a transações;
• desenvolvimento web;
• integração com bancos de dados;
• suporte a testes.

O Spring Framework procura reduzir o acoplamento entre as partes da aplicação.

Em vez de uma classe criar diretamente todos os objetos dos quais depende, o Spring pode construir esses objetos e entregá-los automaticamente onde forem necessários.

Essa abordagem torna o código mais organizado, testável e preparado para mudanças.

Contudo, configurar manualmente uma aplicação com o Spring Framework tradicional podia exigir várias decisões e configurações iniciais. O Spring Boot surgiu para simplificar esse processo.

Qual é a diferença entre Spring e Spring Boot?

Spring Framework e Spring Boot não são concorrentes.

O Spring Boot utiliza o Spring Framework e acrescenta mecanismos que tornam a inicialização e a configuração dos projetos muito mais simples.

O Spring Framework fornece os fundamentos. Já o Spring Boot oferece uma maneira prática e orientada por convenções de usar esses fundamentos.

Entre os principais recursos do Spring Boot estão:

• configuração automática;
• dependências iniciais conhecidas como starters;
• servidor web incorporado;
• configuração externa;
• métricas e verificações de saúde;
• criação de aplicações executáveis;
• menor necessidade de configurações manuais.

Uma aplicação Spring Boot pode ser empacotada como um arquivo JAR executável e iniciada diretamente com o comando java -jar.

Além disso, o servidor web pode acompanhar a própria aplicação. Dessa maneira, não é necessário instalar e configurar manualmente um servidor externo apenas para iniciar o projeto.

A documentação oficial define o Spring Boot como uma ferramenta para criar aplicações Spring independentes e preparadas para produção, com configuração mínima. Entre seus recursos estão servidores incorporados, starters, configuração automática, métricas e verificações de saúde.

Por que aprender Spring?

Java é uma linguagem poderosa, mas apenas conhecer a sintaxe não é suficiente para desenvolver aplicações corporativas modernas.

Em um sistema real, normalmente precisamos lidar com:

• requisições HTTP;
• regras de negócio;
• bancos de dados;
• autenticação;
• autorização;
• transações;
• validação;
• tratamento de erros;
• mensageria;
• integração com outros serviços;
• testes automatizados;
• monitoramento;
• implantação.

O ecossistema Spring oferece soluções para grande parte desses problemas.

Ao aprender Spring, você começa a compreender não apenas anotações e bibliotecas, mas também conceitos importantes de arquitetura de software.

Entre eles estão:

• separação de responsabilidades;
• baixo acoplamento;
• inversão de dependência;
• divisão em camadas;
• configuração por ambiente;
• tratamento centralizado de erros;
• aplicações orientadas a serviços;
• desenvolvimento e consumo de APIs.

Por isso, estudar Spring também ajuda a amadurecer como desenvolvedor Java.

Preciso dominar Java antes de aprender Spring?

Não é necessário conhecer todos os recursos da linguagem antes de começar. Entretanto, uma base de Java tornará o aprendizado muito mais produtivo.

Antes de iniciar, procure compreender pelo menos:

• classes e objetos;
• atributos e métodos;
• construtores;
• encapsulamento;
• herança e composição;
• interfaces;
• exceções;
• coleções;
• generics;
• expressões lambda;
• records;
• pacotes;
• modificadores de acesso;
• método main;
• Maven ou Gradle.

Também é importante conhecer conceitos básicos da web:

• cliente e servidor;
• HTTP;
• métodos GET, POST, PUT e DELETE;
• códigos de status HTTP;
• JSON;
• URL;
• parâmetros de consulta;
• corpo da requisição.

Não espere atingir uma sensação de domínio absoluto do Java. Depois de aprender os fundamentos, comece a construir aplicações.

A prática mostrará quais pontos precisam ser revisados.

O ecossistema Spring

Ao procurar materiais para aprender Spring, você encontrará diferentes projetos. Cada um resolve um tipo de problema.

Spring Framework

É a base do ecossistema. Contém o contêiner de inversão de controle, injeção de dependências, recursos web, transações e várias integrações.

Spring Boot

Simplifica a criação, a configuração, a execução e a distribuição de aplicações Spring.

Spring MVC

Fornece a estrutura tradicional para aplicações web baseadas na especificação Servlet. É muito usado na construção de APIs REST.

Spring Data

Facilita o acesso a dados e oferece integração com bancos relacionais e tecnologias NoSQL.

Spring Data JPA

Simplifica o uso da Jakarta Persistence API em aplicações Spring. É comum utilizá-lo com implementações como Hibernate.

Spring Security

Oferece autenticação, autorização, proteção de rotas e integração com padrões como OAuth 2.0 e OpenID Connect.

Spring Cloud

Reúne soluções para sistemas distribuídos, configurações centralizadas, comunicação entre serviços e diferentes padrões de microsserviços.

Spring Batch

É voltado ao processamento de grandes volumes de dados em tarefas executadas em lote.

Spring Integration

Auxilia na integração entre sistemas utilizando padrões de integração corporativa.

Spring for Apache Kafka

Facilita a produção e o consumo de mensagens pelo Apache Kafka.

Você não precisa estudar todos esses projetos no início. Comece por Spring Boot, injeção de dependências e Spring MVC.

Os fundamentos necessários para aprender Spring

Antes de criar a primeira API, precisamos entender alguns conceitos centrais.

O que é inversão de controle?

Em uma aplicação Java tradicional, uma classe frequentemente cria os objetos de que precisa.

Observe:

public class PedidoService {

    private final EmailService emailService =
            new EmailService();
}

Nesse caso, PedidoService decidiu como criar sua dependência.

Além disso, a classe ficou diretamente ligada à implementação EmailService.

Com inversão de controle, a responsabilidade de criar e organizar os objetos é transferida para um contêiner.

No Spring, esse contêiner é representado principalmente pelo ApplicationContext.

O Spring cria os objetos, gerencia seu ciclo de vida e resolve as dependências entre eles.

A classe passa a receber aquilo de que precisa:

public class PedidoService {

    private final EmailService emailService;

    public PedidoService(EmailService emailService) {
        this.emailService = emailService;
    }
}

Agora, PedidoService não precisa saber como EmailService foi criado.

Esse controle pertence ao contêiner.

O que é injeção de dependências?

Injeção de dependências é a maneira pela qual um objeto recebe suas dependências externas.

No Spring, a forma mais recomendada é a injeção pelo construtor.

Exemplo:

@Service
public class PedidoService {

    private final EmailService emailService;

    public PedidoService(EmailService emailService) {
        this.emailService = emailService;
    }
}

Quando o Spring cria PedidoService, ele procura um objeto compatível com EmailService e o fornece ao construtor.

A injeção pelo construtor apresenta vantagens importantes:

• deixa as dependências visíveis;
• facilita testes unitários;
• permite atributos final;
• evita objetos parcialmente inicializados;
• reduz a dependência direta do código em relação ao framework.

Existe também a injeção diretamente em atributos com @Autowired, mas ela deve ser evitada como padrão em novos projetos.

O que é um bean no Spring?

Um bean é um objeto criado e gerenciado pelo contêiner do Spring.

Classes anotadas com determinados estereótipos podem ser detectadas automaticamente.

Entre as anotações mais comuns estão:

@Component
@Service
@Repository
@Controller
@RestController

Todas indicam, de alguma forma, que aquela classe deve ser registrada no contêiner.

Entretanto, cada anotação comunica uma intenção arquitetural.

• @Component: componente genérico;
• @Service: serviço ou regra de negócio;
• @Repository: acesso a dados;
• @Controller: controlador web tradicional;
• @RestController: controlador de uma API REST.

Também podemos criar beans manualmente em uma classe de configuração:

@Configuration
public class AplicacaoConfig {

    @Bean
    public Relogio relogio() {
        return new Relogio();
    }
}

O que é configuração automática?

A configuração automática permite que o Spring Boot configure diversos componentes com base nas dependências presentes no projeto.

Por exemplo, quando os recursos necessários para uma aplicação Spring MVC estão disponíveis, o Spring Boot configura a infraestrutura web correspondente.

Quando uma dependência de banco de dados é adicionada junto com configurações de conexão, ele pode preparar o acesso aos dados.

Isso não significa que o Spring esteja fazendo algo aleatório.

As configurações são ativadas por condições. Elas observam aspectos como:

• classes disponíveis;
• beans já criados;
• propriedades configuradas;
• tipo da aplicação;
• dependências presentes.

Posteriormente, você poderá substituir configurações automáticas por configurações próprias.

O que são starters?

Starters são conjuntos de dependências preparados para determinado tipo de aplicação.

Em vez de procurar e configurar manualmente cada biblioteca necessária para criar uma API web, você seleciona a dependência Spring Web no Spring Initializr.

Em versões atuais do Spring Boot 4, o projeto web MVC pode utilizar o starter:

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

O guia oficial atual de serviços REST utiliza spring-boot-starter-webmvc e o starter correspondente para testes.

Em projetos criados com versões anteriores do Spring Boot, você poderá encontrar:

<artifactId>spring-boot-starter-web</artifactId>

Por isso, sempre considere a versão do projeto ao acompanhar um tutorial.

Não misture dependências de exemplos antigos com uma versão moderna sem verificar a documentação correspondente.

Qual versão do Java utilizar?

Na atualização deste artigo, a documentação oficial apresenta o Spring Boot 4.1.0 como versão estável.

Essa versão exige pelo menos Java 17 e oferece compatibilidade até Java 26. O suporte explícito de build inclui Maven 3.6.3 ou posterior e versões compatíveis do Gradle 8 e 9.

Para acompanhar este tutorial, utilizaremos:

Java 21
Maven
Spring Boot 4
Spring Web

O Java 21 oferece uma base moderna e adequada para estudos e novos projetos.

Caso sua empresa utilize Spring Boot 3, os fundamentos apresentados continuarão válidos. Entretanto, alguns nomes de dependências e detalhes de configuração podem variar.

Ferramentas necessárias

Prepare o ambiente com:

• JDK 21;
• uma IDE;
• Git;
• navegador;
• Postman, Insomnia ou outro cliente HTTP opcional.

Entre as IDEs mais utilizadas estão:

• IntelliJ IDEA;
• Eclipse;
• Spring Tools;
• Visual Studio Code com extensões Java.

Também confirme no terminal:

java -version

A saída deve indicar a versão correta do Java.

Criando o projeto no Spring Initializr

O Spring Initializr gera a estrutura inicial da aplicação de acordo com suas escolhas.

A documentação oficial recomenda esse serviço para selecionar a ferramenta de build, a linguagem e dependências como Spring Web.

Acesse o Spring Initializr e configure:

Project: Maven
Language: Java
Spring Boot: versão estável
Group: br.com.cursojavanow
Artifact: aprender-spring
Name: aprender-spring
Description: Primeira API REST com Spring Boot
Package name: br.com.cursojavanow.aprenderspring
Packaging: Jar
Java: 21

Em Dependencies, adicione:

Spring Web

Depois, clique em Generate.

O serviço criará um arquivo ZIP. Extraia o conteúdo e abra a pasta do projeto na IDE.

Entendendo a estrutura do projeto

A estrutura inicial será semelhante a esta:

aprender-spring
├── src
│   ├── main
│   │   ├── java
│   │   │   └── br.com.cursojavanow.aprenderspring
│   │   │       └── AprenderSpringApplication.java
│   │   └── resources
│   │       └── application.properties
│   └── test
│       └── java
├── mvnw
├── mvnw.cmd
└── pom.xml

O arquivo pom.xml contém as informações do projeto Maven e suas dependências.

A pasta src/main/java contém o código principal.

A pasta src/main/resources contém arquivos de configuração e outros recursos.

A pasta src/test/java contém os testes.

Os arquivos mvnw e mvnw.cmd pertencem ao Maven Wrapper. Eles permitem executar o Maven usando a versão configurada pelo projeto, mesmo quando o Maven não está instalado globalmente.

A classe principal da aplicação

O Spring Initializr cria uma classe semelhante a esta:

package br.com.cursojavanow.aprenderspring;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AprenderSpringApplication {

    public static void main(String[] args) {
        SpringApplication.run(
                AprenderSpringApplication.class,
                args
        );
    }
}

A anotação @SpringBootApplication reúne três comportamentos importantes:

• configuração da aplicação;
• configuração automática;
• busca por componentes.

Ela combina os efeitos de @Configuration, @EnableAutoConfiguration e @ComponentScan.

O método SpringApplication.run() inicia a aplicação e cria o contexto do Spring. Em uma aplicação web, a infraestrutura necessária e o servidor incorporado também são inicializados. A documentação oficial explica essa composição e mostra que o escaneamento procura componentes nos pacotes da aplicação.

Por esse motivo, a classe principal deve permanecer em um pacote raiz.

As demais classes devem ficar nesse pacote ou em seus subpacotes.

Planejando nossa primeira API REST

Criaremos uma API simples de saudações.

Ela terá dois endpoints:

A resposta terá este formato:

{
  "mensagem": "Olá, Michel! Bem-vindo ao Spring."
}

Mesmo sendo simples, essa aplicação mostrará:

• controlador REST;
• classe de serviço;
• injeção de dependências;
• parâmetro de consulta;
• corpo JSON;
• record;
• código de status HTTP;
• conversão automática para JSON.

Criando o objeto de resposta

Crie o pacote:

br.com.cursojavanow.aprenderspring.dto

Dentro dele, crie SaudacaoResponse.java:

package br.com.cursojavanow.aprenderspring.dto;

public record SaudacaoResponse(String mensagem) {
}

Um record é adequado para transportar dados imutáveis.

Nesse exemplo, ele representa a resposta devolvida pela API.

Não precisamos criar manualmente getter, construtor, equals(), hashCode() e toString().

Criando o objeto da requisição

No mesmo pacote, crie SaudacaoRequest.java:

package br.com.cursojavanow.aprenderspring.dto;

public record SaudacaoRequest(String nome) {
}

Esse record representará o JSON recebido pelo endpoint POST.

Quando o cliente enviar:

{
  "nome": "Michel"
}

O Spring converterá o JSON em um objeto SaudacaoRequest.

Criando a camada de serviço

Crie o pacote:

br.com.cursojavanow.aprenderspring.service

Depois, crie SaudacaoService.java:

package br.com.cursojavanow.aprenderspring.service;

import br.com.cursojavanow.aprenderspring.dto.SaudacaoResponse;
import org.springframework.stereotype.Service;

@Service
public class SaudacaoService {

    public SaudacaoResponse criarSaudacao(String nome) {
        String nomeTratado = tratarNome(nome);

        String mensagem = "Olá, %s! Bem-vindo ao Spring."
                .formatted(nomeTratado);

        return new SaudacaoResponse(mensagem);
    }

    private String tratarNome(String nome) {
        if (nome == null || nome.isBlank()) {
            return "Mundo";
        }

        return nome.trim();
    }
}

A anotação @Service informa que essa classe representa um componente da camada de serviço.

Ao iniciar a aplicação, o Spring detectará a classe e criará um bean.

O método criarSaudacao() contém a pequena regra de negócio da aplicação.

Ele verifica o nome recebido, remove espaços desnecessários e cria a mensagem.

Embora essa regra seja simples, colocá-la no serviço estabelece uma separação importante: o controlador lida com HTTP, enquanto o serviço executa a lógica da aplicação.

Criando o controlador REST

Crie o pacote:

br.com.cursojavanow.aprenderspring.controller

Depois, crie SaudacaoController.java:

package br.com.cursojavanow.aprenderspring.controller;

import br.com.cursojavanow.aprenderspring.dto.SaudacaoRequest;
import br.com.cursojavanow.aprenderspring.dto.SaudacaoResponse;
import br.com.cursojavanow.aprenderspring.service.SaudacaoService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/saudacoes")
public class SaudacaoController {

    private final SaudacaoService saudacaoService;

    public SaudacaoController(
            SaudacaoService saudacaoService
    ) {
        this.saudacaoService = saudacaoService;
    }

    @GetMapping
    public SaudacaoResponse obterSaudacao(
            @RequestParam(
                    defaultValue = "Mundo"
            ) String nome
    ) {
        return saudacaoService.criarSaudacao(nome);
    }

    @PostMapping
    public ResponseEntity<SaudacaoResponse> criarSaudacao(
            @RequestBody SaudacaoRequest request
    ) {
        SaudacaoResponse response =
                saudacaoService.criarSaudacao(
                        request.nome()
                );

        return ResponseEntity
                .status(HttpStatus.CREATED)
                .body(response);
    }
}

Agora temos uma API funcional.

Entendendo as anotações do controlador

@RestController

Indica que a classe recebe requisições web e devolve seus resultados diretamente no corpo da resposta HTTP.

Ao retornar um objeto Java, o Spring utiliza um conversor de mensagens para transformá-lo em JSON.

O guia oficial explica que @RestController combina os comportamentos de @Controller e @ResponseBody. Quando o suporte JSON está presente, os objetos retornados são convertidos automaticamente.

@RequestMapping

Define o caminho base do controlador:

@RequestMapping("/api/saudacoes")

Todos os endpoints dessa classe começam com esse endereço.

@GetMapping

Associa um método Java a uma requisição HTTP GET.

@GetMapping

Como o caminho base já foi definido, esse método responde a:

GET /api/saudacoes

@RequestParam

Obtém um valor enviado na URL:

/api/saudacoes?nome=Michel

O valor de nome será associado ao parâmetro do método.

Quando ele não for informado, será utilizado o valor padrão Mundo.

@PostMapping

Associa um método a uma requisição HTTP POST.

@RequestBody

Solicita que o Spring leia o corpo da requisição e converta seu JSON em um objeto Java.

ResponseEntity

Permite controlar a resposta HTTP, incluindo:

• status;
• cabeçalhos;
• corpo.

No exemplo, retornamos o status 201 Created.

Como a injeção de dependências aconteceu?

O controlador possui esta dependência:

private final SaudacaoService saudacaoService;

Ela é recebida pelo construtor:

public SaudacaoController(
        SaudacaoService saudacaoService
) {
    this.saudacaoService = saudacaoService;
}

Durante a inicialização, o Spring:

1. encontra SaudacaoService;
2. identifica sua anotação @Service;
3. cria um bean dessa classe;
4. encontra SaudacaoController;
5. observa que seu construtor precisa de SaudacaoService;
6. entrega o bean ao controlador.

Não utilizamos:

new SaudacaoService()

dentro do controlador.

Esse é um exemplo direto de inversão de controle e injeção de dependências.

Configurando a aplicação

Abra:

src/main/resources/application.properties

Adicione:

spring.application.name=aprender-spring
server.port=8080

A primeira propriedade define o nome da aplicação.

A segunda configura a porta HTTP.

Como 8080 já é o padrão, essa linha não é obrigatória. Entretanto, deixá-la explícita pode facilitar os primeiros estudos.

Para utilizar outra porta:

server.port=8081

Executando a aplicação

No Windows, abra o terminal dentro da pasta do projeto e execute:

.\mvnw.cmd spring-boot:run

No Linux ou macOS:

./mvnw spring-boot:run

Também é possível executar diretamente a classe:

AprenderSpringApplication

A aplicação deverá iniciar o servidor incorporado.

O terminal mostrará mensagens semelhantes a:

Started AprenderSpringApplication

O guia oficial também apresenta a execução pelo Maven Wrapper com spring-boot:run e a possibilidade de gerar um JAR executável.

Testando o endpoint GET

Abra o navegador ou um cliente HTTP e acesse:

http://localhost:8080/api/saudacoes

A resposta esperada é:

{
  "mensagem": "Olá, Mundo! Bem-vindo ao Spring."
}

Agora informe o nome:

http://localhost:8080/api/saudacoes?nome=Michel

Resultado:

{
  "mensagem": "Olá, Michel! Bem-vindo ao Spring."
}

Também podemos usar curl:

curl "http://localhost:8080/api/saudacoes?nome=Michel"

Testando o endpoint POST

Envie uma requisição para:

POST http://localhost:8080/api/saudacoes

Com o cabeçalho:

Content-Type: application/json

E o corpo:

{
  "nome": "Michel"
}

Com curl:

curl -X POST \
  "http://localhost:8080/api/saudacoes" \
  -H "Content-Type: application/json" \
  -d "{\"nome\":\"Michel\"}"

A resposta terá status HTTP 201 Created:

{
  "mensagem": "Olá, Michel! Bem-vindo ao Spring."
}

O caminho de uma requisição dentro da aplicação

Quando o cliente acessa o endpoint, ocorre um fluxo semelhante a este:

Cliente HTTP
    ↓
Servidor incorporado
    ↓
Spring MVC
    ↓
SaudacaoController
    ↓
SaudacaoService
    ↓
SaudacaoResponse
    ↓
Conversão para JSON
    ↓
Resposta HTTP

O servidor recebe a requisição e a entrega à infraestrutura web do Spring.

O Spring MVC procura um método compatível com o caminho e o método HTTP.

O controlador recebe os dados e chama o serviço.

O serviço aplica a regra de negócio e devolve um objeto.

O Spring converte esse objeto em JSON e cria a resposta.

Esse fluxo será ampliado quando adicionarmos:

• validação;
• acesso ao banco;
• tratamento de exceções;
• autenticação;
• logs;
• métricas.

Criando o primeiro teste unitário

Um bom roteiro para aprender Spring também deve incluir testes.

Crie o arquivo:

src/test/java/br/com/cursojavanow/aprenderspring/service/SaudacaoServiceTest.java

Adicione:

package br.com.cursojavanow.aprenderspring.service;

import br.com.cursojavanow.aprenderspring.dto.SaudacaoResponse;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

class SaudacaoServiceTest {

    private final SaudacaoService saudacaoService =
            new SaudacaoService();

    @Test
    void deveCriarSaudacaoComNomeInformado() {
        SaudacaoResponse response =
                saudacaoService.criarSaudacao(
                        "Michel"
                );

        assertEquals(
                "Olá, Michel! Bem-vindo ao Spring.",
                response.mensagem()
        );
    }

    @Test
    void deveUsarMundoQuandoNomeEstiverVazio() {
        SaudacaoResponse response =
                saudacaoService.criarSaudacao(" ");

        assertEquals(
                "Olá, Mundo! Bem-vindo ao Spring.",
                response.mensagem()
        );
    }
}

Esse é um teste unitário puro.

Ele não precisa iniciar o contêiner do Spring porque SaudacaoService não possui dependências externas.

Essa característica demonstra uma vantagem da boa separação de responsabilidades: as regras podem ser testadas rapidamente sem iniciar toda a aplicação.

Execute:

./mvnw test

No Windows:

.\mvnw.cmd test

Erros comuns ao aprender Spring

Colocar classes fora do pacote principal

Se a classe principal estiver em:

br.com.cursojavanow.aprenderspring

mas o controlador estiver em:

com.exemplo.controller

o escaneamento padrão pode não encontrá-lo.

Mantenha as classes no pacote principal ou em seus subpacotes.

Usar uma versão errada do Java

Confira:

java -version

Também confirme qual JDK foi configurado na IDE.

Às vezes, o terminal utiliza um Java e a IDE utiliza outro.

A porta 8080 já estar ocupada

O erro pode indicar que outro programa está usando a porta.

Altere temporariamente:

server.port=8081

Copiar exemplos de versões antigas

Um tutorial antigo pode utilizar:

• uma versão diferente do Spring Boot;
• dependências antigas;
• javax.* no lugar de jakarta.*;
• configurações que já foram substituídas;
• nomes antigos de starters.

Sempre confirme a versão usada pelo material.

Colocar toda a lógica no controlador

Controladores devem lidar principalmente com HTTP.

Regras de negócio devem ficar em serviços ou componentes adequados.

Usar injeção em atributos como padrão

Evite:

@Autowired
private SaudacaoService saudacaoService;

Prefira injeção pelo construtor.

Ignorar os códigos HTTP

Uma API não deve retornar 200 OK para todas as situações.

Aprenda gradualmente a utilizar:

• 200 OK;
• 201 Created;
• 204 No Content;
• 400 Bad Request;
• 401 Unauthorized;
• 403 Forbidden;
• 404 Not Found;
• 409 Conflict;
• 500 Internal Server Error.

Estudar apenas anotações

Memorizar anotações não é suficiente.

Procure entender:

• quem cria os objetos;
• como as dependências são resolvidas;
• como a requisição encontra o controlador;
• onde fica a regra de negócio;
• como a resposta é convertida;
• como a aplicação é configurada.

Roteiro para aprender Spring do zero

Depois da primeira API, siga uma ordem progressiva.

Etapa 1: fortaleça Java e HTTP

Revise orientação a objetos, interfaces, exceções, collections, records, lambdas, Maven, JSON e HTTP.

Crie pequenos exercícios sem framework.

Etapa 2: domine o núcleo do Spring

Estude:

• inversão de controle;
• injeção de dependências;
• beans;
• escopos;
• ApplicationContext;
• configuração;
• perfis;
• propriedades externas;
• ciclo de vida dos componentes.

Crie exemplos pequenos que mostrem a colaboração entre componentes.

Etapa 3: aprenda Spring Boot

Entenda:

• configuração automática;
• starters;
• Maven Wrapper;
• estrutura do projeto;
• servidor incorporado;
• arquivos de configuração;
• perfis de ambiente;
• empacotamento JAR.

Etapa 4: construa APIs REST

Pratique:

• controllers;
• DTOs;
• GET;
• POST;
• PUT;
• PATCH;
• DELETE;
• parâmetros de consulta;
• parâmetros de caminho;
• cabeçalhos;
• códigos HTTP;
• ResponseEntity.

Crie um CRUD em memória antes de adicionar banco de dados.

Etapa 5: adicione validação e tratamento de erros

Estude:

• Jakarta Bean Validation;
• @Valid;
• @NotBlank;
• @NotNull;
• @Size;
• exceções personalizadas;
• @RestControllerAdvice;
• @ExceptionHandler;
• respostas padronizadas de erro.

Etapa 6: aprenda bancos de dados

Avance para:

• SQL;
• Spring Data JPA;
• entidades;
• repositórios;
• relacionamentos;
• transações;
• paginação;
• consultas;
• migrations;
• PostgreSQL;
• Flyway ou Liquibase.

Evite usar apenas o recurso automático de criação de tabelas em ambientes reais.

Etapa 7: pratique testes

Estude:

• JUnit;
• Mockito;
• testes unitários;
• testes de controller;
• testes de repositório;
• testes de integração;
• MockMvc;
• Testcontainers.

Procure desenvolver regras testáveis sem depender excessivamente do contêiner.

Etapa 8: aprenda segurança

Depois que o CRUD estiver funcionando, avance para:

• Spring Security;
• autenticação;
• autorização;
• armazenamento seguro de senhas;
• tokens;
• JWT;
• OAuth 2.0;
• proteção de endpoints.

Não comece por segurança antes de compreender o fluxo básico de uma API.

Etapa 9: prepare a aplicação para produção

Estude:

• logs;
• configuração por ambiente;
• Actuator;
• métricas;
• observabilidade;
• Docker;
• variáveis de ambiente;
• pipelines;
• CI/CD;
• implantação;
• práticas de segurança.

Etapa 10: avance para sistemas distribuídos

Somente depois de construir aplicações monolíticas organizadas, aprofunde-se em:

• microsserviços;
• mensageria;
• Apache Kafka;
• comunicação assíncrona;
• tolerância a falhas;
• rastreamento distribuído;
• Spring Cloud;
• Kubernetes.

Microsserviços ampliam a complexidade. Eles não eliminam a necessidade de conhecer bem os fundamentos.

Projeto recomendado depois desta API

O próximo projeto pode ser uma API de tarefas.

Ela poderá conter:

POST   /api/tarefas
GET    /api/tarefas
GET    /api/tarefas/{id}
PUT    /api/tarefas/{id}
DELETE /api/tarefas/{id}

Cada tarefa poderá ter:

id
titulo
descricao
concluida
dataCriacao

A evolução pode seguir esta ordem:

1. armazenamento em memória;
2. DTOs;
3. validação;
4. tratamento de erros;
5. banco H2;
6. PostgreSQL;
7. Spring Data JPA;
8. migrations;
9. testes;
10. documentação da API;
11. autenticação;
12. Docker.

Esse único projeto pode servir como laboratório para grande parte dos assuntos essenciais.

Perguntas frequentes sobre aprender Spring

Spring é difícil para iniciantes?

O início pode parecer difícil porque vários conceitos aparecem simultaneamente.

O aprendizado fica mais simples quando os assuntos são separados em etapas. Comece pela injeção de dependências e por uma API pequena. Depois, adicione banco, validação, testes e segurança.

Devo aprender Spring Framework antes do Spring Boot?

Você pode começar criando aplicações com Spring Boot, mas deve estudar os fundamentos do Spring Framework durante o processo.

O Spring Boot simplifica a configuração, porém conceitos como beans, contêiner e injeção de dependências continuam sendo fundamentais.

Preciso conhecer Servlets?

Não é obrigatório dominar Servlets antes de criar sua primeira API. Entretanto, conhecer requisições, respostas, filtros e o funcionamento básico de uma aplicação web Java ajudará bastante.

Preciso aprender XML?

Aplicações modernas Spring Boot normalmente usam configuração Java, anotações e propriedades.

Todavia, XML ainda pode aparecer em sistemas antigos. Conhecê-lo pode ser útil para manutenção, mas ele não deve ser a prioridade inicial.

Spring Boot cria apenas microsserviços?

Não.

Ele pode ser utilizado para criar:

• aplicações monolíticas;
• APIs;
• microsserviços;
• aplicações web;
• processamentos em lote;
• consumidores de mensagens;
• serviços de integração.

Spring Boot é uma plataforma de desenvolvimento, não uma arquitetura obrigatória.

Qual banco de dados devo usar?

Para os primeiros testes, H2 pode ser conveniente.

Em seguida, utilize um banco real, como PostgreSQL ou MySQL, para aprender configurações, migrations, tipos de dados e comportamento de produção.

Posso aprender Spring com Kotlin?

Sim. O ecossistema possui suporte a Kotlin.

Entretanto, quem está construindo uma carreira Java pode começar com Java e depois comparar as duas linguagens.

Quanto tempo leva para aprender Spring?

Não existe um prazo universal.

Aprender a criar uma API simples pode levar pouco tempo. Dominar acesso a dados, segurança, testes, mensageria, observabilidade e arquitetura exige prática contínua.

Avalie sua evolução pela capacidade de construir e explicar aplicações, não apenas pelo número de aulas assistidas.

É necessário decorar todas as anotações?

Não.

Aprenda as mais utilizadas, mas concentre-se no que elas fazem e em como os componentes se relacionam.

A documentação e a IDE podem ajudar com nomes e parâmetros. A compreensão arquitetural é muito mais importante do que a memorização.

Conclusão

Aprender Spring não significa estudar todo o ecossistema antes de escrever a primeira linha de código.

O melhor caminho é começar com uma base sólida de Java, compreender inversão de controle e injeção de dependências e construir uma pequena API REST.

Neste artigo, criamos uma aplicação com:

• Spring Boot;
• Spring MVC;
• controlador REST;
• serviço;
• DTOs;
• injeção pelo construtor;
• endpoints GET e POST;
• respostas JSON;
• código de status HTTP;
• teste unitário.

Esse projeto representa apenas o começo.

O próximo passo é transformar a aplicação em um CRUD, adicionar validação, tratamento de erros, banco de dados e testes de integração.

Ao avançar de forma gradual, o Spring deixa de parecer um conjunto enorme de anotações e começa a revelar sua verdadeira proposta: organizar a aplicação, reduzir acoplamentos e facilitar a construção de sistemas Java profissionais.

Referências oficiais

• Página oficial do Spring Boot e descrição de seus principais recursos.
• Requisitos oficiais do Spring Boot 4.1.0.
• Guia oficial para criação de um serviço REST com Spring.
• Projeto oficial utilizado pelo guia REST e dependências atuais do Spring Boot 4.

Links internos sugeridos

• Por que aprender Spring?
• O método main em Java
• Por que o método main é static?
• O que é Java EE?
• O que são pacotes em Java?
• O problema do código hard coded