Chapitre 2. Zend_Controller
Précédent |  | Suivant

## Chapitre 2. Zend_Controller

## 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
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