Skip to content

2. Aktionen, Routing, Antworten

Dieses Kapitel untersucht den Weg einer Anfrage vom Browser bis zu der Aktion, die sie verarbeitet, sowie die Antwort, die diese Aktion zurückgibt. Views werden erst in Kapitel 4 eingeführt: Hier geben die Aktionen direkt Text oder JSON zurück.

2.1. Beispiel 01: Der Aufbau einer Flask-Anwendung

Das erste Beispiel ist die kleinstmögliche [Flask]-Anwendung: eine einzige Datei.

01-structure/
└── app.py

2.1.1. Die Datei app.py

# app.py: die kleinstmögliche Flask-Anwendung
from flask import Flask

# die Anwendung: ein Objekt der Klasse Flask. __name__ (hier "__main__" oder "app")
# teilt Flask mit, wo sich die Anwendung befindet, damit es dort nach seinen Dateien suchen kann
app = Flask(__name__)


# eine Action (Flask spricht von einer "View"): die Funktion, die für die Anfrage GET / aufgerufen wird
@app.get("/")
def index():
    # der von der Funktion zurückgegebene Wert IST die an den Browser gesendete Antwort
    return "Hello from Flask!"


# wird nur ausgeführt, wenn die Datei selbst gestartet wird: python app.py
if __name__ == "__main__":
    # der Entwicklungsserver: http://localhost:5000; Strg-C beendet ihn.
    # debug=True: automatisches Neuladen nach einer Änderung und eine Debugging-
    # Seite im Fehlerfall (NIEMALS in der Produktion)
    app.run(port=5000, debug=True)

Gehen wir diesen Code Schritt für Schritt durch:

  • Zeile 2: importiert die Klasse [Flask] aus dem Paket [flask], das von [pip] in der virtuellen Umgebung installiert wurde. In [Python] ist eine Datei mit der Endung [.py] ein Modul, und ein Modul verwendet nur die Namen, die es selbst importiert oder definiert hat (abgesehen von den eingebauten Funktionen der Sprache, etwa [print] oder [len]);
  • Zeile 6: die Anwendung, ein Objekt der Klasse [Flask]. Sie empfängt die Anfragen und wählt die Funktion aus, die jede davon verarbeitet. Der Parameter ist der Name des aktuellen Moduls, den [Python] in der Variablen [__name__] ablegt: [Flask] nutzt ihn, um den Anwendungsordner zu finden, in dem es später die Views (Ordner [templates]) und die statischen Dateien (Ordner [static]) sucht;
  • Zeile 10: [@app.get("/")] ist ein Dekorator. Ein Dekorator wird als [@expression] unmittelbar vor der Definition einer Funktion (oder einer Klasse) geschrieben; [Python] ruft den Ausdruck mit der Funktion als Parameter auf, wenn es die Definition ausführt. Hier registriert [app.get("/")] die Funktion [index] in der Anwendung: Sie verarbeitet Anfragen für [GET /]. Das ist das Routing. Eine Funktion, die auf diese Weise mit einer Route verknüpft ist, ist eine Aktion (die Dokumentation von [Flask] bezeichnet sie als View-Funktion; siehe die Einführung);
  • Zeilen 11–13: Die Aktion gibt eine Zeichenkette zurück. Der von einer Aktion zurückgegebene Wert ist die an den Browser gesendete Antwort: [Flask] legt ihn in den Rumpf der HTTP-Antwort. Nach Konvention werden Funktionsnamen ([Python]) in Kleinbuchstaben geschrieben, wobei die Wörter durch Unterstriche getrennt werden ([action01_post]);
  • Zeile 17: Wenn die Datei selbst ausgeführt wird ([python app.py]), [Python] weist der Variablen [__name__] den Wert ["__main__"] zu; wird das Modul von einem anderen Modul importiert, ist sie auf den Namen des Moduls gesetzt (["app"]). Dieser in [Python] sehr verbreitete Test reserviert den restlichen Code also für den Fall, dass die Datei direkt gestartet wird;
  • Zeile 21: [app.run] startet den [Werkzeug] -Entwicklungsserver, der auf Port 5000 des Rechners auf Anfragen lauscht (5000 ist der Standardwert), bis er mit [Ctrl-C] gestoppt wird. [debug=True] aktiviert den Debug-Modus: Der Server überwacht die Dateien der Anwendung und startet sie neu, sobald eine davon geändert wird; eine nicht behandelte Ausnahme zeigt eine Debug-Seite an (siehe Beispiel 03). Dieser Modus ist für die Entwicklung gedacht, und nur dafür: Die Debug-Seite erlaubt es, [Python]-Code auf dem Server auszuführen.

2.1.2. Ausführung

Geben Sie in einem Terminalfenster, das im Ordner [01-structure] geöffnet ist, bei aktivierter virtueller Umgebung der Beispiele [python app.py] ein. [Flask] zeigt seine Startmeldungen an:

1
2
3
4
5
6
7
8
 * Serving Flask app 'app'
 * Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:5000
Press CTRL+C to quit
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 332-612-699

Die Meldungen zeigen den Namen der Anwendung, den Debug-Modus, die Lauschadresse und den Port. [127.0.0.1] ist die Adresse des Rechners selbst ([localhost]): Der Server akzeptiert nur Anfragen von diesem Rechner, was für die Entwicklung geeignet ist ([app.run(host="0.0.0.0")] würde ihn für andere Rechner im Netzwerk öffnen). Die Zeile [Restarting with stat] zeigt den Mechanismus des automatischen Neuladens an: Der von [python app.py] gestartete Prozess überwacht lediglich die Dateien; er startet die Anwendung in einem separaten Prozess, den er bei jeder Änderung neu startet. Die „PIN“ schützt die [Python]-Konsole vor der Debug-Seite.

Es gibt eine zweite Möglichkeit, eine Anwendung zu starten: den Befehl [flask], der zusammen mit [Flask] in der virtuellen Umgebung installiert wird:

flask --app app run --debug

Die Option [--app] gibt das Anwendungsmodul an ([app], also die Datei [app.py]), [run] startet den Entwicklungsserver, und [--debug] aktiviert den Debug-Modus; [--port 5001] würde den Port ändern. Der Befehl selbst sucht im Modul das [Flask] -Objekt mit dem Namen [app] (oder, wie wir in Beispiel 02 sehen werden, eine Funktion namens [create_app]). Damit ist der Test [if __name__ == "__main__"] nicht mehr nötig. Die Beispiele verwenden [python app.py], das sich leichter merken lässt; die Fallstudie wird es genauso halten.

Fordern wir die URL [http://localhost:5000/] mit einem Browser an:

Image

dann mit [curl]. Die Option [-i] zeigt zusätzlich die HTTP-Header der Antwort an:

curl -i http://localhost:5000/
1
2
3
4
5
6
7
8
HTTP/1.1 200 OK
Server: Werkzeug/3.1.8 Python/3.13.7
Date: Sat, 26 Sep 2026 13:22:44 GMT
Content-Type: text/html; charset=utf-8
Content-Length: 17
Connection: close

Hello from Flask!

Die erste Zeile der Antwort enthält die Protokollversion, den Statuscode (200) und seine Bezeichnung ([OK]). Es folgen die Header: der Servername, das Datum, der Inhaltstyp, die Inhaltslänge in Bytes und [Connection: close] (der Entwicklungsserver schließt die Verbindung nach jeder Antwort). Eine Leerzeile trennt die Header vom Rumpf der Antwort. Im weiteren Verlauf dieses Dokuments geben wir die Header [Server], [Date] und [Connection] nicht mehr an, da sie sich nicht ändern.

Der Header [Content-Type: text/html; charset=utf-8] gibt an, dass die Antwort im Format HTML vorliegt und ihre Zeichen in UTF-8 codiert sind. Dies ist die Standardcodierung ([Flask]) für jede von einer Aktion zurückgegebene Zeichenkette: Der Browser interpretiert die Zeichenkette daher als HTML (hier, ohne Tag, wird sie unverändert angezeigt). Beispiel 03 zeigt, wie man einen anderen Inhaltstyp angibt.

Für jede Anfrage zeigt die Serverkonsole eine Log-Zeile an: die Adresse des Clients, das Datum, die Anfrage und den Antwortcode.

127.0.0.1 - - [26/Sep/2026 15:22:44] "GET / HTTP/1.1" 200 -

2.2. Beispiel 02: Routing

Das Routing ordnet einer URL und einer Methode (HTTP, GET, POST ...) eine Aktion zu. Beispiel 02 organisiert diese Aktionen in zwei Dateien:

1
2
3
4
5
6
02-routing/
├── controllers/
│   ├── __init__.py
│   ├── first.py
│   └── home.py
└── app.py

Der Ordner [controllers] ist ein [Python] -Paket (siehe Einführung). Jedes dieser beiden Module definiert einen Blueprint: eine Gruppe von Routen, die die Anwendung anschließend registriert. Das ist das [Flask]-Äquivalent der Controller-Klassen in [Spring MVC] oder [ASP.NET Core MVC].

2.2.1. Die Anwendung: app.py

# app.py: die Anwendung, von einer "Factory" erstellt
from flask import Flask

from controllers.home import home
from controllers.first import first


# die Factory: eine Funktion, die die Anwendung erstellt und konfiguriert
def create_app():
    app = Flask(__name__)
    # jeder Blueprint (eine Gruppe von Routen) wird bei der Anwendung registriert
    app.register_blueprint(home)
    app.register_blueprint(first)
    return app


if __name__ == "__main__":
    create_app().run(port=5000, debug=True)
  • Zeilen 4–5: Importieren die beiden Blueprints, die Objekte [home] und [first], aus den Modulen [controllers/home.py] und [controllers/first.py];
  • Zeilen 9–14: Die Anwendung ist keine beim Import erzeugte Modulvariable mehr; sie wird von einer Funktion erstellt, die man als *Factory* bezeichnet. Dies ist der in der [Flask]-Dokumentation empfohlene Ansatz, dem alle folgenden Beispiele folgen: Die Konfiguration der Anwendung ist an einer einzigen Stelle gebündelt, und es lassen sich mehrere Anwendungen mit unterschiedlichen Konfigurationen erstellen (zum Beispiel für Tests). Der Befehl [flask --app app run] erkennt dies: Fehlt eine Variable [app], ruft er die Funktion [create_app] des Moduls auf;
  • Zeilen 12–13: Jeder Blueprint wird in der Anwendung registriert ; seine Routen werden zu Routen der Anwendung;
  • Zeile 18: Die Anwendung wird erstellt, dann wird der Server gestartet.

2.2.2. Der Blueprint „home“: controllers/home.py

# controllers/home.py: die Startseite
from flask import Blueprint

# ein Blueprint: eine Menge von Routen, die anschließend in der Anwendung registriert wird.
# "home": sein Name; __name__: das Modul, in dem er definiert ist
home = Blueprint("home", __name__)


# GET /: eine HTML-Seite, die Links zu den anderen Actions enthält.
# Ein von einer Action zurückgegebener String wird mit dem Typ text/html gesendet
@home.get("/")
def index():
    return """
        <h2>Example 02 - routing</h2>
        <ul>
          <li><a href="/first">/first</a></li>
          <li><a href="/first/action01">/first/action01</a></li>
          <li><a href="/first/products/17">/first/products/17</a></li>
          <li><a href="/first/products/17/reviews/3">/first/products/17/reviews/3</a></li>
          <li><a href="/first/files/images/logo.png">/first/files/images/logo.png</a></li>
          <li><a href="/first/products/abc">/first/products/abc</a></li>
          <li><a href="/unknown">/unknown</a></li>
        </ul>
        """
  • Zeile 6: der Blueprint. Sein erster Parameter ist sein Name, [home]: Er dient dazu, seine Aktionen zu identifizieren ([home.index], siehe Beispiel 04). Der zweite Parameter ist, wie bei der Anwendung, der Modulname;
  • Zeile 11: Ein Blueprint hat dieselben Dekoratoren wie die Anwendung: Die Aktion [index] verarbeitet [GET /];
  • Zeilen 13–23: Eine in dreifache Anführungszeichen gesetzte Zeichenkette kann sich über mehrere Zeilen erstrecken und Anführungszeichen enthalten. Die Aktion gibt HTML zurück, das mit dem Typ [text/html] gesendet wird (siehe Beispiel 01).

Die Aktion [index] gibt somit eine HTML-Seite zurück, die Links auf die Aktionen des anderen Blueprints enthält:

Image

2.2.3. Der erste Blueprint: controllers/first.py

# controllers/first.py: ein Blueprint, dessen Routen alle mit /first beginnen
from flask import Blueprint

# url_prefix: Präfix, das alle Routen des Blueprints gemeinsam haben
first = Blueprint("first", __name__, url_prefix="/first")


# GET /first: die Route "" bezeichnet das Präfix selbst
@first.get("")
def index():
    return "Action [index] of the [first] blueprint"


# GET /first/action01
@first.get("/action01")
def action01():
    return "Action [action01] of the [first] blueprint, GET request"


# POST /first/action01: gleicher Pfad, andere HTTP-Methode, andere Funktion
@first.post("/action01")
def action01_post():
    return "Action [action01_post] of the [first] blueprint, POST request"


# GET /first/products/17: <int:id> ist eine Pfadvariable;
# der Konverter [int] akzeptiert nur Ziffern und liefert eine Ganzzahl
@first.get("/products/<int:id>")
def product(id):
    return f"Product no. {id}"


# GET /first/products/17/reviews/3: zwei Pfadvariablen
@first.get("/products/<int:id>/reviews/<int:number>")
def review(id, number):
    return f"Review no. {number} of product no. {id}"


# GET /first/files/...: der Konverter [path] akzeptiert jedes Pfadende,
# einschließlich Schrägstrichen
@first.get("/files/<path:path>")
def file(path):
    return f"Requested file: {path}"

Gehen wir diesen Code Schritt für Schritt durch:

  • Zeile 5: Der Parameter [url_prefix] legt das allen Routen des Blueprints gemeinsame Präfix fest: Seine Aktionen verarbeiten URL-Routen, die mit [/first] beginnen;
  • Zeilen 9–10: Die Route [""] bezeichnet das Präfix selbst: Die Aktion [index] verarbeitet [GET /first]. Die URL einer Aktion ist die Verkettung des Präfixes des Blueprints und des Pfads ihrer Route. Der Name der Aktion ([index]) kann in einem anderen Blueprint derselbe sein: [Flask] unterscheidet sie anhand des Blueprint-Namens ([first.index], [home.index]);
  • Zeilen 15–16: Die Aktion [action01] verarbeitet [GET /first/action01];
  • Zeilen 21–22: derselbe Pfad, aber für die Methode POST: Der Dekorator [post] ersetzt [get]. Es gibt außerdem [put], [delete] und [patch] sowie den allgemeinen Dekorator [route], der eine Liste von Methoden akzeptiert: [@first.route("/action01", methods=["GET", "POST"])]. Innerhalb desselben Moduls dürfen zwei Funktionen nicht denselben Namen haben (die zweite würde die erste ersetzen): daher der Name [action01_post];
  • Zeilen 28–30: [<int:id>] ist eine Pfadvariable: Dieses URL-Segment kann mehrere Werte annehmen. [int] ist ein Konverter: Das Segment muss aus Ziffern bestehen, andernfalls passt die Route nicht; sein Wert wird in eine Ganzzahl umgewandelt und dann an den gleichnamigen Parameter der Aktion übergeben, [id]. Für [/first/products/17] ist [id] gleich der Zahl 17. Das ist Data-Binding (*data binding*), das das nächste Kapitel ausführlich behandelt. Ohne Konverter ([<id>]) akzeptiert die Variable jeden Text ohne Schrägstrich und bleibt eine Zeichenkette. [Werkzeug] stellt außerdem die Konverter [float], [uuid] und [path] bereit, und Beispiel 12 zeigt, wie man eigene schreibt;
  • Zeile 30: ein f-String (das Präfix [f]): Jeder Ausdruck in geschweiften Klammern wird ausgewertet, und sein Wert wird in den Text eingefügt;
  • Zeilen 34–36: zwei Pfadvariablen, die als zwei Parameter an die Aktion übergeben werden;
  • Zeilen 41–43: Der Konverter [path] akzeptiert jedes URL-Ende, einschließlich [/].

2.2.4. Ausführung

Hier sind die Antworten auf einige Anfragen:

curl -i http://localhost:5000/first
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 39

Action [index] of the [first] blueprint
curl -i http://localhost:5000/first/products/17/reviews/3
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 30

Review no. 3 of product no. 17

Der Text ist 30 Zeichen lang, und die Antwort ebenso in Bytes: In UTF-8 belegt jedes dieser (ASCII-)Zeichen ein Byte.

curl -i http://localhost:5000/first/files/images/logo.png
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 31

Requested file: images/logo.png

Um eine Anfrage mit POST zu senden, verwenden Sie die Option [-X POST] von [curl]:

curl -i -X POST http://localhost:5000/first/action01
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 61

Action [action01_post] of the [first] blueprint, POST request

Eine HTTP-Methode, die von keiner Aktion für diesen Pfad verarbeitet wird, führt zu einem Fehler 405 ([Method Not Allowed]). Der Header [Allow] listet die akzeptierten Methoden auf; [Flask] fügt [HEAD] (dieselbe Anfrage wie GET, ohne Antwortrumpf) und [OPTIONS] (die Liste der akzeptierten Methoden) hinzu, die es für jede GET-Route selbst verarbeitet:

curl -i -X PUT http://localhost:5000/first/action01
HTTP/1.1 405 METHOD NOT ALLOWED
Content-Type: text/html; charset=utf-8
Allow: HEAD, OPTIONS, POST, GET
Content-Length: 153

<!doctype html>
<html lang=en>
<title>405 Method Not Allowed</title>
<h1>Method Not Allowed</h1>
<p>The method is not allowed for the requested URL.</p>

Schließlich führt eine URL, die keine Route verarbeitet, zu einem Fehler 404. Das gilt auch für einen Bezeichner, der keine Ganzzahl ist: Keine Route passt zu [/first/products/abc].

curl -i http://localhost:5000/first/products/abc
1
2
3
4
5
6
7
8
9
HTTP/1.1 404 NOT FOUND
Content-Type: text/html; charset=utf-8
Content-Length: 207

<!doctype html>
<html lang=en>
<title>404 Not Found</title>
<h1>Not Found</h1>
<p>The requested URL was not found on the server. If you entered the URL manually please check your spelling and try again.</p>

Die Fehlerantworten von [Flask] (genauer gesagt von [Werkzeug]) sind kurze HTML-Seiten in englischer Sprache. In einem Browser:

Image

Kapitel 7 zeigt, wie man sie durch anwendungsspezifische Seiten ersetzt. Beachten Sie außerdem, dass [Flask] zwischen [/first] und [/first/] unterscheidet: Die letztgenannte URL führt ebenfalls zu einem Fehler 404, weil keine Route mit einem Schrägstrich endet. Umgekehrt akzeptiert eine mit abschließendem Schrägstrich deklarierte Route ([@first.get("/list/")]) auch die URL ohne Schrägstrich, über eine Weiterleitung.

Der Befehl [flask routes], im Ordner des Beispiels ausgeführt, listet alle Routen der Anwendung auf:

flask --app app routes
Endpoint             Methods  Rule
-------------------  -------  ---------------------------------------------
first.action01       GET      /first/action01
first.action01_post  POST     /first/action01
first.file           GET      /first/files/<path:path>
first.index          GET      /first
first.product        GET      /first/products/<int:id>
first.review         GET      /first/products/<int:id>/reviews/<int:number>
home.index           GET      /
static               GET      /static/<path:filename>

Die Spalte [Endpoint] listet den Namen jeder Route auf: den Namen des Blueprints, einen Punkt und den Funktionsnamen. Die letzte Route, [static], wird von [Flask] selbst erstellt: Sie liefert die Dateien aus dem Ordner [static] der Anwendung aus (siehe Beispiel 15).

2.3. Beispiel 03: Antworten einer Aktion

Was eine Aktion zurückgibt, bestimmt die HTTP-Antwort. Beispiel 03 geht die wichtigsten Fälle durch. Die Datei [app.py]:

# app.py: die Anwendung von Beispiel 03
from flask import Flask

from controllers.responses import responses


def create_app():
    app = Flask(__name__)
    # das erzeugte JSON behält Akzentzeichen unverändert bei ("é" und nicht
    # "é") sowie die Schlüssel in ihrer ursprünglichen Reihenfolge (nicht sortiert)
    app.json.ensure_ascii = False
    app.json.sort_keys = False
    app.register_blueprint(responses)
    return app


if __name__ == "__main__":
    create_app().run(port=5000, debug=True)
  • Zeilen 11–12: zwei Einstellungen für den JSON-Provider der Anwendung ([app.json]), das Objekt, das [Python]-Objekte in JSON umwandelt. Standardmäßig schreibt er Nicht-ASCII-Zeichen als Escape-Sequenzen ([é] wird zu [\u00e9], was gültiges JSON, aber wenig lesbar ist), und er sortiert die Dictionary-Schlüssel alphabetisch. Wir behalten die Zeichen unverändert bei, und die Schlüssel in der Reihenfolge, in der die Aktion sie geschrieben hat.

Die Datei [controllers/responses.py]:

# controllers/responses.py: die verschiedenen Antworten einer Action
import asyncio
import time
from dataclasses import dataclass

from flask import Blueprint, Response, abort, jsonify

responses = Blueprint("responses", __name__, url_prefix="/responses")


# ein String, als reiner Text angekündigt: der Browser zeigt ihn unverändert an.
# Response: die vollständige Antwort, von der Action selbst erstellt
@responses.get("/text")
def text():
    return Response("<h1>Action [text]</h1>", mimetype="text/plain")


# ein einzelner String: Flask sendet ihn mit dem Typ text/html; der Browser interpretiert ihn
@responses.get("/html")
def html():
    return "<h1>Action [html]</h1>"


# eine Dataclass: eine Datenklasse (siehe Beispiel 06), hier im Modul deklariert
@dataclass
class Person:
    last_name: str
    first_name: str
    age: int


# ein Objekt: jsonify serialisiert es zu JSON, mit dem Typ [application/json]
@responses.get("/json")
def json():
    return jsonify(Person("Martin", "Jean", 42))


# ein unverändert zurückgegebenes Dictionary: Flask serialisiert es selbst zu JSON
@responses.get("/dictionary")
def dictionary():
    return {"last_name": "Martin", "first_name": "Jean", "age": 42}


# eine Liste: wird zu einem JSON-Array serialisiert
@responses.get("/list")
def list():
    return ["Mme", "Melle", "Mr"]


# ein Tupel (Inhalt, Code): der Code 201 (Created) statt 200 (OK)
@responses.get("/created")
def created():
    return {"message": "resource created"}, 201


# keine Antwort: der Code 204 (No Content) bedeutet "nichts anzuzeigen"
@responses.get("/empty")
def empty():
    return "", 204


# eine asynchrone Action (async def): Flask wartet auf das Ende der Coroutine.
# Sie benötigt das Extra [async] von Flask: pip install "flask[async]"
@responses.get("/task")
async def task():
    start = time.perf_counter()
    await asyncio.sleep(0.5)  # 500 ms warten, ohne die Ereignisschleife zu blockieren
    return {"wait": f"{round((time.perf_counter() - start) * 1000)} ms"}


# ein "erwarteter" Fehler: das Tupel (Inhalt, 404) erzeugt eine 404-Antwort
@responses.get("/not-found")
def not_found():
    return {"message": "This resource does not exist"}, 404


# dasselbe mit abort: eine HTTP-Exception, die Flask in eine 404-Antwort umwandelt
@responses.get("/abort")
def abort_action():
    abort(404, "This resource does not exist either")


# ein "unerwarteter" Fehler: eine unbehandelte Exception erzeugt eine 500-Antwort
@responses.get("/exception")
def exception():
    raise RuntimeError("An unexpected error")

Kommentieren wir diesen Code:

  • Zeilen 13–15: Die Klasse [Response] stellt eine vollständige HTTP-Antwort dar. Die Aktion erstellt sie selbst: den Rumpf und den Typ ([mimetype]), hier [text/plain] (reiner Text). Der Browser interpretiert die Tags nicht;
  • Zeilen 19–21: dieselbe Zeichenkette, für sich allein zurückgegeben: [Flask] sendet sie mit dem Typ [text/html], und der Browser interpretiert sie;
  • Zeilen 25–29: eine Dataclass – eine Klasse, in der nur die Felder und ihre Typen deklariert werden; der Dekorator [@dataclass] schreibt den Konstruktor ([Person("Martin", "Jean", 42)]), die Textdarstellung und den Objektvergleich selbst. Beispiel 06 greift dies wieder auf;
  • Zeilen 33–35: Die Funktion [jsonify] wandelt ihren Parameter in JSON um und erzeugt eine Antwort vom Typ [application/json]. Der JSON-Provider von [Flask] kann Dictionaries, Listen, Zeichenketten, Zahlen, Boolesche Werte, [None] (wird zu [null]) sowie Dataclasses, Datumsangaben und [Decimal] -Zahlen umwandeln (siehe Beispiel 06);
  • Zeilen 39–41: noch einfacher: Eine Aktion, die ein Dictionary (oder eine Liste, Zeilen 45–47) zurückgibt, erzeugt eine JSON-Antwort, ohne [jsonify] aufzurufen. Eine Dataclass dagegen muss über [jsonify] laufen: Würde sie für sich allein zurückgegeben, führte das zu einem Fehler („The view function did not return a valid response“);
  • Zeilen 51–53: Eine Aktion kann ein Tupel [(content, code)] zurückgeben: Der Statuscode 201 ([Created]) ersetzt den Statuscode 200. Ein Tupel kann auch Header enthalten: [(content, code, {"X-Example": "03"})];
  • Zeilen 57–59: Der Code 204 ([No Content]) bedeutet „nichts anzuzeigen“: Die Antwort hat keinen Rumpf;
  • Zeilen 64–68: eine asynchrone Aktion, deklariert mit [async def]. Das Schlüsselwort [await] setzt die Coroutine während des Wartens aus ([asyncio.sleep]), ohne das Programm zu blockieren. [Flask] führt die Aktion in einer für die Anfrage erzeugten Ereignisschleife aus und wartet auf ihr Ergebnis: Das ist nützlich, um mehrere Wartevorgänge parallel zu starten (zum Beispiel mehrere Aufrufe von Webservices), macht aber [Flask] selbst nicht asynchron. Sie müssen die Erweiterung [[async]] von [Flask] installieren (siehe [requirements.txt]);
  • Zeilen 72–74: ein „erwarteter“ Fehler: Das Tupel [(content, 404)] gibt eine 404-Antwort zurück ([Not Found]) mit einem von der Aktion gewählten Rumpf (JSON);
  • Zeilen 78–80: derselbe Fehler, erzeugt durch die Funktion [abort]. [abort] gibt nichts zurück: Sie löst eine Ausnahme aus ([NotFound], für den Code 404), die die Aktion beendet; [Flask] wandelt sie in eine Fehlerantwort um, mit der als zweitem Parameter übergebenen Meldung. Dies ist die üblichste Art, eine Aktion wegen eines Fehlers zu beenden, selbst tief in einer von der Aktion aufgerufenen Funktion;
  • Zeilen 84–86: ein „unerwarteter“ Fehler – eine Ausnahme, die niemand behandelt – erzeugt eine 500-Antwort ([Internal Server Error]).

In einem Browser ist der Unterschied zwischen [text/plain] und [text/html] sichtbar:

Image

Image

Hier sind die Antworten der übrigen Aktionen:

curl -i http://localhost:5000/responses/json
1
2
3
4
5
6
7
8
9
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 65

{
  "last_name": "Martin",
  "first_name": "Jean",
  "age": 42
}

Die Dataclass wurde in das JSON-Objekt umgewandelt, mit einem Feld pro Attribut. Im Debug-Modus wird das JSON mehrzeilig und eingerückt angezeigt; ohne Debug-Modus passt es in eine einzige Zeile ([{"last_name":"Martin","first_name":"Jean","age":42}]). Die Aktion [/responses/dictionary] erzeugt exakt dieselbe Ausgabe.

curl -i http://localhost:5000/responses/list
1
2
3
4
5
6
7
8
9
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 31

[
  "Mme",
  "Melle",
  "Mr"
]
curl -i http://localhost:5000/responses/created
1
2
3
4
5
6
7
HTTP/1.1 201 CREATED
Content-Type: application/json
Content-Length: 36

{
  "message": "resource created"
}
curl -i http://localhost:5000/responses/empty
HTTP/1.1 204 NO CONTENT
Content-Type: text/html; charset=utf-8
curl -i http://localhost:5000/responses/task
1
2
3
4
5
6
7
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 23

{
  "wait": "501 ms"
}
curl -i http://localhost:5000/responses/not-found
1
2
3
4
5
6
7
HTTP/1.1 404 NOT FOUND
Content-Type: application/json
Content-Length: 48

{
  "message": "This resource does not exist"
}
curl -i http://localhost:5000/responses/abort
1
2
3
4
5
6
7
8
9
HTTP/1.1 404 NOT FOUND
Content-Type: text/html; charset=utf-8
Content-Length: 122

<!doctype html>
<html lang=en>
<title>404 Not Found</title>
<h1>Not Found</h1>
<p>This resource does not exist either</p>

Die Antwort von [abort] ist die Standardfehlerseite von [Werkzeug] mit unserer Meldung (die nach dem Escapen in die Seite eingefügt wird: In HTML eingefügter Text darf dort keine Tags einführen können; wir kommen darauf zurück).

Bleibt die nicht behandelte Ausnahme. Im Debug-Modus zeigt der Browser die Seite des [Werkzeug] -Debuggers an: den Ausnahmetyp und die Meldung, gefolgt vom Aufrufstack (der Liste der Funktionen, die zum Zeitpunkt des Fehlers ausgeführt wurden), vom ältesten zum jüngsten Eintrag, mit der jeweils relevanten Codezeile:

Image

Die letzte Funktion im Stack ist unsere Aktion [exception] in Zeile 86 der Datei [responses.py]. Wenn Sie auf eine der Zeilen im Stack klicken, können Sie nach Eingabe der beim Start angezeigten PIN sogar eine [Python]-Konsole im Kontext dieser Funktion öffnen: Deshalb sollte der Debug-Modus niemals auf einem Server aktiviert sein, der für andere erreichbar ist. Die Serverkonsole zeigt ebenfalls den Aufrufstack an (hier ist nur das Ende wiedergegeben):

1
2
3
4
5
6
127.0.0.1 - - [26/Sep/2026 15:23:10] "GET /responses/exception HTTP/1.1" 500 -
Traceback (most recent call last):
  ...
  File ".../examples/03-responses/controllers/responses.py", line 86, in exception
    raise RuntimeError("An unexpected error")
RuntimeError: An unexpected error

Ohne Debug-Modus ([app.run(port=5000)]) erzeugt dieselbe Anfrage eine kurze englische 500-Fehlerseite, die nichts über den Code preisgibt („Internal Server Error. The server encountered an internal error and was unable to complete your request ...“); der Aufrufstack wird nur in die Serverkonsole geschrieben. Kapitel 7 zeigt, wie man eine anwendungsspezifische Fehlerseite anzeigt.

2.4. Beispiel 04: Weiterleitungen

Eine Weiterleitung ist eine Antwort, die den Browser anweist, eine andere URL abzurufen: ein 3xx-Code und der Header [Location], der die neue Adresse enthält. Der Browser sendet sofort eine zweite Anfrage an diese Adresse. Die Datei [controllers/redirects.py]:

# controllers/redirects.py: die Weiterleitungen
from flask import Blueprint, redirect, url_for

redirects = Blueprint("redirects", __name__)


# permanente Weiterleitung (301): die Seite hat dauerhaft eine neue Adresse
@redirects.get("/old")
def old_page():
    return redirect("/new", code=301)


@redirects.get("/new")
def new_page():
    return "You are on the [new] page"


# temporäre Weiterleitung (302, der Standardcode) auf eine berechnete Adresse,
# die durch Aneinanderhängen von Textstücken entsteht
@redirects.get("/go/<destination>")
def go(destination):
    return redirect("/page/" + destination)


# url_for erstellt die Adresse einer ACTION, die über ihren Namen bezeichnet wird
# ("blueprint.function"): der Parameter [name] wird für eine URL korrekt kodiert
@redirects.get("/to-template/<destination>")
def to_template(destination):
    return redirect(url_for("redirects.page", name=destination))


@redirects.get("/page/<name>")
def page(name):
    return f"You are on the [{name}] page"


# Weiterleitung auf eine andere Website
@redirects.get("/documentation")
def documentation():
    return redirect("https://flask.palletsprojects.com/")
  • Zeilen 8–10: Die Funktion [redirect] erzeugt eine Weiterleitungsantwort an die angegebene Adresse. Der Statuscode 301 ([Moved Permanently]) zeigt an, dass sich die Adresse der Seite dauerhaft geändert hat: Der Browser (und die Suchmaschinen) dürfen die neue zwischenspeichern;
  • Zeilen 20–22: Ohne den Parameter [code] erzeugt [redirect] eine temporäre Weiterleitung mit dem Statuscode 302 ([Found]). Die Adresse wird durch Aneinanderhängen von Textstücken berechnet, was ein Problem aufwirft, das wir untersuchen werden;
  • Zeilen 27–29: Die Funktion [url_for] erzeugt die URL einer Aktion, die über ihren Namen identifiziert wird (["redirects.page"]: der Blueprint, ein Punkt, die Funktion) und nicht über ihren Pfad. Ihre benannten Parameter liefern die Pfadvariablen (hier [name]), korrekt codiert für eine URL. Wird der Pfad der Route [page] jemals geändert, folgen die Aufrufe von [url_for] automatisch;
  • Zeilen 38–40: eine Weiterleitung auf eine andere Website.

Die Antworten mit [curl] (das ohne Optionen Weiterleitungen nicht folgt):

curl -i http://localhost:5000/old
HTTP/1.1 301 MOVED PERMANENTLY
Content-Type: text/html; charset=utf-8
Content-Length: 195
Location: /new

<!doctype html>
<html lang=en>
<title>Redirecting...</title>
<h1>Redirecting...</h1>
<p>You should be redirected automatically to the target URL: <a href="/new">/new</a>. If not, click the link.

Die Antwort enthält außerdem einen kleinen HTML-Rumpf für einen Client, der Weiterleitungen nicht folgt. Die Option [-L] von [curl] folgt der Weiterleitung, genau wie ein Browser:

curl -L http://localhost:5000/old
You are on the [new] page

Vergleichen wir nun die beiden berechneten Weiterleitungen mit einem Ziel, das ein Fragezeichen enthält, in der URL als [%3F] codiert (ein nicht codiertes [?] würde die Parameter der URL einleiten):

curl -i http://localhost:5000/go/a%3Fb
1
2
3
4
HTTP/1.1 302 FOUND
Content-Type: text/html; charset=utf-8
Content-Length: 205
Location: /page/a?b
curl -i http://localhost:5000/to-template/a%3Fb
1
2
3
4
HTTP/1.1 302 FOUND
Content-Type: text/html; charset=utf-8
Content-Length: 209
Location: /page/a%3Fb

[Flask] hat die Pfadvariable vor ihrer Verarbeitung decodiert: [destination] ist gleich [a?b]. Die erste Aktion fügt sie unverändert in die Adresse ein: [/page/a?b], was der Browser als den Pfad [/page/a] gefolgt vom Parameter [b] interpretiert. Die zweite geht über [url_for], das sie erneut codiert: [/page/a%3Fb]. Folgen wir den Weiterleitungen:

curl -L http://localhost:5000/go/a%3Fb
curl -L http://localhost:5000/to-template/a%3Fb
You are on the [a] page
You are on the [a?b] page

Nur die zweite führt zur richtigen Seite. Daraus folgt die Regel: Eine Adresse, die einen variablen Wert enthält, wird mit [url_for] erzeugt, niemals durch Verketten von Zeichenketten. Im Browser ist nur die endgültige Seite sichtbar; die Adressleiste zeigt die neue URL an:

Image

Es gibt zwei weitere Weiterleitungscodes: 303 ([See Other]) und 307 ([Temporary Redirect]), die man mit [redirect(url, code=303)] erhält. Nach einer POST-Anfrage veranlassen die Codes 302 und 303 den Browser, eine GET-Anfrage an die neue Adresse zu senden, wohingegen 307 (und 308, die dauerhafte Variante) ihn dazu bringen, die POST-Anfrage zu wiederholen. Beispiel 20 verwendet die Weiterleitung nach einem POST.

2.5. Beispiel 05: Die Objekte Request und Response

Bisher erhielten die Aktionen nur Pfadvariablen und gaben einen Wert zurück, den [Flask] in eine Antwort umwandelte. Eine Aktion kann auch auf die aktuelle Anfrage zugreifen und die Antwort selbst erstellen. Die Datei [controllers/http.py]:

# controllers/http.py: die Objekte für Anfrage und Antwort
import time

from flask import Blueprint, Response, make_response, request

http = Blueprint("http", __name__, url_prefix="/http")


# die Anfrage: Methode, Pfad, Parameter, Header ...
# [request] ist ein globales Flask-Objekt, das die AKTUELLE Anfrage bezeichnet
@http.get("/request")
def request_info():
    # ein Python-Dictionary behält die Einfügereihenfolge seiner Schlüssel bei
    return {
        "method": request.method,
        "path": request.path,
        # query_string: Bytes, die wir in Text dekodieren
        "parameters": request.query_string.decode(),
        "browser": request.headers.get("User-Agent"),
        "ip": request.remote_addr,
    }


# die Antwort: make_response erstellt das Antwortobjekt aus dem, was die
# Action zurückgeben würde; wir fügen ihm einen Header hinzu, bevor wir es zurückgeben
@http.get("/header")
def header():
    response = make_response("Response with an added header")
    response.headers["X-Example"] = "05-request-response"
    return response


# die "von Hand" erstellte Antwort: Rumpf, Code, Typ
@http.get("/response")
def response():
    return Response("Response built by [Response(...)]", status=200,
                    mimetype="text/plain")


# eine Antwort, die in TEILEN gesendet wird: der Code und die Header gehen mit dem
# ersten Teil hinaus und können danach nicht mehr geändert werden
@http.get("/stream")
def stream():
    def chunks():
        yield "Start of the response... "
        time.sleep(1)
        # zu spät, um einen Fehler anzukündigen: der Code 200 ist bereits gesendet
        raise RuntimeError("error in the middle of the response")

    return Response(chunks(), mimetype="text/plain")
  • Zeile 4: Import des Objekts [request]. In [Flask] ist die aktuelle Anfrage kein Parameter der Aktion: Sie ist ein globales Objekt, [request], das aus dem Paket [flask] importiert wird. Wie kann sich ein globales Objekt auf die aktuelle Anfrage beziehen, wenn der Server mehrere Anfragen gleichzeitig in mehreren Threads (parallelen Ausführungssträngen) verarbeitet? [request] fungiert als Proxy: Bei jeder Verwendung leitet es die Operation an die Anfrage im aktuellen Thread weiter. [Flask] bezeichnet dies als den Request-Kontext: Während eine Anfrage verarbeitet wird, bezieht sich [request] auf genau diese Anfrage. Außerhalb der Anfrageverarbeitung führt seine Verwendung zu einem Fehler („Working outside of request context“);
  • Zeilen 14–20: einige Eigenschaften der Anfrage: ihre HTTP-Methode, ihr Pfad, ihre rohen Parameter (der Teil der URL nach [?], in Byte-Form, den [decode] in Text umwandelt), ihre Header ([request.headers], ein Dictionary, dessen Methode [get] für einen fehlenden Header [None] zurückgibt), die IP-Adresse des Clients. Die Parameter werden im nächsten Kapitel einzeln behandelt;
  • Zeilen 26–30: Die Funktion [make_response] erstellt das Antwortobjekt (eine [Response]) auf Grundlage dessen, was die Aktion zurückgeben würde (hier eine Zeichenkette); die Aktion kann es dann ändern, bevor sie es zurückgibt. Es wird ein Header [X-Example] hinzugefügt (nach Konvention beginnen anwendungsspezifische Header oft mit [X-]);
  • Zeilen 34–37: die „von Hand gebaute“ Antwort: der Rumpf, der Statuscode und der Typ;
  • Zeilen 42–50: eine Antwort, die in Teilen gesendet wird (*Streaming*). Die Funktion [chunks] ist ein Generator: Jedes [yield] erzeugt ein Teilstück des Rumpfs. Da die Antwort mit einem Generator aufgebaut wird, ist ihre Länge nicht im Voraus bekannt: Der Server sendet den Statuscode und die Header und dann jedes Teilstück, sobald es erzeugt ist. Das ist nützlich für eine sehr lange Antwort, die stückweise erzeugt wird. Sobald aber das erste Teilstück gesendet wurde, kann sich der Statuscode nicht mehr ändern: Hier löst der Generator nach dem ersten Teilstück eine Ausnahme aus. Das ist der Fehler, den es zu vermeiden gilt: Eine bereits begonnene Antwort kann nicht mehr zu einer Fehlerantwort werden.

Antworten:

curl -i "http://localhost:5000/http/request?name=martin&age=42"
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 135

{
  "method": "GET",
  "path": "/http/request",
  "parameters": "name=martin&age=42",
  "browser": "curl/8.5.0",
  "ip": "127.0.0.1"
}

(Die Anführungszeichen um „URL“ verhindern, dass das Terminal das Zeichen „[&]“ interpretiert.) In einem Browser ist der Header [User-Agent] der des Browsers; [Chrome] zeigt das rohe JSON an, mit einem Kontrollkästchen, das es einrückt:

Image

curl -i http://localhost:5000/http/header
1
2
3
4
5
6
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 29
X-Example: 05-request-response

Response with an added header
curl -i http://localhost:5000/http/response
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8
Content-Length: 33

Response built by [Response(...)]
curl -i http://localhost:5000/http/stream
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8
Transfer-Encoding: chunked

Start of the response...

Der Header [Transfer-Encoding: chunked] ersetzt [Content-Length]: Der Rumpf trifft in Teilstücken ein, denen jeweils ihre Länge vorangestellt ist. Nach einer Sekunde bricht die Antwort ab: [curl] hat einen Statuscode 200 und einen abgeschnittenen Rumpf erhalten, ohne zu erfahren, dass ein Fehler aufgetreten ist. Nur die Serverkonsole zeigt es an:

1
2
3
4
5
6
Error on request:
Traceback (most recent call last):
  ...
  File ".../examples/05-request-response/controllers/http.py", line 48, in chunks
    raise RuntimeError("error in the middle of the response")
RuntimeError: error in the middle of the response

2.6. Beispiel 06: Gemeinsame Services und Dependency Injection

Eine Aktion sollte nicht die Anwendungslogik selbst enthalten; sie delegiert sie an Services – Objekte, die eine bestimmte Aufgabe erledigen können (Produkte lesen, einen Warenkorb berechnen usw.). Oft verwenden mehrere Aktionen denselben Service. In [Spring] oder [ASP.NET Core] erstellt ein Dependency-Injection-Container die Services und stellt sie automatisch denjenigen bereit, die sie benötigen. [Flask] hat keinen Container: Die Anwendungsfactory erstellt die Services, und die Aktionen fordern sie bei der Anwendung an. Beispiel 06 organisiert seinen Code nach Fachbereichen (Produkte, Kunden) und nicht nach Typ (Controller, Modelle):

06-services/
├── clients/
│   ├── __init__.py
│   └── controller.py
├── products/
│   ├── __init__.py
│   ├── controller.py
│   ├── in_memory_service.py
│   ├── product.py
│   └── service.py
└── app.py

2.6.1. Das Produkt

# products/product.py: ein Produkt
from dataclasses import dataclass
from decimal import Decimal


# eine Dataclass: Python schreibt den Konstruktor, __repr__, __eq__ ... selbst
# frozen=True: das Objekt ist unveränderlich (seine Felder werden vom Konstruktor gesetzt)
@dataclass(frozen=True)
class Product:
    id: int
    name: str
    price: Decimal  # Decimal: eine exakte Dezimalzahl (keine binäre Rundung)
  • Zeile 8: eine Dataclass (siehe Beispiel 03). Mit [frozen=True] ist das Objekt unveränderlich: Seine Felder werden vom Konstruktor gesetzt, und jeder Versuch, sie zu ändern ([p.price = 2]), löst eine Ausnahme aus. Ein unveränderliches Objekt kann sicher von mehreren Anfragen gemeinsam genutzt werden;
  • Zeilen 10–12: die Felder mit ihren Typen. Die Typen werden von [Python] zur Laufzeit nicht geprüft: Sie sind Annotationen , die von Analysewerkzeugen (etwa dem in [Visual Studio Code]) und bestimmten Bibliotheken ([Pydantic], im nächsten Kapitel behandelt) gelesen werden. Der Preis ist ein [Decimal], eine exakte Dezimalzahl: Ein [float] kann 0,1 oder 3,2 nicht genau darstellen (im Binärsystem haben diese Zahlen unendlich viele Stellen), und eine Summe von Preisen als [float] kann 5.500000000000001 ergeben.

2.6.2. Der Service-Vertrag: service.py

# products/service.py: der VERTRAG des Service, was er kann, ohne zu sagen, wie
from abc import ABC, abstractmethod

from flask import current_app

from products.product import Product


# eine abstrakte Klasse (ABC): aus ihr kann kein Objekt erzeugt werden; eine Kindklasse
# muss alle mit @abstractmethod markierten Methoden schreiben (überschreiben)
class ProductsService(ABC):

    @abstractmethod
    def find_all(self) -> list[Product]: ...

    # Product | None: ein Produkt oder None, wenn es nicht existiert
    @abstractmethod
    def find_by_id(self, id: int) -> Product | None: ...


# der Service der aktuellen Anwendung (siehe app.py). current_app bezeichnet
# die Anwendung, die die aktuelle Anfrage bearbeitet
def products_service() -> ProductsService:
    return current_app.extensions["products_service"]
  • Zeilen 11–18: der Vertrag des Services – was er kann, ohne festzulegen, wie. In [Python] wird ein Vertrag durch eine abstrakte Klasse definiert: eine Klasse, die von [ABC] erbt ([Abstract Base Class]) und deren mit [@abstractmethod] markierte Methoden keinen Rumpf haben (die drei Punkte [...] dienen als leerer Rumpf). Von dieser Klasse kann man kein Objekt erzeugen; eine Unterklasse muss alle ihre abstrakten Methoden überschreiben. Das entspricht den Interfaces von [Java] und [C#];
  • Zeile 14: die Annotation für den von der Methode zurückgegebenen Typ (nach [->]): eine Liste von Produkten. [self] ist das Objekt, auf dem die Methode aufgerufen wird (das Äquivalent von [this] in [Java]), stets als erster Parameter aufgeführt;
  • Zeile 18: [Product | None]: ein Produkt oder [None] , wenn es nicht existiert;
  • Zeilen 23–24: Die Funktion, die den Service bereitstellt für die Aktionen. [current_app] ist, wie [request], ein Proxy: Er bezieht sich auf die Anwendung, die die aktuelle Anfrage verarbeitet. [app.extensions] ist ein Dictionary, das [Flask] den Erweiterungen (den Bibliotheken, die zu [Flask] hinzugefügt werden) zur Verfügung stellt, damit sie dort ihre Objekte ablegen können; wir verwenden es für unsere eigenen Services. Die Funktion gibt außerdem den Typ des Services an ([-> ProductsService]): [Visual Studio Code] kann dann seine Methoden vorschlagen.

2.6.3. Die Implementierung: in_memory_service.py

# products/in_memory_service.py: eine IMPLEMENTIERUNG des Vertrags, mit Daten im Speicher
from decimal import Decimal

from products.product import Product
from products.service import ProductsService


class InMemoryProductsService(ProductsService):

    def __init__(self):
        # ein Tupel: eine Liste, die nicht geändert werden kann
        self._products = (
            Product(1, "pen", Decimal("1.5")),
            Product(2, "notebook", Decimal("3.2")),
            Product(3, "eraser", Decimal("0.8")),
        )

    def find_all(self) -> list[Product]:
        return list(self._products)

    def find_by_id(self, id: int) -> Product | None:
        # next(generator, None): das erste passende Produkt oder None
        return next((p for p in self._products if p.id == id), None)
  • Zeile 8: Die Klasse erbt den Vertrag und definiert seine beiden Methoden neu;
  • Zeilen 10–15: [__init__] ist der Konstruktor der Klasse. Er speichert die Produkte im Attribut [_products] des Objekts; der führende Unterstrich kennzeichnet nach Konvention ein privates Attribut, das Code außerhalb der Klasse nicht verwenden soll. Die Produkte liegen in einem Tupel (in runden Klammern): einer unveränderlichen Sequenz. Der Preis wird aus einer Zeichenkette konstruiert ([Decimal("1.5")]): Aus dem [float] 1.5 erzeugt, würde er dessen Ungenauigkeiten erben;
  • Zeilen 18–19: Die Methode gibt eine neue Liste zurück, eine Kopie des Tupels: Der Aufrufer kann sie ändern, ohne die Daten des Services zu beeinflussen;
  • Zeilen 21–23: [(p for p in self._products if p.id == id)] ist ein Generatorausdruck: Er erzeugt nacheinander die Produkte, deren ID mit der angeforderten übereinstimmt. [next] gibt das erste Produktelement zurück oder, falls es keines gibt, den Standardwert [None].

2.6.4. Der Produkt-Blueprint: controller.py

# products/controller.py: die Actions von /products
from flask import Blueprint, jsonify

from products.service import products_service

products = Blueprint("products", __name__, url_prefix="/products")


@products.get("")
def list_all():
    # der Service wird bei jeder Anfrage von der Anwendung geholt
    return jsonify(products_service().find_all())


@products.get("/<int:id>")
def one_product(id):
    product = products_service().find_by_id(id)
    if product is None:
        return {"message": f"Product no. {id} not found"}, 404
    return jsonify(product)
  • Zeile 4: Der Blueprint kennt nur den Vertrag des Services (das Modul [service]), nicht seine Implementierung: Er weiß nicht, dass die Produkte im Speicher liegen;
  • Zeilen 10–12: Die Aktion fordert den Service von der Anwendung an und delegiert dann die Arbeit an ihn. [jsonify] wandelt die Liste der Dataclasses in ein JSON-Array um;
  • Zeilen 16–20: Ein unbekanntes Produkt liefert eine 404-Antwort mit einer Meldung in JSON.

2.6.5. Der Kunden-Blueprint: controller.py

# clients/controller.py: ein zweiter Blueprint, der DENSELBEN Service verwendet
from dataclasses import dataclass
from decimal import Decimal

from flask import Blueprint, jsonify

from products.service import products_service

clients = Blueprint("clients", __name__, url_prefix="/clients")


# der Inhalt des Warenkorbs, als JSON zurückgegeben
@dataclass
class Cart:
    client: str
    items: int
    total: Decimal


@clients.get("/cart")
def cart():
    products = products_service().find_all()
    # die Summe der Preise; start=Decimal(0): wir addieren Decimal-Werte
    total = sum((p.price for p in products), start=Decimal(0))
    return jsonify(Cart("Jean Martin", len(products), total))
  • Zeilen 14–17: der Inhalt des Warenkorbs, als JSON ausgegeben;
  • Zeile 22: Dieser Blueprint verwendet denselben Service wie der Produkt-Blueprint: ein einziges, gemeinsames Objekt;
  • Zeile 24: [sum] addiert die Elemente eines iterierbaren Objekts; ihr Parameter [start] ist der Anfangswert der Summe (standardmäßig 0). Mit [Decimal(0)] statt der Ganzzahl 0 zu beginnen, ist nicht unerlässlich (eine Ganzzahl und ein [Decimal] lassen sich addieren), garantiert aber ein Ergebnis vom Typ [Decimal] auch bei einem leeren Warenkorb.

2.6.6. Die Deklaration des Services: app.py

# app.py: die Anwendung von Beispiel 06
from flask import Flask

from clients.controller import clients
from products.controller import products
from products.in_memory_service import InMemoryProductsService


def create_app():
    app = Flask(__name__)
    # JSON: Akzente beibehalten, Schlüssel in ihrer ursprünglichen Reihenfolge (siehe Beispiel 03)
    app.json.ensure_ascii = False
    app.json.sort_keys = False
    # der SERVICE: ein einziges Objekt, einmal beim Start erstellt und von
    # allen Anfragen gemeinsam genutzt. Wir speichern ihn in app.extensions, einem Dictionary, das
    # Flask den Erweiterungen zur Verfügung stellt ... und unseren Services
    app.extensions["products_service"] = InMemoryProductsService()
    app.register_blueprint(products)
    app.register_blueprint(clients)
    return app


if __name__ == "__main__":
    create_app().run(port=5000, debug=True)
  • Zeile 17: Hier – und nur hier – wird die Implementierung des Services gewählt. Der Service wird einmal beim Start erstellt, und dasselbe Objekt bearbeitet alle Anfragen aller Benutzer: Es ist ein Singleton (der Standard-Scope der [Spring]-Beans). Um auf eine Implementierung umzustellen, die aus einer Datenbank liest, müsste man nur diese Zeile ändern: Die Blueprints, die nur den Vertrag kennen, blieben unverändert. Das ist der Kern der Dependency Injection, auch wenn sie „von Hand“ umgesetzt wird: Jeder Teil der Anwendung hängt von Verträgen ab, und eine einzige Stelle legt die Implementierungen fest.

Ein von allen Anfragen gemeinsam genutzter Service muss damit umgehen können, gleichzeitig von mehreren Anfragen verwendet zu werden: Der Entwicklungsserver verarbeitet jede Anfrage in einem eigenen Thread. Das ist hier unproblematisch: Er liest lediglich Daten, die sich nie ändern. Beispiel 20 zeigt einen Service, dessen Daten sich ändern, und die dafür nötigen Vorkehrungen.

2.6.7. Ausführung

curl -i http://localhost:5000/products
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 191

[
  {
    "id": 1,
    "name": "pen",
    "price": "1.5"
  },
  {
    "id": 2,
    "name": "notebook",
    "price": "3.2"
  },
  {
    "id": 3,
    "name": "eraser",
    "price": "0.8"
  }
]

Die Preise sind zu Zeichenketten geworden (["1.5"]): JSON kennt nur einen numerischen Typ, den die meisten Programme als Gleitkommazahl interpretieren; daher wandelt der JSON-Provider von [Flask] einen [Decimal] in eine Zeichenkette um, um seine Genauigkeit zu erhalten.

curl -i http://localhost:5000/products/9
1
2
3
4
5
6
7
HTTP/1.1 404 NOT FOUND
Content-Type: application/json
Content-Length: 43

{
  "message": "Product no. 9 not found"
}
curl -i http://localhost:5000/clients/cart
1
2
3
4
5
6
7
8
9
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 62

{
  "client": "Jean Martin",
  "items": 3,
  "total": "5.5"
}