Hvordan fungerer avhengighetsinjeksjon (Depends)?

Question

Accepted Answer

FastAPIs **avhengighetsinjeksjonssystem** lar deg deklarere gjenbrukbare avhengigheter (funksjoner/klasser) som FastAPI kaller og **injiserer** inn i dine path operations via `Depends()`. Det brukes til delt logikk som databaseøkter, autentisering og vanlige parametere — som holder koden DRY og testbar.

## En grunnleggende avhengighet

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

Å deklarere `params = Depends(pagination)` forteller FastAPI å kalle `pagination` (og løse *dens* parametere fra forespørselen også) og sende resultatet inn i funksjonen din. Avhengigheten er gjenbrukbar på tvers av mange endepunkter.

## Avhengigheter med opprydding (yield) — f.eks. databaseøkter

```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` avhengighet gir en ressurs og kjører opprydding etter forespørselen — standardmønsteret for databaseøkter (åpne før, lukke etter, automatisk).

## Avhengigheter kan avhenge av avhengigheter

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

Avhengigheter danner et tre — FastAPI løser hele kjeden. Dette er hvordan autentisering typisk gjøres (en `get_current_user` avhengighet).

## Klasseavhengigheter og gjenbruk

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

Avhengighetsinjeksjon er en av FastAPIs mest kraftige og viktige funksjoner — det er hvordan du deler og gjenbruker logikk rent på tvers av endepunkter (databaseøkter, autentisering, vanlige spørringsparametere, tillatelsesjekker) uten duplikasjon.

Å forstå det er essensielt fordi det ligger til grunn for kjernmønster: **`yield` avhengigheten** er standardmåten å håndtere databaseøkter på (med garantert opprydding etter hver forespørsel), og en **`get_current_user` avhengighet** er den idiomatiske måten å implementere autentisering på.

Avhengighetsinjeksjon gjør også koden svært **testbar** — du kan overstyrer avhengigheter med mocks i tester.

Systemets eleganse (avhengigheter løser sine egne parametere fra forespørselen, kan avhenge av andre avhengigheter som danner et tre, og integrerer med dokumentasjonen) gjør det til et allsidig verktøy for å strukturere virkelige applikasjoner, så å mestre `Depends` er nøkkelen til å bygge velorganiserte, vedlikeholdbare, testbare FastAPI-apper.