Route

Regole di Routing Predefinite

Le regole di routing predefinite di webman sono http://127.0.0.1:8787/{controller}/{azione}.

Il controller predefinito è app\controller\IndexController e l'azione predefinita è index.

Ad esempio, accedendo a:

http://127.0.0.1:8787 si accederà per default al metodo index della classe app\controller\IndexController
http://127.0.0.1:8787/foo si accederà per default al metodo index della classe app\controller\FooController
http://127.0.0.1:8787/foo/test si accederà per default al metodo test della classe app\controller\FooController
http://127.0.0.1:8787/admin/foo/test si accederà per default al metodo test della classe app\admin\controller\FooController (riferimento a Multiapp)

Inoltre, webman dalla versione 1.4 supporta regole di routing più complesse, ad esempio

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

Quando desideri modificare un routing di richiesta, è necessario cambiare il file di configurazione config/route.php.

Se vuoi disabilitare il routing predefinito, aggiungi l'impostazione seguente all'ultima riga del file di configurazione config/route.php:

Route::disableDefaultRoute();

Routing a Chiusa

Aggiungere il seguente codice di routing nel file config/route.php

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

Nota
Poiché la funzione a chiusa non appartiene a nessun controller, $request->app, $request->controller e $request->action saranno tutti stringhe vuote.

Quando l'indirizzo di accesso è http://127.0.0.1:8787/test, verrà restituita la stringa test.

Nota
Il percorso del routing deve iniziare con /, ad esempio

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

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

Routing per Classe

Aggiungere il seguente codice di routing nel file config/route.php

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

Quando l'indirizzo di accesso è http://127.0.0.1:8787/testclass, verrà restituito il valore di ritorno del metodo test della classe app\controller\IndexController.

Parametri di Routing

Se nel routing sono presenti parametri, vengono abbinati tramite {chiave}, e i risultati dell'abbinamento vengono passati ai parametri del metodo del controller corrispondente (a partire dal secondo parametro), ad esempio:

// Abbina /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('Parametro ricevuto: '.$id);
    }
}

Altri esempi:

use support\Request;
// Abbina /user/123, non abbina /user/abc
Route::any('/user/{id:\d+}', function (Request $request, $id) {
    return response($id);
});

// Abbina /user/foobar, non abbina /user/foo/bar
Route::any('/user/{name}', function (Request $request, $name) {
   return response($name);
});

// Abbina /user /user/123 e /user/abc   [] indica opzionale
Route::any('/user[/{name}]', function (Request $request, $name = null) {
   return response($name ?? 'tom');
});

// Abbina qualsiasi richiesta con prefisso /user/
Route::any('/user/[{path:.+}]', function (Request $request) {
    return $request->path();
});

// Abbina tutte le richieste options   : seguito da un'espressione regolare che indica le regole di quest'ultimo parametro
Route::options('[{path:.+}]', function () {
    return response('');
});

Riepilogo sull'uso avanzato

La sintassi [] nella routing di Webman è principalmente utilizzata per gestire parti di percorso opzionali o corrispondere a routing dinamici, consentendoti di definire strutture di percorso e regole di corrispondenza più complesse

: per specificare espressioni regolari

Gruppi di Routing

A volte i routing contengono un gran numero di prefissi simili, in tal caso possiamo utilizzare gruppi di routing per semplificare la definizione. Ad esempio:

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");});
});

Equivalente a

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");});

Uso annidato di group

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 di Routing

Possiamo impostare middleware per un singolo routing o un gruppo di routing.
Ad esempio:

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,
]);

# Esempio di uso errato (valido se 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,
]);

# Esempio di uso corretto
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,
    ]);  
});

Routing di Tipo Risorsa

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

// Definire routing di risorsa specifici
Route::resource('/test', app\controller\IndexController::class, ['index','create']);

// Routing di risorsa non definita
// Un esempio di accesso a notify potrebbe essere un routing di tipo any a /test/notify o /test/notify/{id} con routeName uguale a test.notify
Route::resource('/test', app\controller\IndexController::class, ['index','create','notify']);

Verb	URI	Azione	Nome Route
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

Generazione di URL

Nota
Attualmente non è supportata la generazione di URL per gruppi di routing annidati

Ad esempio, per il routing:

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

Possiamo utilizzare il metodo seguente per generare l'URL di questo routing.

route('blog.view', ['id' => 100]); // Il risultato sarà /blog/100

Quando si utilizza l'URL del routing nella vista, puoi utilizzare questo metodo, in modo tale che, indipendentemente dalle variazioni delle regole di routing, l'URL verrà generato automaticamente, evitando modifiche massive ai file di vista a causa di cambiamenti negli indirizzi di routing.

Ottenere Informazioni sul Routing

Attraverso l'oggetto $request->route possiamo ottenere informazioni sul routing della richiesta corrente, ad esempio

$route = $request->route; // Equivalente a $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());
}

Nota
Se la richiesta corrente non corrisponde a nessun routing configurato in config/route.php, $request->route sarà null, il che significa che durante il routing predefinito $request->route sarà null

Gestire il 404

Quando un routing non viene trovato, verrà restituito per default il codice di stato 404 e verranno visualizzati i contenuti relativi al 404.

Se uno sviluppatore desidera intervenire nel flusso di lavoro quando non viene trovato un routing, può utilizzare il metodo di fallback fornito da webman Route::fallback($callback). Ad esempio, il codice seguente reindirizza alla homepage quando non viene trovato un routing.

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

Un altro esempio quando un routing non esiste e restituisce un dato JSON, utile per webman quando funge da API.

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

Aggiungere Middleware al 404

Le richieste 404 predefinite non passeranno attraverso alcun middleware; se desideri aggiungere middleware a una richiesta 404, fai riferimento al codice seguente.

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

Link correlati Pagine personalizzate per 404 e 500

Disabilitare il Routing Predefinito

// Disabilita il routing predefinito del progetto principale, senza influenzare i plugin dell'app
Route::disableDefaultRoute();
// Disabilita il routing dell'app admin del progetto principale, senza influenzare i plugin dell'app
Route::disableDefaultRoute('', 'admin');
// Disabilita il routing predefinito del plugin foo, senza influenzare il progetto principale
Route::disableDefaultRoute('foo');
// Disabilita il routing predefinito dell'app admin del plugin foo, senza influenzare il progetto principale
Route::disableDefaultRoute('foo', 'admin');
// Disabilita il routing predefinito di [\app\controller\IndexController::class, 'index']
Route::disableDefaultRoute([\app\controller\IndexController::class, 'index']);

Disattivazione del Routing Predefinito tramite Annotazioni

Possiamo disabilitare il routing predefinito di un controller tramite annotazioni, ad esempio:

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

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

Allo stesso modo, possiamo disattivare il routing predefinito di un controller tramite un'annotazione, ad esempio:

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

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

Interfaccia di Routing

// Imposta un routing per qualsiasi richiesta del metodo su $uri
Route::any($uri, $callback);
// Imposta un routing per le richieste get su $uri
Route::get($uri, $callback);
// Imposta un routing per le richieste post su $uri
Route::post($uri, $callback);
// Imposta un routing per le richieste put su $uri
Route::put($uri, $callback);
// Imposta un routing per le richieste patch su $uri
Route::patch($uri, $callback);
// Imposta un routing per le richieste delete su $uri
Route::delete($uri, $callback);
// Imposta un routing per le richieste head su $uri
Route::head($uri, $callback);
// Imposta un routing per le richieste options su $uri
Route::options($uri, $callback);
// Imposta routing per vari metodi di richiesta
Route::add(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'], $uri, $callback);
// Gruppi di routing
Route::group($path, $callback);
// Routing di risorsa
Route::resource($path, $callback, [$options]);
// Disabilita il routing
Route::disableDefaultRoute($plugin = '');
// Fallback del routing, imposta il routing di base
Route::fallback($callback, $plugin = '');
// Ottieni tutte le informazioni sul routing
Route::getRoutes();

Se l'uri non ha un routing corrispondente (incluso il routing predefinito), e il routing di fallback non è impostato, verrà restituito un 404.

Multiple Routing Configuration Files

Se desideri utilizzare più file di configurazione per gestire i routing, ad esempio nel caso di Multiapp dove ogni app ha la propria configurazione di routing, puoi caricare file di configurazione esterni utilizzando require.
Ad esempio, nel file config/route.php

<?php

// Carica la configurazione di routing per l'app admin
require_once app_path('admin/config/route.php');
// Carica la configurazione di routing per l'app api
require_once app_path('api/config/route.php');