Warum Dependency Injection?
Trennen Sie Erstellung und Verwendung für bessere Testbarkeit.
Warum Dependency Injection? ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.
Warum Dependency Injection
Dependency Injection (DI) bedeutet, einem Objekt die benötigten Dinge von außen zu übergeben, anstatt sie vom Objekt selbst erstellen zu lassen. Dadurch werden Komponenten entkoppelt und leichter testbar.
Das Problem: starke Kopplung
Wenn ein Typ seine eigenen Abhängigkeiten erstellt, ist er an deren konkrete Klassen gebunden und kann weder neu konfiguriert noch isoliert getestet werden.
class Logger {
func log(_ m: String) { print("LOG: \(m)") }
}
class Service {
let logger = Logger() // hard-coded dependency
func run() { logger.log("running") }
}
Service().run()Kopplung erschwert Tests
Da Service immer einen echten Logger erstellt, kann ein Test die Protokollausgabe weder erfassen noch simulieren. Die Abhängigkeit ist von außen nicht sichtbar.
class Logger { func log(_ m: String) { print(m) } }
class Service {
let logger = Logger()
func run() { logger.log("hello") }
}
// No way to swap Logger here.
Service().run()Die Idee: Abhängigkeit injizieren
Übergeben Sie die Abhängigkeit stattdessen von außen. Der Aufrufer entscheidet, welche Implementierung bereitgestellt wird, sodass Service davon unabhängig bleibt.
class Logger { func log(_ m: String) { print("LOG: \(m)") } }
class Service {
let logger: Logger
init(logger: Logger) { self.logger = logger }
func run() { logger.log("running") }
}
Service(logger: Logger()).run()Vorteile der Entkopplung
Mit Dependency Injection funktioniert derselbe Service mit verschiedenen Loggern, sowohl in der Produktion als auch in Tests, ohne dass sein Code geändert werden muss.
class Logger { var lines: [String] = []
func log(_ m: String) { lines.append(m) } }
class Service {
let logger: Logger
init(logger: Logger) { self.logger = logger }
func run() { logger.log("event") }
}
let l = Logger()
Service(logger: l).run()
print(l.lines)Einzelverantwortung
DI unterstützt das Prinzip der Einzelverantwortung: Ein Typ konzentriert sich auf seine Aufgabe und überlässt andere Belange injizierten Komponenten.
struct Mailer { func send(_ to: String) { print("Mail to \(to)") } }
struct SignupFlow {
let mailer: Mailer
func register(_ email: String) { mailer.send(email) }
}
SignupFlow(mailer: Mailer()).register("a@b.com")Flexibilität
Sie können Objekte auf neue Weise kombinieren. Die Verdrahtung erfolgt an den Rändern Ihrer App, sodass der Kern flexibel bleibt.
struct Engine { let power: Int }
struct Car {
let engine: Engine
func describe() { print("Power: \(engine.power)") }
}
Car(engine: Engine(power: 200)).describe()
Car(engine: Engine(power: 90)).describe()Explizite Abhängigkeiten
Ein Initializer, der seine Abhängigkeiten auflistet, dokumentiert genau, was der Typ benötigt. Verborgene, selbst erstellte Abhängigkeiten verschleiern diesen Vertrag.
struct Repo { func load() -> [Int] { [1, 2, 3] } }
struct Report {
let repo: Repo // visible dependency
func total() -> Int { repo.load().reduce(0, +) }
}
print(Report(repo: Repo()).total())Komposition statt Konstruktion
DI setzt darauf, Objekte von außen zu kombinieren. Eine kleine Composition Root setzt den Objektgraphen zusammen; der übrige Code erhält einfach, was er benötigt.
struct DB { func count() -> Int { 42 } }
struct Stats { let db: DB; func show() { print(db.count()) } }
// Composition root:
let app = Stats(db: DB())
app.show()Nicht nur für große Apps
Auch kleine Programme profitieren davon: Durch das Injizieren einer Abhängigkeit lässt sich das Verhalten austauschen, und die Absichten bleiben ohne zusätzliche Frameworks klar.
struct Clock { func now() -> Int { 12 } }
struct Greeter {
let clock: Clock
func greet() { print(clock.now() < 12 ? "Morning" : "Afternoon") }
}
Greeter(clock: Clock()).greet()Kein Framework erforderlich
Swift-DI benötigt keine Bibliothek. Einfache Initializer und Protokolle genügen. In den folgenden Lektionen sehen Sie Constructor Injection, Protokolle und Mocking.
struct Adder { func add(_ a: Int, _ b: Int) -> Int { a + b } }
struct Calc {
let adder: Adder
func run() { print(adder.add(2, 3)) }
}
Calc(adder: Adder()).run()Schnelltest
Was ist die zentrale Idee von Dependency Injection?
Zusammenfassung
Dependency Injection stellt Abhängigkeiten von außen bereit, statt sie intern zu erstellen. Dadurch werden Kopplungen reduziert, Abhängigkeiten transparent und Tests ermöglicht. In Swift ist dafür kein Framework erforderlich. Als Nächstes sehen Sie die häufigste Form: Constructor Injection.
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 „Warum Dependency Injection?“ kostenlos?
Ja — der vollständige Text von „Warum Dependency Injection?“ 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 „Warum Dependency Injection?“?
Trennen Sie Erstellung und Verwendung für bessere Testbarkeit. 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 1 von 4.
Wie lange dauert die Lektion „Warum Dependency Injection?“?
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
- Warum Dependency Injection?
- Constructor Injection
- Protocol-basierte Abstraktionen
- Abhängigkeiten in Tests mocken