Swift Academy · Oppitunti

Riippuvuuksien injektointi alustajalla

Välitä riippuvuudet alustajien kautta.

Oppitunti 2/413 vaihetta

Riippuvuuksien injektointi alustajalla on ilmainen Swift Academy-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Swift Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Swift Academy-kurssilla on yhteensä 4 oppituntia.

Konstruktorin kautta injektointi

Yleisin DI-tyyli välittää riippuvuudet alustajan kautta. Olio saa kaiken tarvitsemansa luontihetkellä ja tallentaa riippuvuudet.

Perustason init

Ilmoittakaa tallennettu ominaisuus ja määrittäkää sille arvo init-alustajassa. Kutsujien on annettava riippuvuus, jotta olio voidaan luoda.

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()

Muuttumattomat riippuvuudet

Injektoitujen ominaisuuksien määrittäminen let-ominaisuuksiksi tekee niistä muuttumattomia, joten riippuvuutta ei voi vaihtaa luomisen jälkeen.

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)

Useita riippuvuuksia

Luetelkaa useita parametreja, kun haluatte injektoida useamman yhteistyöolion. Alustaja dokumentoi tällöin kaikki vaatimukset.

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()

Parametrien oletusarvot

Oletusarvon ansiosta kutsuja voi jättää riippuvuuden pois tuotantokoodissa, mutta korvata sen silti testeissä.

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

Luokan konstruktorin kautta injektointi

Luokat noudattavat samaa mallia. Alustaja määrittää jokaisen riippuvuuden ennen kuin ilmentymää voidaan käyttää.

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()

Arvojen injektointi

Riippuvuuksien ei tarvitse olla olioita. Myös määritysarvoja, kuten perus-URL-osoitteen tai lipun, voidaan injektoida samalla tavalla.

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"))

Koostamisjuuri

Sovelluksen aloituskohdan lähellä on yksi paikka, jossa koko olioverkko kytketään yhteen. Muu koodi vastaanottaa vain valmiiksi toimitetut riippuvuudet.

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()

Piilotettujen globaalien välttäminen

Konstruktorin kautta injektointi korvaa piilotetun globaalin käytön. Jokainen riippuvuus on eksplisiittinen, joten tietojen kulkua voi seurata.

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

Pakollinen vai valinnainen

Jos riippuvuus on todella valinnainen, mallintakaa se optional-tyypillä. Muussa tapauksessa tehkää siitä pakollinen, jotta puoliksi määritettyä oliota ei voi olla olemassa.

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

Miksi konstruktorin kautta injektointi

Se takaa täysin alustetun olion, tekee riippuvuudet näkyviksi ja toimii let-muuttumattomuuden kanssa. Se on Swiftissä suositeltu oletusratkaisu.

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

Pikatarkistus

Miksi konstruktorin kautta injektointia usein suositaan?

Vastaa interaktiivisessa oppitunnissa

Kertaus

Konstruktorin kautta injektointi välittää riippuvuudet init-alustajan kautta ja tallentaa ne yleensä muuttumattomina let-ominaisuuksina. Injektoida voidaan olioita tai arvoja, oletusarvoja voidaan antaa ja kaikki riippuvuudet voidaan kytkeä koostamisjuuressa. Seuraavaksi injektoitte konkreettisten tyyppien sijaan protokollia.

Aloita maksutta

Opi Swift tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 122
Oppitunnit: 409

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Riippuvuuksien injektointi alustajalla” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Swift Academy-oppimispolun 3 oppituntia, myös oppitunnin “Riippuvuuksien injektointi alustajalla”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Swift Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Riippuvuuksien injektointi alustajalla”?

Välitä riippuvuudet alustajien kautta. Harjoittelet Swift Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Swift Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Swift Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.

Kuinka kauan ”Riippuvuuksien injektointi alustajalla”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Swift Academy-oppitunnilla?

Kyllä. Jokainen Swift Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Swift Academy