Routeur Standard

Le distributeur

Vue d'ensemble

La distribution est le processus de récupération de l'objet requête, Zend_Controller_Request_Abstract, d'extraction du nom de module, du nom de contrôleur, du nom d'action, et des paramètres facultatifs qui s'y trouvent, et enfin d'instanciation du contrôleur et de l'appel d'une action de ce contrôleur. Si le module, le contrôleur, ou l'action ne sont pas trouvés, il emploiera des valeurs par défaut pour eux. Zend_Controller_Dispatcher_Standard indique index pour le contrôleur et l'action par défaut et default pour le module par défaut, mais permet au développeur de changer ces valeurs par défaut pour chacun en utilisant les méthodes respectives setDefaultController(), setDefaultAction(), et setDefaultModule().

Note: Le module "Default"
Quand vous créez des applications modulaires, vous pouvez constater que vous voulez aussi que votre module par défaut ait son espace de noms (dans la configuration par défaut, le module "default" n'a pas d'espace de noms). A partir de la version 1.5.0, vous pouvez spécifier le paramètre prefixDefaultModule à TRUE soit dans le contrôleur frontal soit dans le distributeur :

  1. // Dans le contrôleur frontal :
  2. $front->setParam('prefixDefaultModule'// Dans le distributeur :
  3. $dispatcher->setParam('prefixDefaultModule'
Ceci vous permet de ré-utiliser un module existant en tant que module par défaut d'une application.

La distribution se produit dans une boucle dans le contrôleur frontal. Avant que le distribution ne se produise, le contrôleur frontal détermine la route de la requête pour récupérer les valeurs spécifiées par l'utilisateur pour le module, le contrôleur , l'action , et les paramètres optionnels. Il entre alors dans la boucle d'expédition, et distribue la requête.

Au début de chaque itération, il régle un drapeau dans l'objet requête indiquant que l'action a été distribuée. Si une action ou un plugin pre/postDispatch remet à zéro ce drapeau, la boucle de distribution continue et tente de distribuer la nouvelle requête. En changeant le contrôleur et/ou l'action dans la requête et en effaçant le drapeau de distribution, le développeur peut définir une chaîne de requêtes à réaliser.

La méthode du contrôleur d'action qui contrôle cette distribution est _forward() ; appelez cette méthode à partir de pre/postDispatch() ou d'une méthode d'action, en fournissant une action, un contrôleur, un module, et optionnellement des paramètres additionnels que vous souhaitez passer à la nouvelle action :

  1. span style="color: #808080; font-style: italic;">// Transférer la nouvelle action dans le contrôleur
  2.     // et le module courant :
  3. 'bar''baz' => 'bogus'// Transférer vers une action dans un autre contrôleur,
  4.     // FooController::bazAction(), dans le module courant :
  5. 'baz', 'foo''baz' => 'bogus'// Transférer vers une action dans un autre contrôleur
  6.     // dans un autre module, Foo_BarController::bazAction():
  7. 'baz', 'bar', 'foo''baz' => 'bogus'));
  8. }

Sous-classer le distributeur

Zend_Controller_Front appelle en premier le routeur pour déterminer la première action dans la requête. Il entre ensuite dans la boucle de distribution, qui demande au distributeur de distribuer l'action.

Le distributeur a besoin de plusieurs données afin de réaliser son travail - il doit connaître le format des noms d'actions et de contrôleur, où chercher les fichiers de classe des contrôleurs, savoir si le nom de module fourni est valide, et il a besoin d'une API pour déterminer si une requête donnée est distribuable suivant les informations disponibles.

Zend_Controller_Dispatcher_Interface définit les méthodes suivantes nécessaires pour toute implémentation d'un distributeur :

  1. span style="color: #808080; font-style: italic;">/**
  2.      * Formate une chaîne en un nom de classe de contrôleur
  3.      *
  4.      * @param string $unformatted
  5.      * @return string
  6.      *//**
  7.      * Formate une chaîne en un nom de méthode d'action
  8.      *
  9.      * @param string $unformatted
  10.      * @return string
  11.      *//**
  12.      * Détermine si une requête est distribuable
  13.      *
  14.      * @param  Zend_Controller_Request_Abstract $request
  15.      * @return boolean
  16.      *//**
  17.      * Règle un paramètre utilisateur
  18.      * (via le contrôleur frontal, ou pour un usage local)
  19.      *
  20.      * @param string $name
  21.      * @param mixed $value
  22.      * @return Zend_Controller_Dispatcher_Interface
  23.      *//**
  24.      * Règle un tableau de paramètres utilisateur
  25.      *
  26.      * @param array $params
  27.      * @return Zend_Controller_Dispatcher_Interface
  28.      *//**
  29.      * Récupère un paramètre utilisateur unique
  30.      *
  31.      * @param string $name
  32.      * @return mixed
  33.      *//**
  34.      * Récupère tous les paramètres utilisateur
  35.      *
  36.      * @return array
  37.      *//**
  38.      * Efface le tableau des paramètres utilisateur,
  39.      * ou un paramètre utilisateur unique :
  40.      *
  41.      * @param null|string|array single key or
  42.      *                          array of keys for params to clear
  43.      * @return Zend_Controller_Dispatcher_Interface
  44.      *//**
  45.      * Règle l'objet réponse à utiliser, s'il existe
  46.      *
  47.      * @param Zend_Controller_Response_Abstract|null $response
  48.      * @return void
  49.      *//**
  50.      * Récupère l'objet réponse, s'il existe
  51.      *
  52.      * @return Zend_Controller_Response_Abstract|null
  53.      *//**
  54.      * Ajoute un dossier de contrôleur dans le tableau
  55.      * des dossiers de contrôleurs
  56.      *
  57.      * @param string $path
  58.      * @param string $args
  59.      * @return Zend_Controller_Dispatcher_Interface
  60.      *//**
  61.      * Règle le(s) dossier(s) où les fichiers de contrôleurs
  62.      * sont stockés
  63.      *
  64.      * @param string|array $dir
  65.      * @return Zend_Controller_Dispatcher_Interface
  66.      *//**
  67.      * Retourne le(s) dossier(s) où les fichiers de contrôleurs
  68.      * sont stockés
  69.      *
  70.      * @return array
  71.      *//**
  72.      * Distribue une requête vers un (module/)contrôleur/action.
  73.      *
  74.      * @param  Zend_Controller_Request_Abstract $request
  75.      * @param  Zend_Controller_Response_Abstract $response
  76.      * @return Zend_Controller_Request_Abstract|boolean
  77.      *//**
  78.      * Informe si un module donné est valide
  79.      *
  80.      * @param string $module
  81.      * @return boolean
  82.      *//**
  83.      * Retourne le nom du module par défaut
  84.      *
  85.      * @return string
  86.      *//**
  87.      * Retourne le nom du contrôleur par défaut
  88.      *
  89.      * @return string
  90.      *//**
  91.      * Retourne le nom de l'action par défaut
  92.      *
  93.      * @return string
  94.      */

Cependant, dans la plupart des cas, vous devriez simplement étendre la classe abstraite Zend_Controller_Dispatcher_Abstract, dans laquelle chacune de ces méthodes a déjà été définie, ou Zend_Controller_Dispatcher_Standard pour modifier une fonctionnalité du distributeur standard.

Les raisons possibles au sous-classement du distributeur incluent un désir d'employer une classe ou un schéma différent de nommage des classes et/ou des méthodes dans vos contrôleurs d'action, ou un désir d'employer un paradigme de distribution différent tel que la distribution de fichiers de classe d'action dans des dossiers de contrôleur (au lieu de la distribution des méthodes de classes).


Routeur Standard