Primeiros Passos com Clean Architecture em Java

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.