Blueprint

Wenn die Anwendung nur aus einer Datei besteht, ist es kein Problem, alle Routen zusammen zu schreiben.

Doch wenn die Funktionen wachsen—Benutzermodul, Artikelmodul, Admin-Backend—wird der Code schwer zu warten.

BlueprintEs ist die modulare Lösung, die Flask bietet, mit der Sie die Anwendung in unabhängige Funktionseinheiten aufteilen können.


Warum Blueprints benötigt werden

Das Kernproblem, das Blueprints lösen:

  • Code-OrganisationZusammengehörige Routen, Templates und statische Dateien gruppieren
  • WiederverwendbarkeitDerselbe Blueprint kann bei verschiedenen Anwendungen registriert werden oder mehrmals registriert werden (mit unterschiedlichen Präfixen)
  • Team-Zusammenarbeit: Verschiedene Entwickler sind für verschiedene Blueprint-Module verantwortlich, wodurch Konflikte reduziert werden.

Flask Blueprint 蓝图模块架构


Erstellen eines Blueprints

Verwendung eines BlueprintsBlueprintKlassenerstellung, Verwendung undFlaskSehr ähnlich—dieselben Routen-Decorators, dieselbe View-Funktions-Syntax:

Beispiel

# Dateipfad: auth.py (Blueprint für Benutzerauthentifizierung)
from flask import Blueprint, render_template, request, session, redirect, url_for

# Blueprint-Instanz erstellen
# Der erste Parameter "auth" ist der Name des Blueprints (wird für url_for-Referenzen verwendet)
# __name__ teilt dem Blueprint mit, wo Templates und statische Dateien zu finden sind
bp = Blueprint("auth", __name__)

# Verwende bp.route im Blueprint, nicht app.route
@bp.route("/login", methods=["GET", "POST"])
def login():
    if request.method == "POST":
        username = request.form.get("username", "")
        if username:
            session["username"] = username
            return redirect(url_for("blog.index"))
    return render_template("auth/login.html")

@bp.route("/register", methods=["GET", "POST"])
def register():
    if request.method == "POST":
        username = request.form.get("username", "")
        if username:
            return redirect(url_for("auth.login"))
    return render_template("auth/register.html")

@bp.route("/logout")
def logout():
    session.clear()
    return redirect(url_for("blog.index"))

Beispiel

# Dateipfad: blog.py (Blog-Blueprint)
from flask import Blueprint, render_template

bp = Blueprint("blog", __name__)

@bp.route("/")
def index():
    # Mock-Artikeldaten
    posts = [
        {"title": Einführung in Flask, "author": "example"},
        {"title": Blueprint erklärt, "author": "EXAMPLE"},
    ]
    return render_template("blog/index.html", posts=posts)

@bp.route("/create", methods=["GET", "POST"])
def create():
    return render_template("blog/create.html")

Registrieren des Blueprints

Ein Blueprint wird nach der Erstellung nicht automatisch wirksam; er muss in der Anwendung registriert werden:

Beispiel

# Dateipfad: app.py
from flask import Flask
from auth import bp as auth_bp
from blog import bp as blog_bp

app = Flask(__name__)
app.secret_key = "dev-secret-key"

# Blueprint bei der App registrieren
# url_prefix: fügt allen Routen im Blueprint ein gemeinsames Präfix hinzu
app.register_blueprint(auth_bp, url_prefix="/auth")
# Die Routen des Auth-Blueprints werden zu: /auth/login, /auth/logout, /auth/register

app.register_blueprint(blog_bp)
# Das Blog-Blueprint hat kein Präfix, die Routen bleiben: /, /create

Vollständige Routentabelle nach der Registrierung:

URL Blueprint Endpunkt (verwendet von url_for)
/ blog blog.index
/create blog blog.create
/auth/login auth auth.login
/auth/register auth auth.register
/auth/logout auth auth.logout

Nach der Registrierung des Blueprints muss inurl_for()beim Endpunkt der Blueprint-Name als Präfix hinzugefügt werden, zum Beispielurl_for("auth.login")statturl_for("login")。


Spezielle Verwendung von url_for in Blueprints

Innerhalb desselben Blueprints können Sie relative Referenzen verwenden, die mit einem Punkt beginnen:

Beispiel

# Innerhalb von auth.py ist die Verwendung relativer Referenzen sauberer
@bp.route("/")
def index():
    # Relative Referenzen innerhalb desselben Blueprints (mit einem Punkt beginnend)
    login_url = url_for(".login")       # Entspricht url_for("auth.login")
    register_url = url_for(".register") # Entspricht url_for("auth.register")
    # Das Referenzieren über Blueprints hinweg erfordert den vollständigen Endpunkt
    blog_url = url_for("blog.index")    # Referenziert den Index des Blog-Blueprints

Blueprint-Templates und statische Dateien

Blueprints können auch eigene Templates und statische Dateien haben.

Wenn ein Blueprint einen eigenen Template-Ordner hat, sucht Flask zuerst in dentemplatesder Anwendung danach und, falls nicht gefunden, dann in dem vom Blueprint angegebenen Ordner.

Beispiel

# Blueprint mit eigenem Template-Ordner erstellen
bp = Blueprint("auth", __name__, template_folder="templates")

# Blueprint-spezifische Template-Organisation
# Pfad: auth/templates/auth/login.html
# Beim Rendern: render_template("auth/login.html")
# Diese Organisation vermeidet Dateinamenskonflikte (login.html kann sich zwischen auth und blog unterscheiden)

Empfohlene Blueprint-Verzeichnisstruktur:

myflaskapp/
├── app.py              # 应用入口,注册蓝图
├── auth.py             # 认证蓝图
├── blog.py             # 博客蓝图
├── templates/          # 应用级模板(公共 base.html 等)
│   └── base.html
├── static/             # 应用级静态文件
│   └── style.css
├── auth/               # auth 蓝图的独立资源(可选)
│   └── templates/
│       └── auth/
│           ├── login.html
│           └── register.html
└── blog/               # blog 蓝图的独立资源(可选)
    └── templates/
        └── blog/
            ├── index.html
            └── create.html

Der einfachste Ansatz ist, keinen separaten Template-Ordner für das Blueprint zu konfigurieren und Templates einheitlich im Projektstammverzeichnis untertemplates/abzulegen, unterschieden durch Unterverzeichnisse:templates/auth/login.html、templates/blog/index.html。


Factory-Muster — create_app

Wenn Blueprints zunehmen, wird das direkte Erstellen auf der obersten Ebene des Modulsapp = Flask(__name__)auf Probleme mit zirkulären Importen stoßen.

Das Factory-Pattern ist die Best Practice zur Lösung dieses Problems:

Beispiel

# Dateipfad: app.py
from flask import Flask

def create_app():
    """Application-Factory-Funktion — gibt eine konfigurierte Flask-Instanz zurück"""
    app = Flask(__name__)
    app.secret_key = "dev-secret-key"

    # Konfiguration laden
    app.config.from_pyfile("config.py", silent=True)

    # Blueprints innerhalb der Funktion importieren, um zirkuläre Importe zu vermeiden
    from auth import bp as auth_bp
    from blog import bp as blog_bp

    # Blueprint registrieren
    app.register_blueprint(auth_bp, url_prefix="/auth")
    app.register_blueprint(blog_bp)

    return app

Vorteile des Factory-Patterns:

  • Zirkuläre Importe eliminierenBlueprints können importiert werdenapp,appMan kann auch Blueprints importieren, weil der Import innerhalb der Funktion erfolgt.
  • TestunterstützungApp-Instanzen können mit unterschiedlichen Konfigurationen für Tests erstellt werden
  • Multi-Instanz-BereitstellungDerselbe Code kann mehrere unabhängige App-Instanzen erstellen

Nach der Verwendung des Factory-Patterns musst duflask --app "app:create_app()" runstarten:

$ flask --app "app:create_app()" run

Weitere Funktionen in Blueprints

Blueprints unterstützen auch Dekoratoren wie before_request, errorhandler usw., und ihre Verwendung ist dieselbe wie bei der App:

Beispiel

@bp.before_request
def check_login():
    """Überprüfe den Anmeldestatus vor allen Anfragen im auth-Blueprint"""
    if request.endpoint not in ("auth.login", "auth.register"):
        if "username" not in session:
            return redirect(url_for("auth.login"))

@bp.errorhandler(404)
def not_found(error):
    """404-Fehlerseite speziell für den auth-Blueprint"""
    return render_template("auth/404.html"), 404

Blueprint'sbefore_requestEs wirkt sich nur auf die Routen innerhalb dieses Blueprints aus. Wenn Sie Logik vor allen Anfragen ausführen möchten, sollten Sieapp.before_request verwenden。

Weitere Erweiterungen