Primeiros Passos com Clean Architecture em Java
- #Java
- #Clean Architecture
Aposto que você já se viu perdido no meio de um projeto Java gigante, com classes gigantescas, responsabilidades misturadas e difícil de entender e testar? Se sim, talvez esteja na hora de conhecer (e aplicar) a Clean Architecture.
Aqui você vai entender:
- O que é Clean Architecture
- Quais são as camadas e suas responsabilidades
- Como aplicar injeção de dependência
- E como tornar seus testes mais fáceis com essa abordagem
O que é Clean Architecture?
A Clean Architecture, proposta por Robert C. Martin (Uncle Bob), é um modelo arquitetural que separa responsabilidades de forma clara entre as partes do sistema. Seu objetivo é criar softwares mais testáveis, independentes de frameworks e fáceis de manter.
A ideia central é manter o núcleo da aplicação isolado de detalhes externos, como banco de dados, interfaces gráficas e frameworks.
Camadas da Clean Architecture em Java
A estrutura típica é dividida em quatro camadas principais:
1. Entidades (Entities)
Contém as regras de negócio mais genéricas. São independentes de qualquer tecnologia ou framework.
public class Cliente {
private String nome;
private String email;
public Cliente(String nome, String email) {
this.nome = nome;
this.email = email;
}
public boolean emailValido() {
return email.contains("@");
}
}
2. Casos de Uso (Use Cases / Application Layer)
Executam as regras de negócio específicas da aplicação. Usam entidades para atingir os objetivos da lógica.
public class CriarClienteUseCase {
private final ClienteRepository repository;
public CriarClienteUseCase(ClienteRepository repository) {
this.repository = repository;
}
public void executar(String nome, String email) {
Cliente cliente = new Cliente(nome, email);
if (!cliente.emailValido()) {
throw new IllegalArgumentException("Email inválido");
}
repository.salvar(cliente);
}
}
3. Adaptadores (Interface Adapters)
Transformam dados de formatos externos (ex: HTTP, banco de dados) para estruturas internas e vice-versa. Aqui ficam os controllers, DTOs e gateways.
@RestController
public class ClienteController {
private final CriarClienteUseCase useCase;
public ClienteController(CriarClienteUseCase useCase) {
this.useCase = useCase;
}
@PostMapping("/clientes")
public ResponseEntity<Void> criar(@RequestBody ClienteDTO dto) {
useCase.executar(dto.nome(), dto.email());
return ResponseEntity.status(HttpStatus.CREATED).build();
}
}
4. Frameworks & Drivers (Infrastructure Layer)
Parte mais externa, que contém implementações de banco de dados, frameworks web (Spring, por exemplo), filas, etc.
@Repository
public class ClienteRepositoryImpl implements ClienteRepository {
private final JpaClienteRepository jpaRepo;
public ClienteRepositoryImpl(JpaClienteRepository jpaRepo) {
this.jpaRepo = jpaRepo;
}
public void salvar(Cliente cliente) {
jpaRepo.save(new ClienteEntity(cliente));
}
}
Inversão de Dependência e Injeção de Dependência
A Clean Architecture inverte a dependência tradicional: em vez de o núcleo depender do banco ou do framework, são os detalhes que dependem do núcleo.
Isso é facilitado pelo uso de interfaces e injeção de dependência, geralmente com Spring ou outro framework DI.
@Configuration
public class AppConfig {
@Bean
public CriarClienteUseCase criarClienteUseCase(ClienteRepository repo) {
return new CriarClienteUseCase(repo);
}
}
✅ Testes Unitários Mais Fáceis
Como as regras de negócio estão isoladas em casos de uso e entidades, você pode testá-las sem precisar subir banco de dados, servidor ou framework:
@Test
public void deveCriarClienteComEmailValido() {
ClienteRepository repo = mock(ClienteRepository.class);
CriarClienteUseCase useCase = new CriarClienteUseCase(repo);
useCase.executar("João", "joao@email.com");
verify(repo).salvar(any());
}
Benefícios da Clean Architecture
- ✅ Código modular e testável
- ✅ Independente de frameworks (como Spring ou Hibernate)
- ✅ Fácil de evoluir sem quebrar o sistema
- ✅ Permite trocar banco de dados ou tecnologia sem afetar a regra de negócio
Aplicar a Clean Architecture em Java é um divisor de águas para quem deseja escrever código limpo, sustentável e escalável. Com um pouco de prática, você vai perceber que os projetos ficam mais organizados, fáceis de entender e manter.
Se você quer se destacar como desenvolvedor em qualquer linguagem, vale muito a pena investir nessa abordagem.