Routage PHP rapide avec phroute

phroute est un package intéressant: c'est un routeur basé sur l'expression régulière rapide que vous pouvez facilement mettre en œuvre dans des projets petits et moyens. Cependant, ce n'est pas seulement très rapide: il y a des filtres, des groupes de filtres et des itinéraires nommés. Vous pouvez également utiliser un système de contrôleurs de base si les choses grossissent.

Cela dit, aujourd'hui, nous verrons comment l'utiliser et comment implémenter ses fonctionnalités dans un exemple de projet. De plus, nous allons voir ce qui est sous le capot: phroute est le résultat de nombreuses expériences et tests de différentes personnes.

Commençons par l'installer!

Les plats clés

• phroute est un package de routage très efficace et basé sur des exploits, idéal pour les projets PHP petits et moyens, offrant des fonctionnalités telles que des filtres, des groupes de filtres et un système de contrôleur de base pour des applications plus grandes.
• L'installation de phroute est simple en utilisant le compositeur, améliorant la vitesse et la simplicité de la configuration du projet.
• phroute prend en charge une variété de méthodes HTTP et permet un routage dynamique avec des paramètres facultatifs, ce qui le rend polyvalent pour le développement d'API et d'autres applications Web.
• Les filtres en phroute peuvent être appliqués avant ou après la manipulation des itinéraires, fournissant un outil puissant pour le contrôle d'accès et la validation des données, l'amélioration de la sécurité et de l'intégrité des données.
• Alors que Phroute excelle dans les performances de routage, surpassant considérablement certains autres routeurs comme celui de Laravel, il manque actuellement de fonctionnalités de contrôleur avancées et de documentation complète, des domaines identifiés pour une amélioration future.

installer

Vous pouvez ajouter Phoute à votre projet avec Composer en quelques secondes. Ajoutez simplement cette ligne à votre fichier composer.json:

{ 
        "require": 
        { 
            "phroute/phroute": "1.*" 
        } 
    }

Tapez la commande d'installation du compositeur et vous êtes. Maintenant, passons à notre projet de test.

Exemple de projet et premier exemple

Pour une meilleure compréhension de chaque concept de phroute, c'est une bonne idée d'avoir un exemple de projet avec lequel travailler. Aujourd'hui, nous allons créer une API de base pour un service de base de données de livres.

Voici le schéma de base de données que nous allons utiliser:

Si vous voulez faire des tests, c'est le vidage de schéma SQL que j'ai utilisé (avec des données factices supplémentaires).

<span>CREATE TABLE IF NOT EXISTS authors (id int(10) unsigned NOT NULL AUTO_INCREMENT, name varchar(250) NOT NULL, PRIMARY KEY (id)) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=3;
</span>
    <span>INSERT INTO authors (id, name) 
</span>    <span>VALUES 
</span>    <span>(1, 'Dan Brown'), 
</span>    <span>(2, 'Paulo Coelho');
</span>
    <span>CREATE TABLE IF NOT EXISTS categories (id int(10) unsigned NOT NULL AUTO_INCREMENT, name varchar(250) NOT NULL, PRIMARY KEY (id)) ENGINE=InnoDB  DEFAULT CHARSET=utf8 AUTO_INCREMENT=3;
</span>
    <span>INSERT INTO categories (id, name) 
</span>    <span>VALUES 
</span>    <span>(1, 'Thriller'), 
</span>    <span>(2, 'Novel');
</span>
    <span>CREATE TABLE IF NOT EXISTS books (id int(10) unsigned NOT NULL AUTO_INCREMENT,   title varchar(250) NOT NULL, isbn varchar(50) NOT NULL, year int(11) NOT NULL,   pages int(11) NOT NULL, author_id int(10) unsigned NOT NULL, category_id int(10) unsigned NOT NULL, PRIMARY KEY (id), KEY author_id (author_id,category_id), KEY category_id (category_id)) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=7;
</span>
    <span>INSERT INTO books (id, title, isbn, year, pages, author_id, category_id) 
</span>    <span>VALUES 
</span>    <span>(1, 'The Zahir', '0-06-083281-9', 2005, 336, 2, 2), 
</span>    <span>(2, 'The Devil and Miss Prym', '0-00-711605-5', 2000, 205, 2, 2), 
</span>    <span>(3, 'The Alchemist', '0-06-250217-4', 1988, 163, 2, 2), 
</span>    <span>(4, 'Inferno', '978-0-385-53785-8', 2013, 480, 1, 1), 
</span>    <span>(5, 'The Da Vinci Code', '0-385-50420-9', 2003, 454, 1, 1), 
</span>    <span>(6, 'Angels & Demons', '0-671-02735-2', 2000, 616, 1, 1);</span>

Nous n'allons rien écrire vraiment complexe. En fait, la rédaction de certains itinéraires pour imiter une demande d'API d'une manière très basique sera suffisante. Si vous voulez écrire une API du monde réel, il y a beaucoup de concepts que vous devez savoir, mais aujourd'hui, nous jetons simplement un coup d'œil à Phroute.

Avant de commencer avec des itinéraires spécifiques, analysons la structure d'application principale. C'est ce que nous allons mettre dans notre fichier index.php.

<span><span><?php </span></span><span>
</span><span>    <span>require 'vendor/autoload.php';
</span></span><span>
</span><span>    <span>function processInput($uri){        
</span></span><span>        <span>$uri = implode('/', 
</span></span><span>            <span>array_slice(
</span></span><span>                <span>explode('/', $_SERVER['REQUEST_URI']), 3));         
</span></span><span>
</span><span>            <span>return $uri;    
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>function processOutput($response){
</span></span><span>        <span>echo json_encode($response);    
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>function getPDOInstance(){
</span></span><span>        <span>return new PDO('mysql:host=localhost;dbname=booksapi;charset=utf8', 'root', '');
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>$router = new Phroute<span>\RouteCollector</span>(new Phroute<span>\RouteParser</span>);
</span></span><span>
</span><span>    <span>$router->get('hello', function(){ 
</span></span><span>        <span>return 'Hello, PHRoute!';   
</span></span><span>    <span>});
</span></span><span>
</span><span>    <span>$dispatcher = new Phroute<span>\Dispatcher</span>(router);
</span></span><span>
</span><span>    <span>try {
</span></span><span>
</span><span>        <span>$response = $dispatcher->dispatch($_SERVER['REQUEST_METHOD'], processInput($_SERVER['REQUEST_URI']));
</span></span><span>
</span><span>    <span>} catch (Phroute<span>\Exception\HttpRouteNotFoundException</span> $e) {
</span></span><span>
</span><span>        <span>var_dump($e);      
</span></span><span>        <span>die();
</span></span><span>
</span><span>    <span>} catch (Phroute<span>\Exception\HttpMethodNotAllowedException</span> $e) {
</span></span><span>
</span><span>        <span>var_dump($e);       
</span></span><span>        <span>die();
</span></span><span>
</span><span>    <span>}
</span></span><span>
</span><span>    <span>processOutput($response);</span></span></span>

Nous avons trois méthodes d'utilité: ProcessInput, ProcessOutput et GetPDOinstance. Nous utiliserons les deux premiers pour être sûr que nous obtenons la bonne entrée et la bonne sortie. Le troisième préparera l'instance APDE nécessaire.

Remarque: Le deuxième paramètre de la méthode Array_Slice est «3» en raison de ma configuration de projet spécifique personnelle. Changez-le à mesure que votre URL de base change.

Après cela, nous déclarons nos itinéraires à l'aide du routeur objet $, instance de la classe RouteController. Ensuite, la magie se produit dans la méthode $ Dispatcher-> Dispatch (), qui prend deux paramètres: la méthode de demande $ _Server (get, post etc.) et l'uri de demande spécifique. Avec ces informations, le répartiteur appelle la bonne route et exécute le code dans la fermeture. La valeur de retour est stockée dans la variable de réponse $, qui est donnée à la méthode processOutput () qui l'échoe comme une chaîne JSON.

Comme vous pouvez le voir, dans cet exemple spécifique, nous avons déclaré un seul itinéraire: Bonjour.

Remarque: si vous le souhaitez, vous pouvez cependant améliorer la structure réelle. Créez un nouveau fichier et appelez-le routes.php. Ensuite, incluez-le à partir du fichier principal index.php juste après l'initialisation de l'objet Router $: vous aurez tous vos itinéraires dans un fichier séparé. Une solution plus élégante, à mon avis.

Cela dit, vous savez maintenant tout ce dont vous avez besoin sur la structure de base de notre exemple.

Faisons nos premiers itinéraires!

routes

un itinéraire simple

ok, voyons ce que nous pouvons faire avec les itinéraires et combien nous pouvons les personnaliser pour nos besoins.

Nous commençons par la chose la plus simple: la liste des auteurs.

{ 
        "require": 
        { 
            "phroute/phroute": "1.*" 
        } 
    }

Dans la première ligne, nous déclarons notre nom de route, auteurs.

Testons l'itinéraire: c'est le résultat.

<span>CREATE TABLE IF NOT EXISTS authors (id int(10) unsigned NOT NULL AUTO_INCREMENT, name varchar(250) NOT NULL, PRIMARY KEY (id)) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=3;
</span>
    <span>INSERT INTO authors (id, name) 
</span>    <span>VALUES 
</span>    <span>(1, 'Dan Brown'), 
</span>    <span>(2, 'Paulo Coelho');
</span>
    <span>CREATE TABLE IF NOT EXISTS categories (id int(10) unsigned NOT NULL AUTO_INCREMENT, name varchar(250) NOT NULL, PRIMARY KEY (id)) ENGINE=InnoDB  DEFAULT CHARSET=utf8 AUTO_INCREMENT=3;
</span>
    <span>INSERT INTO categories (id, name) 
</span>    <span>VALUES 
</span>    <span>(1, 'Thriller'), 
</span>    <span>(2, 'Novel');
</span>
    <span>CREATE TABLE IF NOT EXISTS books (id int(10) unsigned NOT NULL AUTO_INCREMENT,   title varchar(250) NOT NULL, isbn varchar(50) NOT NULL, year int(11) NOT NULL,   pages int(11) NOT NULL, author_id int(10) unsigned NOT NULL, category_id int(10) unsigned NOT NULL, PRIMARY KEY (id), KEY author_id (author_id,category_id), KEY category_id (category_id)) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=7;
</span>
    <span>INSERT INTO books (id, title, isbn, year, pages, author_id, category_id) 
</span>    <span>VALUES 
</span>    <span>(1, 'The Zahir', '0-06-083281-9', 2005, 336, 2, 2), 
</span>    <span>(2, 'The Devil and Miss Prym', '0-00-711605-5', 2000, 205, 2, 2), 
</span>    <span>(3, 'The Alchemist', '0-06-250217-4', 1988, 163, 2, 2), 
</span>    <span>(4, 'Inferno', '978-0-385-53785-8', 2013, 480, 1, 1), 
</span>    <span>(5, 'The Da Vinci Code', '0-385-50420-9', 2003, 454, 1, 1), 
</span>    <span>(6, 'Angels & Demons', '0-671-02735-2', 2000, 616, 1, 1);</span>

génial!

ajoutant un paramètre

Maintenant, nous pouvons faire un pas en avant: qu'en est-il de l'ajout d'un paramètre, pour obtenir les détails d'un seul auteur, compte tenu de l'ID?

quelque chose comme ça:

<span><span><?php </span></span><span>
</span><span>    <span>require 'vendor/autoload.php';
</span></span><span>
</span><span>    <span>function processInput($uri){        
</span></span><span>        <span>$uri = implode('/', 
</span></span><span>            <span>array_slice(
</span></span><span>                <span>explode('/', $_SERVER['REQUEST_URI']), 3));         
</span></span><span>
</span><span>            <span>return $uri;    
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>function processOutput($response){
</span></span><span>        <span>echo json_encode($response);    
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>function getPDOInstance(){
</span></span><span>        <span>return new PDO('mysql:host=localhost;dbname=booksapi;charset=utf8', 'root', '');
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>$router = new Phroute<span>\RouteCollector</span>(new Phroute<span>\RouteParser</span>);
</span></span><span>
</span><span>    <span>$router->get('hello', function(){ 
</span></span><span>        <span>return 'Hello, PHRoute!';   
</span></span><span>    <span>});
</span></span><span>
</span><span>    <span>$dispatcher = new Phroute<span>\Dispatcher</span>(router);
</span></span><span>
</span><span>    <span>try {
</span></span><span>
</span><span>        <span>$response = $dispatcher->dispatch($_SERVER['REQUEST_METHOD'], processInput($_SERVER['REQUEST_URI']));
</span></span><span>
</span><span>    <span>} catch (Phroute<span>\Exception\HttpRouteNotFoundException</span> $e) {
</span></span><span>
</span><span>        <span>var_dump($e);      
</span></span><span>        <span>die();
</span></span><span>
</span><span>    <span>} catch (Phroute<span>\Exception\HttpMethodNotAllowedException</span> $e) {
</span></span><span>
</span><span>        <span>var_dump($e);       
</span></span><span>        <span>die();
</span></span><span>
</span><span>    <span>}
</span></span><span>
</span><span>    <span>processOutput($response);</span></span></span>

Vous pouvez transmettre un paramètre à l'aide d'un espace réservé {variable_name}, avec le même nom choisi qu'un paramètre pour la fermeture. Dans cet exemple, nous avons un espace réservé {id} correspondant au paramètre $ id. Vous pouvez spécifier tout paramètre souhaité: pas de limites.

Parfois, un paramètre peut être facultatif. Faisons un autre exemple: si nous utilisons l'URL des livres, nous voulons récupérer une liste de tous les livres de base de données. Mais, si nous spécifions un identifiant comme des livres / 1, nous obtiendrons la liste des livres de la catégorie donnée.

c'est parti:

<span>$router->get('authors', function(){      
</span>        <span>$db = getPDOInstance();
</span>
        <span>$sql = 'SELECT * FROM authors;';  
</span>        <span>$st = $db->prepare($sql, array(PDO<span>::</span>ATTR_CURSOR => PDO<span>::</span>CURSOR_FWDONLY));
</span>
        <span>$st->execute();
</span>
        <span>$result = $st->fetchAll(PDO<span>::</span>FETCH_CLASS);
</span>	    
        <span>return $result;  
</span>    <span>});</span>

ajoutant un "?" Une fois que l'espace réservé du paramètre signifie qu'il sera facultatif. Bien sûr, c'est une bonne idée de spécifier une valeur par défaut dans la déclaration de fermeture.

en utilisant différents verbes

Jusqu'à présent, nous avons créé uniquement des itinéraires. Qu'en est-il des autres verbes http?

pas de problème. Jetez un œil ici:

[{"id":"1","name":"Dan Brown"},{"id":"2","name":"Paulo Coelho"}]

Faisons un exemple de post-itinéraire. Il est temps d'ajouter un nouveau livre à notre collection!

<span>$router->get('author/{id}', function($id){      
</span>        <span>$db = getPDOInstance(); 
</span>
        <span>$sql = 'SELECT * FROM `authors` WHERE `id` = :id';     
</span>    
        <span>$st = $db->prepare($sql, array(PDO<span>::</span>ATTR_CURSOR => PDO<span>::</span>CURSOR_FWDONLY));
</span>        <span>$st->execute(array(':id' => $id));
</span>
        <span>$result = $st->fetchAll(PDO<span>::</span>FETCH_CLASS);
</span> 
        <span>return $result;
</span>    <span>});</span>

Imaginons que nous avons un formulaire à remplir avec les données du livre: son attribut d'action pointera vers la route du livre que nous avons créée en ce moment!

Maintenant, nous allons faire un autre pas en avant: il est temps de «protéger» nos itinéraires!

Filtres

En fait, tous ceux qui entrent dans la route du poste de livre peuvent insérer un nouveau livre dans notre collection. C'est cool, mais ce n'est pas comme si les choses se passaient généralement. Et si nous voulons protéger nos itinéraires? Les filtres sont ce dont nous avons besoin.

Les filtres sont très similaires aux itinéraires: ils ont un nom et une fermeture associée, exécutés lorsque le filtre est appelé quelque part.

Alors, quelle est la différence? Un filtre peut être facilement appelé avant (ou après) un itinéraire.

Filtre

Faisons un exemple:

{ 
        "require": 
        { 
            "phroute/phroute": "1.*" 
        } 
    }

Tout d'abord, nous avons déclaré le filtre avec la méthode filtre () de l'objet Router $. La syntaxe est la même qu'avec un itinéraire. Nous lui donnons un nom et une fermeture qui seront exécutées au bon moment.

ok, mais quel est le «bon moment»?

Nous le décidons maintenant: nous venons d'ajouter un troisième paramètre à la méthode post (). Ce troisième paramètre est un tableau, où nous spécifions la touche avant avec le nom du filtre (logged_in). À partir de ce moment, avant chaque appel à la route du poste de livre, le filtre Logged_in (et exécuté son contenu de fermeture) sera également appelé.

Dans ce cas spécifique, nous vérifions une variable de session User_ID pour voir si l'utilisateur est connecté.

Il y a aussi la touche After qui est utilisée pour exécuter un filtre juste après l'appel de l'itinéraire. Voici un exemple.

<span>CREATE TABLE IF NOT EXISTS authors (id int(10) unsigned NOT NULL AUTO_INCREMENT, name varchar(250) NOT NULL, PRIMARY KEY (id)) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=3;
</span>
    <span>INSERT INTO authors (id, name) 
</span>    <span>VALUES 
</span>    <span>(1, 'Dan Brown'), 
</span>    <span>(2, 'Paulo Coelho');
</span>
    <span>CREATE TABLE IF NOT EXISTS categories (id int(10) unsigned NOT NULL AUTO_INCREMENT, name varchar(250) NOT NULL, PRIMARY KEY (id)) ENGINE=InnoDB  DEFAULT CHARSET=utf8 AUTO_INCREMENT=3;
</span>
    <span>INSERT INTO categories (id, name) 
</span>    <span>VALUES 
</span>    <span>(1, 'Thriller'), 
</span>    <span>(2, 'Novel');
</span>
    <span>CREATE TABLE IF NOT EXISTS books (id int(10) unsigned NOT NULL AUTO_INCREMENT,   title varchar(250) NOT NULL, isbn varchar(50) NOT NULL, year int(11) NOT NULL,   pages int(11) NOT NULL, author_id int(10) unsigned NOT NULL, category_id int(10) unsigned NOT NULL, PRIMARY KEY (id), KEY author_id (author_id,category_id), KEY category_id (category_id)) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=7;
</span>
    <span>INSERT INTO books (id, title, isbn, year, pages, author_id, category_id) 
</span>    <span>VALUES 
</span>    <span>(1, 'The Zahir', '0-06-083281-9', 2005, 336, 2, 2), 
</span>    <span>(2, 'The Devil and Miss Prym', '0-00-711605-5', 2000, 205, 2, 2), 
</span>    <span>(3, 'The Alchemist', '0-06-250217-4', 1988, 163, 2, 2), 
</span>    <span>(4, 'Inferno', '978-0-385-53785-8', 2013, 480, 1, 1), 
</span>    <span>(5, 'The Da Vinci Code', '0-385-50420-9', 2003, 454, 1, 1), 
</span>    <span>(6, 'Angels & Demons', '0-671-02735-2', 2000, 616, 1, 1);</span>

Si vous en avez besoin, vous pouvez également spécifier plus d'un filtre en même temps.
Tout ce que vous avez à faire est d'utiliser un tableau de chaînes au lieu d'une seule chaîne.

<span><span><?php </span></span><span>
</span><span>    <span>require 'vendor/autoload.php';
</span></span><span>
</span><span>    <span>function processInput($uri){        
</span></span><span>        <span>$uri = implode('/', 
</span></span><span>            <span>array_slice(
</span></span><span>                <span>explode('/', $_SERVER['REQUEST_URI']), 3));         
</span></span><span>
</span><span>            <span>return $uri;    
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>function processOutput($response){
</span></span><span>        <span>echo json_encode($response);    
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>function getPDOInstance(){
</span></span><span>        <span>return new PDO('mysql:host=localhost;dbname=booksapi;charset=utf8', 'root', '');
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>$router = new Phroute<span>\RouteCollector</span>(new Phroute<span>\RouteParser</span>);
</span></span><span>
</span><span>    <span>$router->get('hello', function(){ 
</span></span><span>        <span>return 'Hello, PHRoute!';   
</span></span><span>    <span>});
</span></span><span>
</span><span>    <span>$dispatcher = new Phroute<span>\Dispatcher</span>(router);
</span></span><span>
</span><span>    <span>try {
</span></span><span>
</span><span>        <span>$response = $dispatcher->dispatch($_SERVER['REQUEST_METHOD'], processInput($_SERVER['REQUEST_URI']));
</span></span><span>
</span><span>    <span>} catch (Phroute<span>\Exception\HttpRouteNotFoundException</span> $e) {
</span></span><span>
</span><span>        <span>var_dump($e);      
</span></span><span>        <span>die();
</span></span><span>
</span><span>    <span>} catch (Phroute<span>\Exception\HttpMethodNotAllowedException</span> $e) {
</span></span><span>
</span><span>        <span>var_dump($e);       
</span></span><span>        <span>die();
</span></span><span>
</span><span>    <span>}
</span></span><span>
</span><span>    <span>processOutput($response);</span></span></span>

groupes de filtres

Imaginons un cas du monde réel: disons que nous avons trois itinéraires post, un pour chaque entité (auteur, livre, catégorie). Il serait ennuyeux d'ajouter le filtre logéd_in trois fois différentes.

Ne vous inquiétez pas: les groupes de filtres sont là pour aider.

<span>$router->get('authors', function(){      
</span>        <span>$db = getPDOInstance();
</span>
        <span>$sql = 'SELECT * FROM authors;';  
</span>        <span>$st = $db->prepare($sql, array(PDO<span>::</span>ATTR_CURSOR => PDO<span>::</span>CURSOR_FWDONLY));
</span>
        <span>$st->execute();
</span>
        <span>$result = $st->fetchAll(PDO<span>::</span>FETCH_CLASS);
</span>	    
        <span>return $result;  
</span>    <span>});</span>

Avec ce groupe unique, nous avons défini le même filtre pour trois routes différentes.

Remarque: si vous en avez besoin, vous pouvez également nicher de groupes dans d'autres groupes autant de fois que vous le souhaitez.

Projet de croissance? Il est temps d'utiliser les contrôleurs!

Notre projet grandit et organiser notre base de code dans un seul fichier est vraiment lourd et bâclé. Qu'en est-il de l'utilisation des contrôleurs?

Oui: Phroute ne concerne pas seulement les itinéraires. Quand les choses se déchaînent, il est temps de les organiser.

Tout d'abord, voyons à quoi ressemble la structure d'un contrôleur. Jetez un œil à cet exemple (nous pouvons le mettre dans notre fichier routes.php):

[{"id":"1","name":"Dan Brown"},{"id":"2","name":"Paulo Coelho"}]

Nous avons créé une classe d'auteur. Dans cette classe, nous mettons deux méthodes: getIndex () et postAdd ().

Ensuite, avec la méthode Controller () de l'objet Router $, nous lions l'URL de l'auteur à la classe d'auteur. Donc, si nous entrons l'auteur URL dans notre navigateur, la méthode getIndex () sera automatiquement appelée. Il en va de même pour la méthode postAdd (), qui sera liée à l'URL de l'auteur / ajouter (post)

Cette fonctionnalité de nom de résolution automatique est assez intéressante, mais en fait pas assez.

La partie du contrôleur est à un stade précoce du développement et a besoin de nombreuses améliorations. L'un d'eux est la possibilité de définir des paramètres pour les méthodes de contrôleur. Ou, peut-être, un moyen facile de définir les filtres pour certaines méthodes d'un contrôleur (et non «tout ou rien»).

Conclusion

Il y a beaucoup de travail à faire, en particulier du côté des contrôleurs. En tant que développeur, je pense que ce serait formidable d'avoir une classe de contrôleur de base générique pour gérer tout le sale travail (avec des filtres, des paramètres de méthodes, etc.). Il y a aussi un manque de documentation.

D'un autre côté, Phroute est livré avec un routeur très rapide. Sur la page GitHub du projet, vous pouvez voir certaines statistiques sur une comparaison avec le routeur principal de Laravel: les résultats sont incroyables. Dans le pire des cas, le phroute est environ quarante (oui, 40) fois plus rapide.

Si vous voulez connaître des détails spécifiques sur le «moteur» derrière ce routeur, vous pouvez visiter la page Nikic sur GitHub où il a expliqué tout le monde, avec des tests, des références et des résultats connexes.

Allez-vous essayer PhROUTE? Faites-moi savoir ce que vous en pensez!

Questions fréquemment posées (FAQ) sur le routage PHP rapide avec phroute

Qu'est-ce que Phoute et pourquoi est-il important dans le routage PHP?

phroute est une bibliothèque de routage PHP conçue pour être rapide et efficace. Il est important dans le routage PHP car il fournit un moyen simple et pratique de définir les itinéraires dans votre application PHP. Phroute vous permet de mapper les URL vers des fonctions ou des méthodes spécifiques dans votre application, ce qui facilite la gestion et l'organisation de votre code. Il prend également en charge les paramètres et les filtres de l'itinéraire, vous donnant plus de contrôle sur la façon dont votre application réagit aux différentes URL.

Comment installer Phoute dans mon application PHP?

PhROUTE peut être facilement installée dans votre Application PHP à l'aide de Composer, un outil de gestion des dépendances pour PHP. Vous pouvez installer Composer en suivant les instructions sur son site officiel. Une fois que le compositeur a installé, vous pouvez installer phROUTE en exécutant la commande suivante dans votre terminal: le compositeur nécessite phréte / phroute. Cela téléchargera et installera PhROUTE dans votre application.

Comment définir les itinéraires à l'aide de phroute?

La définition des itinéraires à l'aide de phroute est simple. Vous devez d'abord créer une instance de la classe phro-useCollector. Vous pouvez ensuite utiliser la méthode d'itinéraire de cette classe pour définir vos itinéraires. La méthode de route prend trois paramètres: la méthode HTTP (get, post, etc.), le modèle URL et la fonction ou la méthode du gestionnaire. Voici un exemple:

$ router = new PhrouterateCollect "ID utilisateur: $ id";
});

Comment gérer les paramètres de route avec phroute?

Les paramètres de route sont des parties de l'URL qui peuvent varier. Dans phroute, vous pouvez définir les paramètres de route en les incluant dans le modèle URL lors de la définition de vos itinéraires. Les paramètres de route sont enfermés en accolades bouclées {}. Lorsqu'un itinéraire est apparié, les valeurs des paramètres de route sont transmises à la fonction ou à la méthode du gestionnaire comme arguments. Voici un exemple:

$ router = new PhrouterateCollect "ID utilisateur: $ id";
});

comment utiliser les filtres avec phroute?

Les filtres à phroute sont fonctions ou méthodes exécutées avant ou après un itinéraire correspondant. Ils peuvent être utilisés pour effectuer des tâches comme l'authentification ou la validation d'entrée. Vous pouvez définir des filtres à l'aide de la méthode du filtre de la classe PhrouterOneTellector, et vous pouvez les appliquer aux itinéraires en utilisant les méthodes avant et après. Voici un exemple:

$ router = new PhrouterateCollector ();
$ router-> filter ('auth', function () {
if (! Isset ($ _ session ['user'] )) {
return false;
}
});
$ router-> Route ('get', '/ tableau de bord', ['DashboardController', 'show']) -> avant ('auth');

comment gérer 404 erreurs avec phroute?

phroute fournit un moyen simple de gérer 404 erreurs, qui se produisent lorsqu'aucune route ne correspond à l'URL demandée. Vous pouvez définir un gestionnaire 404 à l'aide de la méthode Notfound de la classe phroterateCollector. Le gestionnaire 404 est une fonction ou une méthode qui est appelée lorsqu'une erreur 404 se produit. Voici un exemple:

$ router = new PhrouterateCollector ();
$ router-> notfound (function () {
return '404 - page introuvable';
});

comment expédier les itinéraires avec phroute?

Une fois que vous avez défini vos itinéraires, vous pouvez les envoyer en utilisant le Classe de phrouteroutEdispatcher. La méthode de répartition de cette classe prend la méthode HTTP et l'URL en tant que paramètres, et renvoie le résultat de la fonction ou de la méthode du gestionnaire de route correspondante. Voici un exemple:

$ Dispatcher = new PhrouteroutEdispatcher ($ router-> getData ());
$ réponse = $ dispatcher-> dispatch ($ _ server ['request_method'], $ _server ['request_uri ']);
Echo $ réponse;

puis-je utiliser phroute avec d'autres php frameworks?

Oui, vous pouvez utiliser PhROUTE avec d'autres frameworks PHP. PHOUTE est une bibliothèque autonome, ce qui signifie qu'elle ne dépend d'un cadre spécifique. Vous pouvez l'utiliser dans n'importe quelle application PHP, quel que soit le cadre que vous utilisez. Cependant, vous devrez peut-être adapter votre code pour travailler avec le système de routage de votre cadre.

Comment déboguer les routes dans phroute?

Les routes de débogage dans phroute peuvent être effectuées en utilisant la méthode de débogage de la classe phro-otecollector. Cette méthode renvoie un tableau de tous les itinéraires définis, qui peuvent être utiles à des fins de débogage. Voici un exemple:

$ router = new PhrouterateCollect "ID utilisateur: $ id";
});
print_r ($ router-> debug ());

comment gérer les exceptions Dans phroute?

Les exceptions dans phroute peuvent être gérées en enveloppez votre code de répartition dans un bloc de coups d'essai. Si une exception est lancée pendant le processus de répartition, vous pouvez l'attraper et le gérer de manière appropriée. Voici un exemple:

essayez {
$ dissatcher = new PhrouteroutEdispatcher ($ router-> getData ());
$ réponse = $ dispatcher-> dispatch ($ _ server ['request_method'], $ _Server ['request_uri']);
echo $ réponse;
} catch (exception $ e) {
echo 'Une erreur s'est produite:'. $ e-> getMessage ();
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!