Comment implémenter la connexion à la base de données et le traitement des transactions dans FastAPI

Comment implémenter la connexion à une base de données et le traitement des transactions dans FastAPI

Introduction :
Avec le développement rapide des applications Web, la connexion à la base de données et le traitement des transactions sont devenus un sujet très important. FastAPI est un framework Web Python hautes performances apprécié des développeurs pour sa rapidité et sa facilité d'utilisation. Dans cet article, nous présenterons comment implémenter des connexions et des transactions de base de données dans FastAPI pour vous aider à créer des applications Web fiables et efficaces.

Première partie : Connexion à la base de données
Dans FastAPI, divers outils de connexion à la base de données peuvent être utilisés, tels que SQLAlchemy et Tortoise-ORM. Nous utiliserons SQLAlchemy comme exemple pour démontrer.

1. Installer SQLAlchemy et le pilote MySQL
   Tout d'abord, nous devons installer la bibliothèque SQLAlchemy et le pilote MySQL correspondant. Vous pouvez l'installer à l'aide de la commande suivante :

pip install sqlalchemy
pip install mysql-connector-python

2. Créer une connexion à la base de données
   Dans l'application FastAPI, nous pouvons créer une connexion à la base de données dans l'application principale et l'injecter dans le gestionnaire de route. Voici un exemple de code :

from fastapi import Depends, FastAPI
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm.session import Session

app = FastAPI()

SQLALCHEMY_DATABASE_URL = "mysql+mysqlconnector://user:password@localhost/db_name"

engine = create_engine(
    SQLALCHEMY_DATABASE_URL,
    pool_size=10,
    max_overflow=20
)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

async def get_db() -> Session:
    try:
        db = SessionLocal()
        yield db
    finally:
        db.close()

Dans le code ci-dessus, nous créons d'abord l'URL de la connexion à la base de données, puis utilisons la fonction create_engine de SQLAlchemy pour créer le moteur de base de données. Ensuite, nous définissons une classe SessionLocal pour maintenir la session de base de données. Enfin, nous créons une fonction de dépendance get_db qui renverra une instance de session de base de données à utiliser dans chaque gestionnaire de requêtes.

Partie 2 : Traitement des transactions
Dans FastAPI, le traitement des transactions peut être utilisé pour garantir l'atomicité et la cohérence des opérations de base de données. Vous trouverez ci-dessous un exemple de code qui montre comment utiliser les transactions avec FastAPI.

1. Injecter la session de base de données à l'aide de dépendances
   Nous continuerons à utiliser la fonction de dépendance get_db que nous avons créée plus tôt dans cet exemple et injecterons la session de base de données dans le gestionnaire de route.

from fastapi import Depends, FastAPI
from sqlalchemy.orm import Session
from .models import User
from .crud import create_user
from .database import get_db

app = FastAPI()

@app.post("/users/")
async def create_user_handler(user: User, db: Session = Depends(get_db)):
    return create_user(db=db, user=user)

Dans le code ci-dessus, nous définissons un gestionnaire de route create_user_handler qui accepte un objet utilisateur et une session de base de données comme paramètres. Dans ce gestionnaire, nous appelons une fonction appelée create_user qui créera un nouvel utilisateur dans la base de données.

2. Implémentation du traitement des transactions
   Ce qui suit est le code d'un exemple de fonction create_user, qui montre comment utiliser le traitement des transactions dans une session de base de données :

from sqlalchemy.orm import Session
from .models import User

def create_user(db: Session, user: User):
    try:
        db.begin()
        db.add(user)
        db.commit()
        db.refresh(user)
        return user
    except:
        db.rollback()
        raise

Dans le code ci-dessus, nous démarrons d'abord une transaction en utilisant le db.begin( ) déclaration . Nous ajoutons ensuite l'objet utilisateur à la session de base de données à l'aide de l'instruction db.add(). Ensuite, nous validons la transaction dans la base de données à l'aide de l'instruction db.commit(). Si une erreur se produit pendant le processus de validation, nous utilisons l'instruction db.rollback() pour annuler la transaction. Enfin, nous actualisons l'objet utilisateur à l'aide de l'instruction db.refresh() pour nous assurer qu'il contient la valeur de clé primaire générée dans la base de données.

Conclusion :
Dans cet article, nous avons présenté comment implémenter la connexion à la base de données et le traitement des transactions dans FastAPI. Nous avons d'abord créé la connexion à la base de données à l'aide de SQLAlchemy, puis avons utilisé la fonction de dépendance pour injecter la session de base de données dans le gestionnaire de route. Ensuite, nous avons montré comment utiliser les transactions au sein d'une session de base de données pour garantir l'atomicité et la cohérence des opérations de base de données. En apprenant et en pratiquant ces techniques, vous serez en mesure de créer des applications Web fiables et efficaces.

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!