Na engenharia de software, especialmente em arquiteturas como a Clean Architecture ou Layered Architecture, o repositório atua como uma ponte entre o domínio e o banco de dados. Acima dele, as camadas se tornam mais focadas em regras de negócio e interface. [1, 2, 3, 4]
Aqui está a organização hierárquica, do mais próximo ao repositório até o topo (usuário):
1. Camada de Domínio / Negócio (Service Layer / Use Cases) [5]
É o "cérebro" da aplicação. Ela contém as regras que definem como o negócio funciona, independentemente de ser um site ou um aplicativo mobile. [6, 7, 8]
- O que faz: Coordena a lógica de negócio. Ela chama o repositório para buscar dados, aplica validações, cálculos e regras de estado, e decide o que deve ser salvo.
- Tipos de Dados:
- Entities (Entidades): Objetos de negócio com identidade (ex: um
Usuariocom ID). - Value Objects: Objetos que definem atributos sem identidade própria (ex:
Cpf,Email,Endereco). [9, 10, 11, 12, 13]
- Entities (Entidades): Objetos de negócio com identidade (ex: um
2. Camada de Aplicação / Adaptação (Application Layer / Controllers)
Esta camada serve como um tradutor. Ela recebe os comandos do mundo externo e os converte em algo que a camada de domínio entenda. [14]
- O que faz: Recebe requisições HTTP, valida o formato dos dados de entrada e orquestra a chamada dos serviços de domínio.
- Tipos de Dados:
- DTOs (Data Transfer Objects): Objetos simples, sem lógica, usados apenas para carregar dados do ponto A ao ponto B.
- Input Models / Request: Formatos específicos de entrada de dados. [15]
3. Camada de Apresentação / Interface (UI Layer) [16]
É a camada com a qual o usuário ou outros sistemas interagem diretamente. [17, 18]
- O que faz: Exibe as informações ao usuário e captura suas interações. Pode ser uma API REST, uma interface gráfica (React, Flutter) ou até uma linha de comando (CLI).
- Tipos de Dados:
- ViewModels / Response Models: Versões "limpas" dos dados, formatadas especificamente para exibição (ex: formatar uma data de
2023-10-27para27/10/2023ou ocultar a senha do usuário). - JSON / XML / HTML: Os formatos de serialização para transporte final. [19, 20, 21, 22]
- ViewModels / Response Models: Versões "limpas" dos dados, formatadas especificamente para exibição (ex: formatar uma data de
Resumo da Hierarquia de Fluxo:
- UI: Recebe JSON, transforma em Request DTO.
- Controller: Valida o DTO e chama o Service.
- Service: Converte o DTO em Entidade, processa a lógica e chama o Repository.
- Repository: Persiste a Entidade no banco (ou a mapeia para um Schema/DAO). [23, 24]
[3] https://guia.dev
[10] https://dev.to
[12] https://medium.com
[17] https://guia.dev
[20] https://www.ibm.com
[21] https://medium.com
Onde declarar os Value Objects, Interfaces e Repositórios?
Em um projeto Blazor Server seguindo a Clean Architecture, a organização segue a regra de ouro: as dependências sempre apontam para dentro (em direção ao Domínio).
Aqui está onde cada item deve ser localizado e o porquê:
1. Value Objects [1]
Onde ficam: No projeto
Domain (ou Core.Domain).- Pasta sugerida:
Domain/ValueObjects/ou junto das entidades relacionadas. - Motivo: Eles representam conceitos fundamentais do negócio (ex:
Cpf,Endereco,Preco) que não possuem identidade própria e são imutáveis. O domínio deve ser o lugar mais "puro" da aplicação, sem dependências externas. [2, 3, 4, 5]
2. Interfaces de Repositório (Contratos)
Onde ficam: No projeto
Domain (ou as vezes no Application). [6] - Pasta sugerida:
Domain/Repositories/ouDomain/Interfaces/. - Motivo: Na Clean Architecture "pura", o domínio define as necessidades de persistência (o "quê" o sistema faz). Isso permite que os Casos de Uso (na camada de
Application) usem essas interfaces sem saber se os dados vêm de um SQL Server, MongoDB ou uma API externa. [7, 8, 9, 10, 11]
3. Repositórios (Implementação)
Onde ficam: No projeto
Infrastructure (ou Infrastructure.Persistence).- Pasta sugerida:
Infrastructure/Persistence/Repositories/. - Motivo: É aqui que você lida com detalhes técnicos como Entity Framework Core, ADO.NET ou Dapper. Esta camada conhece o banco de dados e implementa os contratos definidos no domínio. [4, 12, 13]
Resumo Visual da Estrutura
| Camada (Projeto) [14, 15] | Conteúdo | Depende de... |
|---|---|---|
Domain | Entidades, Value Objects, Interfaces de Repositório | Ninguém (é o núcleo) |
Application | Casos de Uso (Services), DTOs, Handlers | Domain |
Infrastructure | Implementação de Repositórios, DbContext | Application e Domain |
WebUI (Blazor) | Componentes .razor, ViewModels, Registro de DI | Application e Infrastructure |
Dica para Blazor Server
No Blazor Server, o projeto de interface (WebUI) geralmente é o ponto de entrada que registra as dependências. Você injetará as interfaces de repositório (definidas no
Domain) e o contêiner de DI do ASP.NET resolverá para as classes concretas (definidas na Infrastructure). [9, 10, 16]
Comentários