Hogyan működik a dependency injection (Depends)?

Question

Accepted Answer

A FastAPI **függőségi injekciós** rendszere lehetővé teszi olyan újrafelhasználható függőségek (függvények/osztályok) deklarálását, amelyeket a FastAPI meghív és a `Depends()` segítségével **injektál** az útvonal-operációkba. Ezt megosztott logikához használják, mint adatbázis-munkamenetek, hitelesítés és közös paraméterek — így a kód DRY marad és könnyen tesztelhető.

## Alapvető függőség

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

A `params = Depends(pagination)` deklarálása azt mondja a FastAPI-nak, hogy hívja meg a `pagination` függvényt (annak paramétereit is feloldva a requestből) és adja át az eredményt a függvénynek. A függőség újrafelhasználható számos végpont között.

## Függőségek tisztítással (yield) — pl. adatbázis-munkamenetek

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

Egy `yield` függőség erőforrást biztosít és a request után futtat egy cleanup műveletet — ez az adatbázis-munkamenetek szabványos mintája (nyitás előtte, bezárás után, automatikusan).

## A függőségek függhetnek más függőségektől

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

A függőségek fát képeznek — a FastAPI az egész láncot feloldja. Így valósítják meg jellemzően a hitelesítést (egy `get_current_user` függőség).

## Osztály-függőségek és újrafelhasználás

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

## Miért fontos

A függőségi injekció a FastAPI egyik legerősebb és legfontosabb funkciója — így oszthatja meg és használhatja újra a logikát tisztán az összes végpont között (adatbázis-munkamenetek, hitelesítés, közös lekérdezési paraméterek, engedélyellenőrzések) anélkül, hogy megismételné azokat.

Annak megértése elengedhetetlen, mert alapvető mintákat támogat: a **`yield` függőség** az adatbázis-munkamenetek kezelésének szabványos módja (garantált cleanup minden request után), és a **`get_current_user` függőség** a hitelesítés idiomatikus megvalósítási módja.

A DI azt is jelenti, hogy a kód magasan **tesztelhető** — a tesztekben mock-okkal felülírhatja a függőségeket.

A rendszer elegáns volta (a függőségek saját paramétereiket oldják fel a requestből, függhetnek más függőségektől, fát alkotva, és integrálódnak a dokumentációba) olyan sokoldalú eszközzé teszi azt, amely az igazi alkalmazások strukturálásához használható, így a `Depends` elsajátítása kulcsfontosságú a jól szervezett, karbantartható, tesztelhető FastAPI-alkalmazások építéséhez.