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

Powered by OpenSource Softwares

Outil de déboggage colaborative
reduire

HTTPRequest, Gestion des requêtes en PHP

le 12 août 2007 par sahid

Une classe PHP5 pour gérer les requêtes passées à notre application

Une classe outil qui peut être réutilisée et complétée pour gérer les requêtes POST et GET passées à votre application.

Fonctionnement de la classe HttpRequest

La classe est assez simple et plutÃŽt utile, elle est complÚtement réutilisable (cela me fait penser que PHP6 et l’arrivée des espaces de nom (namespaces) sera une trÚs bonne nouvelle pour la communauté PHP. Car le manque de cette fonctionnalité commence réellement à se faire sentir avec les multiples classes et frameworks qui voient le jour !), utilisée via un frontController elle permet d’intercepter les requêtes passées à l’application sous toutes ses couches et les nettoie en fonction du type à retourner.

Exemple d’utilisation

  1. <?php
  2.          $request = new HttpRequest;
  3.  
  4.          # RécupÚre la valeur d’un "module" alphabétique
  5.    $module = $request->getAlpha (‘module’);
  6.  
  7.    # RécupÚre les valeurs d’un formulaire
  8.          $nom = $request->getAlpha (‘nom’); // alphabétique
  9.          $mdp = $request->getAlnum (‘mdp’); // alphanumérique
  10.          $mnt = $request->getFloat (‘mnt’); // flottantes (ex : un montant)
  11.         
  12.          $usr_id = $request->getInt (‘usr_id’); // entier
  13.  
  14.          # RécupÚre les valeurs, sans les échapper (__get)
  15.          $mix = $request->mixedParam ();
  16. // HttpResquest, Gestion des requêtes en PHP
  17.    # Ajoute un nouveau paramÚtre (__set)
  18.    $request->newParam = “Hello World”;  
  19. ?>

A voir…

Au niveau du constructeur de la classe, j’utilise un array_merge pour récupérer les tableaux GET et POST, mais peut être que placer un paramÚtre au constructeur permettrait une meilleure souplesse de la classe.

  1. <?php
  2. class HttpRequest_2 {
  3.          private $_request;
  4.  
  5.          public function __construct ($array) {
  6.            $this->_request = $array;
  7.    }
  8.    // …
  9. }

Ainsi on peut choisir quels sont les types de variable qu’on souhaite récupérer…

  1. <?php
  2. # POST
  3. $request = new HttpRequest ($_POST);
  4.  
  5. # GET
  6. $request = new HttpRequest ($_GET);
  7.  
  8. # POST et GET
  9. $request = new HttpRequest (array_merge ($_POST, $_GET));
  10.  
  11. # POST, GET, COOKIE
  12. $request = new HttpRequest ($_REQUEST);
  13.  
  14. # ou toute autre variante …
  15. ?>

La classe HttpRequest complete

  1. <?php
  2.  
  3.         /**
  4.          * Ferdjaoui Sahid <sahid@funraill.org>
  5.          * http://sahid.funraill.org
  6.          *
  7.          * @copyright Copyright (c) 2007 Ferdjaoui Sahid
  8.          */
  9.  
  10. /**
  11. * HttpRequest, Gestion des requêtes passées à l’application
  12. *
  13. * @category HTTP
  14. * @package  HttpRequest
  15. */
  16. class HttpRequest
  17. {
  18.         private $_request;
  19.  
  20.         /**
  21.          */
  22.         public function __construct ()
  23.         {
  24.                 $this->_request = array_merge ($_POST, $_GET);
  25.         }
  26.  
  27.         /**
  28.          * Retourne la valeur d’un paramÚtre passé à l’appli
  29.          *
  30.          * @param mixed $key
  31.          * @return mixed
  32.          */
  33.         public function get ($key)
  34.         {
  35.                 return array_key_exists ($key, $this->_request)
  36.                         ? $this->_request[$key] : false;
  37.         }
  38.  
  39.         /**
  40.          * Ajoute un nouveau paramÚtre
  41.          *
  42.          * @param mixed $key
  43.          * @param mixed $val
  44.          */
  45.         public function set ($key, $val)
  46.         {
  47.                 $this->_request[$key] = $val;
  48.         }
  49.  
  50.         /**
  51.          * Mapping des méthodes get et set via l’utilisation de __get et __set
  52.          */
  53.         public function __get ($key) { return $this->get ($key); }
  54.         public function __set ($key, $val) { $this->set ($key, $val); }
  55.  
  56.         /**
  57.          * Retourne une chaîne de caractÚres alphabétiques
  58.          *
  59.          * @param mixed $key
  60.          * @return string
  61.          */
  62.         public function getAlpha ($key)
  63.         {
  64.                 return preg_replace (‘/[^[:alpha:]]/’, ”, $this->get ($key));
  65.         }
  66.  
  67.         /**
  68.          * Retourne une chaîne de caractÚres alphanumériques
  69.          *
  70.          * @param mixed $key
  71.          * @return string
  72.          */
  73.         public function getAlnum ($key)
  74.         {
  75.                 return preg_replace (‘/[^[:alnum:]]/’, ”, $this->get ($key));
  76.         }
  77.  
  78.         /**
  79.          * Retourne et convertit une chaîne en nombre à virgule flottante
  80.          *
  81.          * @param mixed $key
  82.          * @return integer
  83.          */
  84.         public function getInt ($key)
  85.         {
  86.                 return intval ($this->get ($key));
  87.         }
  88.  
  89.         /**
  90.          * Retourne une valeur à virgule flottante
  91.          *
  92.          * @param mixed $key
  93.          * @return float
  94.          */
  95.         public function getFloat ($key)
  96.         {
  97.                 return floatval ($this->get ($key));
  98.         }
  99.  
  100.         /**
  101.          * Retourne le nom du dossier qui contient le fichier ou dossier
  102.          *
  103.          * @param mixed $key
  104.          * @return mixed
  105.          */
  106.         public function getDir ($key)
  107.         {
  108.                 return dirname ($this->get ($key));
  109.         }
  110.  
  111.         /**
  112.          * Retourne le chemin canonique absolu
  113.          *
  114.          * @param mixed $key
  115.          * @return mixed
  116.          */
  117.         public function getPath ($key)
  118.         {
  119.                 return realpath ($this->get ($key));
  120.         }
  121.  
  122.         /**
  123.          * Retourne le tableur Requête
  124.          */
  125.         public function getRequest () { return $this->_request; }
  126. }

Tableau de bord

6 commentaires pour HTTPRequest, Gestion des requêtes en PHP

  1. Arnaud S dit :
    19 septembre 2007 at 9:28

    J’utilise la classe Http trouvée sur http://www.troywolf.com/articles (AJAX Cross-Domain Solution: proxy.php) dans le cadre de mes applications 2.0.
    Elle me permet entre autre de rebalancer les headers http (dont les variables passées en POST) à destination de la cible.

    Un proxy php est nécessaire pour faire du cross-domain.
    J’ai d’ailleurs eu la surprise de constater que http://www.domain.com et http://www.domain.com:1234 sont considérés comme des domaines différents et bloque la méthode open juste à cause du port !

  2. sahid dit :
    22 septembre 2007 at 19:09

    Merci pour la classe Arnaud

  3. yoong dit :
    30 janvier 2008 at 11:10

    je ne comprends pas l’intéret de ta classe?
    utilise plutot HttpRequest de Php non?

    Yoong

  4. sahid dit :
    30 janvier 2008 at 12:49

    Salut Yoong,

    Merci pour ton commentaires,
    le but de cette classe est d’être placer dans ton Front Controller afin d’intercepter les entrées et de les filtrer.

    En faite elle n’a pas grand chose à voir avec la classe HttpRequest de PHP. disons qu’elle est d’un plus haut niveau car elle filtre les informations, HttpRequest de PHP fournie des méthodes permetant de travailler directement avec le protocole HTTP.

    ~~

    1. interface FrontController {
    2.   public function loadController (HttpRequest $request);
    3. }
  5. yoong dit :
    30 janvier 2008 at 14:54

    Ha ok,

    mais il n’y a pas confusion quand tu instancies un objet httpRequest avec celui de php?
    question intéressante : quel est l’ordre de recherche d’une classe pour le charger?celui de php par défaut ou le tien?
    Personnellement, j’utilise le zend framework qui fait tout cela.
    Yoong

  6. sahid dit :
    30 janvier 2008 at 16:19

    Si bien sur, il y a un conflit et les classes natives de PHP prenne le pas, seulement la mienne est HttpRequest et non HTTPRequest :)

    Ce genre de problème devrait bientôt se régler avec l’arrivée des espaces de noms.

    j’en parle tres brièvement sur un topic, mais le mieux et de regarder sur la doc php
    http://sahid.funraill.org/2007/11/27/support-des-espaces-de-noms-en-php/

    ~sahid/

Tu peux laisser un commentaire pour HTTPRequest, Gestion des requêtes en PHP

« GPL v3 lutte contre le Trust Computer
Free Software Sticker Book »