Sahid Ferdjaoui Blog - Funraill Foundation Bienvenue, Log in - thème 2007 RC1

Powered by OpenSource Softwares

Outil de déboggage colaborative
reduire

Modele MVC en PHP5 - Front Controller

le 17 février 2007 par sahid

Mise en place d’un Front Controller paramétré en PHP5

Front Controller ?

Dans les applications PHP5, la séparation de notre code en plusieurs couches est devenue primordiale, je me répÚte un peu, mais depuis PHP5, on ne parle plus de scrypt, mais d’application, donc qui dit application dit architecture solide et modulable, c’est pourquoi on à recours au motif de conception comme ceux du GOF qui rescence plusieurs solutions à des problÚmes particuliers. Dans cet article on se consacre à la partie “moteur” de notre application, le Front Controller permettant de charger et d’executer un module. Le notre sera simple et parametré par “module”

Les interfaces en PHP5

Le travail commence, on va définir une interface que nos modules devront implémenter, pourquoi définir cette interface ? tout simplement parce qu’on cherche à créer une application solide modulable et portable.

  1. <?php
  2. interface Module {
  3.         public function execModule (HttpRequest $request);
  4. }

La classe HttpRequest

Comme on le voit, notre interface “Module” demande une méthode, celle-ci prend en paramÚtre la classe HttpRequest. Cette classe permet la récupération de toutes les requetes passées à notre application et pouvant etre utile à notre module donc on récupérera les tableaux $_POST et $_GET qu’on transmettra à notre méthode par l’intermédiaire de HttpRequest

  1. <?php
  2. class HttpRequest {
  3.         private $_request;
  4.        
  5.         public function __construct () {
  6.                 $this->_request = array_merge ($_POST, $_GET);   
  7.         }
  8.         public function getParam ($key) {
  9.                 return $this->_request[$key];
  10.         }
  11. }

Le Front Controller

un peu à la maniÚre de nos modules, on va définir ici une nouvelle interface front controller que notre moteur devra implémenter, le principe est le suivant. Dans notre MVC notre Front Controller impose la méthode LoadModule, celle-ci chargera un module implémenté par l’interface Module, donc possédant une méthode execModule, qu’il initialisera ! Voyons un peu le code…

  1. <?php
  2. interface FrontController {
  3.         public function loadModule (HttpRequest $request);
  4. }

On passe maintenant à l’écriture du la classe Engine, qui implementera Front Controller. Celui-ci traitera donc les requêtes passées à l’application via la classe HttpRequest, notre classe Engine recuperera le paramÚtre module et chargera la classe en rapport à celui-ci…

  1. class Engine implements FrontController {
  2.         public function loadModule (HttpRequest $request) {
  3.                 // récupération du nom du module à charger
  4.                 $moduleName = $request->getParam(“module”);
  5.                 if ($moduleName != ) {
  6.                         // fichier php intégrant le module
  7.                         $fileName = “~/module.{$moduleName}.php”; // pensez au chemin
  8.                         if (!class_exists ($fileName)) {
  9.                                 if (file_exists ($fileName)) {
  10.                                         require_once ($fileName);
  11.                                 } else {
  12.                                         // génération d’une exception
  13.                                         throw new Exception (“Impossible de trouver le module”);
  14.                                 }
  15.                         }
  16.                         // instance du module
  17.                         $o = new $moduleName ();
  18.                         // execution du module
  19.                         $o->execModule ($request);
  20.                 } else {
  21.                         throw new Exception (“Le module à executé est invalide”);
  22.                 }
  23.         }
  24. }

Creation d’un simple module

Pour illustrer notre exemple de Front Controller, on va créer un simple module affichant à l’écran le mythique “Hello World !”, On se souvient qu’il devra implémenter l’interface Module et donc disposer d’une action execModule ()

  1. class SayHelloWorld implements Module {
  2.         public function execModule (HttpRequest $request) {
  3.                 echo “Hello World en PHP5 !”;
  4.         }
  5. }

Donc on accede au module via : “http://monsite.com?module=SayHelloWorld” …hum, il serait peut etre interessent de mettre en plus, l’url rewriting, non ? (;

Conclution

Voila un simple Front controller paramétré, il se veut assez simple et modulable, et devra sans doute être modifié afin d’etre integré dans une application plus poussée. on pourra aussi utiliser la classe View vue dans un article précédent pour commencer à avoir une petite approche d’application PHP légÚrement evoluée. De plus une modification du Modele pourrait être d’ajouter une classe i18n permettant l’internationalisation de l’application.

Un commentaire pour Modele MVC en PHP5 - Front Controller

  1. carpentier dit :

    Chapeau !

Tu peux laisser un commentaire pour Modele MVC en PHP5 - Front Controller