Swift Academy · Lekcja

Warstwy: domena, dane i prezentacja

Oddzielanie logiki biznesowej od dostępu do danych i interfejsu użytkownika w aplikacji Swift.

Lekcja 1 z 413 kroki

Warstwy: domena, dane i prezentacja to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Clean Architecture w Swift

Clean Architecture dzieli kod na warstwy: domeny (logika biznesowa), danych (trwałość danych i sieć) oraz prezentacji (interfejs użytkownika).

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

Warstwa domeny

Warstwa domeny zawiera encje biznesowe, przypadki użycia i protokoły repozytoriów. Nie ma zależności od UIKit, SwiftUI ani baz danych.

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

Przypadki użycia w domenie

Przypadek użycia enkapsuluje jedną konkretną operację biznesową. Zależy wyłącznie od protokołów repozytoriów zdefiniowanych w domenie.

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

Protokoły repozytoriów w domenie

Protokoły repozytoriów definiują kontrakt dostępu do danych. Domena jest właścicielem protokołu, a warstwa danych dostarcza jego implementację.

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

Warstwa danych

Warstwa danych implementuje protokoły domeny za pomocą konkretnych technologii (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 */ }
}

Obiekty transferu danych

DTO to typy Codable używane w warstwie danych do dekodowania odpowiedzi API, a następnie mapowane na encje domenowe.

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

Warstwa prezentacji

Warstwa prezentacji zawiera ViewModels i widoki SwiftUI. Wywołuje przypadki użycia i udostępnia obserwowalny stan.

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

Kierunek zależności

Zależności są skierowane do wewnątrz: warstwa prezentacji zależy od domeny, a warstwa danych zależy od domeny. Domena nie zależy od niczego.

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

Struktura folderów

W dużych aplikacjach należy organizować pliki Swift najpierw według warstwy, a następnie według funkcji.

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

Korzyści

Architektura warstwowa umożliwia niezależne testowanie, wymianę implementacji i równoległą pracę zespołu.

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

Typowe błędy

Należy unikać importowania UIKit/SwiftUI w warstwie domeny oraz przenikania logiki biznesowej do widoków.

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

Szybkie sprawdzenie

Która warstwa jest właścicielem protokołów repozytoriów w Clean Architecture?

Podsumowanie lekcji

Warstwy Clean Architecture: domena (encje, przypadki użycia, kontrakty protokołów), dane (implementacje sieciowe i bazodanowe), prezentacja (UI i ViewModels). Zależności są skierowane do wewnątrz, w stronę domeny. Domena nie ma żadnych zależności od frameworków, dzięki czemu można ją w pełni testować jednostkowo.

Bezpłatny start

Ucz się Swift dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy
122
Lekcje
409

Często zadawane pytania

Czy lekcja „Warstwy: domena, dane i prezentacja” jest bezpłatna?

Tak — pełny tekst „Warstwy: domena, dane i prezentacja” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Warstwy: domena, dane i prezentacja”?

Oddzielanie logiki biznesowej od dostępu do danych i interfejsu użytkownika w aplikacji Swift. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Warstwy: domena, dane i prezentacja”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Warstwy: domena, dane i prezentacja
  2. Wzorce Use Case i Repository
  3. Odwrócenie zależności z abstrakcjami protokołów
  4. Łączenie warstw bez frameworka DI
← Powrót do Swift Academy