Je, dependency injection (Depends) inafanyaje kazi?

Question

Accepted Answer

Mfumo wa **dependency injection** wa FastAPI unakuruhusu kutangaza dependencies zinazoweza kutumika tena (functions/classes) ambazo FastAPI huziita na **kuziingiza** kwenye path operations zako kupitia `Depends()`. Hutumika kwa mantiki ya pamoja kama database sessions, uthibitishaji wa utambulisho (authentication), na parameta za kawaida — kuweka msimbo DRY na unaoweza kupimwa.

## Dependency ya msingi

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

Kutangaza `params = Depends(pagination)` kunaiambia FastAPI iite `pagination` (ikitatua *parameta zake* kutoka kwa ombi pia) na kupitisha matokeo kwenye function yako. Dependency hiyo inaweza kutumika tena katika endpoints nyingi.

## Dependencies zenye usafishaji (yield) — k.m. database sessions

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

Dependency ya `yield` hutoa rasilimali na kuendesha usafishaji baada ya ombi — mfumo wa kawaida wa database sessions (fungua kabla, funga baada, kiotomatiki).

## Dependencies zinaweza kutegemea 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 huunda mti (tree) — FastAPI hutatua mlolongo mzima. Hivi ndivyo uthibitishaji wa utambulisho kawaida hufanyika (dependency ya `get_current_user`).

## Class dependencies na utumiaji tena

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

## Kwa nini ni muhimu

Dependency injection ni mojawapo ya vipengele vyenye nguvu na muhimu zaidi vya FastAPI — ndivyo unavyoshiriki na kutumia tena mantiki kwa usafi katika endpoints (database sessions, uthibitishaji, parameta za kawaida za query, ukaguzi wa ruhusa) bila urudufu.

Kuelewa ni jambo la lazima kwa sababu hutegemeza mifumo ya msingi: **dependency ya `yield`** ndiyo njia ya kawaida ya kusimamia database sessions (na usafishaji wa uhakika baada ya kila ombi), na **dependency ya `get_current_user`** ndiyo njia ya kawaida ya kutekeleza uthibitishaji wa utambulisho.

DI pia hufanya msimbo uweze **kupimwa** kwa kiwango cha juu — unaweza kubadilisha dependencies kwa mocks wakati wa majaribio.

Uzuri wa mfumo huu (dependencies hutatua parameta zao wenyewe kutoka kwa ombi, zinaweza kutegemea dependencies nyingine kuunda mti, na hujumuika na nyaraka) huufanya kuwa zana nyumbufu ya kupanga programu halisi, hivyo kumudu `Depends` ni ufunguo wa kujenga programu za FastAPI zilizopangwa vizuri, zinazodumishika, na zinazopimwa.