Swift Academy · Lekcja

Wstrzykiwanie przez konstruktor

Przekazywanie zależności przez inicjalizatory.

Wstrzykiwanie przez konstruktor to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 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.

Wstrzykiwanie przez konstruktor

Najczęściej stosowany styl DI polega na przekazywaniu zależności przez inicjalizator. Obiekt otrzymuje wszystko, czego potrzebuje, w chwili utworzenia i przechowuje te zależności.

Podstawowy init

Należy zadeklarować przechowywaną właściwość i przypisać jej wartość w init. Wywołujący musi dostarczyć zależność, aby utworzyć obiekt.

struct Greeter { func hi() -> String { "Hi" } }
struct View {
    let greeter: Greeter
    init(greeter: Greeter) { self.greeter = greeter }
    func show() { print(greeter.hi()) }
}
View(greeter: Greeter()).show()

Niezmienne zależności

Użycie let dla wstrzykiwanych właściwości sprawia, że są one niezmienne, więc po utworzeniu nie można podmienić zależności.

struct Engine { let hp: Int }
struct Car {
    let engine: Engine // cannot change later
    init(engine: Engine) { self.engine = engine }
}
let c = Car(engine: Engine(hp: 150))
print(c.engine.hp)

Wiele zależności

Aby wstrzyknąć więcej niż jeden obiekt współpracujący, należy wymienić kilka parametrów. Inicjalizator dokumentuje pełny zestaw wymagań.

struct DB { func get() -> Int { 7 } }
struct Cache { func put(_ v: Int) { print("cached \(v)") } }
struct Service {
    let db: DB
    let cache: Cache
    init(db: DB, cache: Cache) { self.db = db; self.cache = cache }
    func run() { cache.put(db.get()) }
}
Service(db: DB(), cache: Cache()).run()

Wartości domyślne parametrów

Wartość domyślna pozwala pominąć zależność w środowisku produkcyjnym, a jednocześnie nadal umożliwia jej zastąpienie podczas testów.

struct Logger { func log(_ m: String) { print(m) } }
struct Service {
    let logger: Logger
    init(logger: Logger = Logger()) { self.logger = logger }
    func run() { logger.log("go") }
}
Service().run() // uses default

Wstrzykiwanie przez konstruktor klasy

Klasy korzystają z tego samego wzorca. Inicjalizator przypisuje każdą zależność, zanim będzie można używać instancji.

class Mailer { func send() { print("sent") } }
class Signup {
    let mailer: Mailer
    init(mailer: Mailer) { self.mailer = mailer }
    func go() { mailer.send() }
}
Signup(mailer: Mailer()).go()

Wstrzykiwanie wartości

Zależności nie muszą być obiektami. W ten sam sposób można wstrzykiwać wartości konfiguracyjne, takie jak bazowy adres URL lub flaga.

struct Client {
    let baseURL: String
    init(baseURL: String) { self.baseURL = baseURL }
    func endpoint(_ p: String) -> String { baseURL + p }
}
print(Client(baseURL: "https://api").endpoint("/users"))

Główny punkt kompozycji

Jedno miejsce w pobliżu punktu wejścia aplikacji konfiguruje cały graf obiektów. Cała reszta po prostu otrzymuje gotowe zależności.

struct DB { func count() -> Int { 3 } }
struct Repo { let db: DB; func n() -> Int { db.count() } }
struct App { let repo: Repo; func run() { print(repo.n()) } }
// Composition root:
let app = App(repo: Repo(db: DB()))
app.run()

Unikanie ukrytych zmiennych globalnych

Wstrzykiwanie przez konstruktor zastępuje dostęp do ukrytych zmiennych globalnych. Każda zależność jest jawna, więc można prześledzić przepływ danych.

struct Settings { let theme: String }
struct Screen {
    let settings: Settings
    func render() { print("Theme: \(settings.theme)") }
}
Screen(settings: Settings(theme: "dark")).render()

Wymagane a opcjonalne

Jeśli zależność jest rzeczywiście opcjonalna, należy wyrazić to za pomocą typu opcjonalnego. W przeciwnym razie należy jej wymagać, aby obiekt nigdy nie istniał w połowie skonfigurowany.

struct Analytics { func track() { print("tracked") } }
struct Flow {
    let analytics: Analytics?
    func step() { analytics?.track() }
}
Flow(analytics: Analytics()).step()
Flow(analytics: nil).step()

Dlaczego wstrzykiwanie przez konstruktor

Gwarantuje ono w pełni zainicjalizowany obiekt, uwidacznia zależności i współpracuje z niezmiennością let. Jest zalecanym rozwiązaniem domyślnym w Swift.

struct Adder { func add(_ a: Int, _ b: Int) -> Int { a + b } }
struct Calc {
    let adder: Adder
    init(adder: Adder) { self.adder = adder }
}
print(Calc(adder: Adder()).adder.add(4, 5))

Szybki test

Dlaczego często preferuje się wstrzykiwanie przez konstruktor?

Podsumowanie

Wstrzykiwanie przez konstruktor przekazuje zależności przez init i przechowuje je, zazwyczaj jako niezmienne właściwości let. Można wstrzykiwać obiekty lub wartości, podawać wartości domyślne i konfigurować wszystko w głównym punkcie kompozycji. Następnie wstrzykną Państwo protokoły zamiast konkretnych typów.

Często zadawane pytania

Czy lekcja „Wstrzykiwanie przez konstruktor” jest bezpłatna?

Tak — pełny tekst „Wstrzykiwanie przez konstruktor” 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 „Wstrzykiwanie przez konstruktor”?

Przekazywanie zależności przez inicjalizatory. Ć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 2 z 4.

Ile czasu zajmuje lekcja „Wstrzykiwanie przez konstruktor”?

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

Dlaczego warto stosować dependency injection
Wstrzykiwanie przez konstruktor
Abstrakcje oparte na protokołach
Mockowanie zależności w testach

← Powrót do Swift Academy