Hvordan fungerer dependency injection (Depends)?

Question

Accepted Answer

FastAPI's **dependency injection**-system lader dig deklarere genanvendelige dependencies (funktioner/klasser), som FastAPI kalder og **injicerer** ind i dine path operations via `Depends()`. Det bruges til delt logik som databasesessioner, godkendelse og almindelige parametre — holder kode DRY og testbar.

## En grundlæggende dependency

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

At deklarere `params = Depends(pagination)` fortæller FastAPI at kalde `pagination` (løse *dens* parametre fra anmodningen også) og sende resultatet ind i din funktion. Dependency'en kan genbruges på tværs af mange endpoints.

## Dependencies med oprydning (yield) — f.eks. databasesessioner

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

En `yield` dependency leverer en ressource og kører nedlukning efter anmodningen — standardmønsteret for databasesessioner (åbn før, luk efter, automatisk).

## Dependencies kan afhænge af 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 danner et træ — FastAPI løser hele kæden. Sådan implementeres typisk godkendelse (en `get_current_user` dependency).

## Klassedependencies og genbrug

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

## Hvorfor det betyder noget

Dependency injection er en af FastAPI's mest kraftfulde og vigtige funktioner — det er hvordan du deler og genbruger logik rent på tværs af endpoints (databasesessioner, godkendelse, almindelige query-parametre, tilladelseskontrol) uden duplikering.

At forstå det er væsentligt, fordi det understøtter kernemnønstre: **`yield` dependency'en** er standardmåden at administrere databasesessioner på (med garanteret oprydning efter hver anmodning), og en **`get_current_user` dependency** er den idiomatiske måde at implementere godkendelse på.

DI gør også koden meget **testbar** — du kan overstyreafhængigheder med mocks i tests.

Systemets elegance (dependencies løser deres egne parametre fra anmodningen, kan afhænge af andre dependencies der danner et træ, og integreres med dokumentationen) gør det til et alsidigt værktøj til at strukturere rigtige applikationer, så at mestre `Depends` er nøglen til at bygge velorganiserede, vedligeholdbare, testbare FastAPI-apps.