Bagaimana dependency injection (Depends) bekerja?

Question

Accepted Answer

Sistem **dependency injection** FastAPI memungkinkan Anda mendeklarasikan dependencies yang dapat digunakan kembali (fungsi/kelas) yang dipanggil FastAPI dan **diinjeksikan** ke dalam operasi path Anda melalui `Depends()`. Ini digunakan untuk logika bersama seperti session database, autentikasi, dan parameter umum — menjaga kode tetap DRY dan dapat diuji.

## Sebuah dependency dasar

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

Mendeklarasikan `params = Depends(pagination)` memberitahu FastAPI untuk memanggil `pagination` (menyelesaikan *parameter*-nya dari request juga) dan meneruskan hasilnya ke dalam fungsi Anda. Dependency dapat digunakan kembali di berbagai endpoint.

## Dependencies dengan pembersihan (yield) — misalnya session database

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

Sebuah dependency `yield` menyediakan sumber daya dan menjalankan teardown setelah request — pola standar untuk session database (buka sebelum, tutup sesudah, otomatis).

## Dependencies dapat bergantung pada 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 membentuk pohon — FastAPI menyelesaikan seluruh rantai. Ini adalah cara autentikasi biasanya dilakukan (sebuah dependency `get_current_user`).

## Class dependencies dan penggunaan kembali

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

## Mengapa ini penting

Dependency injection adalah salah satu fitur paling kuat dan penting di FastAPI — ini adalah cara Anda berbagi dan menggunakan kembali logika dengan bersih di seluruh endpoint (session database, autentikasi, parameter query umum, pemeriksaan izin) tanpa duplikasi.

Memahaminya sangat penting karena mendasari pola-pola inti: **dependency `yield`** adalah cara standar untuk mengelola session database (dengan pembersihan yang dijamin setelah setiap request), dan **dependency `get_current_user`** adalah cara idiomatik untuk mengimplementasikan autentikasi.

DI juga membuat kode sangat **dapat diuji** — Anda dapat mengganti dependencies dengan mock dalam test.

Elegansistem (dependencies menyelesaikan parameter mereka sendiri dari request, dapat bergantung pada dependencies lain membentuk pohon, dan terintegrasi dengan docs) menjadikannya alat serbaguna untuk menyusun aplikasi nyata, jadi menguasai `Depends` adalah kunci untuk membangun aplikasi FastAPI yang terorganisir dengan baik, dapat dipertahankan, dan dapat diuji.