Dependency injection (Depends) कैसे काम करता है?

Question

Accepted Answer

FastAPI का **dependency injection** सिस्टम आपको पुन: उपयोग योग्य dependencies (functions/classes) घोषित करने देता है जिन्हें FastAPI कॉल करता है और `Depends()` के माध्यम से आपके path operations में **inject** करता है। इसका उपयोग database sessions, authentication और common parameters जैसी साझा logic के लिए किया जाता है — जिससे code DRY और testable बना रहता है।

## एक बुनियादी dependency

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

`params = Depends(pagination)` घोषित करना FastAPI को बताता है कि वह `pagination` को कॉल करे (request से *उसके* parameters को भी resolve करते हुए) और परिणाम को आपके function में pass करे। यह dependency कई endpoints में पुन: उपयोग योग्य है।

## cleanup वाली dependencies (yield) — जैसे 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
```

एक `yield` dependency एक resource प्रदान करती है और request के बाद teardown चलाती है — यह database sessions के लिए मानक pattern है (पहले खोलें, बाद में बंद करें, स्वचालित रूप से)।

## Dependencies दूसरी 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 एक tree बनाती हैं — FastAPI पूरी chain को resolve करता है। आमतौर पर authentication इसी तरह किया जाता है (एक `get_current_user` dependency)।

## Class dependencies और पुन: उपयोग

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

## यह क्यों महत्वपूर्ण है

Dependency injection FastAPI की सबसे शक्तिशाली और महत्वपूर्ण विशेषताओं में से एक है — यह वह तरीका है जिससे आप endpoints में logic (database sessions, authentication, common query parameters, permission checks) को बिना दोहराव के साफ-सुथरे ढंग से साझा और पुन: उपयोग करते हैं।

इसे समझना आवश्यक है क्योंकि यह core patterns को आधार प्रदान करता है: **`yield` dependency** database sessions को manage करने का मानक तरीका है (प्रत्येक request के बाद guaranteed cleanup के साथ), और एक **`get_current_user` dependency** authentication लागू करने का idiomatic तरीका है।

DI code को अत्यधिक **testable** भी बनाता है — आप tests में dependencies को mocks के साथ override कर सकते हैं।

इस सिस्टम की elegance (dependencies request से अपने स्वयं के parameters resolve करती हैं, एक tree बनाते हुए अन्य dependencies पर निर्भर हो सकती हैं, और docs के साथ integrate होती हैं) इसे वास्तविक applications को structure करने के लिए एक बहुमुखी tool बनाती है, इसलिए `Depends` में महारत हासिल करना सुव्यवस्थित, maintainable, testable FastAPI apps बनाने की कुंजी है।