Cum funcționează dependency injection (Depends)?

Question

Accepted Answer

Sistemul de **dependency injection** din FastAPI vă permite să declarați dependențe reutilizabile (funcții/clase) pe care FastAPI le apelează și le **injectează** în operațiile dvs. path prin `Depends()`. Se folosește pentru logică partajată, cum ar fi sesiuni de bază de date, autentificare și parametri comuni — păstrând codul DRY și testabil.

## O dependență de bază

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

Declararea `params = Depends(pagination)` îi spune FastAPI să apeleze `pagination` (rezolvând și *parametrii* acesteia din cerere) și să transmită rezultatul în funcția dvs. Dependența este reutilizabilă în mai multe endpoint-uri.

## Dependențe cu curățare (yield) — de exemplu, sesiuni de bază de date

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

O dependență `yield` furnizează o resursă și rulează curățarea după cerere — modelul standard pentru sesiuni de bază de date (deschidere înainte, închidere după, automat).

## Dependențele pot depinde de alte dependențe

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

Dependențele formează un arbore — FastAPI rezolvă întregul lanț. Aceasta este modul în care autentificarea se face de obicei (o dependență `get_current_user`).

## Dependențe de clasă și reutilizare

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

## De ce este important

Dependency injection este una dintre cele mai puternice și importante funcții ale FastAPI — este modul în care partajați și reutilizați logica curat în endpoint-uri (sesiuni de bază de date, autentificare, parametri comuni de interogare, verificări de permisiuni) fără duplicare.

Înțelegerea acesteia este esențială deoarece stă la baza modelelor de bază: **dependența `yield`** este modul standard pentru gestionarea sesiunilor de bază de date (cu garantia curățării după fiecare cerere), iar **dependența `get_current_user`** este modul idiomativ pentru implementarea autentificării.

DI face, de asemenea, codul foarte **testabil** — puteți suprascrie dependențele cu mock-uri în teste.

Eleganța sistemului (dependențele rezolvă propriii parametri din cerere, pot depinde de alte dependențe formând un arbore și se integrează cu documentația) o face un instrument versatil pentru structurarea aplicațiilor reale, deci stăpânirea `Depends` este cheia pentru construirea aplicațiilor FastAPI bine organizate, ușor de întreținut și testabile.