Jak działa dependency injection (Depends)?

Question

Accepted Answer

System **dependency injection** FastAPI pozwala deklarować wielokrotnie używane zależności (funkcje/klasy), które FastAPI wywołuje i **wstrzykuje** do twoich operacji ścieżki poprzez `Depends()`. Jest używany do wspólnej logiki, takiej jak sesje bazy danych, uwierzytelnianie i wspólne parametry — utrzymując kod DRY i testowalny.

## Podstawowa zależność

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

Deklaracja `params = Depends(pagination)` mówi FastAPI, aby wywołał `pagination` (rozwiązując *jej* parametry z żądania również) i przekazał wynik do funkcji. Zależność jest wielokrotnie używalna na wielu punktach końcowych.

## Zależności z czyszczeniem (yield) — np. sesje bazy danych

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

Zależność `yield` zapewnia zasób i uruchamia teardown po żądaniu — standardowy wzorzec dla sesji bazy danych (otwórz wcześniej, zamknij potem, automatycznie).

## Zależności mogą zależeć od zależności

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

Zależności tworzą drzewo — FastAPI rozwiązuje cały łańcuch. W ten sposób typowo implementuje się uwierzytelnianie (zależność `get_current_user`).

## Zależności klasy i wielokrotne użycie

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

## Dlaczego to ważne

Dependency injection jest jedną z najmocniejszych i najważniejszych funkcji FastAPI — to sposób, w jaki dzielisz i wielokrotnie używasz logikę czyszczej na wszystkich punktach końcowych (sesje bazy danych, uwierzytelnianie, wspólne parametry zapytania, kontrola uprawnień) bez duplikowania.

Zrozumienie tego jest istotne, ponieważ stanowi podstawę kluczowych wzorców: **zależność `yield`** to standardowy sposób zarządzania sesjami bazy danych (z gwarantowanym czyszczeniem po każdym żądaniu), a **zależność `get_current_user`** to idiomatyczny sposób implementacji uwierzytelniania.

DI czyni również kod wysoce **testowalnym** — możesz przesłaniać zależności mockami w testach.

Elegancja systemu (zależności rozwiązują swoje własne parametry z żądania, mogą zależeć od innych zależności tworząc drzewo i integrują się z dokumentacją) czyni go wszechstronnym narzędziem do strukturyzowania rzeczywistych aplikacji, dlatego opanowanie `Depends` jest kluczowe do budowania dobrze zorganizowanych, utrzymywalnych, testowalnych aplikacji FastAPI.