Dependency injection (Depends) எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

FastAPI-இன் **dependency injection** அமைப்பு, FastAPI அழைத்து உங்கள் path operations-இல் `Depends()` மூலம் **inject** செய்யும் மீண்டும் பயன்படுத்தக்கூடிய dependencies-ஐ (functions/classes) அறிவிக்க உங்களை அனுமதிக்கிறது. 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`-ஐ அழைக்கச் சொல்கிறது (*அதன்* parameters-ஐயும் request-இலிருந்து தீர்க்கிறது) மற்றும் முடிவை உங்கள் function-இல் அனுப்புகிறது. 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-க்கான standard 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-ஐயும் தீர்க்கிறது. 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-இன் மிகவும் சக்திவாய்ந்த மற்றும் முக்கியமான அம்சங்களில் ஒன்றாகும் — duplication இல்லாமல் endpoints முழுவதும் logic-ஐ (database sessions, authentication, common query parameters, permission checks) சுத்தமாகப் பகிர்ந்து மீண்டும் பயன்படுத்துவது இவ்வாறுதான்.

இதைப் புரிந்துகொள்வது அவசியம், ஏனெனில் இது core patterns-ஐ அடித்தளமாகக் கொண்டுள்ளது: **`yield` dependency** database sessions-ஐ நிர்வகிக்கும் standard வழி (ஒவ்வொரு request-க்குப் பிறகும் உறுதிப்படுத்தப்பட்ட cleanup-உடன்), மேலும் ஒரு **`get_current_user` dependency** authentication-ஐ செயல்படுத்தும் idiomatic வழியாகும்.

DI code-ஐ மிகவும் **testable**-ஆகவும் ஆக்குகிறது — tests-இல் dependencies-ஐ mocks-உடன் override செய்யலாம்.

அமைப்பின் நேர்த்தி (dependencies request-இலிருந்து தங்கள் சொந்த parameters-ஐ தீர்க்கின்றன, ஒரு tree-ஐ உருவாக்கி மற்ற dependencies-ஐ சார்ந்திருக்கலாம், docs-உடன் integrate ஆகின்றன) இதை உண்மையான applications-ஐ structure செய்ய ஒரு பல்துறை கருவியாக ஆக்குகிறது, எனவே `Depends`-ஐ தேர்ச்சி பெறுவது நன்கு ஒழுங்கமைக்கப்பட்ட, maintainable, testable FastAPI apps-ஐ உருவாக்குவதற்கு முக்கியமானது.