Le système Zend_Controller
est conçu pour être léger, modulaire, et extensible. Il est de conception minimaliste pour permettre la flexibilité et la liberté aux utilisateurs tout en fournissant assez de structure de sorte que les systèmes établis autour de Zend_Controller
partagent certaines conventions communes et dispositions semblables de code.
Le diagramme suivant décrit le déroulement des opérations, et ce qui suit décrit en détail les interactions :
Le déroulement des opérations de Zend_Controller
est implémenté par plusieurs composants. Même s'il n'est pas nécessaire de comprendre complètement les détails de tous ces composants pour employer le système, avoir une bonne connaissance du fonctionnement du processus est utile.
Zend_Controller_Front
orchestre le déroulement entier des opérations du système Zend_Controller. C'est une interprétation du modèle contrôleur frontal ("FrontController"). Zend_Controller_Front
traite toutes les demandes reçues par le serveur et est finalement responsable de déléguer les demandes aux contrôleurs d'action ("ActionControllers" [Zend_Controller_Action
]).
Zend_Controller_Request_Abstract
(souvent référencé comme Request Object
) représente l'environnement de la requête et fournit les méthodes pour régler et rechercher le contrôleur, les noms et d'action et les paramètres fournis. De plus il contient l'information si l'action qu'elle contient a été dispatchée ou non par Zend_Controller_Dispatcher
. Des extensions de l'objet abstrait de requête peuvent être employées pour encapsuler l'environnement entier de requête, permettant à des routeurs de récupérer les informations issues de l'environnement de requête afin de régler les noms de contrôleur et d'action.
Par défaut, Zend_Controller_Request_Http
est employé, ce qui permet d'accéder à l'environnement complet de requête HTTP.
Zend_Controller_Router_Interface
est employé pour définir les routeurs. Le routage est le processus d'examen de l'environnement de requête pour déterminer quel contrôleur, et action de ce contrôleur, devraient recevoir la requête. Ces contrôleur, action, et paramètres facultatifs sont alors placés dans l'objet de requête à traiter par Zend_Controller_Dispatcher_Standard
. Le routage se produit seulement une fois : quand la demande est initialement reçue et avant que le premier contrôleur ne soit dispatché.
Le routeur de défaut, Zend_Controller_Router_Rewrite
, récupére un URI comme indiqué dans Zend_Controller_Request_Http
et le décompose en contrôleur, action, et paramètres basés sur l'information de chemin de l'URL. Par exemple, l'URL http://localhost/foo/bar/key/value
serait décodé pour employer le contrôleur foo
, l'action bar
, et pour indiquer un paramètre key
avec une valeur value
.
Zend_Controller_Router_Rewrite
peut également être utilisé pour faire correspondre des chemins arbitraires ; voir la documentation du routeur pour plus d'information.
Zend_Controller_Dispatcher_Interface
est utilisé pour définir les dispatcheurs. Le dispatchage est le processus charger de récupérer le contrôleur et l'action issus de l'objet de requête et de les faire correspondre à un fichier/classe de contrôleur et à une méthode d'action dans la classe du contrôleur. Si le contrôleur ou l'action n'existent pas, il se charge de déterminer des contrôleurs et des actions par défaut à dispatcher.
Le processus de dispatchage réel se compose de l'instanciation de la classe de contrôleur et de l'appel de la méthode d'action dans cette classe. A la différence du routage, qui se produit seulement une fois, le dispatchage se produit dans une boucle. Si le statut dispatché de l'objet de requête est remis à zéro à un moment quelconque, la boucle sera répétée, en appelant l'action actuellement placée dans l'objet de demande. La première fois que la boucle se termine avec une propriété de statut d'objet de requête dispatché à vrai (booléen true), le processus s'arrête.
Le dispatcheur par défaut est Zend_Controller_Dispatcher_Standard
. Il définit les contrôleurs comme des classes se nommant suivant la NotationCamel et se terminant par le mot Controller, et des méthodes d'action suivant le notationCamel se terminant avec le mot Action : FooController::barAction()
. Dans ce cas-ci, le contrôleur est désigné comme foo
et l'action comme bar
.
Zend_Controller_Action
est le composant contrôleur d'action de base. Chaque contrôleur est une classe simple qui étend la classe de Zend_Controller_Action
et devrait contenir une ou plusieurs méthodes d'action.
Zend_Controller_Response_Abstract
définit une classe de réponse de base employée pour rassembler et retourner les réponses des contrôleurs d'action. Il rassemble les en-têtes et le contenu du corps.
La classe de réponse par défaut est Zend_Controller_Response_Http
, qui convient pour l'usage dans un environnement HTTP.
Le déroulement des opérations de Zend_Controller
est relativement simple. Une demande est reçue par Zend_Controller_Front
, qui appelle alternativement Zend_Controller_Router_Rewrite
pour déterminer le contrôleur (et l'action dans ce contrôleur) à dispatcher. Zend_Controller_Router_Rewrite
décompose l'URI afin de régler les noms de contrôleur et d'action dans la requête. Zend_Controller_Front
entre alors dans une boucle de dispatchage. Il appelle Zend_Controller_Dispatcher_Standard
, en lui passant la requête, pour dispatcher le contrôleur et l'action indiqués dans la requête (ou utiliser les valerus par défauts). Après que le contrôleur ait fini, la commande revient à Zend_Controller_Front
. Si le contrôleur a indiqué qu'un autre contrôleur devait être dispatché en remettant à zéro le statut dispatché de la requête, la boucle continue et un autre dispatchage est effectué. Sinon, le processus se termine.