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.
2.1.1. Die Datei app.py
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:
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:
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:

dann mit [curl]. Die Option [-i] zeigt zusätzlich die HTTP-Header der Antwort an:
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.
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:
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
- 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
- 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:

2.2.3. Der erste Blueprint: controllers/first.py
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:
Der Text ist 30 Zeichen lang, und die Antwort ebenso in Bytes: In UTF-8 belegt jedes dieser (ASCII-)Zeichen ein Byte.
Um eine Anfrage mit POST zu senden, verwenden Sie die Option [-X POST] von [curl]:
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:
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].
Die Fehlerantworten von [Flask] (genauer gesagt von [Werkzeug]) sind kurze HTML-Seiten in englischer Sprache. In einem Browser:

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:
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]:
- 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]:
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:


Hier sind die Antworten der übrigen Aktionen:
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.
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:

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):
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]:
- 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):
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:
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):
[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:
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:

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]:
- 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:
(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:

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:
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):
2.6.1. Das Produkt
- 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
- 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
- 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
- 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
- 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
- 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
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.