Skip to content

7. Der Lebenszyklus einer Anfrage

Zwischen dem Eintreffen einer Anfrage und dem Versand ihrer Antwort durchläuft [Laravel] mehrere Stufen, und die Anwendung kann an jeder von ihnen eingreifen. Mehreren davon sind wir bereits begegnet: Middleware (Beispiele 03, 12, 16, 22), Parameter-Binding von Routen (Beispiel 12) und Exception-Handler (Beispiele 08 und 12). Dieses Kapitel führt sie in einem einzigen Beispiel zusammen, das bei jedem Schritt eine Meldung in der Konsole ausgibt, damit Sie ihre Reihenfolge beobachten können:

  • 1 und 7. Globale Middleware, ausgeführt für alle Anfragen, noch vor dem Routing. Eine Middleware-Komponente umschließt die übrige Verarbeitung: Sie sieht die Anfrage vor sich vorbeilaufen und die Antwort nach sich (Beispiel 03). [Laravel] installiert standardmäßig mehrere (leere Zeichenketten werden zu [null], Wartungsmodus, CORS für Anfragen ...), in der Reihenfolge der Liste der globalen Middleware;
  • Routing. [Laravel] sucht die Route, die zur URL und zur Methode passt. Passt keine, wird eine [NotFoundHttpException]-Exception ausgelöst (404);
  • Die Gruppen- und Route-Middleware der Reihe nach: zuerst die der Gruppe [web] (Cookies, Session, Formularfehler, Anti-CSRF-Schutz, Parameter-Binding), dann die der Route. Eine davon, [SubstituteBindings], bindet die Routenparameter (2, Beispiel 12). Die Route-Middleware (3 und 4) ist der richtige Ort für Prüfungen, die für bestimmte Actions spezifisch sind: So funktioniert die [auth]-Middleware im nächsten Kapitel. Gibt eine von ihnen eine Antwort zurück, ohne [$next] aufzurufen (oder löst sie eine Exception aus), endet die Verarbeitung dort: Die Action wird nicht aufgerufen;
  • 5. Die Action und die von ihr erzeugte View;
  • 6. Das Ende der Middleware-Kette in umgekehrter Reihenfolge: Jede Komponente erhält die Antwort von [$next], kann sie ändern (einen Header oder ein Cookie hinzufügen) und muss sie zurückgeben;
  • 8. Die [terminate]-Methoden der Middleware-Komponenten, die eine besitzen, werden nach dem Senden der Antwort an den Browser ausgeführt. Sie können die Antwort nicht mehr ändern: Sie dienen für Aufgaben, die warten können (ein Log schreiben, Statistiken senden usw.), ohne den Benutzer warten zu lassen;
  • x. Exception-Handler: Eine Exception, die von einer Middleware-Komponente, einer Action oder einer View ausgelöst wird, wird an den für ihre Klasse registrierten Handler ([render] in [bootstrap/app.php]) übergeben, der eine Fehlerantwort erstellt. Diese Antwort läuft dann, genau wie eine reguläre Antwort, durch die Middleware-Komponenten zurück.

Das entspricht den Filtern in [Java] und den Interceptoren in [Spring MVC], den Action-Filtern in [ASP.NET Core MVC]und den Funktionen [before_request] / [after_request] von [Flask]. Das Besondere an [Laravel] ist, dass dort fast alles Middleware ist: Dasselbe Konzept dient zur Verarbeitung aller Anfragen (globale Middleware), einer Familie von Routen (Gruppen) oder einiger weniger Routen.

7.1. Beispiel 24: Die Schritte bei der Verarbeitung einer Anfrage

24-lifecycle/
├── app/
│   └── Http/
│       ├── Controllers/
│       │   └── CalcController.php
│       └── Middleware/
│           ├── Block.php
│           ├── Timing.php
│           └── Logger.php
├── bootstrap/
│   └── app.php
├── resources/
│   └── views/
│       ├── calc/
│       │   └── result.blade.php
│       ├── error.blade.php
│       └── layout.blade.php
├── routes/
│   └── web.php
└── ...

Die Anwendung hat nur eine Action, die das Quadrat einer ganzen Zahl berechnet: [/square/7]. Je nach URL gelingt sie oder schlägt auf verschiedene Weise fehl. Meldungen werden von der Funktion [error_log] von [PHP] in die Server-Konsole geschrieben, die vom Befehl [php artisan serve] angezeigt wird.

7.1.1. Die globale Middleware: app/Http/Middleware/Logger.php

<?php
// app/Http/Middleware/Logger.php: eine GLOBALE Middleware, die erste von allen: sie
// sieht jede Anfrage VOR dem Rest der Anwendung vorbeikommen und die Antwort DANACH

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class Logger
{
    public function handle(Request $request, Closure $next): Response
    {
        // error_log: eine Meldung in der Konsole des Entwicklungsservers
        error_log('--- '.$request->method().' '.$request->getRequestUri());
        error_log('1. global middleware Logger (before)');
        // der ganze Rest: die anderen Middlewares, das Routing, die Action, die View
        $response = $next($request);
        error_log('7. global middleware Logger (after: code '.$response->getStatusCode().')');
        return $response;
    }
}
  • Zeilen 16–17: Die Middleware zeigt die Anfrage an ([getRequestUri()]: Pfad und Parameter). Das ist Meldung Nr. 1: In [Laravel] ist noch nichts geschehen, nicht einmal das Routing;
  • Zeile 19: Die übrige Verarbeitung findet innerhalb dieses Aufrufs statt;
  • Zeile 20: Meldung Nr. 7, sobald alles andere abgeschlossen ist. [getStatusCode()] ist der Antwortcode.

Eine globale Middleware kennt die gewählte Route nicht, da das Routing noch nicht stattgefunden hat. Sie dient für Verarbeitungen, die für alle Anfragen gelten: Logging, Komprimierung und die Behandlung eines Proxys (die [TrustProxies]-Middleware von [Laravel] korrigiert die Adresse des Clients, wenn sich die Anwendung hinter einem Proxy-Server befindet; die Fallstudie behandelt dies im Zusammenhang mit der IP-Adresse der Clients).

7.1.2. Das Parameter-Mapping: routes/web.php

<?php
// routes/web.php: die Routen von Beispiel 24

use App\Http\Controllers\CalcController;
use App\Http\Middleware\Block;
use App\Http\Middleware\Timing;
use Illuminate\Support\Facades\Route;

// ein Parameter-BINDING: jeder Routenparameter namens {integer} wird von
// dieser Funktion umgewandelt, bevor er an die Action übergeben wird: eine Ganzzahl oder null, falls er
// keine Ganzzahl ist (dann entscheidet die Action)
Route::bind('integer', function (string $value) {
    error_log("2. binding of the parameter (received value: \"$value\")");
    $n = filter_var($value, FILTER_VALIDATE_INT);
    return $n === false ? null : $n;
});

// die Route: zwei Route-Middlewares, in dieser Reihenfolge vor der Action ausgeführt
Route::get('square/{integer}', [CalcController::class, 'square'])->name('square')
    ->middleware([Block::class, Timing::class]);
  • Zeilen 12–16: [Route::bind] registriert ein explizites Binding: Jeder Routenparameter mit dem Namen [{integer}] durchläuft diese Funktion, die den Text aus der URL erhält und den Wert zurückgibt, den die Action erhalten wird. Sie akzeptiert beliebigen Text und wandelt ihn in eine ganze Zahl um, oder in [null] , falls er keine ist: Anders als [whereNumber] (Beispiel 02), das für [/square/abc] eine 404-Seite liefern würde, entscheidet hier die Action. Sie gibt Meldung Nr. 2 aus. Das ist die andere Form des Route-Bindings aus Beispiel 12, das einen Parameter an eine Klasse band ([UrlRoutable]);
  • Zeilen 19–20: Die Route mit dem Namen [square] hat zwei Route-Middleware-Komponenten, die in dieser Reihenfolge ausgeführt werden, und zwar nach denen der Gruppe [web].

7.1.3. Die Route-Middleware: Block.php und Timing.php

<?php
// app/Http/Middleware/Block.php: eine ROUTE-Middleware, nur für die
// Routen ausgeführt, die sie anfordern

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class Block
{
    public function handle(Request $request, Closure $next): Response
    {
        // $request->route(): die vom Routing gewählte Route; getName(): ihr Name
        error_log('3. middleware Block (route: '.$request->route()->getName().')');
        if ($request->has('block')) {
            // eine Exception: der Rest (Timing, die Action) wird nicht ausgeführt
            abort(403);
        }
        return $next($request);
    }
}
  • Zeile 16: Meldung Nr. 3. Eine Route-Middleware kennt die gewählte Route: [$request->route()] gibt die Route zurück, und [getName()] gibt ihren Namen zurück;
  • Zeilen 17–19: Der Parameter [?block] der URL ([has] prüft sein Vorhandensein) verursacht einen 403-Fehler (*Forbidden*, Zugriff verweigert): [abort] löst eine Exception aus, die die Verarbeitung unterbricht.
<?php
// app/Http/Middleware/Timing.php: eine Route-Middleware, die VOR und NACH
// der Action wirkt, dann ein letztes Mal NACH dem Senden der Antwort (terminate)

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class Timing
{
    public function handle(Request $request, Closure $next): Response
    {
        error_log('4. middleware Timing (before)');
        // die Startzeit (hrtime: eine präzise Uhr, in Nanosekunden), gespeichert
        // in den Attributen der Anfrage (Geltungsbereich Anfrage, siehe Beispiel 12)
        $request->attributes->set('start', hrtime(true));
        $response = $next($request);
        error_log('6. middleware Timing (after: code '.$response->getStatusCode().')');
        return $response;
    }

    // terminate: ganz am Ende aufgerufen, NACHDEM die Antwort an den Browser gesendet wurde;
    // sie kann die Antwort nicht mehr ändern
    public function terminate(Request $request, Response $response): void
    {
        $start = $request->attributes->get('start');
        // die Messung hat nicht begonnen, falls die Anfrage vor dieser Middleware blockiert wurde
        if ($start !== null) {
            $ms = round((hrtime(true) - $start) / 1e6);
            error_log("8. terminate Timing (end, $ms ms)");
        }
    }
}
  • Zeilen 15–18: Meldung Nr. 4 und die Startzeit, gespeichert in den Attributen der Anfrage (Beispiel 12). [hrtime(true)] ist eine präzise Uhr in Nanosekunden, die zum Messen von Zeitspannen gedacht ist;
  • Zeile 20: Meldung Nr. 6, nach der Action, mit dem Antwortcode;
  • Zeilen 26–34: die Methode [terminate], die von [Laravel] nach dem Senden der Antwort mit der Anfrage und der Antwort aufgerufen wird: Meldung Nr. 8, mit der seit Meldung Nr. 4 verstrichenen Zeit. [Laravel] ruft sie für alle Middleware-Komponenten der Route auf, auch wenn diese nicht ausgeführt wurden (wenn eine vorherige Middleware-Komponente die Verarbeitung unterbrochen hat): Die Prüfung in Zeile 30 stellt sicher, dass die Messung begonnen hat.

7.1.4. Fehlerbehandlung: bootstrap/app.php

<?php
// bootstrap/app.php: die Anwendung von Beispiel 24

use App\Http\Middleware\Logger;
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Foundation\Configuration\Middleware;
use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;

(require __DIR__.'/../../vendor/autoload.php')->addPsr4('App\\', __DIR__.'/../app/');

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        // die Route, die Bootstrap ausliefert (siehe Beispiel 15)
        then: fn () => require __DIR__.'/../../common/bootstrap.php')
    ->withMiddleware(function (Middleware $middleware): void {
        // prepend: die globale Middleware Logger kommt VOR alle anderen
        $middleware->prepend(Logger::class);
    })
    ->withExceptions(function (Exceptions $exceptions): void {
        // eine "unerwartete" Exception eines bestimmten Typs: DomainException und ihre Unterklassen
        $exceptions->render(function (DomainException $e) {
            error_log("x. render DomainException ({$e->getMessage()})");
            // statt der Standardfehlerseite unsere View [error] mit dem Code 500
            return response()->view('error', ['code' => 500], 500);
        });
        // die HTTP-Fehler (abort(400), abort(403), unbekannte Seite -> 404...):
        // HttpExceptionInterface ist das Interface aller HTTP-Exceptions
        $exceptions->render(function (HttpExceptionInterface $e) {
            error_log("x. render HttpException (code {$e->getStatusCode()})");
            return response()->view('error', ['code' => $e->getStatusCode()], $e->getStatusCode());
        });
    })
    ->create();
  • Zeile 19: [prepend] setzt die globale Middleware an den Anfang der Liste: Sie läuft vor allen anderen und sieht die Antwort nach allen anderen;
  • Zeilen 23–27: Ein Exception-Handler für die Klasse [DomainException] (und ihre Unterklassen; siehe Beispiel 08): Ein „unerwarteter“ Fehler wird in eine benutzerdefinierte Fehlerseite mit dem Statuscode 500 (*Internal Server Error*) umgewandelt. Die Exception-Meldung wird in der Konsole angezeigt, nicht aber auf der Seite: Sie kann interne Details enthalten, die für den Benutzer nicht relevant sind;
  • Zeilen 30–33: ein Handler für alle HTTP-Fehler. [abort(400)], [abort(403)], eine URL einer nicht vorhandenen Route (404), eine unzulässige Methode (405): Alle lösen eine Exception aus, die die Schnittstelle [HttpExceptionInterface] von [Symfony] implementiert und ihren Code enthält ([getStatusCode()]). Dieser eine Handler ersetzt somit alle englischsprachigen Fehlerseiten von [Laravel] durch unsere.

[Laravel] übergibt eine Exception an den ersten Handler, dessen Parametertyp zu ihr passt. Eine Exception ohne Handler wird zu einem 500-Fehler: Im Debug-Modus ist das die detaillierte Seite (Beispiel 03), ohne Debug-Modus die standardmäßige 500-Fehlerseite. Es gibt eine weitere, noch einfachere Möglichkeit, Fehlerseiten zu ersetzen: Eine View mit dem Namen [resources/views/errors/404.blade.php] ersetzt die 404-Fehlerseite, und dasselbe gilt für jeden Fehlercode (Beispiel 26 verwendet diesen Ansatz). Die [render]-Handler hingegen erlauben jede Art der Behandlung: eine Log-Meldung, eine JSON-Antwort, eine Weiterleitung ...

7.1.5. Der Controller und die Fehlerseite

<?php
// app/Http/Controllers/CalcController.php: eine durch zwei Middlewares geschützte Action

namespace App\Http\Controllers;

use DomainException;
use Illuminate\View\View;

class CalcController
{
    // $n: der Routenparameter {integer}, gebunden durch Route::bind (siehe routes/web.php);
    // ein an null gebundener Parameter wird nicht an die Action übergeben: daher der Standardwert
    public function square(?int $n = null): View
    {
        error_log("5. action square($n)");
        if ($n === null) {
            abort(400);    // ein 400-Fehler: siehe bootstrap/app.php
        }
        if ($n === 13) {
            throw new DomainException('13 brings bad luck');    // ein "unerwarteter" Fehler
        }
        return view('calc.result', ['n' => $n, 'square' => $n * $n]);
    }
}
  • Zeile 13: Der Parameter [$n] erhält den von [Route::bind] gebundenen Wert. [Laravel] übergibt einen an [null] gebundenen Parameter nicht an die Action: Der Parameter der Action hat daher einen Standardwert, [null], der in diesem Fall sein Wert sein wird;
  • Zeile 17: ein Parameter, der keine ganze Zahl ist: Fehler 400;
  • Zeile 20: Die Zahl 13 verursacht einen „unerwarteten“ Fehler. [DomainException] ist eine Exception-Klasse aus der Standardbibliothek von [PHP];
  • Zeile 22: der Normalfall.
@extends('layout')
{{-- the error page; its model: the error code --}}

@section('content')
  <div class="alert alert-danger">
    <h1 class="h4">Error {{ $code }}</h1>
    <p class="mb-0">
      @switch($code)
        @case(400) Bad request. @break
        @case(403) Access denied. @break
        @case(404) Page not found. @break
        @default Internal server error.
      @endswitch
    </p>
  </div>
@endsection

Die Fehlerseite erhält den Fehlercode und zeigt eine passende Meldung an. Die Direktive [@switch] wählt anhand eines Wertes einen Block aus: [@case] gibt einen Wert an, [@break] beendet den Block, und [@default] behandelt die übrigen Werte. Die View [calc/result.blade.php] zeigt einfach das Ergebnis an.

7.1.6. Ausführung

Der Normalfall, [/square/7]:

Image

Die Server-Konsole zeigt die acht Schritte in der richtigen Reihenfolge an:

  --- GET /square/7
  1. global middleware Logger (before)
  2. binding of the parameter (received value: "7")
  3. middleware Block (route: square)
  4. middleware Timing (before)
  5. action square(7)
  6. middleware Timing (after: code 200)
  7. global middleware Logger (after: code 200)
  8. terminate Timing (end, 5 ms)
  2026-09-26 18:19:51 /square/7 .................................... ~ 0.35ms

Die letzte Zeile ist das Log des Entwicklungsservers, das geschrieben wird, sobald die Anfrage abgeschlossen ist. Ein blockierter Zugriff, [/square/7?block]:

Image

1
2
3
4
5
6
  --- GET /square/7?block
  1. global middleware Logger (before)
  2. binding of the parameter (received value: "7")
  3. middleware Block (route: square)
  x. render HttpException (code 403)
  7. global middleware Logger (after: code 403)

Die erste Route-Middleware hat eine Exception ausgelöst: Die zweite Middleware und die Action wurden nicht ausgeführt. Die vom Handler erzeugte Fehlerantwort wird an die globale Middleware weitergereicht. [terminate] wurde aufgerufen, zeigte aber nichts an, da die Messung nicht begonnen hatte. Ein Parameter, der keine ganze Zahl ist, [/square/abc]:

Image

  --- GET /square/abc
  1. global middleware Logger (before)
  2. binding of the parameter (received value: "abc")
  3. middleware Block (route: square)
  4. middleware Timing (before)
  5. action square()
  x. render HttpException (code 400)
  6. middleware Timing (after: code 400)
  7. global middleware Logger (after: code 400)
  8. terminate Timing (end, 6 ms)

Diesmal wurde die Action mit [null] aufgerufen (was als leere Zeichenkette dargestellt wird: [square()]), und diese Action löste den 400-Fehler aus. Ein „unerwarteter“ Fehler, [/square/13]:

Image

  --- GET /square/13
  1. global middleware Logger (before)
  2. binding of the parameter (received value: "13")
  3. middleware Block (route: square)
  4. middleware Timing (before)
  5. action square(13)
  x. render DomainException (13 brings bad luck)
  6. middleware Timing (after: code 500)
  7. global middleware Logger (after: code 500)
  8. terminate Timing (end, 3 ms)

Die Exception wurde von ihrem Handler behandelt: Der Benutzer sieht die „benutzerdefinierte“ Fehlerseite, nicht die detaillierte Seite, obwohl der Debug-Modus aktiviert ist. Die Exception wird weiterhin im Log [storage/logs/laravel.log] protokolliert: [Laravel] unterscheidet zwischen dem Report einer Exception (*report*, ihr Eintrag im Log) und ihrem Rendering (*render*, die Antwort). Schließlich eine URL, die keiner Route entspricht, [/unknown]:

1
2
3
4
  --- GET /unknown
  1. global middleware Logger (before)
  x. render HttpException (code 404)
  7. global middleware Logger (after: code 404)

Das Routing ist fehlgeschlagen: keine Verbindung, keine Route-Middleware, keine Action. Die 404-Seite ist unsere eigene:

curl http://localhost:8000/unknown
1
2
3
4
5
6
7
...
        <div class="alert alert-danger">
    <h1 class="h4">Error 404</h1>
    <p class="mb-0">
       Page not found.     </p>
  </div>
...

Konzentrieren wir uns auf das Wesentliche. Route-Middleware ist der richtige Ort für Prüfungen, die vielen Actions gemeinsam sind (ist der Benutzer angemeldet? Hat er die Berechtigung, auf diese Action zuzugreifen?): Das nächste Kapitel nutzt sie für die Authentifizierung. Exception-Handler und Views ([errors/...]) stellen sicher, dass der Benutzer unabhängig vom Fehler nie eine technische Seite sieht: Die Fallstudie nutzt dies.