Comment fonctionne l'injection de dépendances (Depends) ?

Question

Accepted Answer

Le système d'**injection de dépendances** de FastAPI vous permet de déclarer des dépendances réutilisables (fonctions/classes) que FastAPI appelle et **injecte** dans vos opérations de chemin via `Depends()`. Il est utilisé pour la logique partagée comme les sessions de base de données, l'authentification et les paramètres communs — maintenant le code DRY et testable.

## Une dépendance basique

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

Déclarer `params = Depends(pagination)` dit à FastAPI d'appeler `pagination` (en résolvant *ses* paramètres à partir de la requête aussi) et de passer le résultat dans votre fonction. La dépendance est réutilisable sur de nombreux points d'accès.

## Dépendances avec nettoyage (yield) — par ex. sessions de base de données

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

Une dépendance `yield` fournit une ressource et exécute le nettoyage après la requête — le modèle standard pour les sessions de base de données (ouvrir avant, fermer après, automatiquement).

## Les dépendances peuvent dépendre d'autres dépendances

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

Les dépendances forment un arbre — FastAPI résout toute la chaîne. C'est ainsi que l'authentification est généralement implémentée (une dépendance `get_current_user`).

## Dépendances de classe et réutilisation

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

## Pourquoi c'est important

L'injection de dépendances est l'une des fonctionnalités les plus puissantes et les plus importantes de FastAPI — c'est comment vous partagez et réutilisez la logique de manière claire sur les points d'accès (sessions de base de données, authentification, paramètres de requête communs, vérifications de permissions) sans duplication.

La comprendre est essentiel car elle sous-tend les modèles fondamentaux : la **dépendance `yield`** est la manière standard de gérer les sessions de base de données (avec nettoyage garanti après chaque requête), et une **dépendance `get_current_user`** est la manière idiomatique d'implémenter l'authentification.

DI rend également le code hautement **testable** — vous pouvez remplacer les dépendances par des mocks dans les tests.

L'élégance du système (les dépendances résolvent leurs propres paramètres à partir de la requête, peuvent dépendre d'autres dépendances formant un arbre, et s'intègrent avec la documentation) en fait un outil polyvalent pour structurer les applications réelles, donc maîtriser `Depends` est essentiel pour construire des applications FastAPI bien organisées, maintenables et testables.