Kako deluje vbrizgavanje odvisnosti (Depends)?

Question

Accepted Answer

FastAPI-jev sistem **vbrizgavanja odvisnosti** vam omogoči, da deklarirate ponovno uporabne odvisnosti (funkcije/razrede), ki jih FastAPI pokliče in **vbrizga** v vaše operacije poti prek `Depends()`. Uporablja se za skupno logiko, kot so seje podatkovne baze, avtentifikacija in skupni parametri — to drži kodo SUHO in testabilno.

## Osnovna odvisnost

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

Deklaracija `params = Depends(pagination)` FastAPI-ju pove, da pokliče `pagination` (pri čemer reši *njegove* parametre iz zahteve tudi) in rezultat prosledi v vašo funkcijo. Odvisnost je ponovno uporabna na več končnih točkah.

## Odvisnosti s čiščenjem (yield) — npr. seje podatkovne baze

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

Odvisnost `yield` zagotovi vir in izvede čiščenje po zahtevi — standardni vzorec za seje podatkovne baze (odpri prej, zapri po, samodejno).

## Odvisnosti lahko依isijo od odvisnosti

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

Odvisnosti tvorijo drevo — FastAPI razreši celotno verigo. To je način, kako se običajno opravi avtentifikacija (odvisnost `get_current_user`).

## Odvisnosti razreda in ponovno uporaba

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

## Zakaj je to važno

Vbrizgavanje odvisnosti je ena najbolj zmogljivih in pomembnih funkcij FastAPI-ja — to je način, kako si delite in ponovno uporabljate logiko čisto na več končnih točkah (seje podatkovne baze, avtentifikacija, skupni parametri poizvedbe, preverjanja dovoljenj) brez podvajanja.

Razumevanje tega je bistveno, ker podpira jedrnate vzorce: **odvisnost `yield`** je standardni način upravljanja sej podatkovne baze (s garantiranim čiščenjem po vsaki zahtevi), in **odvisnost `get_current_user`** je idiomatski način za izvajanje avtentifikacije.

DI tudi naredi kodo zelo **testabilno** — odvisnosti lahko v testih nadomestite z napeljavami.

Eleganca sistema (odvisnosti razrešijo svoje lastne parametre iz zahteve, lahko so odvisne od drugih odvisnosti, ki tvorijo drevo, in se integrirajo v dokumentacijo) jo naredi vsestranski orodji za strukturiranje prav aplikacij, zato je obvladovanje `Depends` ključno za gradnjo dobro organiziranih, vzdrževalnih, testabilnih FastAPI aplikacij.