Conas a oibríonn ionjectúchán spleáchais (Depends)?

Question

Accepted Answer

Ligeann córas **ionjectúchán spleáchais** FastAPI duit spleáchais inúsáidte (feidhmeanna/ranganna) a dhearbhú agus **ionjectálann** FastAPI isteach do do thúsú conair trí `Depends()`. Úsáidtear é do loighic roinnte ar nós seisiún bunachar sonraí, fíordheimhniú, agus paraiméadair choiteanna — ag coinneáil an chóid DRY agus intuigthe.

## Spleáchais bhunúsach

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

A rá `params = Depends(pagination)` le FastAPI go bhfuil air `pagination` a ghlaoch (ag réiteach *a* pharaiméadair ó an iarratas freisin) agus an toradh a rá isteach do do fheidhm. Tá an spleáchais inúsáidte ar fud go leor pointí deirí.

## Spleáchais le glanadh (yield) — e.g. seisiúin bhunachar sonraí

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

Soláthraíonn spleáchais `yield` acmhainn agus rith sé teardown tar éis an iarratas — an patrún caighdeánach do sheisiúin bhunachar sonraí (oscailt roimh, dúnta tar éis, go fautomatically).

## Is féidir le spleáchais a bheith ag brath ar spleáchais

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

Foirmíonn spleáchais crann — réitíonn FastAPI an slabhra iomlán. Seo an tslí agus a bhítear ag déanamh fíordheimhniú de ghnáth (spleáchais `get_current_user`).

## Spleáchais ranga agus atúsáil

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

## Cén fáth a bhí sé ábhartha

Tá ionjectúchán spleáchais ar an bhféidir is cumhachtaí agus is tábhachtaí FastAPI — seo an tslí agus a bhíonn tú ag roinnt agus ag atúsáil loighic go geal ar fud pointí deirí (seisiúin bhunachar sonraí, fíordheimhniú, paraiméadair choiteanna iarratas, seiceanna ceada) gan dhúbailt.

Tá sé riachtanach tuiscint a fháil air toisc go bhfuil sé i mbunus patrún bunúsach: is é an **spleáchais `yield`** an tslí chaighdeánach chun seisiúin bhunachar sonraí a bhainistiú (le cleanup rathaithe tar éis gach iarratas), agus is é an **spleáchais `get_current_user`** an tslí idiomaiteach chun fíordheimhniú a chur i bhfeidhm.

Déanann DI cód an-**intuigthe** freisin — is féidir leat spleáchais a fhorshríobh le mock-thúsanna i dtrialacha.

Déanann gréine an chórais (spleáchais a réitíonn a bparaiméadair féin ó an iarratas, is féidir leo a bheith ag brath ar spleáchais eile crann a fhoirmiú, agus comhpháirt leis na doiciméid) uirlis leaisteach ann chun feidhmchlár fíorúil a struchtúrú, mar sin tá é ríachtanach `Depends` a mháistiriú chun aplaicéid dea-eagraithe, inbhuan-choimeáda, intuigthe FastAPI a thógáil.