Antes de entender por que o Spring Boot é tão produtivo, vale compreender como uma aplicação Spring normalmente é organizada.
Uma aplicação desenvolvida com Spring Boot continua seguindo a arquitetura em camadas tradicional do Spring Framework. A diferença é que praticamente toda a infraestrutura é configurada automaticamente.
Em uma aplicação REST típica, o fluxo de uma requisição ocorre da seguinte maneira:
- O cliente (navegador, aplicativo móvel ou outro sistema) envia uma requisição HTTP.
- O Spring Boot direciona essa requisição para um Controller.
- O Controller delega o processamento para um Service.
- O Service executa toda a regra de negócio.
- Caso seja necessário acessar dados, o Service chama um Repository.
- O Repository consulta o banco de dados utilizando JPA ou outro mecanismo de persistência.
- Os dados retornam pelo mesmo caminho até chegar ao cliente.
Visualmente, podemos representar esse fluxo da seguinte forma:
Cliente
│
▼
Controller
│
▼
Service
│
▼
Repository
│
▼
Banco de DadosEssa separação em camadas oferece diversas vantagens:
- maior organização do código;
- facilidade de manutenção;
- reutilização de componentes;
- testes unitários mais simples;
- baixo acoplamento entre as partes da aplicação.
Embora essa arquitetura já existisse antes do Spring Boot, era necessário configurar manualmente praticamente todos esses componentes. O Spring Boot automatizou essa tarefa.
Controllers: A Porta de Entrada da Aplicação
Os Controllers representam a camada responsável por receber requisições HTTP.
Sempre que um usuário acessa uma URL da aplicação, quem recebe essa requisição é um Controller.
No Spring Boot existem duas anotações bastante utilizadas:
@Controller@RestController
A primeira normalmente é utilizada em aplicações MVC que retornam páginas HTML.
Já a segunda é utilizada em APIs REST, retornando normalmente objetos JSON.
Por exemplo, um Controller extremamente simples pode ser escrito assim:
@RestController
@RequestMapping("/users")
public class UserController {
@GetMapping
public List<String> listarUsuarios() {
return List.of("João", "Maria", "Pedro");
}
}Esse pequeno trecho já disponibiliza um endpoint HTTP funcional.
Ao acessar:
GET /userso navegador receberá automaticamente:
[
"João",
"Maria",
"Pedro"
]Sem XML.
Sem configuração de servlet.
Sem configurar conversores JSON.
Sem registrar o Controller.
Tudo isso acontece automaticamente.
Quer aprofundar seus estudos em Spring Boot?
Para quem deseja sair da teoria e criar aplicações reais, livros como Spring in Action, Learning Spring Boot 3.0 e Pro Spring Boot 3 ajudam a entender desde os fundamentos do framework até práticas modernas para aplicações escaláveis.
Quer aprofundar seus estudos em Spring Boot?
Spring in Action
Spring in Action. Produto recomendado para estudos, programação e produtividade.
Learning Spring Boot 3.0 – Third Edition: Simplify the development of lightning-fast applications based on microservices and reactive programming
Learning Spring Boot 3.0 - Third Edition: Simplify the development of lightning-fast applications based on microservices and reactive programming. Produto recomendado para estudos, programação e produtividade.
Pro Spring Boot 3: An Authoritative Guide with Best Practices
Pro Spring Boot 3: An Authoritative Guide with Best Practices. Produto recomendado para estudos, programação e produtividade.
A Camada de Serviços
Uma boa prática muito importante é manter o Controller o mais simples possível.
Ele não deve conter regras de negócio.
Sua função é apenas receber a requisição, validar parâmetros básicos e delegar o processamento para um Service.
Por exemplo:
@RestController
@RequestMapping("/users")
public class UserController {
private final UserService service;
public UserController(UserService service){
this.service = service;
}
@GetMapping
public List<User> listar(){
return service.buscarTodos();
}
}Agora toda a inteligência da aplicação fica concentrada no Service.
@Service
public class UserService {
public List<User> buscarTodos(){
// regra de negócio
return ...
}
}Esse modelo facilita muito a manutenção.
Se amanhã a regra de negócio mudar, apenas o Service será alterado.
O Controller continuará exatamente igual.
Repositories e Persistência de Dados
A próxima camada é o Repository.
Ela é responsável exclusivamente pelo acesso aos dados.
No Spring Boot, normalmente utiliza-se o Spring Data JPA.
Uma das maiores vantagens é que praticamente não precisamos escrever SQL.
Basta criar uma interface.
@Repository
public interface UserRepository extends JpaRepository<User, Long>{
}Só isso.
Automaticamente o Spring gera uma implementação contendo dezenas de operações prontas:
- salvar;
- excluir;
- atualizar;
- buscar por ID;
- paginação;
- ordenação;
- filtros simples.
Tudo isso já vem implementado.
Por exemplo:
userRepository.findAll();
userRepository.findById(1L);
userRepository.save(usuario);
userRepository.delete(usuario);Não existe implementação manual.
O próprio Spring cria essa classe durante a inicialização da aplicação.
As Entidades (Entities)
Para que o JPA saiba como armazenar informações no banco, utilizamos entidades.
Uma entidade representa uma tabela.
Cada objeto criado representa um registro.
Exemplo:
@Entity
public class User{
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String nome;
private String email;
}Observe as principais anotações.
@Entity
Informa ao JPA que essa classe representa uma tabela.
@Id
Define qual atributo é a chave primária.
@GeneratedValue
Determina que o banco será responsável pela geração automática do identificador.
O restante dos atributos torna-se colunas da tabela.
Ou seja, não é necessário escrever comandos SQL como:
CREATE TABLE USER(...)Nem comandos INSERT.
Nem UPDATE.
Nem DELETE.
O JPA faz esse mapeamento automaticamente.
Injeção de Dependências
Um dos pilares do Spring é a Injeção de Dependência (Dependency Injection).
Sem ela, precisaríamos criar objetos manualmente.
Exemplo tradicional:
UserRepository repository = new UserRepository();O problema desse modelo é o forte acoplamento.
Já no Spring Boot basta declarar a dependência no construtor.
@Service
public class UserService{
private final UserRepository repository;
public UserService(UserRepository repository){
this.repository = repository;
}
}Quem cria o objeto?
O próprio Spring.
Quem controla o ciclo de vida?
O Spring.
Quem resolve as dependências?
Também o Spring.
Essa abordagem torna o código muito mais desacoplado e facilita enormemente os testes unitários.
Component Scan
Mas como o Spring encontra todas essas classes?
A resposta está no Component Scan.
Sempre que iniciamos uma aplicação, o Spring Boot percorre automaticamente todos os pacotes abaixo da classe principal.
Sempre que encontra anotações como:
@Component@Service@Repository@Controller@RestController
ele registra automaticamente esses componentes no contexto da aplicação.
Isso elimina completamente a necessidade de registrar beans manualmente.
A Classe Principal da Aplicação
Toda aplicação Spring Boot possui uma classe principal.
Ela normalmente é extremamente simples.
@SpringBootApplication
public class MinhaAplicacao{
public static void main(String[] args){
SpringApplication.run(MinhaAplicacao.class,args);
}
}Apesar de pequena, essa classe faz muita coisa.
A anotação @SpringBootApplication reúne três funcionalidades importantes:
- habilita o Component Scan;
- ativa a Auto Configuration;
- registra configurações padrão do Spring Boot.
Já o método:
SpringApplication.run(...)executa uma série de etapas automaticamente:
- cria o contexto Spring;
- localiza todos os componentes;
- cria os beans;
- resolve dependências;
- inicia o servidor embarcado;
- disponibiliza a aplicação para receber requisições.
Tudo isso acontece com apenas uma linha de código.
Auto Configuration: A Grande Mágica do Spring Boot
Provavelmente o recurso mais famoso do Spring Boot é a Auto Configuration.
Ela é responsável por analisar automaticamente as bibliotecas presentes no projeto e configurar tudo o que for necessário.
Imagine que você adiciona apenas esta dependência ao Maven:
spring-boot-starter-data-jpaO Spring Boot entende que sua aplicação utilizará JPA.
Automaticamente ele configura:
- EntityManager;
- Hibernate;
- TransactionManager;
- DataSource;
- Repositórios JPA.
Da mesma forma, se você adicionar:
spring-boot-starter-webele configura automaticamente:
- Spring MVC;
- DispatcherServlet;
- conversores JSON;
- Jackson;
- Tomcat embarcado;
- tratamento de exceções HTTP;
- serialização e desserialização.
O desenvolvedor praticamente não precisa configurar nada.
É justamente essa inteligência que faz com que um projeto Spring Boot comece a funcionar poucos minutos após sua criação.
Deixe um comentário