Camadas: domínio, dados e apresentação
Separe a lógica de negócio do acesso a dados e da interface em um aplicativo Swift.
Camadas: domínio, dados e apresentação é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.
Arquitetura Limpa no Swift
A Arquitetura Limpa separa o código em camadas: Domínio (lógica de negócio), Dados (persistência/rede) e Apresentação (interface do usuário).
// Domain: pure Swift, no framework imports
// Data: Core Data / URLSession / JSON
// Presentation: SwiftUI / UIKitA Camada de Domínio
A camada de Domínio contém entidades de negócio, casos de uso e protocolos de repositório. Ela não tem dependências de UIKit, SwiftUI ou bancos de dados.
// Domain/Entities/User.swift
struct User {
let id: Int
var name: String
var email: String
}
// No import UIKit, no import SwiftDataCasos de Uso no Domínio
Um caso de uso encapsula uma operação de negócio específica. Ele depende apenas dos protocolos de repositório do domínio.
// Domain/UseCases/FetchUserUseCase.swift
struct FetchUserUseCase {
let repo: UserRepository
func execute(id: Int) async throws -> User {
try await repo.getUser(id: id)
}
}Protocolos de Repositório no Domínio
Os protocolos de repositório definem o contrato de acesso aos dados. O domínio é responsável pelo protocolo; a camada de dados fornece a implementação.
// Domain/Repositories/UserRepository.swift
protocol UserRepository {
func getUser(id: Int) async throws -> User
func saveUser(_ user: User) async throws
}A Camada de Dados
A camada de Dados implementa os protocolos do domínio usando tecnologias concretas, como URLSession, Core Data, SwiftData e Keychain.
// Data/Repositories/RemoteUserRepository.swift
struct RemoteUserRepository: UserRepository {
func getUser(id: Int) async throws -> User {
let data = try await URLSession.shared.data(from: userURL(id)).0
return try JSONDecoder().decode(User.self, from: data)
}
func saveUser(_ user: User) async throws { /* PUT request */ }
}Objetos de Transferência de Dados
Os objetos de transferência de dados são tipos Codable usados na camada de dados para decodificar respostas de APIs e depois mapeá-las para entidades do domínio.
struct UserDTO: Decodable {
var user_id: Int
var full_name: String
func toDomain() -> User { User(id: user_id, name: full_name, email: "") }
}A Camada de Apresentação
A camada de Apresentação contém ViewModels e visualizações SwiftUI. Ela chama casos de uso e expõe um estado observável.
// Presentation/ViewModels/ProfileViewModel.swift
@MainActor
final class ProfileViewModel: ObservableObject {
@Published var user: User?
private let useCase: FetchUserUseCase
init(useCase: FetchUserUseCase) { self.useCase = useCase }
func load(id: Int) async {
user = try? await useCase.execute(id: id)
}
}Direção das Dependências
As dependências apontam para dentro: a Apresentação depende do Domínio; os Dados dependem do Domínio. O Domínio não depende de nada.
// Outer → Inner dependency rule:
Presentation → Domain ← Data
// Domain is the stable core; outer layers are swappableEstrutura de Pastas
Organize os arquivos Swift primeiro por camada e depois por funcionalidade em aplicativos grandes.
// MyApp/
// ├── Domain/
// │ ├── Entities/
// │ ├── UseCases/
// │ └── Repositories/ (protocols)
// ├── Data/
// │ └── Repositories/ (implementations)
// └── Presentation/
// ├── Views/
// └── ViewModels/Benefícios
A arquitetura em camadas permite testes independentes, implementações substituíveis e desenvolvimento paralelo pelas equipes.
// Test Domain in isolation: no network, no DB
// Swap RemoteUserRepo with LocalUserRepo for offline mode
// Teams own layers independentlyErros Comuns
Evite importar UIKit/SwiftUI na camada de Domínio e evite que a lógica de negócio se infiltre nas visualizações.
// WRONG: Domain entity with SwiftUI Color
struct Product {
var color: Color // UIKit/SwiftUI import in Domain!
}
// CORRECT: Use a plain string or enum
struct Product { var colorHex: String }Verificação Rápida
Qual camada é responsável pelos protocolos de repositório na Arquitetura Limpa?
Recapitulação da lição
Camadas da Arquitetura Limpa: Domínio (entidades, casos de uso e contratos de protocolo), Dados (implementações de rede/banco de dados) e Apresentação (interface do usuário + ViewModels). As dependências apontam para dentro, em direção ao Domínio. O Domínio não tem dependências de estruturas, o que permite testá-lo totalmente com testes unitários.
Perguntas Frequentes
A aula “Camadas: domínio, dados e apresentação” é grátis?
Sim — o texto completo de “Camadas: domínio, dados e apresentação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.
O que vou aprender em “Camadas: domínio, dados e apresentação”?
Separe a lógica de negócio do acesso a dados e da interface em um aplicativo Swift. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Swift Academy?
Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.
Quanto tempo leva a aula “Camadas: domínio, dados e apresentação”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Swift Academy?
Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Camadas: domínio, dados e apresentação
- Padrões de caso de uso e repositório
- Inversão de dependências com abstrações de protocolos
- Integração das camadas sem um framework de DI