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.
Erstellen eines Blueprints
Verwendung eines BlueprintsBlueprintKlassenerstellung, Verwendung undFlaskSehr ähnlich—dieselben Routen-Decorators, dieselbe View-Funktions-Syntax:
Beispiel
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
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
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
@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
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
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
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
Weitere ErweiterungenBlueprint'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。