RouterOne

Routerone

Une bibliothèque de routage URL de l'application Web PHP indépendante, facile à utiliser, extensible et simple à comprendre, MYBE, augmentez votre boîte à outils de développement ou vous avez fourni un peu d'inspiration.

Caractéristiques

• Itinéraires groupés
• Chargement de fichiers de map d'itinéraire
• Domaine URL Distinguable
• Prise en charge interne du middleware
• Préfixe du chemin d'itinéraire et personnalisation du suffixe

Exigences

• Php> = 7.0
• Une mise en œuvre de la classe-autoloader dépend de votre mécanisme de chargement préféré, par exemple la charge de charge (à strictement, ce n'est pas nécessaire, juste pour la commodité.)

installation

Téléchargez le code source et placez-le à droite de votre répertoire de projet.

Utilisation de base

Obtenez l'instance d'objet du routeur

 use RouterOne  Router ;

$ router = Router:: getInstance ();

Créez une carte d'itinéraire dans un seul fichier et situé dans un discours spécifique de votre prjectif, dans le fichier $this se réfère à l'instance d'objet de $router béton. Pour les verbes de la demande HTTP, RouteOne Soutien de GET , POST (alignez simplement avec $ _get & $ _post de PHP, s'étendant totalement si vous voulez ou nécessaire.)

Par exemple, Foo.php . RouterOne peut prendre en charge plusieurs fichiers de carte d'itinéraire, tels que 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 ' ]);
  

Définissez le chemin du répertoire des fichiers de carte d'itinéraire et le chargement. (L'extension par défaut du fichier de carte d'itinéraire est .php )

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

Ou appelez comme ça

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

Exécutez Dispatch et activez tous les itinéraires chargés, il sera renvoyé le résultat sur réellement l'itinéraire appelé.

 $ res = $ router -> dispatch ();

Explique

Ajouter un itinéraire

Action d'itinéraire du contrôleur:

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

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

Action de l'itinéraire de fermeture:

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

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

Demander des paramètres

Avec les paramètres d'itinéraire, les paramètres dynamiques avec {} enveloppés, seront ensuite transférés vers la méthode du contrôleur ou le paramètre de la fonction Cloure par l'ordre d'apparence.

 $ 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

Le middleware devrait être une implémentation de RouteMiddleWareInterface , vous pouvez localiser le fichier de classe de classe intermédiaire dans le répertoire arbitraire, tel que MiddleWare Dir;

Une classe de classe intermédiaire typique contient une méthode handle() avec un paramètre $action d'action de route - comme ci-dessous:

 use RouterOne  MiddleWare  RouteMiddleWareInterface ;

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

Dans certains cas, vous voudrez peut-être faire un processus après l'exécution de l'action de l'itinéraire, placez simplement la logique de niveau intermédiaire derrière la déclaration d'appel $action() .

 use RouterOne  MiddleWare  RouteMiddleWareInterface ;

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

Lorsqu'il est défini intermédiaire, et peut via les routes de la méthode de la méthode du routeur en tant que formulaire grouped , middleware() middleware() a deux paramètres, le premier est un tableau de nom de classe de classe middle-ware et prend en charge plus de bandes moyennes ici, et l'autre est une fonction de fermeture inclut la cartographie de route commune.

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

Peut également nested

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

Préfixe et suffixe

prefix() et suffix() sont également des itinéraires grouped , ils peuvent également ajouter un préfixe et un suffixe pratiques à des itinéraires spécifiques.

Ajoutez le préfixe static/ , puis URLS ': // domain / static / page1', '// domain / static / page2' sera apparié.

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

Ajoutez le preifx the , puis les urls ': // domain / thepage1', '// domaine / thepage2' seront appariés.

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

Ainsi que prefix() en utilisant, ajoutez le suffixe .html , puis le changement d'URL en ': //domain/page1.html'.

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

Entre prefix() et suffix() peut nested les uns les autres.

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

Restreindre le domaine

Si votre application a plusieurs domaines URL, utilisez la méthode domain() peut distinguer ce domaine et guider la demande de groupe de routes correspondant.

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