Kaip jūs struktūrizuojate didelę programą naudodami APIRouter?

Question

Accepted Answer

**`APIRouter`** leidžia padalinti didelę FastAPI programą į kelis modulius — kiekvienas maršrutizatorius sugrupuoja susijusius galapunktus (pvz., visus `/users` maršrutus), ir pagrindinė programa juos įtraukia. Tai padeda augančiai kodo bazei išlikti organizuotai ir lengvai priežiūrint.

## Maršrutizatoriaus apibrėžimas jo paties modulyje

```python
# routers/users.py
from fastapi import APIRouter

router = APIRouter(
    prefix="/users",          # all routes here start with /users
    tags=["users"],           # grouped under "users" in the docs
)

@router.get("/")              # GET /users/
def list_users(): ...

@router.get("/{user_id}")     # GET /users/{user_id}
def get_user(user_id: int): ...
```

`APIRouter` veikia kaip mini-programa — jame apibrėžiate kelio operacijas su tomis pačiomis dekoratūromis, ir `prefix` taikomas visiems.

## Maršrutizatorių įtraukimas į pagrindinę programą

```python
# main.py
from fastapi import FastAPI
from routers import users, items, auth

app = FastAPI()
app.include_router(users.router)     # mounts /users/* endpoints
app.include_router(items.router)
app.include_router(auth.router)
```

`app.include_router()` prijungia kiekvieno maršrutizatoriaus galapunktus prie pagrindinės programos — sujungia visą API iš modulinių dalių.

## Tipinė projekto struktūra

```text
app/
  main.py              # creates the app, includes routers
  routers/
    users.py           # APIRouter for /users
    items.py           # APIRouter for /items
    auth.py            # APIRouter for /auth
  models.py            # Pydantic models
  database.py          # DB setup
  dependencies.py      # shared dependencies
```

Kiekviena funkcija/sritis gauna savo maršrutizatoriaus modulį — saugodama susijusius maršrutus ir gerai organizuotą kodo bazę.

## Maršrutizatoriaus lygio priklausomybės ir konfigūracija

```python
router = APIRouter(
    prefix="/admin",
    dependencies=[Depends(verify_admin)],   # apply a dependency to ALL routes in the router
)
# you can also nest routers via include_router on a router
```

Maršrutizatoriai gali turėti bendrinamas priklausomybes (pvz., reikalauti administratoriaus autentifikavimo visai maršrutų grupei) — taikomos visiems jų galapunktams iš karto.

## Kodėl tai svarbu

`APIRouter` yra esminis bet kuriai ne trivialiai FastAPI programai kurti — be jo, visi galapunktai būtų viename faile, kuris tampa nevaldomu, kai API auga.

Šio supratimas svarbus **kodo organizacijai ir priežiūrai**: galapunktų padalijimas į su funkcijomis susijusius maršrutizatoriaus modulius (vartotojai, elementai, autentifikacija) leidžia laikyti susijusį kodą kartu, padaryt projektą lengviau navigacijai ir leidžia komandoms darbą su skirtingomis sritimis atlikti nepriklausomai.

`prefix` ir `tags` organizuoja maršrutus ir dokumentaciją, o **maršrutizatoriaus lygio priklausomybės** (pvz., reikalavimas administratoriaus autentifikavimo visai grupei) teikia švarų, grupės lygio elgesį.

Ši modulinė struktūra yra standartinė praktika tikrosioms FastAPI programoms, todėl `APIRouter` ir aplink ją esantys projekto organizavimo šablonai yra svarbus, praktiškai būtinas žinojimas kuriant mastelį išlaikančias, lengvai priežiūrimas API.