Routinen

Standard Routing-Regeln

Die Standard Routing-Regel von Webman ist http://127.0.0.1:8787/{Controller}/{Aktion}.

Der Standard-Controller ist app\controller\IndexController, die Standard-Aktion ist index.

Beispielsweise:

http://127.0.0.1:8787 wird standardmäßig die Methode index der Klasse app\controller\IndexController aufrufen
http://127.0.0.1:8787/foo wird standardmäßig die Methode index der Klasse app\controller\FooController aufrufen
http://127.0.0.1:8787/foo/test wird standardmäßig die Methode test der Klasse app\controller\FooController aufrufen
http://127.0.0.1:8787/admin/foo/test wird standardmäßig die Methode test der Klasse app\admin\controller\FooController aufrufen (siehe Mehrere Anwendungen)

Zusätzlich unterstützt Webman seit Version 1.4 komplexere Standard-Routing-Regeln, wie z.B.

app
├── admin
│   └── v1
│       └── v2
│           └── v3
│               └── controller
│                   └── IndexController.php
└── controller
    ├── v1
    │   └── IndexController.php
    └── v2
        └── v3
            └── IndexController.php

Wenn Sie eine bestimmte Routing-Anfrage ändern möchten, bearbeiten Sie die Konfigurationsdatei config/route.php.

Wenn Sie das Standard-Routing deaktivieren möchten, fügen Sie am Ende der Konfigurationsdatei config/route.php folgende Konfiguration hinzu:

Route::disableDefaultRoute();

Closure Routing

Fügen Sie in config/route.php den folgenden Routing-Code hinzu:

use support\Request;
Route::any('/test', function (Request $request) {
    return response('test');
});

Hinweis
Da Closure-Funktionen zu keinem Controller gehören, sind $request->app, $request->controller und $request->action alle leer.

Wenn die Adresse http://127.0.0.1:8787/test aufgerufen wird, wird der String test zurückgegeben.

Hinweis
Der Routing-Pfad muss mit / beginnen, beispielsweise:

use support\Request;
// Falsche Verwendung
Route::any('test', function (Request $request) {
    return response('test');
});

// Richtige Verwendung
Route::any('/test', function (Request $request) {
    return response('test');
});

Klassenrouting

Fügen Sie in config/route.php den folgenden Routing-Code hinzu:

Route::any('/testclass', [app\controller\IndexController::class, 'test']);

Wenn die Adresse http://127.0.0.1:8787/testclass aufgerufen wird, wird der Rückgabewert der Methode test der Klasse app\controller\IndexController zurückgegeben.

Routing-Parameter

Wenn im Routing Parameter vorhanden sind, werden diese durch {key} abgeglichen, das Ergebnis wird an die Parameter der entsprechenden Controller-Methode übergeben (ab dem zweiten Parameter fortlaufend), zum Beispiel:

// Passend für /user/123 /user/abc
Route::any('/user/{id}', [app\controller\UserController::class, 'get']);

namespace app\controller;
use support\Request;

class UserController
{
    public function get(Request $request, $id)
    {
        return response('Parameter empfangen'.$id);
    }
}

Weitere Beispiele:

use support\Request;
// Passend für /user/123, nicht passend für /user/abc
Route::any('/user/{id:\d+}', function (Request $request, $id) {
    return response($id);
});

// Passend für /user/foobar, nicht passend für /user/foo/bar
Route::any('/user/{name}', function (Request $request, $name) {
   return response($name);
});

// Passend für /user, /user/123 und /user/abc   [] bedeutet optional
Route::any('/user[/{name}]', function (Request $request, $name = null) {
   return response($name ?? 'tom');
});

// Passend für alle Anfragen, die mit /user/ beginnen
Route::any('/user/[{path:.+}]', function (Request $request) {
    return $request->path();
});

// Passend für alle options-Anfragen   : wird gefolgt von einem regulären Ausdruck, der die Regel für diesen benannten Parameter angibt
Route::options('[{path:.+}]', function () {
    return response('');
});

Zusammenfassung für fortgeschrittene Anwendungen

[] Syntax wird in Webman-Routing hauptsächlich verwendet, um optionale Pfadteile zu behandeln oder dynamisches Routing abzugleichen. Es ermöglicht Ihnen, komplexere Pfadstrukturen und Abgleichregeln für Routing zu definieren.

: wird verwendet, um den regulären Ausdruck zu spezifizieren

Routing-Gruppe

Manchmal enthalten Routen viele gemeinsame Präfixe, zu diesem Zweck können wir Routing-Gruppen verwenden, um die Definition zu vereinfachen. Zum Beispiel:

Route::group('/blog', function () {
   Route::any('/create', function (Request $request) {return response('create');});
   Route::any('/edit', function (Request $request) {return response('edit');});
   Route::any('/view/{id}', function (Request $request, $id) {return response("view $id");});
});

Entspricht

Route::any('/blog/create', function (Request $request) {return response('create');});
Route::any('/blog/edit', function (Request $request) {return response('edit');});
Route::any('/blog/view/{id}', function (Request $request, $id) {return response("view $id");});

Gruppeneingebettete Verwendung

Route::group('/blog', function () {
   Route::group('/v1', function () {
      Route::any('/create', function (Request $request) {return response('create');});
      Route::any('/edit', function (Request $request) {return response('edit');});
      Route::any('/view/{id}', function (Request $request, $id) {return response("view $id");});
   });  
});

Routing-Middleware

Wir können für eine bestimmte Route oder eine Gruppe von Routen Middleware einstellen.
Zum Beispiel:

Route::any('/admin', [app\admin\controller\IndexController::class, 'index'])->middleware([
    app\middleware\MiddlewareA::class,
    app\middleware\MiddlewareB::class,
]);

Route::group('/blog', function () {
   Route::any('/create', function () {return response('create');});
   Route::any('/edit', function () {return response('edit');});
   Route::any('/view/{id}', function ($request, $id) {response("view $id");});
})->middleware([
    app\middleware\MiddlewareA::class,
    app\middleware\MiddlewareB::class,
]);

# Falsches Beispiel (diese Verwendung ist gültig, wenn webman-framework >= 1.5.7)
Route::group('/blog', function () {
   Route::group('/v1', function () {
      Route::any('/create', function (Request $request) {return response('create');});
      Route::any('/edit', function (Request $request) {return response('edit');});
      Route::any('/view/{id}', function (Request $request, $id) {return response("view $id");});
   });  
})->middleware([
    app\middleware\MiddlewareA::class,
    app\middleware\MiddlewareB::class,
]);

# Richtiges Beispiel
Route::group('/blog', function () {
   Route::group('/v1', function () {
      Route::any('/create', function (Request $request) {return response('create');});
      Route::any('/edit', function (Request $request) {return response('edit');});
      Route::any('/view/{id}', function (Request $request, $id) {return response("view $id");});
   })->middleware([
        app\middleware\MiddlewareA::class,
        app\middleware\MiddlewareB::class,
    ]);  
});

Ressourcen-Routing

Route::resource('/test', app\controller\IndexController::class);

// Gibt die Ressourcen-Routen an
Route::resource('/test', app\controller\IndexController::class, ['index','create']);

// Nicht-definierte Ressourcen-Routen
// Wenn notify die Zugriffsadresse dann ist es eine any Route /test/notify oder /test/notify/{id}, routeName ist test.notify
Route::resource('/test', app\controller\IndexController::class, ['index','create','notify']);

Verb	URI	Aktion	Routenname
GET	/test	index	test.index
GET	/test/create	create	test.create
POST	/test	store	test.store
GET	/test/{id}	show	test.show
GET	/test/{id}/edit	edit	test.edit
PUT	/test/{id}	update	test.update
DELETE	/test/{id}	destroy	test.destroy
PUT	/test/{id}/recovery	recovery	test.recovery

URL Generierung

Hinweis
Momentan werden keine generierten URLs für gruppenverschachtelte Routen unterstützt

Zum Beispiel das Routing:

Route::any('/blog/{id}', [app\controller\BlogController::class, 'view'])->name('blog.view');

Wir können folgende Methode verwenden, um die URL dieser Route zu generieren:

route('blog.view', ['id' => 100]); // Ergebnis ist /blog/100

Wenn Sie die URL der Routen in einer Ansicht verwenden, können Sie diese Methode anwenden, damit die URL automatisch generiert wird, egal wie sich die Routing-Regeln ändern und vermeiden, dass beim Anpassen der Routing-Adressen viele Ansichtsdateien geändert werden müssen.

Abrufen von Routeninformationen

Über das Objekt $request->route können wir Informationen der aktuellen Anfrage-Routen abrufen, zum Beispiel:

$route = $request->route; // Entspricht $route = request()->route;
if ($route) {
    var_export($route->getPath());
    var_export($route->getMethods());
    var_export($route->getName());
    var_export($route->getMiddleware());
    var_export($route->getCallback());
    var_export($route->param());
}

Hinweis
Wenn die aktuelle Anfrage keine in config/route.php konfigurierten Routen abgleicht, ist $request->route null, das heißt, bei Verwendung der Standardroute ist $request->route null.

Behandlung von 404

Wenn eine Route nicht gefunden wird, wird standardmäßig der Statuscode 404 zurückgegeben und der Inhalt zu 404 ausgegeben.

Wenn ein Entwickler in den Geschäftsablauf eingreifen möchte, wenn eine Route nicht gefunden wird, kann er die von Webman bereitgestellte Fallback-Route Route::fallback($callback) verwenden. Zum Beispiel, der folgende Code leitet um, wenn die Route nicht gefunden wird:

Route::fallback(function(){
    return redirect('/');
});

Oder wenn die Route nicht existiert, kann ein JSON-Daten zurückgegeben werden. Dies ist besonders nützlich, wenn Webman als API-Schnittstelle fungiert.

Route::fallback(function(){
    return json(['code' => 404, 'msg' => '404 nicht gefunden']);
});

Middleware zu 404 hinzufügen

Standardmäßig durchläuft eine 404-Anfrage keine Middleware. Wenn Sie Middleware zu einer 404-Anfrage hinzufügen möchten, beziehen Sie sich auf den folgenden Code.

Route::fallback(function(){
    return json(['code' => 404, 'msg' => '404 nicht gefunden']);
})->middleware([
    app\middleware\MiddlewareA::class,
    app\middleware\MiddlewareB::class,
]);

Verwandte Links Benutzerdefinierte 404 500 Seiten

Deaktivieren des Standard-Routings

// Deaktivieren des Standard-Routings des Hauptprojekts, beeinflusst nicht die Anwendungsplugins
Route::disableDefaultRoute();
// Deaktivieren des Routings der Admin-Anwendung des Hauptprojekts, beeinflusst nicht die Anwendungsplugins
Route::disableDefaultRoute('', 'admin');
// Deaktivieren des Standard-Routings des foo-Plugins, beeinflusst nicht das Hauptprojekt
Route::disableDefaultRoute('foo');
// Deaktivieren des Standard-Routings der Admin-Anwendung des foo-Plugins, beeinflusst nicht das Hauptprojekt
Route::disableDefaultRoute('foo', 'admin');
// Deaktivieren der Standardroute des Controllers [\app\controller\IndexController::class, 'index']
Route::disableDefaultRoute([\app\controller\IndexController::class, 'index']);

Annotation zum Deaktivieren des Standard-Routings

Wir können eine Annotation verwenden, um das Standard-Routing eines Controllers zu deaktivieren, zum Beispiel:

namespace app\controller;
use support\annotation\DisableDefaultRoute;

#[DisableDefaultRoute]
class IndexController
{
    public function index()
    {
        return 'index';
    }
}

Ebenso können wir eine Annotation verwenden, um das Standard-Routing einer Methode zu deaktivieren, zum Beispiel:

namespace app\controller;
use support\annotation\DisableDefaultRoute;

class IndexController
{
    #[DisableDefaultRoute]
    public function index()
    {
        return 'index';
    }
}

Routing-API

// Setzt eine Route für beliebige Methoden-Anfragen an $uri
Route::any($uri, $callback);
// Setzt eine Route für GET-Anfragen an $uri
Route::get($uri, $callback);
// Setzt eine Route für POST-Anfragen an $uri
Route::post($uri, $callback);
// Setzt eine Route für PUT-Anfragen an $uri
Route::put($uri, $callback);
// Setzt eine Route für PATCH-Anfragen an $uri
Route::patch($uri, $callback);
// Setzt eine Route für DELETE-Anfragen an $uri
Route::delete($uri, $callback);
// Setzt eine Route für HEAD-Anfragen an $uri
Route::head($uri, $callback);
// Setzt eine Route für OPTIONS-Anfragen an $uri
Route::options($uri, $callback);
// Setzt eine Route für mehrere Methoden gleichzeitig
Route::add(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'], $uri, $callback);
// Gruppen-Routing
Route::group($path, $callback);
// Ressourcen-Routing
Route::resource($path, $callback, [$options]);
// Deaktivieren von Routen
Route::disableDefaultRoute($plugin = '');
// Fallback-Routen, setzen Sie die Standardroute als Rückfall
Route::fallback($callback, $plugin = '');
// Abrufen aller Routing-Informationen
Route::getRoutes();

Wenn für uri keine entsprechende Route (einschließlich der Standardroute) vorhanden ist und keine Fallbackroute gesetzt ist, wird ein 404 zurückgegeben.

Mehrere Routing-Konfigurationsdateien

Wenn Sie mehrere Routing-Konfigurationsdateien verwenden möchten, um Routen zu verwalten, beispielsweise wenn jede Anwendung unter Mehrere Anwendungen ihre eigene Routing-Konfiguration hat, können Sie externe Routing-Konfigurationsdateien durch require laden.
Beispiel in config/route.php:

<?php

// Laden Sie die Routing-Konfiguration unter der Admin-Anwendung
require_once app_path('admin/config/route.php');
// Laden Sie die Routing-Konfiguration unter der API-Anwendung
require_once app_path('api/config/route.php');