Flask 数据库操作

作者likuolei

直接回答

关键要点：
Flask 本身没有内置数据库支持，常用 Flask-SQLAlchemy 扩展与数据库交互，提供 ORM（对象关系映射）功能，简化数据库操作。以下是 Flask 数据库操作的核心概念和用法：

  • 安装 Flask-SQLAlchemy：
  pip install flask-sqlalchemy
  • 配置数据库：
  from flask import Flask
  from flask_sqlalchemy import SQLAlchemy

  app = Flask(__name__)
  app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
  app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
  db = SQLAlchemy(app)
  • 定义模型：
  class User(db.Model):
      id = db.Column(db.Integer, primary_key=True)
      username = db.Column(db.String(80), unique=True, nullable=False)
  • 创建数据库和表：
  with app.app_context():
      db.create_all()
  • 基本 CRUD 操作：
  @app.route('/add_user/<username>')
  def add_user(username):
      user = User(username=username)
      db.session.add(user)
      db.session.commit()
      return f'Added {username}'

  @app.route('/users')
  def get_users():
      users = User.query.all()
      return '<br>'.join([u.username for u in users])

注意事项：

  • 配置 SQLALCHEMY_DATABASE_URI 支持 SQLite、MySQL、PostgreSQL 等。
  • 使用 app.app_context() 确保数据库操作在应用上下文中。
  • 生产环境推荐 PostgreSQL 或 MySQL，结合 Gunicorn/Nginx 部署。

参考资源：

详细报告

Flask 的数据库操作通常通过 Flask-SQLAlchemy 扩展实现，结合 SQLAlchemy 提供强大的 ORM 功能，支持多种数据库（如 SQLite、MySQL、PostgreSQL）。本文详细讲解 Flask 数据库操作的概念、配置、模型定义、CRUD 操作及最佳实践，基于 2025 年 8 月 2 日的最新信息。

1. 什么是 Flask 数据库操作？

Flask 本身没有内置数据库支持，开发者需通过扩展（如 Flask-SQLAlchemy）与数据库交互。Flask-SQLAlchemy 封装了 SQLAlchemy 的 ORM 功能，允许：

  • 定义模型（Model）映射数据库表。
  • 执行 CRUD 操作（创建、读取、更新、删除）。
  • 支持多种数据库，配置灵活。
  • 集成 Flask 应用上下文，简化数据库操作。

2. 配置 Flask-SQLAlchemy

2.1 安装
pip install flask-sqlalchemy
  • 可选：安装数据库驱动（如 MySQL 用 pymysql 或 PostgreSQL 用 psycopg2）。
  pip install pymysql psycopg2-binary
2.2 配置

在 Flask 应用中初始化 SQLAlchemy：

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'  # SQLite 示例
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False  # 禁用追踪，节省资源
db = SQLAlchemy(app)
  • 数据库 URI：
  • SQLite：sqlite:///path/to/database.db
  • MySQL：mysql+pymysql://user:password@host/dbname
  • PostgreSQL：postgresql+psycopg2://user:password@host/dbname
  • 上下文：Flask-SQLAlchemy 要求数据库操作在应用上下文中执行。
2.3 初始化数据库

创建数据库和表：

with app.app_context():
    db.create_all()  # 创建所有定义的表
  • db.create_all()：根据模型创建表，需在应用上下文中运行。
  • 可手动运行或在应用启动时执行。

3. 定义模型

模型是 Python 类，映射数据库表，使用 db.Model 基类：

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}>'
  • db.Column：定义表列，指定数据类型（如 db.Integer、db.String）。
  • 常用参数：primary_key、unique、nullable。
  • __repr__：便于调试，定义模型的字符串表示。

关系（示例：一对多）：

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    content = db.Column(db.Text, nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    user = db.relationship('User', backref='posts')
  • db.ForeignKey：定义外键。
  • db.relationship：建立 ORM 关系，便于查询。

4. CRUD 操作

4.1 创建（Create）

添加新记录：

@app.route('/add_user/<username>/<email>')
def add_user(username, email):
    user = User(username=username, email=email)
    db.session.add(user)
    db.session.commit()
    return f'Added {username}'
  • db.session.add()：将对象添加到会话。
  • db.session.commit()：提交更改到数据库。
4.2 读取（Read）

查询数据：

@app.route('/users')
def get_users():
    users = User.query.all()  # 查询所有
    return '<br>'.join([u.username for u in users])

@app.route('/user/<username>')
def get_user(username):
    user = User.query.filter_by(username=username).first_or_404()
    return f'User: {user.username}, Email: {user.email}'
  • User.query：SQLAlchemy 查询对象。
  • filter_by：按条件过滤。
  • first_or_404()：返回第一条记录或抛出 404。
4.3 更新（Update）

修改记录：

@app.route('/update_user/<username>/<new_email>')
def update_user(username, new_email):
    user = User.query.filter_by(username=username).first_or_404()
    user.email = new_email
    db.session.commit()
    return f'Updated {username} email to {new_email}'
4.4 删除（Delete）

删除记录：

@app.route('/delete_user/<username>')
def delete_user(username):
    user = User.query.filter_by(username=username).first_or_404()
    db.session.delete(user)
    db.session.commit()
    return f'Deleted {username}'

5. 结合表单

结合 Flask-WTF 处理用户输入（参考前文表单处理）：

from flask import Flask, render_template, redirect, url_for
from flask_wtf import FlaskForm
from wtforms import StringField, SubmitField
from wtforms.validators import DataRequired
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)

class UserForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired()])
    submit = SubmitField('Add User')

@app.route('/add', methods=['GET', 'POST'])
def add_user():
    form = UserForm()
    if form.validate_on_submit():
        user = User(username=form.username.data)
        db.session.add(user)
        db.session.commit()
        return redirect(url_for('list_users'))
    return render_template('add_user.html', form=form)

@app.route('/users')
def list_users():
    users = User.query.all()
    return render_template('users.html', users=users)
  • templates/add_user.html：
  {% extends 'base.html' %}
  {% block content %}
      <h1>Add User</h1>
      <form method="post">
          {{ form.hidden_tag() }}
          {{ form.username.label }} {{ form.username() }}
          {{ form.submit() }}
      </form>
  {% endblock %}
  • templates/users.html：
  {% extends 'base.html' %}
  {% block content %}
      <h1>Users</h1>
      <ul>
      {% for user in users %}
          <li>{{ user.username }}</li>
      {% endfor %}
      </ul>
  {% endblock %}

6. 项目结构

推荐结构（参考前文）：

myproject/
├── app/
│   ├── __init__.py
│   ├── models/
│   │   ├── __init__.py
│   │   └── user.py
│   ├── forms/
│   │   ├── __init__.py
│   │   └── user.py
│   ├── templates/
│   │   ├── base.html
│   │   ├── add_user.html
│   │   └── users.html
│   ├── routes/
│   │   └── home.py
├── run.py
└── venv/

7. 高级功能

7.1 查询高级用法
  • 分页：
  @app.route('/users/<int:page>')
  def paginated_users(page):
      users = User.query.paginate(page=page, per_page=10)
      return render_template('users.html', users=users.items)
  • 复杂过滤：
  users = User.query.filter(User.username.like('%test%')).order_by(User.id.desc()).all()
7.2 数据库迁移

使用 Flask-Migrate 管理数据库结构变更：

pip install flask-migrate
  • 配置：
  from flask_migrate import Migrate
  db = SQLAlchemy(app)
  migrate = Migrate(app, db)
  • 初始化迁移：
  flask db init
  flask db migrate -m "Initial migration"
  flask db upgrade

8. 最佳实践

  • 应用上下文：始终在 app.app_context() 中执行数据库操作。
  • 模块化：模型定义在 models/，表单在 forms/，路由在 routes/。
  • 安全性：验证用户输入，防止 SQL 注入（ORM 自动处理）。
  • 生产数据库：使用 PostgreSQL 或 MySQL，SQLite 仅适合开发。
  • 迁移管理：使用 Flask-Migrate 跟踪表结构变更。

9. 注意事项

  • 上下文错误：缺少 app.app_context() 可能导致 No application found 错误。
  • 性能：大数据量查询使用分页或索引优化。
  • 生产环境：配置数据库连接池，部署时使用 Gunicorn/Nginx（参考前文）。
  • 事务管理：确保 db.session.commit() 或 db.session.rollback() 正确处理。

10. 参考资源

11. 结论

Flask 数据库操作通过 Flask-SQLAlchemy 提供便捷的 ORM 功能，支持模型定义和 CRUD 操作。结合 Flask-WTF 和 Flask-Migrate，可实现安全的表单处理和数据库迁移。开发者应遵循模块化设计和最佳实践，确保代码健壮性。本指南基于 2025 年 8 月 2 日的最新实践，为初学者和开发者提供清晰的 Flask 数据库操作指南。

类似文章

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注