Effiziente URL-Steuerung mit PHP-Routern - Einfache Ansätze

Inhalt

• Wofür wird ein Router verwendet?
• Ein einfacher Router
  • Schematische Funktionsweise
• Vorteile dieses Ansatzes
• Komplexerer Router
• Ein Router mit Middleware und Platzhalter

Wofür wird ein Router verwendet?

Ein Router wird verwendet, um URLs mit Aktionen zu verbinden und er leitet Anfragen wie GET /about an eine spezifische Funktion oder einen Controller weiter (MVC-Design Pattern). Ein Router verbessert die Flexibilität und Dynamik und ermöglicht, Anfragen effizient abzufangen, zu analysieren und darauf reagieren. Zudem können Fehlerseiten bequem verwaltet werden und Routen, die nicht existieren, können elegant mit einer 404-Seite behandelt werden.

Ein einfacher Router

Ein PHP Router ist ein Werkzeug, das Webanfragen verarbeitet und diese an die entsprechende Funktion oder Datei weiterleitet. Anstatt für jede Seite eine eigene PHP-Datei zu erstellen, können Entwickler mit einem Router die gesamte Anfragensteuerung zentral verwalten. Dies fördert eine klare Struktur und erleichtert die Wartung von Anwendungen, insbesondere in größeren Projekten.

$routes = [
    'GET' => [
        '/'       => function() {echo "Willkommen auf der Startseite!";},
        '/about'  => function() {echo "Dies ist die Über uns-Seite.";}
    ],
    'POST' => [
        '/submit' => function() {echo "Formular wurde gesendet.";}
    ]
];

$requestUri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
$requestMethod = $_SERVER['REQUEST_METHOD'];

if (isset($routes[$requestMethod][$requestUri])) {
    $routes[$requestMethod][$requestUri]();
} else {
    http_response_code(404);
    echo "404 - Nicht gefunden";
}

Einfacher Router - Grundform

Gibt der Besucher die URL http://domain.de/about ein, erfolgt die Anzeige von Dies ist die Über uns-Seite. Entsprechend Willkommen auf der Startseite!, wenn der Leser / im Browser eingibt. Zudem kann der Router auf das Absenden von Eingabeformularen die mit POST gesendet werden, gesondert reagieren.

Schematische Funktionsweise

1. Anfrage abfangen: Der Router analysiert die HTTP-Methode (z. B. GET, POST) und die angeforderte URL (/, /about). Dies erfolgt durch den simplen Schlüssel-Zugriff auf das Array $routes['GET'] oder das Array $routes['POST'].

2. Route identifizieren: Anhand einer Liste (oft als Array oder Tabelle implementiert) wird geprüft, ob eine passende Route existiert. In diesem Beispiel über den Befehl if (isset($routes[...][...])) realisiert, der auf die Existenz des Kay-Value Paares prüft.

3. Funktion ausführen: Der Router führt die mit der Route verknüpfte Funktion aus, die beispielsweise HTML oder JSON zurückgibt. Indem dem Befehl $request[...][...]() das Klammerpaar angehängt wird, interpretiert der Server dies als Methode und startet den darin enthaltenen Programmcode.

4. Fehlerbehandlung: Ist keine passende Route vorhanden, wird ein Fehler wie „404 - Nicht gefunden“ zurückgegeben.

Vorteile dieses Ansatzes

Das vorgestellte Beispiel verwendet ein einfaches Array zur Verwaltung der Routen. Dies hat folgende Vorteile:

1. Klarheit: Die Routen sind leicht verständlich in einem zentralen Array organisiert.

2. Kompakt und flexibel: Funktionen können direkt definiert werden, ohne zusätzliche Klassen oder komplexe Strukturen.

3. Leicht erweiterbar: Neue Routen lassen sich durch Hinzufügen von Einträgen schnell ergänzen.

Durch die Verwendung eines solchen Routers gewinnen Sie Struktur und behalten selbst bei wachsender Anwendung den Überblick.

Komplexerer Router

Der Hauptunterschied zwischen dem ersten und dem folgenden Codevorschlag liegt in der Komplexität und Struktur der beiden Ansätze. Beide implementieren einen PHP-Router, jedoch auf unterschiedlichen Ebenen von Flexibilität und Skalierbarkeit. Hier ist ein Vergleich:

class Router {
    private $routes = [];

    public function addRoute(string $method, string $path, callable $handler) {
        $this->routes[] = [
            'method' => strtoupper($method),
            'path' => $path,
            'handler' => $handler,
        ];
    }

    public function dispatch() {
        $requestMethod = $_SERVER['REQUEST_METHOD'];
        $requestUri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);

        foreach ($this->routes as $route) {
            if ($route['method'] === $requestMethod && $route['path'] === $requestUri) {
                call_user_func($route['handler']);
                return;
            }
        }

        http_response_code(404);
        echo "404 - Not Found";
    }
    }

    $router = new Router();

    $router->addRoute('GET', '/', function() {
    echo "Willkommen auf der Startseite!";
    });

    $router->addRoute('GET', '/about', function() {
    echo "Dies ist die Über uns-Seite.";
    });

    $router->addRoute('POST', '/submit', function() {
    echo "Formular wurde gesendet.";
    });

    $router->dispatch();

Komplexer PHP-Router

Ein Router mit Middleware und Platzhalter

Das folgende Coding implementiert ebenfalls einen Router nach dem bekannten Schematas aus den vorangegangenen Absätzen, jedoch wird so genannte middleware() hinzugefügt, die die Ausführung von zusätzlichem Code vor Start des Routings erlaubt.

Class Router 
{
    private $routes = [];
    private $middlewares = [];

    public function add($method, $path, $handler) {
        $this->routes[strtoupper($method)][] = [
            'path' => $this->convertPathToRegex($path),
            'handler' => $handler
        ];
    }

    public function addMiddleware(callable $middleware) {
        $this->middlewares[] = $middleware;
    }

    public function start($method, $uri) {
        $method = strtoupper($method);

        foreach ($this->middlewares as $middleware) {
            if (!$middleware($method, $uri)) {
                return;
            }
        }

        if (isset($this->routes[$method])) {
            foreach ($this->routes[$method] as $route) {
                if (preg_match($route['path'], $uri, $matches)) {
                    // Parameter extrahieren und Handler ausführen
                    array_shift($matches); // Erstes Element entfernen (kompletter Match)
                    return call_user_func_array($route['handler'], $matches);
                }
            }
        }

        http_response_code(404);
        echo "404 - Seite nicht gefunden!";
    }

    private function convertPathToRegex($path) {
        $path = preg_replace('/{([^}]+)}/', '([^/]+)', $path); // Platzhalter in Regex umwandeln
        return "#^" . $path . "$#";
    }
}

PHP Router mit middleware

Mit start() wird der Router und dessen Verarbeitung gestartet. Sofern funktionen für middleware existieren, werden diese vor dem eigentlichen Routing ausgeführt.