Comment parvenir à une répartition raisonnable et à une organisation modulaire des requêtes dans FastAPI

Comment parvenir à une répartition raisonnable et à une organisation modulaire des requêtes dans FastAPI

Introduction :
FastAPI est un framework Web hautes performances basé sur Python, qui fournit un support asynchrone et une génération automatisée de documents API. Ainsi, lors du développement de grands projets, nous devons prendre en compte comment diviser et modulariser raisonnablement les demandes. Cet article présentera une méthode pour réaliser une répartition raisonnable et une organisation modulaire des requêtes dans FastAPI, et donnera des exemples de code correspondants.

1. Pourquoi nous avons besoin d'une répartition raisonnable et d'une organisation modulaire des demandes
À mesure que l'ampleur du projet augmente, le nombre et la complexité des API augmenteront également. Si toutes les fonctions de traitement des requêtes sont écrites dans un seul fichier, le code sera long, peu lisible et difficile à maintenir. De plus, si une requête implique le fonctionnement de plusieurs tables de base de données, la logique peut être séparée par un fractionnement raisonnable pour réduire le couplage.

2. Comment diviser et modulariser raisonnablement les demandes

1. Créez un dossier d'application pour stocker toutes les fonctions de traitement des demandes.
2. Dans le dossier app, créez un fichier nommé main.py pour définir l'application d'instance d'application FastAPI. L'exemple de code
   main.py est le suivant :

from fastapi import FastAPI

app = FastAPI()

# 引入其他模块中的路由
from app import module1, module2
app.include_router(module1.router)
app.include_router(module2.router)

3. Dans le dossier de l'application, créez plusieurs fichiers modulaires pour stocker les fonctions de traitement des requêtes correspondantes.
   Prenons module1.py comme exemple. L'exemple de code est le suivant :

from fastapi import APIRouter

router = APIRouter()

@router.get("/api/module1/")
def module1_handler():
    return {"message": "This is module 1."}

4. Dans chaque fichier modulaire, un fractionnement supplémentaire peut être effectué en fonction des besoins.
   Prenons module2.py comme exemple. L'exemple de code est le suivant :

from fastapi import APIRouter

router = APIRouter()

@router.get("/api/module2/")
def module2_handler():
    return {"message": "This is module 2."}

@router.get("/api/module2/{id}")
def module2_detail_handler(id: int):
    return {"message": f"This is detail page of module 2 with id {id}."}

5. Enfin, introduisez les fichiers modulaires et ajoutez des routes dans le fichier principal main.py.

from fastapi import FastAPI

app = FastAPI()

from app import module1, module2
app.include_router(module1.router)
app.include_router(module2.router)

3. Résumé
En divisant et modularisant raisonnablement les demandes, la structure du code peut être rendue plus claire, une séparation logique peut être obtenue et la lisibilité et la maintenabilité du code peuvent être améliorées. Dans FastAPI, nous pouvons utiliser APIRouter pour créer des routes modulaires et les ajouter à l'application via app.include_router(). Cette approche peut nous aider à mieux organiser et gérer les fonctions de traitement des demandes.

Référence :
https://fastapi.tiangolo.com/tutorial/bigger-applications/

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!