RouterOne

Enrutado

Una biblioteca de enrutamiento de URL de aplicación web de PHP, fácil de usar, fácil de usar, ampliable y simple de comprender, aumenta su conjunto de herramientas de desarrollo o le proporcionó un poco de inspiración.

Características

• Rutas agrupadas
• Carga de archivos de mapa de ruta
• Dominio de URL distinguible
• Soporte interno de middleware
• Ruta de ruta prefijo y personalización de sufijo

Requisitos

• Php> = 7.0
• Una implementación de clase Autoloader depende de su mecanismo de carga preferido, por ejemplo, loaderone (estrictamente hablando, no es necesario, solo por conveniencia).

instalación

Descargue el código fuente y coloque la ubicación correcta de su directorio de proyecto.

Uso básico

Obtener instancia de objeto de enrutador

 use RouterOne  Router ;

$ router = Router:: getInstance ();

Cree el mapa de ruta en un solo archivo y se encuentre en DIR específico de su pruesto, en el archivo $this consulte la instancia de objeto concreto $router . Para los verbos de solicitud HTTP, RouteOne solo admite GET , POST (simplemente alinee con $ _get y $ _post de PHP, extendiéndose totalmente si lo desea o es necesario).

Por ejemplo, Foo.php . Routerone puede admitir múltiples archivos de mapa de ruta, como frontend_route_map.php , backend_route_map.php ,.

 // Closure function call
$ this -> get ( ' / ' , function () {
    echo ' Hello! RouterOne ' ;
});

// `WelcomeController::hello()` call
$ this -> get ( ' / ' , [WeclomeController::class, ' hello ' ]);
  

Establezca ruta del directorio de archivos de mapa y cargándola. (La extensión predeterminada del archivo de mapa de ruta es .php )

 $ router -> setIncludePath (` YOUR_ROUTE_MAP_FILE_DIR `);
$ router -> load ([ ' Foo ' ]); // Just file's name without extension

O llamar así

 $ router -> setIncludePath (` YOUR_ROUTE_MAP_FILE_DIR `)-> load ([ ' Foo ' ]); // Just file's name without extension

Ejecutar envío y habilitar todas las rutas cargadas, devolverá el resultado sobre la ruta realmente llamada.

 $ res = $ router -> dispatch ();

Explica

Agregar una ruta

Acción de ruta del controlador:

 // Http GET
$ this -> get ( ' index ' , [ Controllers SiteController::class, ' index ' ]);

// Http POST
$ this -> post ( ' news/add ' , [ Controllers NewsController::class, ' add ' ]);

Acción de ruta de cierre:

 // Http GET
$ this -> get ( ' index ' , function () {
    /**
    * Some logic process code here
    */
});

// Http POST
$ this -> post ( ' news/add ' , function () {
    /**
    * Some logic process code here
    */
});

Parámetros de solicitud

Con los parámetros de ruta, los parámetros dinámicos con {} envueltos, luego se transferirán al método del controlador o parámetro de función Clousre por orden de apariencia.

 $ this -> get ( ' test/{param1}/{param2} ' , [ Controllers TestController::class, ' params ' ]);

class TestController
{
    public function params ( $ param1 , $ param2 )
    {
        // Some code ...
    }
}

 $ this -> get ( ' test/{param1}/{param2} ' , function ( $ param1 , $ param2 ) {
    // Some code
});

Middleware

El middleware debe ser una implementación para RouteMiddleWareInterface , puede localizar el archivo de clase de prisión media en el directorio arbitrario, como MiddleWare Dir;

Una clase típica de la vida media contiene un método handle() con el parámetro $action de la ruta, como a continuación:

 use RouterOne  MiddleWare  RouteMiddleWareInterface ;

class AuthCheckMiddleWare implements RouteMiddleWareInterface
{
    public static function handle ( $ action )
    {
        if ( ! AdminUser::Logged) {
            exit ( ' Please login first. ' );
        }
        
        $ action ();
    }
}

En algunos casos, es posible que desee hacer algún proceso después de la acción de la ruta excutada, simplemente coloque la lógica de la vida media detrás del estado de llamadas $action() .

 use RouterOne  MiddleWare  RouteMiddleWareInterface ;

class AfterMiddleWare implements RouteMiddleWareInterface
{
    public static function handle ( $ action )
    {
        $ action ();
        
        echo ' This text will print after route action excuted. ' ;
    }
}

Cuando se define el manejo medio, y puede a través de las rutas de configuración del método middleware() del enrutador como forma grouped , middleware() tiene dos parámetros, el primero es una matriz de nombre de clase middle-ware y admite más claras medias aquí, y la otra es una función de cierre incluye el mapeo de rutas comunes.

 $ this -> middleware (
    [
        AuthCheckMiddleWare::class,
        ...
        . . .
    ], function () {
        $ this -> get ( ' admin/index ' , [ Controllers  Admin AdminController::class, ' index ' ]);
        $ this -> get ( ' admin/news/list ' , [ Controllers  Admin NewsController::class, ' list ' ]);
        . . .
        . . .
});

También puede nested

 $ this ->middleware(
    [
        OuterMiddleWare::class,
        
    ], function () {
        . . .
        
        $ this ->middleware([
            InnerMiddleWare::class
        ], function () {
            $ this ->get(...
            $ this ->post(...
            . . .
        });
        
        ...
        . . .
});

Prefijo y sufijo

El método prefix() y suffix() también se grouped rutas, pueden agregar un prefijo práctico y sufijo a rutas específicas.

Agregue el prefijo static/ , luego las URL ': // dominio/static/page1', '// domain/static/page2' se combinará.

 $ this -> prefix ( ' static/ ' , function () {
    $ this -> get ( ' page1 ' , ...);
    $ this -> get ( ' page2 ' , ...);
    . . .
});

Agregue el the , luego las urls ': // dominio/thepage1', '// domain/thepage2' se combinará.

 $ this -> prefix ( ' the ' , function () {
    $ this -> get ( ' page1 ' , ...);
    $ this -> get ( ' page2 ' , ...);
    . . .
});

Al igual que prefix() usando, agregue el sufijo .html , luego la url cambie a ': //domain/page1.html'.

 $ this -> suffix ( ' .html ' , function () {
    $ this -> get ( ' page1 ' , ...);
    . . .
    . . .
});

Entre prefix() y suffix() se pueden nested entre sí.

 $ this -> prefix ( ' static/ ' , function () {
    $ this -> get ( ' page1 ' , ...);  // request url '://domain/static/page1' matched here
    . . .
    
    $ this -> suffix ( ' .html ' , function () {
        $ this -> get ( ' page2 ' ,  ...); // request url '://domain/static/page2.html' matched here
    });
});

Restringir el dominio

Si su aplicación tiene un dominio de URL múltiple, el método de uso domain() puede distinguir este dominio y guiar la solicitud al grupo de ruta correspondiente.

 $ this -> domain ( ' www.hereisyoursite.com ' , function () { // PC Pages
    $ this -> get ( ' index ' , ...);
    . . .
});
            
$ this -> domain ( ' m.hereisyoursite.com ' , function () { // Mobile Pages
    $ this -> get ( ' index ' , ...);
    . . .
    
});



$ this -> domain ( ' new.hereisyoursite.com ' , function () { // Current Domain routes
    $ this -> get ( ' index ' , ...);
    . . .
});
            
$ this -> domain ( ' old.hereisyoursite.com ' , function () { // Legacy Domain routes
    $ this -> get ( ' index ' , ...);
    . . .
    
});