Hoe werkt dependency injection (Depends)?

Question

Accepted Answer

FastAPI's **dependency injection** systeem stelt je in staat om herbruikbare dependencies (functies/klassen) te declareren die FastAPI aanroept en **injecteert** in je path operations via `Depends()`. Het wordt gebruikt voor gedeelde logica zoals databasesessies, authenticatie en gemeenschappelijke parameters — waardoor code DRY en testbaar blijft.

## Een basisafhankelijkheid

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

Door `params = Depends(pagination)` te declareren vertel je FastAPI om `pagination` aan te roepen (waarbij ook *de* parameters van deze functie uit het request worden opgelost) en het resultaat in je functie in te voegen. De dependency is herbruikbaar over veel endpoints.

## Dependencies met opschonen (yield) — bijv. databasesessies

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

Een `yield` dependency biedt een resource en voert opschoning uit na het request — het standaardpatroon voor databasesessies (openen voor, sluiten na, automatisch).

## Dependencies kunnen afhangen van dependencies

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

Dependencies vormen een boom — FastAPI lost de hele keten op. Dit is hoe authenticatie meestal wordt gedaan (een `get_current_user` dependency).

## Class dependencies en hergebruik

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

## Waarom het belangrijk is

Dependency injection is een van FastAPI's meest krachtige en belangrijkste functies — het is hoe je logica schoon en herbruikbaar deelt en hergebruikt over endpoints (databasesessies, authenticatie, gemeenschappelijke queryparameters, permissiecontroles) zonder duplicatie.

Het begrijpen ervan is essentieel omdat het onderliggende kernpatronen ondersteunt: de **`yield` dependency** is de standaardmanier om databasesessies te beheren (met gegarandeerde opschoning na elk request), en een **`get_current_user` dependency** is de idiomatische manier om authenticatie te implementeren.

DI maakt code ook zeer **testbaar** — je kunt dependencies in tests overschrijven met mocks.

De elegantie van het systeem (dependencies lossen hun eigen parameters uit het request op, kunnen afhangen van andere dependencies die een boom vormen, en integreren met de documentatie) maakt het een veelzijdig gereedschap voor het structureren van echte applicaties, dus het beheersen van `Depends` is essentieel voor het bouwen van goed georganiseerde, onderhoudsbare, testbare FastAPI-applicaties.