Miten riippuvuuksien injektio (Depends) toimii?

Question

Accepted Answer

FastAPIn **riippuvuuksien injektio** -järjestelmä antaa sinun ilmoittaa uudelleenkäytettävät riippuvuudet (funktiot/luokat), joita FastAPI kutsuu ja **injektoi** polkuoperaatioihisi `Depends()` -kautta. Sitä käytetään jaettuun logiikkaan, kuten tietokantaistuntoihin, todentamiseen ja yleisiin parametreihin — pitää koodin kuivana ja testattavana.

## Perusriippuvuus

```python
from fastapi import Depends

# a dependency is just a callable that returns something
def pagination(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(pagination)):   # FastAPI calls pagination() and injects the result
    return params
# the skip/limit query params are now handled by the reusable dependency
```

`params = Depends(pagination)` ilmoittaminen kertoo FastAPIlle kutsua `pagination` (ratkaisemaan myös sen *parametrit* pyynnöstä) ja välittää tulos funktiollesi. Riippuvuus on uudelleenkäytettävissä monilla päätepistilla.

## Riippuvuudet puhdistuksen kanssa (yield) — esim. tietokannan istunnot

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                  # provide the session to the endpoint
    finally:
        db.close()                # cleanup runs AFTER the response — guaranteed

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query(User).all()    # uses the injected, auto-closed session
```

A `yield` riippuvuus toimittaa resurssin ja suorittaa puhdistuksen pyynnön jälkeen — vakiokuvio tietokannan istunnoille (avaa ennen, sulje jälkeen, automaattisesti).

## Riippuvuudet voivat riippua riippuvuuksista

```python
def get_current_user(token: str = Depends(get_token)):   # depends on another dependency
    return decode(token)

@app.get("/me")
def me(user: User = Depends(get_current_user)):           # auth via injection
    return user
```

Riippuvuudet muodostavat puun — FastAPI ratkaisee koko ketjun. Näin todentaminen tyypillisesti toteutetaan (`get_current_user` riippuvuus).

## Luokkariippuvuudet ja uudelleenkäyttö

```python
@app.get("/items", dependencies=[Depends(verify_api_key)])   # run a dependency without using its return
def items(): ...                                              # e.g. enforce auth as a side effect
```

## Miksi se on tärkeää

Riippuvuuksien injektio on yksi FastAPIn voimakkaimmista ja tärkeimmistä ominaisuuksista — se on kuinka jaat ja käytät logiikkaa puhtaasti päätepisteiden välillä (tietokannan istunnot, todentaminen, yleiset kyselyparametrit, oikeuksien tarkistukset) ilman kaksinkertaisuutta.

Sen ymmärtäminen on olennaista, koska se tukee ydinmalleja: **`yield` riippuvuus** on vakiotapa hallita tietokannan istuntoja (takuulla olevan puhdistuksen jälkeen jokaisen pyynnön jälkeen), ja **`get_current_user` riippuvuus** on idiomatinen tapa toteuttaa todentamista.

DI tekee myös koodista erittäin **testattavaa** — voit ohittaa riippuvuuksia nauhoituksilla testeissä.

Järjestelmän eleganssi (riippuvuudet ratkaisevat omat parametrinsa pyynnöstä, voivat riippua muista riippuvuuksista muodostaen puun ja integroituvat dokumentaatioon) tekee siitä monipuolisen työkalun todellisten sovellusten rakenteelle, joten `Depends` hallinta on avain hyvin järjestettyjen, ylläpidettävien, testattavien FastAPI-sovellusten rakentamiseen.