Hur fungerar beroendeinjicering (Depends)?

Question

Accepted Answer

FastAPIs **beroendeinjiceringssystem** låter dig deklarera återanvändbara beroenden (funktioner/klasser) som FastAPI anropar och **injicerar** in i dina path operations via `Depends()`. Det används för delad logik som databasessioner, autentisering och gemensamma parametrar — vilket håller koden torr och testbar.

## Ett grundläggande beroende

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

Att deklarera `params = Depends(pagination)` talar om för FastAPI att anropa `pagination` (lösa *dess* parametrar från begäran också) och skicka resultatet in i din funktion. Beroendet är återanvändbart över många endpoints.

## Beroenden med rensning (yield) — t.ex. databasessioner

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

Ett `yield`-beroende tillhandahåller en resurs och kör nedmontering efter begäran — standardmönstret för databasessioner (öppna innan, stäng efter, automatiskt).

## Beroenden kan bero på beroenden

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

Beroenden formar ett träd — FastAPI löser hela kedjan. Det här är hur autentisering vanligtvis görs (ett `get_current_user`-beroende).

## Klassberoenden och återanvändning

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

## Varför det spelar roll

Beroendeinjicering är en av FastAPIs mest kraftfulla och viktiga funktioner — det är hur du delar och återanvänder logik på ett rent sätt över endpoints (databasessioner, autentisering, gemensamma frågeparametrar, behörighetskontroller) utan duplicering.

Att förstå det är väsentligt eftersom det ligger till grund för kärnmönster: **`yield`-beroendet** är standardsättet att hantera databasessioner (med garanterad rensning efter varje begäran), och ett **`get_current_user`-beroende** är det idiomatiska sättet att implementera autentisering.

DI gör också kod mycket **testbar** — du kan åsidosätta beroenden med mockar i tester.

Systemets elegans (beroenden löser sina egna parametrar från begäran, kan bero på andra beroenden som formar ett träd, och integreras med dokumenten) gör det till ett flexibelt verktyg för att strukturera riktiga applikationer, så att behärska `Depends` är nyckeln till att bygga väl organiserade, underhållbara, testbara FastAPI-appar.