Réécriture, routage : Quel choix ?

[RunCodePhp]

Salut à tous

D'abord, désolé si ce topic est mal placé, j'en sais trop rien où le mettre

Le principe actuel que j'ai concernant la réécriture et le routage des pages ne me satisfait pas (mal pensé au départ), et je tente de repartir d'une feuille blanche.

Le problème c'est que je ne sais pas trop l'orientation à prendre, sans compter que j'ai peut être une mauvaise vision.
Toujours est il que je tente petit à petit d'adopter le concept MVC.

D'après ce que j'ai compris, il faudrait au moins renseigner le module et l'action dans les URLs.
Qui serait quelque chose comme :
Soit : domaine.com/index.php?module=accueil&action=index
Soit : domaine.com/accueil/index.html

Aussi, au niveau du .htaccess, j'ai ceci :

Code :

1
2
3
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^(.*)\.(html|php) index.php/$0 [PT]

Donc j'ai opté que la réécriture concerne les .html ou .php (pour le moment)

Déjà, est ce que le principe que le module soit le nom de la page et de mettre l'action que le controller devra exécuter est bon ?

En partant de ce principe, il faudra que le controller de l'accueil est une méthode index
-> fichier accueil.php
-> classe Accueil {...}
-> Méthode index() {...}

Que je mette le module (ou le nom de la page) me parais indispensable, mais l'action, pas tant que ça, car la majorité des cas ça sera "index", l'action par défaut.

Le problème que je perçois si j'omets de mettre l'action, c'est par exemple la page catégorie, qui avec l'action donnerait par exemple :
domaine.com/categorie/index/une_categorie-10.html

Et si je ne mets pas l'action en partant du principe que s'il y en a pas, c'est celle par défaut :
domaine.com/categorie/une_categorie-10.html

Ici, la logique est faussée car la 2ème position est théoriquement prévu pour l'action, mais ici c'est le nom (réécrit) de la catégorie.
Je dirais qu'ici c'est quand même un détail.


L'autre difficulté que je vois, c'est surtout celle là, c'est lors de la pagination rajouté un tri, par exemple :
domaine.com/categorie/index/une_categorie-10/art_name/desc/3.html
Donc un trie sur le nom des articles de la catégorie 10, et décroissant, en 3ème page.

Voir
domaine.com/categorie/index/une_categorie-10/art_name/desc/date/asc/3.html
2 tries cette fois, sur le nom décroissant, et sur la date de création ascendant, en 3ème page.
Je me dis que pour décortiquer ça, chaud les marrons


Je me dit que si c'est trop compliqué de tout intégrer dans la réécriture, et bien faire comme ceci :
domaine.com/categorie/index/une_categorie-10.html?tri=cat_name&ordre=des&page=3
Donc en partie en paramètre (QUERY_STRING)


Comment feriez-vous, quel serait selon vous le concept de réécriture assez souple ?

[grunk]

Je t'expose rapidement comment marche le router que j'ai fait , cela devrait te donner des pistes.

1- Coté Apache , je renvoi toutes les requêtes sur l'index :

Code :

1
2
3
 
RewriteEngine on
RewriteRule !\.(js|css|jpg...tous les truc que tu ne veux pas)$ index.php

2- Ensuite dans ma page index.php j'instancie mon routeur :

Code :

1
2
3
4
 
$router = Controller_Router::getInstance();
$router->setPath('includes/controllers/'); // je défini ou se trouve les controllers
$router->addRule('test/regles/:id/hello', array('controller'=>'index','action'=>'monAction')); // Je défini ici une règle de routage qui redirigera l'url site.com/test/regles/5/hello vers le controller index et l'action monAction.

Tu remarqueras que la règle de routage va répondre à ta problématique des arguments multiples.

Une fois tous cela défini mes url marche comme ceci :
monsite.com/controller/action/param-1/param-2/.../param-n
Les paramètres sont donc dispo dans un tableau.

Et avec les règles de routage je peux faire pointer n'importe quelle url sur n'importe quel couple controller/action


Coté technique c'est assez simple :
Je récupère l'url via

Code php :

$_SERVER['REQUEST_URI'];

Et fait un petit traitement dessus pour récupérer ce dont j'ai besoin :

Code :

1
2
3
4
5
6
7
8
 
$items = explode('/',$url);
if(!empty($items))
{
    $this->controller = array_shift($items);
    $this->action     = array_shift($items);
    $this->params    = $items;
}

A partir de là j'ai le controller à exécuté , l'action et les paramètres. Je peux donc faire à peut près tout ce que je veux ^^

Si jamais l'url récupéré correspond à une règle de routage, le traitement sera bien entendu légèrement différent.

En revanche il existe quelques limitations :

- Il est possible de ne pas spécifier l'action (donc celle par défaut) mais on ne peut alors pas ajouter de paramètres
- On doit forcément connaitre l'ordre des attributs passé ou alors utiliser une règle de routage auquel cas les attribut seront dispo dans un tableau avec la clé défini dans la règle ($param[':id'] pour reprendre mon exemple plus haut).

[Thes32]

salut grunk,

Ta combinaison est en effet bien pensé, personnellement j'ai eu à voir/travailler sur des modèles semblable.

Comment gères-tu l'absence de mod_rewrite ?

[grunk]

Envoyé par Thes32

salut grunk,

Ta combinaison est en effet bien pensé, personnellement j'ai eu à voir/travailler sur des modèles semblable.

Comment gères-tu l'absence de mod_rewrite ?

Je le gère pas ^^
J'ai la main sur tous mes serveurs donc pas vraiment inclus cette problématique dans le développement.

[RunCodePhp]

J'ai mis un peu de temps, mais il me semble avoir saisie l'idée générale.
Elle me semble aussi vachement bien

L'idée serait donc de définir pour chaque controller (j'ai plutôt envie de dire chaque page) la règle, ceci dans le but de retrouver ces petits dans le REQUEST_URI, donc sans trop se soucier de l'ordre des paramètres.


Il y a quand même un truc qui m'échappe dans ton exemple.
Pourquoi avoir mis :id, 2 points devant le id ?
Pourquoi donc le "hello" n'en a t-il pas ?
Est ce une astuce que je n'aurais pas compris ?


Un autre aspect jailli tout un coup.
Il me semble qu'on peu considérer ici que les 2 premiers éléments que sont ...controller/action/... relève du routage pure.
Du coup, tout de reste n'est pas du routage, mais des paramètres divers si on peu dire.
En gros, ces paramètres là relèverait plus de paramètres GET.
Ne faudrait il pas dispatcher dans le tableau GET ou autre classe Request ?


Petite parenthèse d'ailleurs, j'utilise le terme dispatcher presque par hasard.
En parcourant divers FrameWork, j'ai vu plusieurs fois des classes Dispatcher.
Parmi les traitements quelles font, sont ils dans le même esprit que je viens d'évoquer précédemment, soit de mettre tel paramètre ici, tel autre là-bas ?


Merci pour les idées en tout cas

Comment gères-tu l'absence de mod_rewrite ?

Comme je suis en pleine méditation, j'en sais trop rien, mais je me dis que si les paramètres ne sont pas dans le REQUEST_URI, ils devront être dans le QUERY_STRING, non ?
Donc à l'origine, ce sont des liens, les infos devront être des paramètres GET.
Enfin, il faudrait au moins que le nom de la page soit le nom du controller, qui correspondra au REQUEST_URI.
Tout le reste devra alors êtres en paramètre GET : L'action, les paramètres optionnels.

Ceci devrait donc permettre de faire certaines alternatives dans le routeur.
Mais il vrai qu'il est plus simple de s'imposer le mod_rewrite.

Enfin, c'est ainsi que je perçois les choses ... mais ce n'est pas encore fait.

[grunk]

Envoyé par RunCodePhp

L'idée serait donc de définir pour chaque controller (j'ai plutôt envie de dire chaque page) la règle, ceci dans le but de retrouver ces petits dans le REQUEST_URI, donc sans trop se soucier de l'ordre des paramètres.

Pas vraiment, la vérification des règles ayant un certains coût (expression régulière) il faut les utiliser intelligemment. Si une page remplie le "pattern" de base c'est à dire controller/action/param nulle besoin de définir une règle.
Là ou les règles sont intéressante c'est lorsque tu as besoin de déplacer tes paramètres dans ton url (par exemple param1/controller/param2/param3/action/param4)

Il y a quand même un truc qui m'échappe dans ton exemple.
Pourquoi avoir mis :id, 2 points devant le id ?
Pourquoi donc le "hello" n'en a t-il pas ?
Est ce une astuce que je n'aurais pas compris ?

Dans ma règles les mot précédé de ":" sont des mot clé qui indique la place d' un paramètre.
"test" et "Hello" ne sont que du vent. Ca pourrait être foo et bar que le résultat serait le même , c'est à dire appel du controller et de l'action défini dans le tableau passé en paramètre

Il me semble qu'on peu considérer ici que les 2 premiers éléments que sont ...controller/action/... relève du routage pure.
Du coup, tout de reste n'est pas du routage, mais des paramètres divers si on peu dire.
En gros, ces paramètres là relèverait plus de paramètres GET.
Ne faudrait il pas dispatcher dans le tableau GET ou autre classe Request ?

C'est une possibilité. mais dans mon cas comme la variable contenant les paramètre est transmise au controller , elle est accessible ensuite dans la vue et les modèles donc pas réellement besoin du classe gérant le tout.

[RunCodePhp]

Rien qu'avec ce que tu as apporté, ça correspond tout à fait à ce que je recherchais.
Déjà de mon coté, je ferais simple, les 2er seront respectivement le controller et l'action.
Puis après, la quasi majorité des cas je pense ne pas avoir besoin de définir de règles, ça sera comme précédemment, une convention personnelle.

Reste au niveau du moteur de recherche interne par exemple qui réclamera peut être une règle vu les nombreuses possibilités.
Faut que je regarde tout ça de plus près.


Grand merci pour toutes ces idées et précisions, depuis samedi j'étais dessus, et franchement pas inspiré du tout.

[grunk]

Je viens de retrouver l'article dont je m'étais inspirer pour la gestion des règles de routage (comme quoi ca sert de commenter son code ^^ ).
Il présente un exemple de classe qui devrait t'aider dans ce que tu souhaite faire :

http://blog.sosedoff.com/2009/07/04/...ng-controller/

[RunCodePhp]

Il présente un exemple de classe qui devrait t'aider dans ce que tu souhaite faire

C'est plus qu'un exemple, ça fait tout ce que je souhaite faire tu veux dire.

Pour quelqu'un en mal d'inspiration, cette fois j'ai plus d'excuse.
Comme dirait l'autre : Yapluka

Les quelques petits essai actuels pour comprendre un peu le Router::ruleMatch($rule, $data) suffisent pour me dire que ça va l'faire.


Mille merci.

[RunCodePhp]

Quelques petites questions ou précisions si c'est pas abusé


Pour le coté pratique, et en essayant de faire court.
Admettons cette page "categorie" qui liste des articles, qui par défaut n'aura pas de paramètres.
Actuellement les tries et la pagination sont dans des formulaires, ce qui n'est pas correcte du tout.
Ca sera donc sous forme de lien, tout ça avec la réécriture.


Du coup, je me pose la question suivante :
- Serait il mieux de mettre l'intégralité des divers paramètres dans tous les liens, en respectant bien à chaque fois le même ordre, quitte à mettre une valeur par défaut ?
Exemple : .../categorie/index/une_categorie-10/2/art_name/desc/date/asc.html
respectivement : .../controller/action/nom_catégorie/page/trie1/ordre1/trie2/ordre2.html

- Ou alors ça n'a pas importance qu'ils y soient tous, peut être juste se contenter de respecter l'ordre ?
Exemple : .../categorie/index/une_categorie-10/2/art_name/desc/date/asc.html
respectivement : .../controller/action/nom_catégorie/page.html

- Ou est ce que tout ça est un faux problème ?
Je ne visualise pas bien encore.


Une autre question.
Est ce que coté MVC, le fait que cette page "categorie" débouche tantôt sur aucun paramètre (action par défaut) et que tantôt avec plusieurs paramètres demande que ce soit une autre action ?
Par défaut : action -> index
Avec critères : action -> criteres


Dernière question ... oufff
Si par exemple je sens que des règles soient obligatoire, à quel niveau devrait s'ajouter ces règles ?
Peut on le faire dans le controller de la page concernée (comme classe Categorie {})
Ou est ce obligatoirement en amont ?
Là aussi je ne visualise pas bien.


Les questions fusent.

[grunk]

Envoyé par RunCodePhp

Du coup, je me pose la question suivante :
- Serait il mieux de mettre l'intégralité des divers paramètres dans tous les liens, en respectant bien à chaque fois le même ordre, quitte à mettre une valeur par défaut ?
Exemple : .../categorie/index/une_categorie-10/2/art_name/desc/date/asc.html
respectivement : .../controller/action/nom_catégorie/page/trie1/ordre1/trie2/ordre2.html

C'est plus un faux problème à mon avis. Si tu juges que tes paramètres peuvent avoir un impact bénéfique sur le référencement pourquoi pas tous les afficher.
Cela mis de coté , 99% des utilisateurs finaux ne savent même pas ce qu'est une url et à quoi elle sert donc tu fait bien comme ca t'arrange.

Envoyé par RunCodePhp

Une autre question.
Est ce que coté MVC, le fait que cette page "categorie" débouche tantôt sur aucun paramètre (action par défaut) et que tantôt avec plusieurs paramètres demande que ce soit une autre action ?
Par défaut : action -> index
Avec critères : action -> criteres

J'aurais tendance à dire que le traitement de fond est le même (afficher des article) donc que l'action devrait être la même. Mais peut être me trompe-je

Envoyé par RunCodePhp

Dernière question ... oufff
Si par exemple je sens que des règles soient obligatoire, à quel niveau devrait s'ajouter ces règles ?
Peut on le faire dans le controller de la page concernée (comme classe Categorie {})
Ou est ce obligatoirement en amont ?
Là aussi je ne visualise pas bien.

Je défini mes règles dans le bootstrap (l'index.php). C'est la ou j'instancie le routeur et le configure , ca me semble logique d'ajouter les règles ici.
Si vraiment tu en as beaucoup peut être se tourner vers un fichier à inclure pour garder le tout clair.

[RunCodePhp]

Merci pour toutes ces précisions


Je découvre par la même occasion la raison d'être de ces fameux bootstrap que j'ai vu dans les divers FrameWork.
Je ne parvenais pas à comprendre à quoi ils servaient.

[RunCodePhp]

Je continu le sujet du routage, et du controller lié au controller/action.

J'ai ce code pour le moment dans le index.php :
(le boostap, mais il me semble qu'on l'appel aussi le Front Controller non ?)

Code :

1
2
3
4
5
6
7
8
9
10
 
// ROUTEUR
Config::getRouteur()->routage();
// CONTROLLER
$controller = 'Controllers_'.Routeur::getController();
$action = Routeur::getAction();
 
$controller_class = new $controller($action);
$controller_class->$action();
$controller_class->main();

Ce qui me dérange un peu, c'est si je provoque volontairement une erreur, que je qualifierait de toute bête, ça provoque une erreur fatale.
Pas cool
Exemple :

Code :

1
2
3
 
$action = 'truc';
$controller_class->$action();

La méthode Controllers_Accceuil::truc() n'existe pas.
Cette erreur peut être obtenue via une banale URL, genre : -http://domaine.com/accueil/truc/
Trop "casse gueule" à mon gout.

Comment gérer au mieux une action qui n'existerait pas ? (donc éviter une Fatale Erreur)

A cet instant, je me dis qu'il serait pas mal de "passer" en argument l'action au controller, puis ce serait géré dans le constructeur, et l'appel à l'action se ferait aussi dans le constructeur.
En gros :
- Une vérif avec method_exists()
- Puis si elle n'existe pas, appeler une méthode par défaut, genre Controllers_Accueil::index() qui de mon coté tous les controllers ont cette méthode index().

Ca donnerait quelque chose du genre dans le index.php :

Code :

1
2
3
4
5
6
7
8
 
// ROUTEUR
Config::getRouteur()->routage();
// CONTROLLER
$controller = 'Controllers_'.Routeur::getController();
$action = Routeur::getAction();
 
$controller_class = new $controller($action);

Puis dans un des controllers :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
class Controllers_Accueil extends Controller {
 
    public function  __construct($action = 'index') {
        $existe = method_exists(__CLASS__, $action);
        if ($existe == FALSE) {
            $action = 'index';
        }
        //
        $this->$action();
        $this->main();
    }
 
    public function  index() {
        // action par défaut
    }
}

Ceci peu donner la possibilité de générer un message d'erreur de les logs comme ajouter un message pour l'utilisateur, par exemple.


Comment faites vous gérer ça, une erreur au départ presque banale mais très grave coté Php ?

[grunk]

Voila comment je gère ça :

Partie controller , je vérifie si le fichier existe. Si ce n'est pasle cas je renvois sur un controller d'erreur indiquant au gentil internaute de ne pas faire n'importe quoi.

Code :

1
2
3
4
5
6
7
8
 
 
if(!file_exists($this->file)) {
	header("Status: 404 Not Found");
	$this->controller   = $this->errorController;
	$this->action       = $this->errorAction;
	$this->file         = $this->path.$this->controller.'.php';
}

Pour les actions , je vérifie simplement que la méthode est appelable (callable), si ce n'est pas le cas je renvoi sur une action par défaut.

Code :

1
2
3
4
5
6
 
 
if(!is_callable(array($controller,$this->action)))
	$action = $this->defaultAction;
else
	$action = $this->action;

[RunCodePhp]

Génial ça

Je connaissais de nom is_callable(), mais jusqu'à lors j'ai jamais utilisé ça, ni même prospecté.
Ca me parais tout à fait adapté pour ce cas là.


Pour ce qui est des controllers, de mon coté ce sont des pages, et elles sont toutes stockées dans la Bdd, ce qui fait que je vérifie à ce niveau s'ils existent.
J'avoue que le manière est un peu lourde, vérifier l'existence du fichier me parais plus simple et surtout moins gourmand.
Je vais y penser.


En tout cas merci pour cette réponse rapide et avisée.

[boo64]

Je n'ai pas verifié mais un bon faq sur tout ça sur dvp.com ca le ferait !

[RunCodePhp]

Envoyé par boo64

Je n'ai pas verifié mais un bon faq sur tout ça sur dvp.com ca le ferait !

Tout ça relève du concept MVC, et il y en déjà des tutos.
Celui-ci entre autre : http://julien-pauli.developpez.com/t...vc-controleur/
Il est vrai que si on cherche, on en trouve d'autres.

Ce tuto là me parais assez "hard" tout de même.

Disons qu'ici j'étais plus à la recherche de solutions simple mais efficace pour un petit FrameWork "maison", sans prétention.
Rien que ça déjà, c'est loin d'être évident.
Jusqu'à lors j'ai appliqué les conseils donnés par Grunk, et ça me conviens vraiment bien.

En tout cas, rédiger une Faq sur des concepts où j'ai du mal déjà à adhérer, ça ne va pas être possible.

[RunCodePhp]

Je reviens un peu "à la charge" concernant cette réécriture où je rencontre un souci plutôt désagréable, et surtout (particulièrement) énigmatique.

J'avais déjà ouvert un topic, mis "résolu", mais finalement il en est rien
-> (en local) Bug Apage, navigateurs, ou de l'OS ?


Je l'évoque ici car c'est vraiment depuis cette réécriture que je rencontre ce problème.

Je réacapitule un peu la situation.
Le .htaccess :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
 
Options -Indexes
 
DirectoryIndex index.php index.html
 
Options +FollowSymLinks
 
RewriteEngine On
RewriteBase /
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule !\.(js|css|jpg|jpeg|gif|png|ico|pdf|xml)$ index.php [PT]

Ceci dans mon host coté Windows :

Code :

1
2
127.0.0.1 localhost
127.0.0.1 srun.dom1

Et coté httpd.conf créé 2 virtualhost :
1 pour le localhost (www de wamp)
1 pour srun.dom1 (dans D:/wamp/apps/srun)

(tout ça histoire d'être au plus proche d'un domaine sur le Net car tout ceci ne l'est pas actuellement)


Le phénomène que je rencontre fait que selon l'URL demandée (clic sur un lien) débouche sur une pléiade d'erreurs, Apache est bombardée de demandes (URLs) non valides.
Selon le nombres d'URLS non valides ça va jusqu'à faire stopper/redémarrer Apache.


Je m'explique.
Si je demande cette URL par exemple : -http://srun.dom1/entree/index/
Puis coté html si je ne mets pas de <base href="http://srun.dom1/"> dans le <head> ceci va provoquer ces pléiades d'erreurs plutôt désagréable (qui ne me semble pas logique) pour toutes URLs relatives.
Les URLs du genre : images/logo.jpg

Une image dans la page sera recherchée vers : -http://srun.dom1/entree/index/images/logo.jpg
Alors quelle devrait être recherchée vers : -http://srun.dom1/images/logo.jpg


Donc si je n'indique pas cette base (ou référence) d'URL, ça part en sucette.


Mais là où ça devient encore tordue comme situation, c'est si je provoque une erreur de html volontaire comme mettre un banal texte avant le DOCTYPE, ça provoque le même phénomène, soit ces même erreurs successives.
Ici, même la base d'URL (dans le <base>) ne serait plus tenu compte.
Les navigateurs (FF et IE entre autre) prennent comme base du domaine ceci : -http://srun.dom1/entree/index/ au lieu de ça : -http://srun.dom1/


Résultat des courses et pour éviter tout ça, je n'aurais pas d'autres choix que d'utiliser partout des URLs absolues et complètes, genre :
-http://srun.dom1/images/logo.jpg
chose qui me dérange vraiment, ce qui me semble impensable.


Comment est ce possible de ne pas (ou plus) pouvoir utiliser d'URLs relatives sans rencontrer ces phénomènes plutôt déroutants ?

C'est dingue ça quand même non ?
Je me dis qu'il doit bien avoir une solution par là, que je dois faire une erreur.
Mais alors à quel niveau ???


Si vous avez une piste, alors je suis vraiment preneur.

[RunCodePhp]

J'avais pourtant fais des tonnes d'essais en tout genre, sauf celui que je vient de faire et apparemment ça à l'air de le régler.

En faite, jusqu'à lors j'ai toujours indiquer des URLs relatives comme ceci :

Code :

1
2
 
<img src="images/logo.jpg" />

En faisant comme ci-dessous, ça a plutôt l'air de tout remettre dans l'ordre (ne plus déboussoler les navigateurs) :

Code :

1
2
 
<img src="/images/logo.jpg" />

En rajoutant un slash au début.

Et par le même coup, plus besoin de préciser de base d'URL (balise <base href="...">) dans le head.


Personnellement, je trouve ça plutôt surprenant.
M'enfin, si c'est ainsi.

Vous en pensez quoi ? Est-ce normal ?