Bagaimana injeksi kebergantungan (Depends) berfungsi?

Question

Accepted Answer

Sistem **injeksi kebergantungan** FastAPI memungkinkan Anda mendeklarasikan kebergantungan yang dapat digunakan kembali (fungsi/kelas) yang FastAPI panggil dan **suntikkan** ke operasi path Anda melalui `Depends()`. Ini digunakan untuk logika bersama seperti sesi database, autentikasi, dan parameter umum — menjaga kode tetap DRY dan dapat diuji.

## Ketergantungan 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)` memberi tahu FastAPI untuk memanggil `pagination` (menyelesaikan *parameternya* dari permintaan juga) dan meneruskan hasilnya ke fungsi Anda. Ketergantungan dapat digunakan kembali di banyak endpoint.

## Ketergantungan dengan pembersihan (yield) — misalnya sesi 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
```

Ketergantungan `yield` menyediakan sumber daya dan menjalankan pembersihan setelah permintaan — pola standar untuk sesi database (buka sebelumnya, tutup sesudahnya, secara otomatis).

## Ketergantungan dapat bergantung pada ketergantungan

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

Ketergantungan membentuk pohon — FastAPI menyelesaikan seluruh rantai. Ini adalah cara autentikasi biasanya dilakukan (ketergantungan `get_current_user`).

## Ketergantungan kelas 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

Injeksi kebergantungan adalah salah satu fitur FastAPI yang paling kuat dan penting — ini adalah cara Anda membagikan dan menggunakan kembali logika dengan bersih di endpoint (sesi database, autentikasi, parameter kueri umum, pemeriksaan izin) tanpa duplikasi.

Memahaminya sangat penting karena ini mendasari pola inti: **ketergantungan `yield`** adalah cara standar untuk mengelola sesi database (dengan pembersihan terjamin setelah setiap permintaan), dan **ketergantungan `get_current_user`** adalah cara idiomatis untuk mengimplementasikan autentikasi.

DI juga membuat kode sangat dapat **diuji** — Anda dapat mengganti ketergantungan dengan mock dalam tes.

Elegansi sistem (ketergantungan menyelesaikan parameternya sendiri dari permintaan, dapat bergantung pada ketergantungan lain yang membentuk pohon, dan terintegrasi dengan dokumentasi) menjadikannya alat serbaguna untuk menstruktur aplikasi nyata, jadi menguasai `Depends` adalah kunci untuk membangun aplikasi FastAPI yang terorganisir dengan baik, dapat dipertahankan, dan dapat diuji.