FastAPI என்ன advanced dependency patterns-ஐ ஆதரிக்கிறது?

Question

Accepted Answer

அடிப்படை `Depends`-க்கு அப்பால், FastAPI-இன் dependency injection advanced patterns-ஐ ஆதரிக்கிறது: **sub-dependencies**, **parameters உள்ள dependencies** (class-based அல்லது factories வழியாக), **scoped resources** (yield), **global/router dependencies**, மற்றும் testing-க்கான **dependency overrides** — இது உண்மையான applications-ஐ கட்டமைப்பதற்கான ஒரு பல்துறை கருவியாக ஆக்குகிறது.

## Sub-dependencies (dependency trees)

```python
def get_token(authorization: str = Header()):
    return parse(authorization)

def get_current_user(token: str = Depends(get_token)):   # depends on another dependency
    return decode(token)

def get_admin(user: User = Depends(get_current_user)):    # depends on that, in turn
    if not user.is_admin: raise HTTPException(403)
    return user
# FastAPI resolves the whole chain, caching shared dependencies within a request
```

Dependencies மற்ற dependencies-ஐ சார்ந்திருக்கலாம், FastAPI தானாகவே resolve செய்யும் ஒரு tree-ஐ உருவாக்குகிறது (மேலும் shared-வற்றை per request **cache** செய்கிறது, எனவே `get_token` பல dependencies-ஆல் பயன்படுத்தப்பட்டாலும் ஒருமுறை மட்டுமே இயங்குகிறது).

## Parameterized (class-based) dependencies

```python
class RateLimiter:
    def __init__(self, calls: int):        # configure the dependency
        self.calls = calls
    def __call__(self, request: Request):  # callable → acts as a dependency
        check_rate_limit(request, self.calls)

@app.get("/items", dependencies=[Depends(RateLimiter(calls=100))])  # configured per route
def items(): ...
```

`__call__` உள்ள ஒரு class ஒரு **configurable** dependency ஆகும் — அதை நீங்கள் பயன்படுத்தும் நேரத்தில் parameterize செய்கிறீர்கள் (எ.கா. route-க்கு route வேறுபட்ட rate limits).

## Side-effects ஆக dependencies (return தேவையில்லை)

```python
@app.get("/admin", dependencies=[Depends(verify_admin)])   # run for the effect (auth check)
def admin(): ...                                            # don't need its return value
```

## Global மற்றும் router-level dependencies

```python
app = FastAPI(dependencies=[Depends(verify_api_key)])      # applies to EVERY route
router = APIRouter(dependencies=[Depends(get_current_user)])  # to all routes in a router
```

cross-cutting தேவைகளுக்கு (auth, rate limiting) dependencies-ஐ app முழுவதும் அல்லது per-router பயன்படுத்துங்கள்.

## Testing-க்கான overrides

```python
app.dependency_overrides[get_db] = get_test_db    # swap any dependency in tests
```

## இது ஏன் முக்கியம்

FastAPI-இன் dependency injection அதன் மிக சக்திவாய்ந்த features-இல் ஒன்றாகும், மேலும் இந்த advanced patterns தான் உண்மையான, சிக்கலான applications-ஐ நேர்த்தியாக கட்டமைக்க உங்களை அனுமதிக்கின்றன.

இவற்றைப் புரிந்துகொள்வது மதிப்புமிக்க senior-level அறிவாகும்: **sub-dependencies** தானியங்கி resolution மற்றும் per-request caching உடன் (மீண்டும் மீண்டும் வேலையைத் தவிர்த்து) reusable layers-ஐ (token → user → admin) உருவாக்குகின்றன; **parameterized/class-based dependencies** configurable, reusable components-ஐ (rate limiters, route-க்கு route வேறுபட்ட அமைப்புகளுடன் permission checks) உருவாக்குகின்றன; **side-effects ஆக dependencies** function signatures-ஐ குழப்பாமல் தேவைகளை (auth) சுத்தமாக நடைமுறைப்படுத்துகின்றன; மேலும் **global/router-level dependencies** cross-cutting concerns-ஐ (authentication, rate limiting) routes-இன் முழு குழுக்களுக்கும் ஒரே இடத்தில் பயன்படுத்துகின்றன.

முக்கியமாக, **dependency overrides** சிக்கலான dependency graphs-ஐ கூட எளிதாக testable ஆக்குகின்றன.

இந்த patterns-ஐ master செய்வது — dependencies-ஐ compose செய்வது, அவற்றை parameterize செய்வது, அவற்றை globally அல்லது per-router scope செய்வது, மற்றும் அவற்றை tests-இல் override செய்வது — non-trivial FastAPI applications-இல் clean, DRY, testable architecture-ஐ சாத்தியமாக்குகிறது, framework-இன் DI system-ஐ முழுமையாக பயன்படுத்தக்கூடிய developers-ஐ அடிப்படை `Depends`-ஐ மட்டுமே பயன்படுத்துபவர்களிடமிருந்து வேறுபடுத்துகிறது.

இது நன்கு கட்டமைக்கப்பட்ட, maintainable, large-scale FastAPI apps-ஐ உருவாக்குவதற்கான ஒரு முக்கியமான தலைப்பாகும்.