RouterOne

Routerone

Uma biblioteca de roteamento de URL de aplicativo PHP independente, fácil de usar, expansível e simples de entender PHP, MyBe Aument Your Development Toolkit ou forneceu uma inspiração para você.

Características

• Rotas agrupadas
• Arquivos de mapa de rota carregando
• Domínio URL distinguível
• Suporte interno do middleware
• ROTA PATH PREFIXA E CUSTAÇÃO

Requisitos

• Php> = 7.0
• Uma implementação de classe automática depende do seu mecanismo de carregamento preferido, por exemplo, LoaderOne (estritamente falando, não é necessário, apenas por conveniência.)

instalação

Faça o download do código -fonte e coloque o local certo do seu diretório de projeto.

Uso básico

Obtenha a instância do objeto do roteador

 use RouterOne  Router ;

$ router = Router:: getInstance ();

Crie mapa de rota em um único arquivo e localizado em diretor específico do seu caroço, no arquivo $this refere à instância do objeto de $router de concreto. Para os verbos de solicitação HTTP, RouteOne só suporta GET , POST (apenas alinhe com o $ _get & $ _post do PHP, estendendo totalmente se você quiser ou necessário.)

Por exemplo, Foo.php . O Routerone pode suportar vários arquivos de mapa de rota, 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 ' ]);
  

Defina o caminho do diretório de arquivos do mapa de rota e carregando -o. (A extensão padrão do arquivo do mapa de rota é .php )

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

Ou ligue assim

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

Executar e ativar todas as rotas carregadas, ele retornará o resultado sobre a rota realmente chamada.

 $ res = $ router -> dispatch ();

Explica

Adicione uma rota

Ação da rota do controlador:

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

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

Ação da rota de fechamento:

 // 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 solicitação

Com os parâmetros da rota, os parâmetros dinâmicos com {} envolvidos, serão transferidos para o método do controlador ou paramter da função clousre pela ordem da aparência.

 $ 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

O middleware deve ser uma implementação para RouteMiddleWareInterface , você pode localizar o arquivo de classe de u-uare no diretório arbitrário, como MiddleWare dir;

Uma aula típica de utensílios intermediários contém um método handle() com Ação de Rota- $action , como abaixo:

 use RouterOne  MiddleWare  RouteMiddleWareInterface ;

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

Em alguns casos, você pode querer fazer algum processo após a ação da rota, excluída, basta colocar a lógica do meio-louça atrás da declaração de chamada de $action() .

 use RouterOne  MiddleWare  RouteMiddleWareInterface ;

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

Quando definido, o Middle-Ware, e pode através do middleware() de configuração de métodos do roteador, como formulário grouped , middleware() possui dois parâmetros, o primeiro é uma matriz de nome de classe de middle-ware e suporta mais guerras médias aqui, e a outra é uma função de fechamento inclui mapeamento de rota comum.

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

Também pode nested

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

Prefixo e sufixo

O método prefix() e suffix() também são rotas grouped , elas podem adicione prefixo e sufixo práticos a rotas específicas.

Adicione o prefixo static/ , então URLS ': // domain/static/page1', '// domain/static/page2' será correspondido.

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

Adicione o preiFX the , então URLS ': // domain/thepage1', '// domain/thepage2' será correspondido.

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

Da mesma forma que prefix() usando, adicione o sufixo .html e, em seguida, altere o URL para ': //domain/page1.html'.

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

Entre prefix() e suffix() podem nested -se.

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

Domínio restrito

Se o seu aplicativo tiver vários domínios de URL, o método use domain() poderá distinguir esses domínios e guiar a solicitação ao grupo de rota correspondente.

 $ 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 ' , ...);
    . . .
    
});