Jak funguje injekce závislostí (Depends)?

Question

Accepted Answer

Systém **injekce závislostí** FastAPI vám umožňuje deklarovat opakovaně použitelné závislosti (funkce/třídy), které FastAPI volá a **injektuje** do vašich operací cesty přes `Depends()`. Používá se pro sdílené logiky jako databázové relace, ověřování a společné parametry — udržuje kód DRY a testovatelný.

## Základní závislost

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

Deklarace `params = Depends(pagination)` říká FastAPI, aby zavolal `pagination` (vyřešit *jeho* parametry z požadavku také) a předat výsledek do vaší funkce. Závislost je opakovaně použitelná v mnoha koncových bodech.

## Závislosti s čištěním (yield) — např. databázové relace

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

Závislost `yield` poskytuje zdroj a spustí čištění po požadavku — standardní vzor pro databázové relace (otevřít před, zavřít po, automaticky).

## Závislosti mohou záviset na závislostech

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

Závislosti tvoří strom — FastAPI vyřeší celý řetězec. Takto se typicky provádí ověřování (závislost `get_current_user`).

## Závislosti třídy a opakované použití

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

## Proč je to důležité

Injekce závislostí je jednou z nejsilnějších a nejdůležitějších funkcí FastAPI — je to, jak sdílíte a znovu používáte logiku čistě v koncových bodech (databázové relace, ověřování, běžné parametry dotazu, kontroly oprávnění) bez duplikace.

Rozmět je podstatné, protože podpírá základní vzory: **závislost `yield`** je standardní způsob, jak spravovat databázové relace (s garantovaným čištěním po každém požadavku), a **závislost `get_current_user`** je idiomatickou cestou k implementaci ověřování.

DI také činí kód vysoce **testovatelným** — můžete přepsat závislosti s mock objekty v testech.

Elegance systému (závislosti řeší své vlastní parametry z požadavku, mohou záviset na jiných závislostech tvořících strom a integrují se do dokumentace) z něj dělá universální nástroj pro strukturování skutečných aplikací, takže zvládnutí `Depends` je klíčem k vytváření dobře organizovaných, udržovatelných, testovatelných aplikací FastAPI.