0Pricing
Swift Academy · Lezione

Livelli: dominio, dati e presentazione

Separare la logica di business dall’accesso ai dati e dall’interfaccia utente in un’app Swift.

Livelli: dominio, dati e presentazione è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Clean Architecture in Swift

Clean Architecture separa il codice in livelli: Domain (logica di business), Data (persistenza/rete) e Presentation (interfaccia utente).

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

Il livello Domain

Il livello Domain contiene entità di business, casi d'uso e protocolli dei repository. Non ha dipendenze da UIKit, SwiftUI o database.

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

I casi d'uso nel livello Domain

Un caso d'uso incapsula una specifica operazione di business. Dipende solo dai protocolli dei repository definiti nel livello Domain.

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

I protocolli dei repository nel livello Domain

I protocolli dei repository definiscono il contratto per l'accesso ai dati. Il livello Domain è proprietario del protocollo; il livello Data ne fornisce l'implementazione.

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

Il livello Data

Il livello Data implementa i protocolli del livello Domain utilizzando tecnologie concrete (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 */ }
}

Data Transfer Object

I DTO sono tipi Codable usati nel livello Data per decodificare le risposte delle API e poi convertirle in entità del dominio.

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

Il livello Presentation

Il livello Presentation contiene ViewModel e viste SwiftUI. Chiama i casi d'uso ed espone uno stato osservabile.

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

Direzione delle dipendenze

Le dipendenze puntano verso l'interno: Presentation dipende da Domain; Data dipende da Domain. Domain non dipende da nulla.

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

Struttura delle cartelle

Per le app di grandi dimensioni, organizzare i file Swift prima per livello e poi per funzionalità.

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

Vantaggi

Un'architettura a livelli consente di eseguire test indipendenti, sostituire le implementazioni e sviluppare in parallelo all'interno del team.

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

Errori comuni

Evitare di importare UIKit/SwiftUI nel livello Domain ed evitare che la logica di business finisca nelle viste.

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

Quale livello è proprietario dei protocolli dei repository in Clean Architecture?

Riepilogo della lezione

Livelli di Clean Architecture: Domain (entità, casi d'uso, contratti dei protocolli), Data (implementazioni di rete/database), Presentation (UI + ViewModel). Le dipendenze puntano verso l'interno, verso Domain. Domain non ha dipendenze da framework, quindi può essere sottoposto interamente a unit test.

Domande Frequenti

La lezione «Livelli: dominio, dati e presentazione» è gratuita?

Sì — il testo completo di «Livelli: dominio, dati e presentazione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Livelli: dominio, dati e presentazione»?

Separare la logica di business dall’accesso ai dati e dall’interfaccia utente in un’app Swift. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Livelli: dominio, dati e presentazione»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Livelli: dominio, dati e presentazione
  2. Pattern Use Case e Repository
  3. Inversione delle dipendenze con astrazioni basate su protocolli
  4. Collegare i livelli senza un framework DI
← Torna a Swift Academy