0Pricing
Swift Academy · Aula

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 / UIKit

A 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 SwiftData

Casos 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 swappable

Estrutura 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 independently

Erros 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

  1. Camadas: domínio, dados e apresentação
  2. Padrões de caso de uso e repositório
  3. Inversão de dependências com abstrações de protocolos
  4. Integração das camadas sem um framework de DI
← Voltar para Swift Academy