Kako radi dependency injection (Depends)?

Question

Accepted Answer

FastAPI-ev **sustav dependency injection** vam omogućava da deklarirate ponovno upotrebljive ovisnosti (funkcije/klase) koje FastAPI poziva i **ubacuje** u vaše path operacije putem `Depends()`. Koristi se za dijeljenu logiku poput sesija baza podataka, autentifikacije i uobičajenih parametara — čuvajući kod DRY-om i testabilnom.

## Osnovna ovisnost

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

Deklaracija `params = Depends(pagination)` govori FastAPI-ju da pozove `pagination` (rješavajući *njegove* parametre iz zahtjeva isto tako) i proslijedi rezultat u vašu funkciju. Ovisnost je ponovno upotrebljiva na mnogim endpointima.

## Ovisnosti s čišćenjem (yield) — npr. sesije baza podataka

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

Ovisnost s `yield`-om pruža resurs i pokreće čišćenje nakon zahtjeva — standardni uzorak za sesije baza podataka (otvoriti prije, zatvoriti nakon, automatski).

## Ovisnosti mogu ovisiti o ovisnostima

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

Ovisnosti tvore stablo — FastAPI rješava cijeli lanac. Na taj način se obično provodi autentifikacija (ovisnost `get_current_user`).

## Ovisnosti klasa i ponovno korištenje

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

## Zašto je važno

Dependency injection je jedna od najmoćnijih i najvažnijih značajki FastAPI-ja — to je način na koji dijelite i ponovno koristite logiku čisto na svim endpointima (sesije baza podataka, autentifikacija, uobičajeni parametri upita, provjere dozvola) bez dupliciranja.

Razumijevanje tog sustava je bitno jer je u temelju osnovnih uzoraka: **`yield` ovisnost** je standardni način upravljanja sesijama baza podataka (s jamstvenim čišćenjem nakon svakog zahtjeva), a **`get_current_user` ovisnost** je idiomatski način za implementaciju autentifikacije.

DI također čini kod vrlo **testabilnim** — možete prebrisati ovisnosti s mock-ovima u testima.

Elegancija sustava (ovisnosti rješavaju svoje vlastite parametre iz zahtjeva, mogu ovisiti o drugim ovisnostima formirajući stablo, i integriraju se s dokumentacijom) čini ga svestranim alatom za strukturiranje stvarnih aplikacija, tako da savladavanje `Depends` je ključno za izgradnju dobro organiziranih, održivih, testabilnih FastAPI aplikacija.