Use-Case- und Repository-Pattern
Definieren Sie Use Cases als Swift-Protokolle und implementieren Sie Repository-Schnittstellen.
Use-Case- und Repository-Pattern ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ist ein Use Case?
Ein Use Case (Interactor) kapselt eine einzelne Geschäftsaktion und koordiniert Geschäftsobjekte und Repositories.
struct PlaceOrderUseCase {
let cart: CartRepository
let payment: PaymentService
let orders: OrderRepository
func execute(userId: Int) async throws -> Order {
let items = try await cart.items(for: userId)
let receipt = try await payment.charge(items: items)
return try await orders.create(receipt: receipt)
}
}Einzelverantwortung
Jeder Use Case erledigt genau eine Aufgabe. Mehrere Verantwortlichkeiten bedeuten, dass mehrere Use Cases erforderlich sind.
// One use case per business action:
struct FetchUserUseCase { ... }
struct UpdateUserUseCase { ... }
struct DeleteUserUseCase { ... }Use Case als Protokoll
Definieren Sie ein Protokoll für den Use Case, damit Sie ihn in Tests der Presentation-Schicht mocken können.
protocol PlacingOrder {
func execute(userId: Int) async throws -> Order
}
struct PlaceOrderUseCase: PlacingOrder { ... }Was ist ein Repository?
Ein Repository abstrahiert die Datenquelle. Aufrufer interagieren mit einem Swift-Protokoll; die Implementierung kann auf dem Netzwerk, Core Data oder einem In-Memory-Speicher basieren.
protocol OrderRepository {
func create(receipt: PaymentReceipt) async throws -> Order
func list(userId: Int) async throws -> [Order]
func cancel(orderId: Int) async throws
}Repository-Implementierung
Das konkrete Repository übersetzt Aufrufe aus der Domain in Netzwerk- oder Datenbankoperationen.
struct RemoteOrderRepository: OrderRepository {
func create(receipt: PaymentReceipt) async throws -> Order {
let dto = receipt.toDTO()
let data = try await api.post("/orders", body: dto)
return try JSONDecoder().decode(OrderDTO.self, from: data).toDomain()
}
func list(userId: Int) async throws -> [Order] { ... }
func cancel(orderId: Int) async throws { ... }
}In-Memory-Repository für Tests
Stellen Sie ein In-Memory-Repository für schnelle, deterministische Tests ohne I/O bereit.
final class InMemoryOrderRepo: OrderRepository {
var orders: [Order] = []
func create(receipt: PaymentReceipt) async throws -> Order {
let order = Order(id: orders.count + 1, items: receipt.items)
orders.append(order)
return order
}
func list(userId: Int) async throws -> [Order] { orders }
func cancel(orderId: Int) async throws { orders.removeAll { $0.id == orderId } }
}Use Cases kombinieren
Use Cases können andere Use Cases für gemeinsam genutzte Teiloperationen aufrufen, sodass jeder Use Case fokussiert bleibt.
struct CheckoutUseCase {
let validateCart: ValidateCartUseCase
let placeOrder: PlaceOrderUseCase
let notifyUser: NotifyUserUseCase
func execute(userId: Int) async throws -> Order {
try await validateCart.execute(userId: userId)
let order = try await placeOrder.execute(userId: userId)
try await notifyUser.execute(order: order)
return order
}
}Repository oder Service
Repository: CRUD für einen einzelnen Objekttyp. Service: koordiniert mehrere Objekte oder ruft externe APIs auf, ohne direkt auf dem Speicher zu arbeiten.
// Repository: single entity
protocol UserRepository { func getUser(id: Int) async throws -> User }
// Service: cross-entity operation
protocol AuthService { func login(email: String, password: String) async throws -> Session }Caching in Repositories
Repositories können Ergebnisse transparent zwischenspeichern, ohne dass der Use Case die Implementierungsdetails kennen muss.
struct CachedUserRepository: UserRepository {
private var cache: [Int: User] = [:]
private let remote: UserRepository
func getUser(id: Int) async throws -> User {
if let cached = cache[id] { return cached }
let user = try await remote.getUser(id: id)
cache[id] = user
return user
}
func saveUser(_ user: User) async throws { try await remote.saveUser(user) }
}Testbarkeit
Da Use Cases von Repository-Protokollen abhängen, können Sie Stubs einschleusen, um die Geschäftslogik isoliert zu testen.
let repo = InMemoryOrderRepo()
let sut = PlaceOrderUseCase(orders: repo, ...)
let order = try await sut.execute(userId: 1)
XCTAssertEqual(repo.orders.count, 1)Fehlerübersetzung
Repositories sollten Fehler der Data-Schicht (Netzwerk, Datenbank) vor der Rückgabe in Domain-Fehler übersetzen.
func getUser(id: Int) async throws -> User {
do {
let data = try await api.get("/users/\(id)")
return try decode(data)
} catch let e as URLError where e.code == .notConnectedToInternet {
throw DomainError.offline
}
}Kurze Überprüfung
Was ist der wesentliche Unterschied zwischen einem Repository und einem Service in der Clean Architecture?
Zusammenfassung der Lektion
Use Cases kapseln einzelne Geschäftsaktionen und hängen von Repository-Protokollen ab. Repositories abstrahieren Datenquellen hinter einem Protokoll. Verwenden Sie In-Memory-Repositories für schnelle Tests. Repositories übersetzen Infrastrukturfehler in Domain-Fehler. Services koordinieren Operationen mit mehreren Objekten.
Lerne Swift mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 122
- Lektionen
- 409
Häufig gestellte Fragen
Ist die Lektion „Use-Case- und Repository-Pattern“ kostenlos?
Ja — der vollständige Text von „Use-Case- und Repository-Pattern“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Use-Case- und Repository-Pattern“?
Definieren Sie Use Cases als Swift-Protokolle und implementieren Sie Repository-Schnittstellen. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Swift Academy zu starten?
Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Use-Case- und Repository-Pattern“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?
Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Schichten: Domain, Daten und Präsentation
- Use-Case- und Repository-Pattern
- Dependency Inversion mit Protokollabstraktionen
- Schichten ohne DI-Framework verbinden