Use-case- en repositorypatronen
Use-cases als Swift-protocollen definiëren en repository-interfaces implementeren.
Use-case- en repositorypatronen is een gratis Swift Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Swift Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Swift Academy bevat in totaal 4 lessen.
Wat is een gebruiksscenario?
Een gebruiksscenario (interactor) kapselt één bedrijfsactie in en coördineert domeinentiteiten en 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)
}
}Eén verantwoordelijkheid
Elk gebruiksscenario doet precies één ding. Meerdere verantwoordelijkheden betekenen meerdere gebruiksscenario's.
// One use case per business action:
struct FetchUserUseCase { ... }
struct UpdateUserUseCase { ... }
struct DeleteUserUseCase { ... }Gebruiksscenario als protocol
Definieer een protocol voor het gebruiksscenario, zodat je het in testen van de presentatielaag kunt nabootsen.
protocol PlacingOrder {
func execute(userId: Int) async throws -> Order
}
struct PlaceOrderUseCase: PlacingOrder { ... }Wat is een repository?
Een repository abstraheert de gegevensbron. Aanroepers werken met een Swift-protocol; de implementatie kan een netwerk, Core Data of het geheugen zijn.
protocol OrderRepository {
func create(receipt: PaymentReceipt) async throws -> Order
func list(userId: Int) async throws -> [Order]
func cancel(orderId: Int) async throws
}Repository-implementatie
De concrete repository vertaalt domeinaanroepen naar netwerk- of databasebewerkingen.
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 { ... }
}Repository in het geheugen voor testen
Lever een repository in het geheugen voor snelle, deterministische testen zonder invoer en uitvoer.
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 } }
}Gebruiksscenario's samenstellen
Gebruiksscenario's kunnen andere gebruiksscenario's aanroepen voor gedeelde deelbewerkingen, zodat elk scenario doelgericht blijft.
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 versus service
Repository: CRUD-bewerkingen voor één entiteitstype. Service: coördineert meerdere entiteiten of roept externe API's aan zonder rechtstreekse opslag.
// 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 kunnen resultaten transparant cachen zonder dat het gebruiksscenario de implementatiedetails hoeft te kennen.
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) }
}Testbaarheid
Omdat gebruiksscenario's afhankelijk zijn van repositoryprotocollen, kun je stubs injecteren om bedrijfslogica geïsoleerd te testen.
let repo = InMemoryOrderRepo()
let sut = PlaceOrderUseCase(orders: repo, ...)
let order = try await sut.execute(userId: 1)
XCTAssertEqual(repo.orders.count, 1)Foutvertaling
Repositories moeten fouten uit de datalaag (netwerk, database) vóór het teruggeven vertalen naar domeinfouten.
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
}
}Korte controle
Wat is het belangrijkste verschil tussen een repository en een service in een schone architectuur?
Lesoverzicht
Gebruiksscenario's kapselen afzonderlijke bedrijfsacties in en zijn afhankelijk van repositoryprotocollen. Repositories abstraheren gegevensbronnen achter een protocol. Gebruik repositories in het geheugen voor snelle testen. Repositories vertalen infrastructuurfouten naar domeinfouten. Services coördineren bewerkingen met meerdere entiteiten.
Leer Swift met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 122
- Lessen
- 409
Veelgestelde vragen
Is de les “Use-case- en repositorypatronen” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad Swift Academy, waaronder “Use-case- en repositorypatronen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Swift Academy bevat in totaal 4 lessen.
Wat leer ik in “Use-case- en repositorypatronen”?
Use-cases als Swift-protocollen definiëren en repository-interfaces implementeren. Je oefent met Swift Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Swift Academy te beginnen?
Ervaring vooraf is niet nodig. Swift Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Use-case- en repositorypatronen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Swift Academy?
Ja. Elke les over Swift Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Lagen: domein, data en presentatie
- Use-case- en repositorypatronen
- Dependency inversion met protocolabstracties
- Lagen koppelen zonder een DI-framework