0Pricing
Swift Academy · Lección

Capas: dominio, datos y presentación

Separe la lógica de negocio del acceso a datos y de la interfaz en una app de Swift.

Capas: dominio, datos y presentación es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Arquitectura limpia en Swift

La arquitectura limpia separa el código en capas: Dominio (lógica de negocio), Datos (persistencia/red) y Presentación (UI).

// Domain: pure Swift, no framework imports
// Data: Core Data / URLSession / JSON
// Presentation: SwiftUI / UIKit

La capa de dominio

La capa de dominio contiene entidades de negocio, casos de uso y protocolos de repositorio. No tiene dependencias de UIKit, SwiftUI ni bases de datos.

// Domain/Entities/User.swift
struct User {
  let id: Int
  var name: String
  var email: String
}
// No import UIKit, no import SwiftData

Casos de uso en el dominio

Un caso de uso encapsula una operación de negocio específica. Solo depende de los protocolos de repositorio del dominio.

// Domain/UseCases/FetchUserUseCase.swift
struct FetchUserUseCase {
  let repo: UserRepository
  func execute(id: Int) async throws -> User {
    try await repo.getUser(id: id)
  }
}

Protocolos de repositorio en el dominio

Los protocolos de repositorio definen el contrato de acceso a los datos. El dominio es propietario del protocolo; la capa de datos proporciona la implementación.

// Domain/Repositories/UserRepository.swift
protocol UserRepository {
  func getUser(id: Int) async throws -> User
  func saveUser(_ user: User) async throws
}

La capa de datos

La capa de datos implementa los protocolos del dominio mediante tecnologías concretas (URLSession, Core Data, SwiftData, 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 transferencia de datos

Los DTO son tipos Codable que se usan en la capa de datos para decodificar respuestas de API y luego convertirlas en entidades de dominio.

struct UserDTO: Decodable {
  var user_id: Int
  var full_name: String
  func toDomain() -> User { User(id: user_id, name: full_name, email: "") }
}

La capa de presentación

La capa de presentación contiene ViewModels y vistas de SwiftUI. Llama a los casos de uso y expone un estado observable.

// 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)
  }
}

Dirección de las dependencias

Las dependencias apuntan hacia dentro: Presentación depende de Dominio; Datos depende de Dominio. Dominio no depende de nada.

// Outer → Inner dependency rule:
Presentation → Domain ← Data
// Domain is the stable core; outer layers are swappable

Estructura de carpetas

Organice los archivos Swift primero por capa y después por funcionalidad en las aplicaciones grandes.

// MyApp/
// ├── Domain/
// │   ├── Entities/
// │   ├── UseCases/
// │   └── Repositories/  (protocols)
// ├── Data/
// │   └── Repositories/  (implementations)
// └── Presentation/
//     ├── Views/
//     └── ViewModels/

Ventajas

La arquitectura por capas permite realizar pruebas independientes, intercambiar implementaciones y desarrollar en paralelo dentro del equipo.

// Test Domain in isolation: no network, no DB
// Swap RemoteUserRepo with LocalUserRepo for offline mode
// Teams own layers independently

Errores comunes

Evite importar UIKit o SwiftUI en la capa de dominio y evite que la lógica de negocio se filtre en las vistas.

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

Comprobación rápida

¿Qué capa es propietaria de los protocolos de repositorio en la arquitectura limpia?

Resumen de la lección

Capas de la arquitectura limpia: Dominio (entidades, casos de uso y contratos de protocolos), Datos (implementaciones de red o bases de datos) y Presentación (UI y ViewModels). Las dependencias apuntan hacia dentro, hacia Dominio. Dominio no tiene dependencias de frameworks, por lo que se puede probar completamente mediante pruebas unitarias.

Preguntas frecuentes

¿La lección «Capas: dominio, datos y presentación» es gratis?

Sí — el texto completo de «Capas: dominio, datos y presentación» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Capas: dominio, datos y presentación»?

Separe la lógica de negocio del acceso a datos y de la interfaz en una app de Swift. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Capas: dominio, datos y presentación»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Capas: dominio, datos y presentación
  2. Patrones de casos de uso y repositorios
  3. Inversión de dependencias con abstracciones de protocolos
  4. Integración de capas sin un framework de DI
← Volver a Swift Academy