Spring Boot na prática: do básico ao avançado no desenvolvimento Java

Resposta rápida: Spring Boot é um framework do ecossistema Spring que acelera o desenvolvimento de aplicações Java, reduzindo configuração manual e facilitando a criação de APIs, sistemas web e microserviços.

Se você quer sair do “hello world” e usar Spring Boot de forma produtiva em projetos reais, este guia foi feito para isso. Aqui você vai entender o que é Spring Boot e como usar na prática, desde a criação do projeto até recursos avançados como segurança, testes, observabilidade e performance.

Spring Boot na prática: o que você precisa saber primeiro

Spring Boot simplifica tarefas que, em Java puro, costumam exigir mais configuração. Em vez de montar tudo do zero, você aproveita auto-configuração, dependências prontas e convenções que aceleram o desenvolvimento.

O que muda na prática

• Menos XML e menos configuração manual.
• Inicialização mais rápida do projeto.
• Integração simples com web, banco de dados, segurança e testes.
• Base sólida para aplicações monolíticas e microserviços.

Pré-requisitos para começar

• JDK: prefira Java 17 ou superior em projetos novos.
• IDE: IntelliJ IDEA, Eclipse ou VS Code com suporte a Java.
• Build tool: Maven ou Gradle.
• Spring Initializr: ponto de partida mais rápido para criar o projeto.

Como criar um projeto Spring Boot do jeito certo

O caminho mais simples é usar o Spring Initializr. Ele já gera a estrutura base com dependências essenciais para o seu caso de uso.

1. Abra o Spring Initializr.
2. Escolha Maven ou Gradle.
3. Selecione Java como linguagem.
4. Defina a versão do Spring Boot.
5. Adicione dependências como Spring Web, Spring Data JPA, Validation e Spring Security, se necessário.
6. Gere o projeto e importe na IDE.

Na prática, um projeto de API REST simples costuma começar com estas dependências:

• Spring Web
• Spring Boot DevTools
• Spring Data JPA
• Validation
• Driver do banco de dados

Conceitos essenciais de Spring Boot

Inversão de Controle e injeção de dependência

Spring gerencia os objetos da aplicação e injeta as dependências quando necessário. Isso deixa o código mais desacoplado, testável e fácil de manter.

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

Auto-configuração

A anotação @SpringBootApplication reúne configurações importantes e permite que o Spring Boot configure boa parte da aplicação automaticamente com base nas dependências incluídas.

Starter dependencies

Os starters reduzem o trabalho de escolher e montar bibliotecas manualmente. Por exemplo, ao adicionar spring-boot-starter-web, você já ganha suporte básico para criar endpoints REST com Tomcat embarcado.

Construindo uma API REST com Spring Boot

Um dos usos mais comuns do Spring Boot é criar APIs REST para sistemas web, apps mobile e integrações entre serviços.

Exemplo real: cadastro de usuários

Imagine uma API de cadastro de clientes. Você normalmente terá camadas como controller, service e repository.

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> findById(@PathVariable Long id) {
        return ResponseEntity.ok(userService.findById(id));
    }

    @PostMapping
    public ResponseEntity<User> create(@Valid @RequestBody User user) {
        User created = userService.save(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(created);
    }
}

Validação de dados

Validação evita que dados inválidos cheguem à camada de negócio. Em um cenário real, isso é essencial para impedir campos vazios, e-mails inválidos ou formatos errados.

public class User {

    @NotBlank
    private String name;

    @Email
    @NotBlank
    private String email;
}

Exemplo prático de payload

{
  "name": "Maria Silva",
  "email": "maria@empresa.com"
}

Persistência com Spring Data JPA

Quando a aplicação precisa falar com banco de dados, o Spring Data JPA reduz bastante o trabalho repetitivo.

Configuração básica

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=senha
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

Repository com poucos métodos

public interface UserRepository extends JpaRepository<User, Long> {
}

Com isso, você já ganha operações como salvar, buscar por ID, listar, atualizar e excluir sem implementar SQL manualmente para cada caso.

Exemplo real de uso no service

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User save(User user) {
        return userRepository.save(user);
    }

    public User findById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("Usuário não encontrado"));
    }
}

Erro comum ao usar Spring Boot

Erro: tentar colocar toda a regra de negócio dentro do controller.

Por que isso é um problema? O controller deve receber a requisição, validar o básico, chamar a camada de serviço e devolver a resposta. Se você concentra lógica demais ali, o código fica difícil de testar e manter.

Como evitar:

• deixe o controller fino;
• coloque regras de negócio no service;
• deixe o repository responsável pelo acesso aos dados;
• trate exceções de forma centralizada.

Bloco prático: montando uma estrutura simples e escalável

Se você estiver começando um projeto real, esta estrutura costuma funcionar bem:

• controller para endpoints HTTP;
• service para regras de negócio;
• repository para persistência;
• domain/model para entidades;
• exception para tratamento centralizado de erros.

Exemplo de fluxo: o cliente envia um POST /api/users, o controller recebe a requisição, o service valida a regra de negócio, o repository salva no banco e a API responde com 201 Created.

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<String> handleRuntimeException(RuntimeException ex) {
        return ResponseEntity.badRequest().body(ex.getMessage());
    }
}

Recursos avançados de Spring Boot

Segurança com Spring Security

Em sistemas reais, autenticação e autorização são indispensáveis. Spring Security ajuda a proteger rotas, controlar perfis de acesso e integrar autenticação baseada em JWT.

public String generateToken(UserDetails userDetails) {
    return Jwts.builder()
            .setSubject(userDetails.getUsername())
            .setExpiration(new Date(System.currentTimeMillis() + JWT_EXPIRATION))
            .signWith(SignatureAlgorithm.HS512, JWT_SECRET)
            .compact();
}

Testes unitários e de integração

Testar é parte essencial do uso profissional do Spring Boot. Com JUnit e Mockito, você valida serviços isoladamente. Com @SpringBootTest, você verifica a aplicação mais próxima do ambiente real.

@SpringBootTest
class UserServiceTest {

    @MockBean
    private UserRepository userRepository;

    @Autowired
    private UserService userService;

    @Test
    void shouldSaveUser() {
        User user = new User("Maria", "maria@empresa.com");
        when(userRepository.save(any(User.class))).thenReturn(user);

        User created = userService.save(user);

        assertEquals("Maria", created.getName());
    }
}

Monitoramento e observabilidade

O Actuator ajuda a acompanhar saúde, métricas e informações da aplicação. Em produção, isso facilita diagnóstico e monitoramento.

management.endpoints.web.exposure.include=health,info,metrics

Boas práticas para performance e manutenção

• Use pool de conexões, como HikariCP.
• Evite consultas desnecessárias no banco.
• Use cache quando houver leituras repetidas.
• Separe responsabilidades por camada.
• Centralize tratamento de exceções.
• Escreva testes para regras críticas.

Exemplo de cache

@Cacheable("users")
public User findById(Long id) {
    return userRepository.findById(id)
            .orElseThrow(() -> new RuntimeException("Usuário não encontrado"));
}

Deploy com Docker

Empacotar a aplicação em Docker ajuda a padronizar ambientes e simplificar deploys.

FROM eclipse-temurin:17-jre
COPY target/myapp.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

Perguntas frequentes sobre Spring Boot

Spring Boot substitui o Spring Framework?

Não. Spring Boot é uma camada que facilita o uso do ecossistema Spring. Ele simplifica configuração e inicialização, mas continua aproveitando os conceitos do Spring Framework.

Spring Boot serve só para APIs REST?

Não. Ele também é usado em aplicações web tradicionais, integrações, jobs, sistemas corporativos e microserviços.

Preciso usar Spring Boot em todo projeto Java?

Não necessariamente. Em projetos pequenos ou utilitários simples, Java puro pode ser suficiente. Já em aplicações com regras de negócio, banco, segurança e múltiplos endpoints, Spring Boot costuma trazer mais produtividade.

Qual versão do Java devo usar?

Para projetos novos, o ideal é usar uma versão LTS recente, como Java 17 ou 21, alinhando com a versão compatível do Spring Boot.

Spring Boot é bom para iniciantes?

Sim, desde que o iniciante entenda os conceitos básicos de Java, orientação a objetos e HTTP. A curva inicial é menor do que montar tudo manualmente.

Conclusão: próximos passos para evoluir com Spring Boot

Spring Boot é uma base excelente para desenvolver aplicações Java modernas com menos burocracia e mais foco na solução. Se você dominar o ciclo básico — controller, service, repository, validação, testes e segurança — já consegue trabalhar em projetos reais com muito mais segurança.

Como próximos passos, vale aprofundar em:

• Spring Security com JWT e OAuth2;
• paginação e filtros em APIs;
• tratamento global de erros;
• testes de integração com banco;
• Docker e deploy em produção;
• observabilidade com Actuator e métricas.

Se quiser continuar evoluindo, o melhor caminho é praticar com um projeto pequeno, como uma API de usuários, tarefas ou catálogo de produtos, e ir adicionando recursos aos poucos.

Leia também

• Front-end ou Back-end: qual escolher em 2025?
• Coisas que fiz para me tornar um desenvolvedor