Chapitre 2. Zend_Controller
Précédent     Suivant

Chapitre 2. Zend_Controller

Table des matières

2.1. Vue d'ensemble
2.1.1. Introduction
2.1.2. Processus de routage
2.1.3. Jeton d'Aiguillage
2.1.4. Processus d'Aiguillage
2.2. Mise en Route
2.2.1. Introduction
2.2.2. Configuration Serveur
2.2.3. Fichier d'Amorçage
2.2.4. Arborescence des Répertoires
2.2.5. IndexController
2.3. Sous-classement
2.3.1. Introduction
2.3.2. Conventions
2.3.3. Interface de Routage
2.3.4. Interface d'aiguillage
2.4. Plugins
2.4.1. Introduction

2.1. Vue d'ensemble

2.1.1. Introduction

Zend_Controller fournit la fondation pour construire un site Web basé sur le design pattern Modèle-Vue-Contrôleur (MVC).

Le Zend_Controller est créé pour être léger, modulaire et extensible. Cette architecture minimaliste permet de donner flexibilité et liberté aux utilisateurs, mais fournit en même temps assez de structuration pour que les systèmes conçus autour de Zend_Controller partagent des conventions communes, et un code de base similaire.

Le workflow du Zend_Controller est implémenté par plusieurs composants. Cependant, il n'est pas nécessaire de comprendre totalement les rouages de tout ces composants pour utiliser le système, il est préférable d'avoir une connaissance du fonctionnement du processus.

  • Zend_Controller_Front dirige totalement la chaine de processus du Zend_Controller. C'est une interprétation du pattern FrontController. Zend_Controller_Front traite toutes les requêtes reçues par le serveur et est responsable de la délégation des requêtes aux ActionControllers (Zend_Controller_Action).

  • Zend_Controller_Router est le routeur. Le routage est le processus qui consiste à prendre une URI et à la décomposer pour déterminer quel contrôleur et action de ce contrôleur doit recevoir la requête. Cette définition du contrôleur, de l'action et des paramètres optionnels est empaquetée dans un objet de valeur appelé Zend_Controller_Dispatcher_Token. Elle est ensuite traitée par le Zend_Controller_Dispatcher. Le routage a lieu une seule fois: lorsque la requête est initialement reçue et avant que le premier contrôleur soit aiguillé.

  • Zend_Controller_Dispatcher est l'aiguilleur. L'aiguillage est le processus qui consiste à prendre le Zend_Controller_Dispatcher_Token, trouver le fichier de contrôleur approprié, instancier un contrôleur (qui doit implémenter Zend_Controller_Action), et au final, lancer la méthode d'action de cet objet contrôleur. Contrairement au routage, qui n'à lieu qu'une seule fois, l'aiguillage à lieu dans une boucle. Zend_Controller_Dispatcher est appelé de façon répétée par Zend_Controller_Front jusqu'à ce que toutes les actions aient été aiguillées les unes après les autres.

  • Zend_Controller_Action est le composant contrôleur de base. Chaque contrôleur est une seule classe qui étend la classe Zend_Controller_Action , et cette classe à des méthodes d'action.

Le workflow du Zend_Controller est assez simple. Une requête est reçue par Zend_Controller_Front, qui à son tour apelle Zend_Controller_Router pour déterminer quel contrôleur (et quelle action dans ce contrôleur) aiguiller. Zend_Controller_Router décompose l'URI dans un objet Zend_Controller_Dispatcher_Token qui décrits où aiguiller. Zend_Controller_Front entre ensuite dans une boucle d'aiguillage. Il apelle Zend_Controller_Dispatcher, le passe dans le token pour aiguiller dans l'actuel contrôleur et l'actuelle action. Après que le contrôleur aie finit, le contrôle retourne au Zend_Controller_Front. Si le contrôleur a indiqué qu'un autre contrôleur doit être aiguillé en retournant un nouveau jeton, la boucle continue et une autre action a lieu, sinon le processus s'arrête.

2.1.2. Processus de routage

Avant que votre premier contrôleur soit construit, vous avez besoin de comprendre le fonctionnement du processus de routage tel qu'il est implémenté dans Zend_Controller_Router. Rappelez vous que le workflow est composé du routage, qui n'à lieu une seule fois, et de l'aiguillage qui à lieu dans une boucle.

Zend_Controller_Front appelle Zend_Controller_Router pour envoyer une URI dans un contrôleur -- et une action à l'intérieur de ce contrôleur. Zend_Controller_Router prend cette URI et la décompose en un objet de valeur Zend_Controller_Dispatcher_Token, qui sera passé dans l'aiguilleur (Zend_Controller_Dispatcher).

Le routeur utilise un analyseur très simple pour déterminer le nom du contrôleur et le nom de l'action qu'il contient : 

http://framework.zend.com/controleur/action/

Notez que le premier segment est toujours le nom du contrôleur, et le second, toujours celui de l'action.

Optionellement, les paramètres peuvent être définis dans cette URI qui sera ensuite passée au contrôleur. Ceux-ci prennent la forme de paires clés/valeurs : 

http://framework.zend.com/controler/action/cle1/valeur1/

Si rien n'est présent dans la partie /controller/ de l'URI, alors cela deviendra "index". Si rien n'est présent dans la partie /action/ de l'URI, alors cela deviendra aussi "index". Prenez ces exemples : 

http://framework.zend.com/roadmap/future/
Controller: roadmap
Action    : future

http://framework.zend.com/roadmap/
Controller: roadmap
Action    : index

http://framework.zend.com/
Controller: index
Action    : index

[Note] Note
Nous sommes actuellement en train de développer un nouveau routeur avec un moteur de ré-écriture d'URI, qui donnera plus de flexibilité que le routeur présenté actuellement. Celui-ci sera inclus dans une 'preview release' très bientôt.

Le nom du contrôleur, l'action à l'intérieur de ce contrôleur, ainsi que tous les paramètres optionnels sont regroupés dans un jeton Zend_Controller_Dispatcher_Token. Ce jeton est retourné au Zend_Controller_Front, qui entrera dans la boucle d'aiguillage. Une fois dans la boucle d'aiguillage, le jeton sera passé au Zend_Controller_Dispatcher.

2.1.3. Jeton d'Aiguillage

Le jeton d'aiguillage est un simple objet de valeur qui est passé entre le Zend_Controller_Front et les classes qui implémentent le routeur et les interfaces d'aiguillages. Il regroupe une définition du contrôleur, une action, et les paramètres à passer dans l'action.

  • Il est possible d'accéder au nom du contrôleur avec getControllerName() et setControllerName().

  • Le nom de l'action à appeler à l'intérieur de ce contrôleur est accessible avec getActionName() et setActionName().

  • Les paramètres à passer dans cette action sont un tableau associatif de paires clés/valeurs, accessibles avec getParams() et setParams().

2.1.4. Processus d'Aiguillage

L'aiguillage est l'action de prendre un jeton Zend_Controller_Dispatcher_Token, d'en extraire les informations contenues : un nom de contrôleur, un nom d'action, des paramètres, et ensuite instancier un contrôleur et appeler une action de ce contrôleur.

Précédent     Suivant
1.8. Zend::registry()  Sommaire  2.2. Mise en Route