Intégration de base de données Flask
La plupart des applications web ont besoin d'un stockage de données persistant.
Ce chapitre utilise la base de données SQLite intégrée à Python pour montrer comment intégrer une base de données dans Flask sans installer de dépendances supplémentaires.
Démarrage rapide avec SQLite
SQLite est une base de données légère qui stocke les données dans un seul fichier, et est prise en charge par la bibliothèque standard de Python.
C'est le meilleur choix pour l'apprentissage et le prototypage—pas besoin d'installer un serveur de base de données ni de configurer quoi que ce soit.
Exemple
import sqlite3
# Se connecter à la base de données (example.db est automatiquement créé s'il n'existe pas)
conn = sqlite3.connect("example.db")
# row_factory rend les résultats de requête accessibles par nom de champ comme un dictionnaire
conn.row_factory = sqlite3.Row
# Créer une table
conn.execute("CREATE TABLE IF NOT EXISTS user (id INTEGER PRIMARY KEY, username TEXT UNIQUE, password TEXT)")
# Insérer des données
conn.execute("INSERT INTO user (username, password) VALUES (?, ?)", ("example", "pass123"))
conn.commit()
# Interroger des données
rows = conn.execute("SELECT * FROM user").fetchall()
for row in rows:
print(dict(row)) # Sortie : {'id': 1, 'username': 'example', 'password': 'pass123'}
conn.close()
Utilisation de l'objet g dans Flask pour gérer les connexions à la base de données
gC'est un objet spécial dont le cycle de vie est une seule requête.
Stocker la connexion à la base de donnéesgIl garantit que plusieurs opérations de base de données au sein de la même requête partagent la même connexion, qui est automatiquement nettoyée après la fin de la requête.
Exemple
import sqlite3
from flask import g, current_app
def get_db():
"""Obtenir une connexion à la base de données, réutilisée au sein de la même requête"""
if "db" not in g:
# Lire le chemin de la base de données à partir de la configuration
db_path = current_app.config.get("DATABASE", "example.db")
g.db = sqlite3.connect(db_path)
g.db.row_factory = sqlite3.Row # Autoriser l'accès aux résultats par nom de champ
return g.db
def close_db(error=None):
"""Ferme la connexion à la base de données (appelée automatiquement à la fin de la requête)"""
db = g.pop("db", None)
if db is not None:
db.close()
def init_db():
"""Initialiser la structure de la table de la base de données"""
db = get_db()
db.execute("""
CREATE TABLE IF NOT EXISTS user (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
password TEXT NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
""")
db.execute("""
CREATE TABLE IF NOT EXISTS post (
id INTEGER PRIMARY KEY AUTOINCREMENT,
title TEXT NOT NULL,
body TEXT NOT NULL,
author_id INTEGER NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (author_id) REFERENCES user (id)
)
""")
db.commit()
def init_app(app):
"""Enregistrer les fonctions liées à la base de données dans l'application Flask"""
# Fermer automatiquement la connexion à la base de données à la fin de la requête
app.teardown_appcontext(close_db)
# Enregistrer la commande CLI : flask init-db
app.cli.command("init-db")(init_db)
Intégration du patron de conception Factory
Utilisez le patron de fabrique pour intégrer la base de données aux autres modules :
Exemple
from flask import Flask
def create_app():
app = Flask(__name__)
app.secret_key = "dev-secret-key"
# Configurer le chemin de la base de données (stocké dans le dossier instance)
import os
app.config["DATABASE"] = os.path.join(app.instance_path, "example.db")
# S'assurer que le dossier instance existe
os.makedirs(app.instance_path, exist_ok=True)
# Initialiser la base de données
from db import init_app as init_db
init_db(app)
# Enregistrer le blueprint
from auth import bp as auth_bp
from blog import bp as blog_bp
app.register_blueprint(auth_bp, url_prefix="/auth")
app.register_blueprint(blog_bp)
return app
Écrivez une API de blog complète
Combinez la base de données pour implémenter les opérations CRUD (Create, Read, Update, Delete) sur les articles :
Exemple
from flask import Blueprint, request, jsonify, abort, g
from db import get_db
bp = Blueprint("blog", __name__)
@bp.get("/api/posts")
def list_posts():
"""Obtenir la liste de tous les articles"""
db = get_db()
posts = db.execute(
"SELECT p.id, p.title, p.body, p.created_at, u.username"
" FROM post p JOIN user u ON p.author_id = u.id"
" ORDER BY p.created_at DESC"
).fetchall()
# Convertir une liste d'objets Row en une liste de dictionnaires
return jsonify([dict(post) for post in posts])
@bp.get("/api/posts/<int:post_id>")
def get_post(post_id):
"""Obtenir les détails d'un seul article"""
db = get_db()
post = db.execute(
"SELECT id, title, body, created_at FROM post WHERE id = ?",
(post_id,)
).fetchone()
if post is None:
abort(404, description=f"L'article {post_id} n'existe pas")
return jsonify(dict(post))
@bp.post("/api/posts")
def create_post():
"""Créer un nouvel article"""
data = request.json
title = data.get("title", "").strip()
body = data.get("body", "").strip()
author_id = data.get("author_id", 1) # ID de l'auteur par défaut
if not title:
return jsonify({"error": "Le titre ne peut pas être vide"}), 400
db = get_db()
cursor = db.execute(
"INSERT INTO post (title, body, author_id) VALUES (?, ?, ?)",
(title, body, author_id)
)
db.commit()
return jsonify({"id": cursor.lastrowid, "title": title, "message": "Article créé avec succès"}), 201
@bp.put("/api/posts/<int:post_id>")
def update_post(post_id):
"""Mettre à jour un article"""
data = request.json
title = data.get("title", "").strip()
body = data.get("body", "").strip()
if not title:
return jsonify({"error": "Le titre ne peut pas être vide"}), 400
db = get_db()
db.execute(
"UPDATE post SET title = ?, body = ? WHERE id = ?",
(title, body, post_id)
)
db.commit()
return jsonify({"id": post_id, "message": "Article mis à jour avec succès"})
@bp.delete("/api/posts/<int:post_id>")
def delete_post(post_id):
"""Supprimer un article"""
db = get_db()
db.execute("DELETE FROM post WHERE id = ?", (post_id,))
db.commit()
return jsonify({"message": "Article supprimé"})
Tester l'API :
# 获取文章列表
$ curl http://127.0.0.1:5000/api/posts
# 创建文章
$ curl -X POST http://127.0.0.1:5000/api/posts \
-H "Content-Type: application/json" \
-d '{"title":"EXAMPLE 教程","body":"Flask 入门教程内容","author_id":1}'
# 更新文章
$ curl -X PUT http://127.0.0.1:5000/api/posts/1 \
-H "Content-Type: application/json" \
-d '{"title":"EXAMPLE 教程(修订版)","body":"更新后的内容"}'
# 删除文章
$ curl -X DELETE http://127.0.0.1:5000/api/posts/1
Bonnes pratiques: Lorsque l'API renvoie des données JSON, utilisez le bon code de statut HTTP—pour la création, utilisez201, utilisez200Utilisez pour les erreurs client400Utilisez pour les ressources inexistantes404Cela permet au code frontend de déterminer plus facilement le résultat de la requête.
Commande d'initialisation de la base de données
Via la CLI Flask, vous pouvez créer des commandes personnalisées pour initialiser la base de données :
# 初始化数据库(创建表结构) (.venv) $ flask init-db # 验证表已创建 (.venv) $ sqlite3 instance/example.db ".tables" post user
Protection contre l'injection SQL
L'utilisation de requêtes paramétrées (?Espaces réservés) est essentielle pour prévenir les injections SQL :
Exemple
# Le pilote SQLite échappe automatiquement les paramètres pour empêcher qu'une entrée malveillante soit exécutée en tant que SQL
db.execute("SELECT * FROM user WHERE username = ?", (username,))
# Approche incorrecte : Utiliser f-string pour concaténer du SQL (extrêmement dangereux !)
# db.execute(f"SELECT * FROM user WHERE username = '{username}'")
# Entrée malveillante '; DROP TABLE user; -- supprimerait toute la table !
Utilisation de Flask-SQLAlchemy (Lecture avancée facultative)
Pour les grands projets, écrire manuellement du SQL devient progressivement fastidieux.
Flask-SQLAlchemyC'est une extension très populaire qui fournit une capacité ORM (mapping objet-relationnel) :
Exemple
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///example.db"
db = SQLAlchemy(app)
# Définir le modèle de données (structure de table représentée par une classe Python)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return f"<User {self.username}>"
# Créer une table
with app.app_context():
db.create_all()
# Créer un utilisateur
user = User(username="example", email="test@example.com")
db.session.add(user)
db.session.commit()
# Interroger un utilisateur
users = User.query.all()
example_user = User.query.filter_by(username="example").first()
autres extensionsCe chapitre utilise SQLite natif pour éviter d'introduire des dépendances supplémentaires, ce qui le rend adapté à l'apprentissage et aux petits projets. Pour de vrais projets de production, nous recommandons d'utiliser SQLAlchemy ou un ORM similaire, ce qui peut considérablement réduire le code répétitif et améliorer la sécurité.