2. Actions, Routing, Antworten
Dieses Kapitel untersucht den Weg einer Anfrage vom Browser bis zur Action, die sie verarbeitet, und die Antwort, die diese Action zurückgibt. Views werden erst in Kapitel 4 behandelt: Hier geben die Actions Text oder JSON direkt zurück.
2.1. Beispiel 01: Die Struktur einer Laravel-Anwendung
Das erste Beispiel ist die kleinstmögliche [Laravel]-Anwendung. Ein mit [composer create-project laravel/laravel] angelegtes Projekt enthält etwa fünfzig Dateien und Ordner (siehe Einführung); hier behalten wir nur diejenigen, ohne die die Anwendung nicht auskommt:
- [public/index.php]: der Einstiegspunkt der Anwendung. Alle HTTP-Anfragen werden, unabhängig von ihrer URL, von dieser Datei bearbeitet. Der Ordner [public] ist der einzige Ordner, den der Webserver ausliefert: Er enthält auch statische Dateien (Stylesheets, Bilder, Skripte) und nur diese;
- [bootstrap/app.php]: der Aufbau und die Konfiguration der Anwendung. Der Ordner [bootstrap/cache] nimmt Dateien auf, die [Laravel] selbst berechnet, um schneller zu starten;
- [routes/web.php]: die Routing-Tabelle, die jeder URL die Action zuordnet, die sie verarbeitet;
- [storage]: die Dateien, die die Anwendung im Betrieb schreibt: das Fehlerprotokoll ([storage/logs]), Sessions, der Cache und kompilierte Views ([storage/framework]);
- [.env]: die Konfiguration der Anwendung in Form von [NAME=value]-Paaren;
- [artisan]: das Kommandozeilenwerkzeug von [Laravel];
- [composer.json]: die Projektbeschreibung für [Composer].
2.1.1. Der Einstiegspunkt: public/index.php
- Zeile 1: Eine [PHP]-Datei beginnt mit dem Tag [<?php]. Alles, was folgt, ist [PHP]-Code; eine Datei, die nur Code enthält, schließt dieses Tag nicht;
- Zeile 2: ein Kommentar, von [//] bis zum Zeilenende ([/* ... */] begrenzt einen mehrzeiligen Kommentar);
- Zeile 4: Die Anweisung [use] importiert einen Klassennamen. Der vollständige Name einer [PHP] -Klasse enthält ihren Namespace (*namespace*), das Äquivalent der Pakete in [Java]: [Illuminate\Http\Request] ist die Klasse [Request] im Namespace [Illuminate\Http]. Nach [use] kann die Klasse in der Datei einfach [Request] genannt werden. [Illuminate] ist der Codename für die Komponenten von [Laravel];
- Zeile 7: [require] führt eine weitere [PHP]-Datei aus. [__DIR__] ist das Verzeichnis der aktuellen Datei (hier [public]); der Operator [.] verkettet zwei Zeichenketten. Die Datei [vendor/autoload.php], die von [Composer] geschrieben wird, installiert den Class-Loader: Wird eine Klasse zum ersten Mal verwendet, findet und lädt er die Datei, die sie definiert. Dadurch müssen wir für Klassen nie eine [require]-Anweisung schreiben. Der Ordner [vendor] liegt im Ordner [examples] und wird von allen Beispielen gemeinsam genutzt (siehe Einführung): daher die beiden [..]-Einträge;
- Zeile 10: Eine Datei, die von [require] ausgeführt wird, kann mit der Anweisung [return] einen Wert zurückgeben: [bootstrap/app.php] gibt die Anwendung – ein Objekt der Klasse [Illuminate\Foundation\Application] – zurück, die in der Variablen [$app] gespeichert wird. In [PHP] beginnen Variablennamen immer mit [$]. [require_once] würde nichts tun, wenn die Datei bereits ausgeführt worden wäre;
- Zeile 11: [Request::capture()] ruft die statische Methode [capture] der Klasse [Request] auf (der Operator [::] verweist auf ein Mitglied einer Klasse, der Operator [->] verweist auf ein Mitglied eines Objekts). Sie erzeugt aus der von [PHP] empfangenen HTTP-Anfrage ein [Request]-Objekt. [$app->handleRequest(...)] lässt die Anwendung diese Anfrage verarbeiten und sendet die Antwort an den Browser.
Diese Datei ist für alle Beispiele gleich und entspricht – mit Ausnahme der beiden [..]-Einträge – der eines standardmäßigen [Laravel]-Projekts. Sie zeigt eine Besonderheit von [PHP], die vieles an [Laravel] erklärt: Die Anwendung wird bei jeder Anfrage neu aufgebaut. Der Webserver führt [public/index.php] für jede empfangene Anfrage von Anfang bis Ende aus: Er lädt die Klassen, baut die Anwendung auf, verarbeitet die Anfrage, sendet die Antwort und vergisst dann alles. Kein Objekt überlebt von einer Anfrage zur nächsten. Im Kapitel zu den Datenbereichen sehen wir die Folgen dieses Verhaltens, das dem von [Java], [C#] oder [Python] entgegengesetzt ist, deren Anwendungen zwischen den Anfragen im Speicher bleiben.
2.1.2. Die Struktur der Anwendung: bootstrap/app.php
- Zeile 7: Der Class-Loader von [Composer] kennt die Klassen der Bibliotheken im Ordner [vendor]. Er muss auch die Klassen der Anwendung kennen, die üblicherweise in ihrem Ordner [app] liegen, im Namespace [App]. In einem Standardprojekt bezieht [Composer] diese Information aus der Datei [composer.json] des Projekts. Unsere Beispiele teilen sich einen einzigen Ordner namens [vendor], haben aber jeweils einen eigenen Ordner namens [app]: Jedes Beispiel meldet ihn daher selbst beim Loader an, über dessen Methode [addPsr4] (der Standard [PSR-4] ordnet Namespaces Ordnern zu: Die Klasse [App\Http\Controllers\FirstController] liegt in der Datei [app/Http/Controllers/FirstController.php]). Ein [require] gibt den Wert der ausgeführten Datei zurück; [vendor/autoload.php] gibt den Loader zurück (er wird nur einmal installiert, auch wenn die Datei zweimal ausgeführt wird). In einer Zeichenkette in einfachen Anführungszeichen steht [\\] für ein einzelnes Zeichen, [\]. Dieses Beispiel hat noch keinen Ordner [app]: Die Zeile ist für die folgenden Beispiele vorgesehen;
- Zeile 9: der Aufbau der Anwendung. [Application::configure(...)] gibt ein Builder-Objekt (*builder*) zurück, dessen Methoden jeweils einen Aspekt der Anwendung konfigurieren und den Builder selbst zurückgeben, sodass sich Aufrufe verketten lassen; [create()] baut schließlich die Anwendung. Der Parameter [basePath: dirname(__DIR__)] ist ein benannter Parameter: Der Wert wird dem Parameter [basePath] über seinen Namen zugeordnet, nicht über seine Position. [dirname(__DIR__)] ist der übergeordnete Ordner von [bootstrap] – also der Ordner des Beispiels: Von diesem Ordner aus findet [Laravel] alle anderen ([routes], [storage] ...);
- Zeile 11: Die Routen der Anwendung sind die in der Datei [routes/web.php]. Der Name [web] ist von Bedeutung: Diese Routen erhalten die Middleware der Gruppe [web] (Sessions, verschlüsselte Cookies, CSRF-Schutz usw.), die für eine Anwendung geeignet ist, die HTML-Seiten erzeugt. Wir begegnen ihnen in allen Kapiteln;
- Zeilen 13–14: die Middleware und die Ausnahmebehandlung mit ihren Standardeinstellungen. Wir erweitern sie in den folgenden Beispielen.
2.1.3. Die Routing-Tabelle: routes/web.php
- Zeile 4: Import der Klasse [Route]. Dies ist eine Fassade von [Laravel]: eine Klasse, deren statische Methoden ([Route::get]) den Aufruf an ein Objekt der Anwendung weiterleiten, hier an den Router. Fassaden sind eines der Markenzeichen von [Laravel]: Sie bieten schnellen Zugriff auf die Services der Anwendung, ohne das Objekt beschaffen zu müssen, das sie bereitstellt;
- Zeilen 7–10: [Route::get] deklariert eine Route: Anfragen für [GET /] werden von der Funktion bearbeitet, die als zweiter Parameter angegeben ist. Das ist das Routing. Diese Funktion hat keinen Namen: Sie ist eine anonyme Funktion – ein Wert wie jeder andere –, die als Parameter übergeben werden kann. Die einer Route zugeordnete Funktion ist eine Action. Es gibt außerdem [Route::post], [Route::put], [Route::delete] ...;
- Zeile 9: Die Action gibt eine Zeichenkette zurück. Der von einer Action zurückgegebene Wert ist die an den Browser gesendete Antwort: [Laravel] legt ihn in den Body der HTTP-Antwort. Eine Zeichenkette in einfachen Anführungszeichen (['...']) wird unverändert geschrieben; steht sie in doppelten Anführungszeichen (["..."]), werden die darin enthaltenen Variablen durch ihre Werte ersetzt (z. B. 02).
2.1.4. Konfiguration: .env
Die Datei [.env] enthält Einstellungen, die für eine bestimmte Installation der Anwendung gelten: Dieselbe Anwendung, auf dem Rechner eines Entwicklers und auf einem Produktionsserver installiert, hat nicht dieselbe [.env]. Außerdem darf diese Datei nicht zusammen mit dem Quellcode veröffentlicht werden (sie enthält Geheimnisse). Zeilen, die mit [#] beginnen, sind Kommentare.
- Zeile 2: der Name der Anwendung. [Laravel] verwendet ihn zum Beispiel, um das Session-Cookie zu benennen ([example01_session], siehe unten);
- Zeile 4: die Umgebung: [local] für die Entwicklung, [production] auf einem Server;
- Zeile 6: der geheime Schlüssel der Anwendung: 32 zufällige Bytes, Base64-kodiert. [Laravel] verwendet ihn, um Cookies zu verschlüsseln und bestimmte Daten zu signieren (wir kommen darauf zurück). Er wird mit dem Befehl [php artisan key:generate] erzeugt, der ihn in die Datei [.env] schreibt; jedes Beispiel hat seinen eigenen. Ohne ihn verweigert die Anwendung den Start („No application encryption key has been specified“);
- Zeile 8: der Debug-Modus: Eine unbehandelte Ausnahme zeigt eine detaillierte Seite an (siehe Beispiel 03). Dieser Modus ist für die Entwicklung gedacht, und nur dafür: Die Fehlerseite verrät den Quellcode und die Konfiguration der Anwendung;
- Zeilen 10–11: Sessions und der Cache (siehe das Kapitel zu den Datenbereichen) werden in Dateien im Ordner [storage] gespeichert. Standardmäßig legt [Laravel] sie in einer Datenbank ab, die wir noch nicht haben.
Alles, was [Laravel] in [.env] nicht findet, behält seinen Standardwert. Diese Standardwerte sind in den Konfigurationsdateien des Frameworks definiert ([vendor/laravel/framework/config/*.php]); ein Standardprojekt hat davon eine Kopie in seinem Ordner [config], die geändert werden kann. Unsere Beispiele kommen ohne sie aus: Wenige Zeilen in [.env] genügen.
2.1.5. Das Werkzeug artisan und die Datei composer.json
Die Datei [artisan] ist ein [PHP]-Skript, das die Anwendung genauso aufbaut wie [public/index.php], aber um einen Befehl auszuführen, statt eine Anfrage zu verarbeiten:
- Zeile 1: Unter [Linux] und [macOS] ermöglicht diese Zeile die direkte Ausführung der Datei ([./artisan]); unter [Windows] geben Sie immer [php artisan] ein;
- Zeile 13: [ArgvInput] repräsentiert die Kommandozeilenparameter ([serve], [route:list] ...); [handleCommand] führt den Befehl aus und gibt seinen Exit-Code zurück.
[php artisan list] zeigt die Liste der verfügbaren Befehle an: etwa hundert, von denen wir einige verwenden werden. Schließlich beschreibt die Datei [composer.json] das Beispiel:
Dies ist ein JSON-Dokument. [Laravel] liest aus dieser Datei den Klassen-Namespace der Anwendung ([App\], im Ordner [app/]), den es zum Beispiel benötigt, um in seinen Fehlerseiten den Code der Anwendung vom Code des Frameworks zu unterscheiden. Die Datei [composer.json] eines Standardprojekts enthält außerdem die Liste seiner Bibliotheken; bei den Beispielen steht diese Liste in der Datei [examples/composer.json] (siehe Einführung).
2.1.6. Ausführung
Geben Sie in einem Terminalfenster, das im Ordner [01-structure] geöffnet ist, [php artisan serve] ein. [Laravel] zeigt an:
Der Befehl [serve] startet den Entwicklungsserver , der in [PHP] ([php -S]) integriert und so konfiguriert ist, dass er alle Anfragen an [public/index.php] weiterleitet (außer Anfragen nach Dateien im Ordner [public], die er unverändert ausliefert). Er lauscht auf Port 8000 an der Adresse [127.0.0.1], der Adresse des Rechners selbst ([localhost]): Er akzeptiert nur Anfragen von diesem Rechner, was für die Entwicklung geeignet ist ([--host=0.0.0.0] würde ihn für andere Rechner im Netzwerk öffnen; [--port=8001] würde den Port ändern). Er wird mit [Ctrl-C] beendet. Dieser Server ist für die Entwicklung gedacht: In der Produktion kommt ein Webserver wie [Apache] oder [Nginx] in Verbindung mit [PHP-FPM] zum Einsatz (siehe Fallstudie). Nach einer Codeänderung muss er nicht neu gestartet werden: Da [PHP] die Dateien bei jeder Anfrage neu einliest, greift die Änderung bei der nächsten Anfrage. Nur eine Änderung der Datei [.env] erfordert einen Neustart, den der Befehl [serve] automatisch durchführt.
Rufen wir die URL [http://localhost:8000/] mit einem Browser auf:

und 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]). Danach folgen die Header: der angeforderte Host, [Connection: close] (der Entwicklungsserver schließt die Verbindung nach jeder Antwort), die Version von [PHP], der Inhaltstyp, eine Cache-Direktive, das Datum und zwei Cookies. Eine Leerzeile trennt die Header vom Body der Antwort. Im weiteren Verlauf dieses Dokuments geben wir die Header [Host], [Connection], [X-Powered-By], [Cache-Control] und [Date] – die sich nicht ändern – sowie die Cookies nicht mehr wieder, außer wenn sie Gegenstand des Beispiels sind.
Der Header [Content-Type: text/html; charset=utf-8] zeigt an, dass die Antwort HTML ist, dessen Zeichen in UTF-8 kodiert sind. Das ist die Standardkodierung ([Laravel]) für jede von einer Action zurückgegebene Zeichenkette: Der Browser interpretiert die Zeichenkette daher als HTML (hier wird sie ohne Tag unverändert angezeigt). Beispiel 03 zeigt, wie sich ein anderer Typ festlegen lässt.
Die beiden Cookies können überraschen: Die Anwendung hat keines von beiden angefordert. Sie werden von zwei Middleware-Komponenten der Gruppe [web] gesetzt (siehe [bootstrap/app.php]): [example01_session] identifiziert die Session des Benutzers, und [XSRF-TOKEN] enthält das CSRF-Token. Ihre Werte sind verschlüsselt mit dem Schlüssel [APP_KEY]. Wir untersuchen sie in den Beispielen 20 und 21.
Für jede Anfrage zeigt die Serverkonsole einen Log-Eintrag an: das Datum, den angeforderten Pfad und die Verarbeitungszeit.
2.2. Beispiel 02: Routing
Das Routing ordnet einer URL und einer HTTP-Methode (GET, POST ...) eine Action zu. Alle Actions in [routes/web.php] als anonyme Funktionen zu schreiben, würde schnell unübersichtlich; stattdessen werden sie in Klassen organisiert – den Controllern. Beispiel 02 hat zwei davon:
Die Dateien [artisan], [public/index.php], [composer.json] und [.env] sowie die Ordner [bootstrap/cache] und [storage] sind dieselben wie in Beispiel 01: Wir erwähnen sie nicht mehr (nur der Name des Beispiels und der geheime Schlüssel ändern sich). Jeder Controller ist eine Klasse im Namespace [App\Http\Controllers] im Ordner [app/Http/Controllers]: So lautet die Konvention für [Laravel], und der Standard [PSR-4] ordnet beides einander zu (Beispiel 01).
2.2.1. Der Controller HomeController
- Zeile 4: der Namespace der Klasse. Ihr vollständiger Name lautet daher [App\Http\Controllers\HomeController];
- Zeile 6: die Klasse. Üblicherweise wird ein Klassenname mit einem Großbuchstaben am Anfang jedes Wortes geschrieben ([HomeController]), während ein Methoden- oder Variablenname mit einem Kleinbuchstaben beginnt ([action01Post]). Ein Controller in [Laravel] muss von keiner Klasse erben;
- Zeile 10: die Action [index], eine öffentliche Methode der Klasse (der Router kann nur öffentliche Methoden aufrufen). [: string] deklariert den Typ des Rückgabewerts: eine Zeichenkette. Typen sind in [PHP] optional, aber wenn sie angegeben sind, prüft [PHP] sie zur Laufzeit;
- Zeilen 12–23: eine mehrzeilige Zeichenkette. Die Syntax [<<<'HTML'] ... [HTML] (*nowdoc*) begrenzt Text, der unverändert geschrieben wird, zwischen zwei Zeilen mit demselben Wort, hier [HTML]; die Einrückung der schließenden Zeile wird von allen Zeilen entfernt. Die Action gibt HTML zurück, das mit dem Typ [text/html] gesendet wird (siehe Beispiel 01).
Die Action [index] gibt somit eine HTML-Seite zurück, die Links zu den Actions des anderen Controllers enthält:

2.2.2. Der Controller FirstController
- Zeilen 9–11: dieselbe Methode [index] wie im anderen Controller: Es gibt keinen Konflikt, da jeder Controller eine eigene Klasse ist;
- Zeilen 21–23: die Action für die Anfrage [POST /first/action01]. Der Name einer Action kann beliebig sein; die Routing-Tabelle ordnet ihn einer URL und einer HTTP-Methode zu;
- Zeilen 28–30: Der Parameter [$id] der Action erhält den Wert des Routenparameters [{id}] (siehe [routes/web.php]): Für die URL [/first/products/17] ist das 17. Der Parametertyp [int] weist [PHP] an, den Wert (eine aus der URL extrahierte Zeichenkette) in eine ganze Zahl umzuwandeln. Das ist das Daten-Binding, das im nächsten Kapitel ausführlich behandelt wird. In der Zeichenkette in Anführungszeichen ["Product no. $id"] wird die Variable [$id] durch ihren Wert ersetzt: Das nennt man Interpolation;
- Zeilen 34–36: zwei Routenparameter, die an zwei Parameter der Action übergeben werden. [Laravel] ordnet sie über den Namen zu: Die Reihenfolge der Parameter der Action spielt keine Rolle;
- Zeilen 40–42: ein Routenparameter, der [/] enthält.
2.2.3. Die Routing-Tabelle: routes/web.php
- Zeilen 4–5: Import der beiden Controller;
- Zeile 9: Die Action ist keine anonyme Funktion mehr, sondern ein Array mit zwei Elementen: der Controller-Klasse und dem Methodennamen. [HomeController::class] ist der vollständige Name der Klasse als Zeichenkette (['App\Http\Controllers\HomeController']). Für jede Anfrage [GET /] erzeugt [Laravel] ein [HomeController]-Objekt und ruft dessen Methode [index] auf;
- Zeile 12: eine Gruppe von Routen: Die Routen, die in der an [group] übergebenen Funktion deklariert werden, teilen sich die Einstellungen der Gruppe. [prefix('first')] stellt ihren Pfaden [/first] voran; [controller(FirstController::class)] weist ihnen ihren Controller zu, sodass jede Route nur noch ihre Methode nennen muss. Die URL einer Action ist die Verkettung aus dem Präfix der Gruppe und dem Pfad ihrer Route;
- Zeile 14: Die Route ['/'] bezeichnet das Präfix selbst: [GET /first];
- Zeilen 16–18: Derselbe HTTP-Pfad entspricht zwei Methoden: [GET] und [POST], die von zwei verschiedenen Actions bearbeitet werden. Es gibt außerdem [Route::match(['get', 'post'], ...)] für eine Action, die mehrere Methoden bearbeitet, und [Route::any] für alle;
- Zeile 21: [{id}] ist ein Routenparameter: Dieses URL-Segment kann mehrere Werte annehmen. Standardmäßig akzeptiert ein Parameter jeden Text ohne Schrägstrich; [whereNumber('id')] beschränkt den Parameter darauf, nur Ziffern zu enthalten: Andernfalls passt die Route nicht. Es gibt außerdem [whereAlpha] (Buchstaben), [whereUuid], [whereIn('id', [...])] (eine Liste von Werten) und [where], das einen regulären Ausdruck akzeptiert;
- Zeile 23: zwei Routenparameter, die beide eingeschränkt sind ([whereNumber] akzeptiert ein Array von Namen). In [PHP] ist [[a, b]] ein Array (*array*);
- Zeile 26: Die Einschränkung [where('path', '.*')] ist ein regulärer Ausdruck: [.] steht für ein beliebiges Zeichen und [*] steht für seine Wiederholung. Der Parameter akzeptiert somit jedes Ende einer URL, auch [/].
2.2.4. Die Konfiguration: bootstrap/app.php
- Zeilen 11–15: Die Methode [withMiddleware] erhält diesmal eine Funktion, die [Laravel] aufruft und der es das Objekt [$middleware] übergibt, das die Middleware der Anwendung beschreibt. [: void] gibt an, dass die Funktion nichts zurückgibt. Wir verwenden sie, um den CSRF-Schutz für die URLs [/first/...] zu umgehen: Dieser Schutz, den wir in Beispiel 21 untersuchen, weist jede POST-Anfrage zurück, die nicht aus einem Formular der Anwendung stammt – auch die, die wir mit [curl] senden. Der benannte Parameter [except] gibt die Liste der auszuschließenden Pfade an, wobei [*] für eine beliebige Zeichenfolge steht. Ohne diese Zeile würde die POST-Anfrage von [curl] mit einem Fehler 419 beantwortet (*Page Expired*).
2.2.5. Ausführung
Hier sind die Antworten auf einige Anfragen:
Um eine POST-Anfrage zu senden, verwenden Sie die Option [-X POST] von [curl]:
Eine HTTP-Methode, für die keine Action diesen Pfad bearbeitet, führt zu einem Fehler 405 ([Method Not Allowed]). Der Header [allow] listet die akzeptierten Methoden auf; [Laravel] fügt [HEAD] hinzu (dieselbe Anfrage wie GET, aber ohne Antwort-Body), das es für jede Route GET selbst bearbeitet:
Im Debug-Modus ist der Body der Antwort die detaillierte Fehlerseite von [Laravel], die wir in Beispiel 03 sehen werden: Sie erklärt, dass die Methode PUT für diese Route nicht unterstützt wird („The PUT method is not supported for route first/action01. Supported methods: GET, HEAD, POST.“).
Schließlich führt eine URL, die keine Route bearbeitet, zu einem Fehler 404. Das gilt auch für eine Kennung, die keine Zahl ist: Die Einschränkung [whereNumber] verhindert, dass die Route auf [/first/products/abc] passt.
Die Antwort ist eine Fehlerseite von [Laravel] auf Englisch. In einem Browser:

Kapitel 7 zeigt, wie sie durch eine anwendungsspezifische Seite ersetzt werden kann. Beachten Sie außerdem, dass [Laravel] nicht zwischen [/first] und [/first/] unterscheidet: Der abschließende Schrägstrich wird vom Router ignoriert, und beide URLs führen zur selben Action.
Der Befehl [php artisan route:list], ausgeführt im Verzeichnis des Beispiels, listet alle Routen der Anwendung auf:
Jede Zeile nennt die HTTP-Methoden, den Pfad und die Action ([Controller@method]). Die letzten beiden Routen mit den Namen [storage.local] und [storage.local.upload] werden von [Laravel] selbst angelegt: Sie liefern die Dateien aus, die die Anwendung in ihrem Ordner [storage/app] ablegt, sofern sie von einer Signatur begleitet werden (eine signierte URL, die nur die Anwendung erzeugen kann). Wir werden sie nicht verwenden.
2.3. Beispiel 03: Antworten einer Action
Was eine Action zurückgibt, bestimmt die HTTP-Antwort. Beispiel 03 geht die wichtigsten Fälle durch:
Die Routing-Tabelle ordnet jede URL [/responses/xxx] der Action [xxx] des Controllers zu:
Der Controller [ResponsesController]:
Kommentieren wir diesen Code:
- Zeilen 16–19: Die Funktion [response] erzeugt eine vollständige HTTP-Antwort, ein Objekt [Illuminate\Http\Response], dessen erster Parameter der Body ist. [Laravel] stellt viele Funktionen dieser Art bereit, die überall verfügbar sind und die es „Helper“ nennt: [response], [redirect], [abort], [view], [collect] ... Die Methode [header] setzt einen Header der Antwort – hier ihren Typ: [text/plain] (einfacher Text). Der Browser interpretiert die Tags nicht. [header] gibt die Antwort selbst zurück: Die Aufrufe lassen sich aneinanderreihen;
- Zeilen 23–25: dieselbe Zeichenkette, für sich allein zurückgegeben: [Laravel] sendet sie mit dem Typ [text/html], und der Browser interpretiert sie;
- Zeilen 29–31: [response()] liefert ohne Parameter aufgerufen eine Factory für Antworten, deren Methode [json] ihren Parameter in JSON umwandelt und eine Antwort vom Typ [application/json] erzeugt (ein [JsonResponse]-Objekt). Die Umwandlung übernimmt die Funktion [json_encode] von [PHP]: Ein Objekt wird zu einem JSON-Objekt, dessen Felder die öffentlichen Eigenschaften des Objekts sind. Die Klasse [Person] wird weiter unten beschrieben;
- Zeilen 35–37: noch einfacher: Eine Action, die ein Array zurückgibt, erzeugt eine JSON-Antwort, ohne [response()->json] aufzurufen. Das [PHP] -Array ist eine universelle Struktur: [['lastName' => 'Martin', ...]] ist ein assoziatives Array, in dem jedes Element einen Schlüssel hat (hier ['lastName']); es wird zu einem JSON-Objekt. Ein gewöhnliches Objekt dagegen kann nicht für sich allein ausgegeben werden: [Laravel] würde versuchen, es in eine Zeichenkette umzuwandeln, und der Vorgang würde fehlschlagen („Object of class App\Models\Person could not be converted to string“); es muss über [response()->json] ausgegeben werden;
- Zeilen 41–43: Ein Array mit impliziten Schlüsseln (0, 1, 2) ist eine Liste; sie wird zu einem JSON-Array;
- Zeilen 47–49: Die Funktion [collect] erzeugt eine [Laravel] -Collection – ein Objekt, das ein Array umhüllt und etwa hundert Methoden zu seiner Transformation bereitstellt –, die dann aneinandergereiht werden: [sort] sortiert die Elemente, [values] nummeriert die Schlüssel ab 0 neu, und [map] wendet eine Funktion auf jedes Element an. [fn (int $n) => $n * 10] ist eine Pfeilfunktion: eine anonyme Funktion, die auf einen Ausdruck reduziert ist und dessen Wert zurückgibt. Eine von einer Action zurückgegebene Collection wird ebenfalls zu einem JSON-Array. Auf Collections kommen wir im Zusammenhang mit Datenbanken in Kapitel 9 zurück;
- Zeilen 53–55: Der zweite Parameter von [json] ist der Statuscode: 201 ([Created]) ersetzt 200. Ein dritter, optionaler Parameter würde Header liefern: [['X-Example' => '03']];
- Zeilen 59–61: Der Code 204 ([No Content]) bedeutet „nichts anzuzeigen“: Die Antwort hat keinen Body;
- Zeilen 65–67: ein „erwarteter“ Fehler: eine Antwort 404 ([Not Found]) mit einem von der Action gewählten Body (JSON);
- Zeilen 71–73: derselbe Fehler, erzeugt von der Funktion [abort]. [abort] gibt nichts zurück: Es wirft eine Ausnahme ([NotFoundHttpException] für den Code 404), die die Action beendet; [Laravel] wandelt sie in eine Fehlerantwort um. Der Typ [never] zeigt an, dass die Methode nie normal endet. Das ist die gebräuchlichste Art, eine Action wegen eines Fehlers zu beenden, auch tief in einer von der Action aufgerufenen Funktion;
- Zeilen 77–79: ein „unerwarteter“ Fehler – eine Ausnahme, die niemand behandelt – erzeugt eine Antwort 500 ([Internal Server Error]). Die Anweisung [throw] wirft eine Ausnahme; [RuntimeException] ist eine Ausnahmeklasse aus der Standardbibliothek von [PHP], die wie jede andere Klasse über ein [use] importiert wird (Zeile 10). Die Action heißt nicht [exception], wie in den anderen Versionen des Kurses: Für [Laravel] würde sich eine Action namens ['exception'] auf die Klasse [Exception] von [PHP] beziehen (bei Klassennamen wird die Groß-/Kleinschreibung nicht unterschieden), und die Route würde abgelehnt.
Die Klasse [Person]:
- Zeile 8: [readonly] macht alle Eigenschaften der Klasse nach ihrer Initialisierung unveränderbar: Ein [Person]-Objekt ist unveränderlich;
- Zeilen 10–14: [__construct] ist der Konstruktor der Klasse, aufgerufen durch [new Person('Martin', 'Jean', 42)]. Seine Parameter, denen [public] vorangestellt ist, sind hochgestuft (promoted): Jeder deklariert eine gleichnamige Eigenschaft, die durch den Parameter initialisiert wird. Diese Syntax erspart es, die Eigenschaften zu deklarieren und sie dann im Rumpf des Konstruktors (der hier leer ist) einzeln zuzuweisen. Die Eigenschaften sind öffentlich: [json_encode] kann auf sie zugreifen.
Bleibt noch die Datei [bootstrap/app.php]:
- Zeile 15: Der Anwendung wird eine Middleware-Komponente hinzugefügt: die Klasse [ReadableJson], die unten gezeigt wird.
Standardmäßig erzeugt [Laravel] kompaktes, einzeiliges JSON, in dem Nicht-ASCII-Zeichen als Escape-Sequenzen geschrieben werden: [créée] wird zu [cr\u00e9\u00e9e], was gültiges JSON, aber nicht sehr gut lesbar ist. Für die Beispiele dieses Kurses wünschen wir uns lesbares JSON. Eine Middleware ist eine Klasse, deren Methode [handle]*** bei jeder Anfrage aufgerufen wird und die Action *umschließt: [$next($request)] gibt die Anfrage an den Rest der Anwendung weiter (die anderen Middleware, dann die Action) und liefert die Antwort zurück (Zeile 17). Die Middleware kann sie dann ändern: Handelt es sich um eine JSON-Antwort (der Operator [instanceof] prüft die Klasse eines Objekts), ändert sie ihre Kodierungsoptionen: Nicht-ASCII-Zeichen und Schrägstriche werden unverändert geschrieben, und die Ausgabe wird eingerückt (Zeile 21). Der Operator [|] kombiniert die drei Optionen, bei denen es sich um Konstanten von [PHP] handelt. Das Kapitel zum Lebenszyklus einer Anfrage untersucht Middleware im Detail; die Beispiele 05 bis 12 verwenden diese wieder.
In einem Browser ist der Unterschied zwischen [text/plain] und [text/html] sichtbar:


Hier sind die Antworten der anderen Actions:
Das Objekt wurde in ein JSON-Objekt umgewandelt, mit einem Feld pro öffentlicher Eigenschaft. Die Action [/responses/array] erzeugt exakt dieselbe Antwort.
Die Antwort von [abort] ist die standardmäßige 404-Fehlerseite von [Laravel], wie in Beispiel 02 gezeigt. Unsere Meldung erscheint dort nicht: Die Standardseite zeigt nur den Code und seine Bezeichnung an. Sie erscheint jedoch, wenn der Client über den Header [Accept: application/json] (Option [-H] von [curl]) eine JSON-Antwort anfordert: [Laravel] passt dann seine Fehlerantworten an, die zu JSON-Dokumenten werden:
Im Debug-Modus enthält das JSON-Dokument außerdem den Namen der Ausnahme, die Datei und die Zeile, in der sie geworfen wurde, sowie den Aufruf-Stack (die Liste der Funktionen, die zum Zeitpunkt des Fehlers ausgeführt wurden). Ohne Debug-Modus enthält es nur die Meldung. Kapitel 7 zeigt, wie die Meldung auf einer benutzerdefinierten Fehlerseite angezeigt wird.
Bleibt noch die unbehandelte Ausnahme. Im Debug-Modus zeigt der Browser die Fehlerseite von [Laravel] an: den Typ und die Meldung der Ausnahme, die Datei und die Zeile, in der sie geworfen wurde, und dann den Aufruf-Stack – vom jüngsten bis zum ältesten Eintrag – mit der jeweils relevanten Codezeile:

Der erste Eintrag im Stack ist unsere Action [unexpectedError] in Zeile 79 der Datei [ResponsesController.php]. Weiter unten zeigt die Seite die Anfrage (ihre Header und Parameter) und die Anwendung (Routen und Einstellungen) an: Deshalb sollte der Debug-Modus niemals auf einem Server aktiviert sein, der für andere erreichbar ist. Die Schaltfläche „Copy as Markdown“ kopiert die Fehlerbeschreibung, bereit zum Einfügen in eine Frage an eine KI. Der Fehler wird außerdem in das Log der Anwendung geschrieben, die Datei [storage/logs/laravel.log] (wir zeigen hier nur den Anfang):
Ohne Debug-Modus ([APP_DEBUG=false] in [.env]) erzeugt dieselbe Anfrage eine knappe Fehlerseite, „500 | Server Error“, die nichts über den Code verrät; der Fehler wird nur im Log beschrieben. Kapitel 7 zeigt, wie eine anwendungsspezifische Fehlerseite angezeigt wird.
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. Der Controller [RedirectsController]:
- Zeilen 11–13: Die Funktion [redirect] erzeugt eine Weiterleitungsantwort (ein [RedirectResponse]-Objekt) an die angegebene Adresse. Der Code 301 ([Moved Permanently]) bedeutet, dass die Seite ihre Adresse dauerhaft geändert hat: Der Browser (und Suchmaschinen) können sich die neue merken;
- Zeilen 23–25: Ohne zweiten Parameter erzeugt [redirect] eine vorübergehende Weiterleitung mit dem Statuscode 302 ([Found]). Die URL wird durch Verkettung von Textfragmenten (der Operator [.]) gebildet, was ein Problem darstellt, wie wir sehen werden;
- Zeilen 30–32: Ohne Parameter aufgerufen, liefert [redirect()] ein Objekt, dessen Methode [route] eine Weiterleitung zu einer Route erzeugt, die über ihren Namen (['page']) statt über ihren Pfad identifiziert wird. Das assoziative Array liefert die Routenparameter (hier [name]), korrekt kodiert für eine URL. Wird der Pfad der Route [page] jemals geändert, werden die Weiterleitungen dorthin automatisch aktualisiert;
- Zeilen 41–43: eine Weiterleitung auf eine andere Site. Die Methode [away] übernimmt die Adresse unverändert.
Ihr wird in der Routing-Tabelle ein Routenname zugewiesen:
- Zeile 7: eine Gruppe von Routen ohne Präfix, die sich nur den Controller teilen (Beispiel 02);
- Zeile 13: Die Methode [name] weist der Route einen Namen zu. Die überall verfügbare Funktion [route] erzeugt die URL für eine benannte Route: [route('page', ['name' => 'a?b'])] ergibt [http://localhost:8000/page/a%3Fb].
Die Ergebnisse mit [curl] (das ohne Optionen Weiterleitungen nicht folgt):
[Laravel] hat die Adresse [/new] in eine absolute Adresse umgewandelt (einschließlich Protokoll, Host und Port), die aus der empfangenen Anfrage berechnet wird. Die Antwort enthält außerdem einen kurzen HTML-Body für einen Client, der Weiterleitungen nicht folgt. Die Option [-L] von [curl] folgt der Weiterleitung, genau wie ein Browser es tun würde:
Vergleichen wir nun die beiden berechneten Weiterleitungen mit einem Ziel, das ein Fragezeichen enthält, in der URL codiert als [%3F] (ein nicht codiertes [?] würde die Parameter der URL einleiten):
[Laravel] hat den Routenparameter vor der Verarbeitung decodiert: [$destination] entspricht [a?b]. Die erste Action setzt ihn unverändert wieder in die Adresse ein: [/page/a?b], was der Browser als Pfad [/page/a] mit dem Parameter [b] interpretiert. Die zweite Action folgt der benannten Route, deren Parameter erneut codiert wird: [/page/a%3Fb]. Wir folgen den Weiterleitungen:
Nur die zweite führt zur richtigen Seite. Daraus folgt die Regel: Eine Adresse mit einem variablen Wert wird mit [route] erzeugt, niemals durch das Verketten von Zeichenketten. Im Browser ist nur die endgültige Seite zu sehen; die Adressleiste zeigt die neue URL an:

Es gibt zwei weitere Weiterleitungscodes: 303 ([See Other]) und 307 ([Temporary Redirect]), die man mit [redirect($url, 303)] erhält. Nach einer POST-Anfrage veranlassen die Codes 302 und 303 den Browser, eine GET-Anfrage an die neue Adresse zu senden, während 307 (und 308, die dauerhafte Variante) ihn dazu bringen, die POST-Anfrage zu wiederholen. Beispiel 20 verwendet eine Weiterleitung nach einem POST.
2.5. Beispiel 05: Die Objekte Request und Response
Bisher erhielten Actions nur Routenparameter und gaben einen Wert zurück, den [Laravel] in eine Antwort umwandelte. Eine Action kann auch auf die aktuelle Anfrage zugreifen und die Antwort selbst aufbauen. Der Controller [HttpController]:
- Zeile 15: Die Action hat einen Parameter vom Typ [Request]. Dieser Parameter stammt nicht aus der URL: [Laravel] erkennt seinen Typ und übergibt ihr das [Request]-Objekt der aktuellen Anfrage. Das ist Dependency Injection, die das folgende Beispiel ausführlich veranschaulicht: Eine Action deklariert über die Typen ihrer Parameter die Objekte, die sie benötigt, und [Laravel] stellt sie bereit. Die Reihenfolge der Parameter spielt keine Rolle: Eine Action kann sowohl die Anfrage als auch Routenparameter erhalten;
- Zeilen 17–24: einige Methoden der Anfrage: ihre HTTP-Methode, ihr Pfad (ohne den führenden Schrägstrich), ihre vollständige URL, ihre unverarbeiteten Parameter (der Teil der URL, der auf das Zeichen [?] folgt), der Header [User-Agent] (der Browser; [$request->header('User-Agent')] ist die kürzere Schreibweise) und die IP-Adresse des Clients. Die Klasse [Illuminate\Http\Request] erbt von der Klasse [Request], die ihrerseits von [Symfony] erbt, einem weiteren [PHP]-Framework, auf dessen Komponenten [Laravel] aufbaut. Die einzelnen Parameter werden im nächsten Kapitel behandelt. Der zurückgegebene Typ [array] erzeugt eine JSON-Antwort (Beispiel 03);
- Zeilen 28–31: Die von [response] erzeugte Antwort erhält einen Header [X-Example] (per Konvention beginnen anwendungsspezifische Header oft mit [X-]);
- Zeilen 35–38: die „von Hand“ mit dem Operator [new] aufgebaute Antwort: der Body, der Statuscode und die Header;
- Zeilen 43–52: eine in Teilen gesendete Antwort (Chunks) (*Streaming*). [response()->stream] erhält eine Funktion, die den Body der Antwort selbst schreibt, und zwar mit [echo] (der Anweisung von [PHP] , die in die Antwort schreibt); [flush()] sendet das Geschriebene sofort an den Browser. Die Länge der Antwort ist im Voraus nicht bekannt: Der Server sendet den Statuscode und die Header und anschließend jeden Chunk, sobald er erzeugt ist. Das ist nützlich für eine sehr lange Antwort, die nach und nach erzeugt wird. Sobald aber der erste Chunk gesendet wurde, kann sich der Statuscode nicht mehr ändern: Hier löst die Funktion nach dem ersten Chunk eine Exception aus. Das ist der Fehler, den es zu vermeiden gilt: Eine bereits begonnene Antwort kann nicht mehr zu einer Fehlerantwort werden.
Die Routing-Tabelle und [bootstrap/app.php] enthalten nichts Neues ([bootstrap/app.php] fügt die Middleware [ReadableJson] aus Beispiel 03 hinzu). Die Antworten:
Die Anführungszeichen um „URL“ verhindern, dass das Terminal das Zeichen „[&]“ interpretiert. Beachten Sie, dass die Parameter alphabetisch sortiert wurden: [getQueryString] und [fullUrl] erzeugen eine normalisierte Form der Parameterzeichenkette, die den Vergleich zweier URL-Werte ermöglicht (das ist zum Beispiel für einen Cache nützlich). In einem Browser ist der Header [User-Agent] der Header des Browsers.
Nach einer Sekunde bricht die Antwort ab: [curl] erhielt den Statuscode 200 und einen abgeschnittenen Body, ohne erkennen zu können, dass ein Fehler aufgetreten ist. Nur das Anwendungsprotokoll zeigt dies durch zwei Fehler an: unsere Exception, gefolgt vom Scheitern von [Laravel], das versuchte, eine Fehlerseite zu senden, obwohl die Header bereits gesendet waren:
2.6. Beispiel 06: Gemeinsam genutzte Services und Dependency Injection
Eine Action sollte die Anwendungslogik nicht selbst enthalten; sie delegiert sie an Services – Objekte, die eine bestimmte Aufgabe erledigen können (Produkte lesen, einen Warenkorb berechnen usw.). Mehrere Actions verwenden oft denselben Service. [Laravel] besitzt, wie [Spring] oder [ASP.NET Core], einen Service-Container: ein Objekt, das Services erstellt und sie automatisch denjenigen bereitstellt, die sie benötigen. Das ist Dependency Injection, der wir in Beispiel 05 beim Objekt [Request] bereits begegnet sind. Beispiel 06 organisiert seinen Code nach Fachbereichen (Produkte, Kunden) statt nach Typen (Controller, Modelle):
Es ist nicht zwingend, Controller in [app/Http/Controllers] abzulegen: [Laravel] findet eine Klasse anhand ihres vollständigen Namens gemäß dem Standard [PSR-4] (die Klasse [App\Products\ProductsController] befindet sich in der Datei [app/Products/ProductsController.php]).
2.6.1. Das Produkt
- Zeile 9: eine unveränderliche Klasse (siehe Beispiel 03). Ein unveränderliches Objekt kann bedenkenlos von mehreren Teilen des Codes gemeinsam genutzt werden;
- Zeilen 12–15: die vom Konstruktor übernommenen Eigenschaften samt ihren Typen. Der Preis ist ein [BigDecimal], eine exakte Dezimalzahl, die von der Bibliothek [brick/math] bereitgestellt wird (installiert mit [Laravel], das sie selbst verwendet). [PHP] hat keinen Dezimaltyp: Eine Gleitkommazahl vom Typ [float] wird binär dargestellt und kann 0,1 oder 3,2 nicht exakt darstellen (binär haben diese Zahlen unendlich viele Stellen): Eine Preissumme in [float] könnte 5.500000000000001 ergeben.
2.6.2. Der Service-Vertrag: ProductsService.php
- Zeile 6: der Vertrag des Services: was er kann, ohne festzulegen, wie. In [PHP] wird ein Vertrag wie in [Java] oder [C#] durch ein Interface definiert: eine Liste von Methoden ohne Rumpf, die alle von einer Klasse implementiert werden müssen, die das Interface implementiert;
- Zeile 8: ein Dokumentationskommentar ([/** ... */]). Der Typ [array] gibt nicht an, was das Array enthält; die Annotation [@return list<Product>] – die [PHP] ignoriert – gibt es für den Code-Editor an: eine Liste von Produkten;
- Zeile 11: [?Product]: ein Produkt oder [null] , wenn es nicht existiert.
2.6.3. Die Implementierung: InMemoryProductsService.php
- Zeile 8: Die Klasse implementiert den Vertrag und definiert seine beiden Methoden;
- Zeile 11: eine private Eigenschaft: Nur der Code der Klasse kann sie verwenden;
- Zeilen 13–19: Der Konstruktor speichert die Produkte in der Eigenschaft [$this->products] ([$this] ist das aktuelle Objekt). [BigDecimal::of('1.5')] erzeugt eine Dezimalzahl aus einer Zeichenkette: Würde sie aus dem [float] 1.5 erzeugt, erbte sie dessen Ungenauigkeiten;
- Zeilen 22–25: Die Methode gibt das Array der Produkte zurück. In [PHP] ist ein Array ein Wert, der bei der Übergabe kopiert wird: Der Aufrufer erhält eine Kopie, die er ändern kann, ohne die Daten des Services zu beeinflussen (die [Product]-Objekte hingegen werden nicht kopiert, sind aber unveränderlich);
- Zeilen 28–30: Die Funktion [array_find] ([PHP] 8.4) gibt das erste Element eines Arrays zurück, für das die übergebene Funktion [true] liefert, oder [null] , wenn es kein solches gibt. [===] steht für strikte Gleichheit: gleicher Wert und gleicher Typ.
2.6.4. Der Produkt-Controller: ProductsController.php
- Zeilen 12–14: Der Controller benötigt den Service; er deklariert ihn als Parameter seines Konstruktors. Wenn [Laravel] den Controller erstellt (um eine Anfrage zu verarbeiten), untersucht es die Typen der Konstruktorparameter, fordert vom Container für jeden Typ ein Objekt an und übergibt sie dem Konstruktor: Das ist Konstruktorinjektion. Der mit [private] versehene Parameter wird zu einer privaten Eigenschaft hochgestuft (siehe Beispiel 03): Die Actions verwenden ihn über [$this->service]. Der Controller kennt nur den Vertrag des Services (das Interface), nicht seine Implementierung: Er weiß nicht, dass die Produkte im Speicher liegen;
- Zeilen 16–18: Die Action delegiert die Arbeit an den Service. Das zurückgegebene Array von Produkten wird zu einem JSON-Array (Beispiel 03): Jedes [Product] wird zu einem JSON-Objekt (seine Eigenschaften sind öffentlich);
- Zeilen 21–27: Ein unbekanntes Produkt liefert eine 404-Antwort mit einer Meldung in JSON. Ein einzelnes [Product]-Objekt muss über [response()->json] ausgegeben werden (Beispiel 03).
2.6.5. Der Kunden-Controller: ClientsController.php
- Zeile 13: Dieser Controller verwendet denselben Service wie der Produkt-Controller. Diesmal erhält er ihn als Parameter der Action: [Laravel] injiziert auch die Parameter von Actions, wie bei der Anfrage aus Beispiel 05. Die Injektion über den Konstruktor eignet sich für Services, die alle Actions benötigen; die Injektion über die Action eignet sich für Services, die nur eine einzelne Action benötigt;
- Zeilen 17–18: [array_reduce] reduziert ein Array auf einen einzelnen Wert: Die Funktion erhält den akkumulierten Wert ([$sum]) und das aktuelle Element und gibt den neuen akkumulierten Wert zurück; der dritte Parameter ist der Startwert, ein [BigDecimal] mit dem Wert null. [plus] addiert zwei Dezimalzahlen und gibt eine neue Dezimalzahl zurück (ein [BigDecimal] ist unveränderlich);
- Zeile 19: [count] gibt die Anzahl der Elemente eines Arrays zurück.
2.6.6. Die Service-Deklaration: bootstrap/app.php
- Zeilen 20–22: Hier, und nur hier, wird die Implementierung des Services festgelegt. Das Array ordnet einem angeforderten Typ (dem Interface) die Klasse zu, die ihn bereitstellt. Wenn eine Klasse einen [ProductsService] anfordert, erstellt der Container einen [InMemoryProductsService]; [withSingletons] gibt an, dass er nur einmal erstellt wird: Jeder, der danach einen [ProductsService] anfordert, erhält dasselbe Objekt. Das ist ein Singleton. Um zu einer Implementierung zu wechseln, die aus einer Datenbank liest, müsste man lediglich diese Zeile ändern: Die Controller, die nur den Vertrag kennen, blieben unverändert. Genau darin liegt der Sinn der Dependency Injection: Jeder Teil der Anwendung hängt von Verträgen ab, und eine einzige Stelle entscheidet über die Implementierungen.
Eine konkrete Klasse (die kein Interface ist) muss nicht einmal deklariert werden: Der Container weiß selbst, wie er sie erstellt, indem er die Parameter in ihren Konstruktor injiziert. So erstellt er die Controller. Ein Interface hingegen muss einer Implementierung zugeordnet werden; andernfalls scheitert der Container („Target [App\Products\ProductsService] is not instantiable“). Diese Zuordnung kann auch am Interface selbst deklariert werden, mit einem Attribut (einer Annotation, in [PHP]): [#[Bind(InMemoryProductsService::class)]] über [interface ProductsService] und [#[Singleton]] über der Implementierungsklasse. Wir behalten die Deklaration in [bootstrap/app.php] bei, das alle Entscheidungen der Anwendung an einer einzigen Stelle bündelt; die Fallstudie fasst sie in einem Service-Provider zusammen, der Klasse, die [Laravel] dafür bereitstellt.
Zum Schluss noch ein Wort zur Lebensdauer dieses Singletons. Wie wir in Beispiel 01 gesehen haben, wird die Anwendung in [PHP] bei jeder Anfrage neu aufgebaut. Das Singleton ist daher auf eine einzelne Anfrage beschränkt: Alle Klassen, die es während der Verarbeitung einer Anfrage anfordern, erhalten dasselbe Objekt, die nächste Anfrage erhält jedoch ein neues. Für einen Service, der nur statische Daten liest, wie diesen hier, macht das keinen Unterschied. Bei einem Service, dessen Daten sich ändern (die Aufgabenliste in Beispiel 20), müssen diese Daten an anderer Stelle als im Objekt gespeichert werden: in einer Datei, in einer Datenbank oder im Cache von [Laravel]. Andererseits kann ein [PHP]-Service nicht von zwei Anfragen gleichzeitig verwendet werden: Jede Anfrage hat ihren eigenen. Die Vorkehrungen, die für Services nötig sind, die von mehreren gleichzeitigen Anfragen gemeinsam genutzt werden, in [Java], [C#] oder [Python] (insbesondere Sperren), sind hier nicht erforderlich.
Die Routing-Tabelle:
2.6.7. Ausführung
Die Preise sind zu Zeichenketten geworden (["1.5"]): JSON kennt nur einen Zahlentyp, den die meisten Programme als Gleitkommazahl lesen; ein [BigDecimal] wird daher in eine Zeichenkette umgewandelt, um keine Genauigkeit zu verlieren (die Klasse [BigDecimal] implementiert das Interface [JsonSerializable] von [PHP], das ihr erlaubt, ihre JSON-Form selbst zu wählen).