Démarrer avec Zend Framework 1.10

Les outils pour démarrer

Pour démarrer, il vous faudra un simple logiciel, genre WampServer 2.0 suffira. Vous pouvez télécharger WampServer sur son site officiel.

Pour réaliser les bases de données, vous pourrez utiliser MySQL Workbench qui est un logiciel permettant de créer vos tables MySQL graphiquement et ensuite de les exporter sous forme de requêtes SQL. Vous pouvez télécharger MySQL Workbench sur le site officiel de MySQL.

Pour réaliser vos codes, il vous faudra un éditeur de code. Vous avez plusieurs solutions, en fonction de vos goûts. Pour ma part, j'utilise Eclipse fo PHP Developersqui permet l'auto-complétion et est assez pratique mais il m'arrive aussi, pour de petites modifications, d'utiliser Notepad++.

Comme il est question de travailler avec le Zend Framework, il nous faudra le récupérer. Les sources sont téléchargeables sur son site officiel. Si une fois sur la page du site vous hésitez, choisissez le zip ou tar.gz situé en face de la ligne'Zend Framework 1.10.x Full'.

Pour Smarty et Doctrine, nous verrons cela plus tard, au moment de leur intégration avec Zend Framework.

A cela, on ajoute la documentation de Zend Framework, qui sera utile lorsque vous serait perdu.

Cela suffit pour démarrer.

Créer sa première application avec Zend_Application

Ajouter l'exécutable de PHP aux variables d'environnement Windows

Tout d'abord, avant de commencer, nous aurons besoin de configurer le chemin vers l'exécutable PHP : cela nous servira pour pouvoir utiliser certains scripts PHP en ligne de commande.

Pour ce faire :

• Cliquez sur le bouton Démarrer,
• Clic-droit sur Ordinateur,
• Cliquez sur Propriétés,
• Dans la partie gauche de la fenêtre choisir Paramètres système avancés :
• Cliquez sur le bouton Variables d'environnement... :
  
• Sélectionnez la ligne Path, puis cliquez sur Modifier... :
  
• Ajoutez le chemin vers le fichier php.exe à la suite des chemins déjà présents :
  
  Dans mon cas, il s'agit de D:\wamp\bin\php\php5.3.0\

• Il suffit de valider les fenêtres ouvertes avec OK.

Créer le squelette de la première application

Nous passons aux choses sérieuses maintenant.

Si vous avez suivi ce qui a été fait jusqu'à présent, vous devez avoir l'archive du Zend Framework : sinon, vous pouvez la télécharger ici.

Vous devez extraire l'archive dans un répertoire qui servira au développement. Dans mon cas, j'ai extrait le tout dans un répertoire à la racine du répertoire www de Wamp.

Ce qui nous donne :

Pour démarrer rapidement un projet, le répertoire bin contient ce qu'il nous faut : les scripts zf.

Pour créer un projet, lancer l'invite de commande Windows (Windows + R, puis tapez cmd, puis OK).

Rendez vous dans le répertoire bin de l'archive extraite (via la commande cd), puis tapez :

zf.bat create project nom_projet

En détails, cela donne, dans mon cas :

C:\Users\Nom_Utilisateur>d:

D:\>cd wamp\www\ZendFramework-1.10.2\bin

D:\wamp\www\ZendFramework-1.10.2\bin>

D:\wamp\www\ZendFramework-1.10.2\bin>zf.bat create project projet_zend
Creating project at D:/wamp/www/ZendFramework-1.10.2/bin/projet_zend
Note: This command created a web project, for more information setting up your V
HOST, please see docs/README

D:\wamp\www\ZendFramework-1.10.2\bin>

Cela nous donne une arborescence de répertoires et de fichiers : c'est notre projet, nous l'appelons pour l'occasion projet_zend.

Maintenant que notre projet possède son squelette, il faut copier les fichiers de librairies de Zend dans le répertoire library de notre projet : copiez directement le répertoire Zend dans ce dossier. Déplacez le répertoire du projet à la racine du répertoire www de Wamp.

Notre projet est enfin prêt. Démarrez Wamp, n'oubliez pas d'activer le module rewrite_module dans Apache pour activer l'URL Rewriting. Rendez vous à l'adresse de notre fichier d'index du projet, depuis votre navigateur : http://localhost/projet_zend/public/

Vous devriez voir cette page :

Détails de l'architecture de notre projet sous Zend Framework

Voyons en détails à quoi servent les différents répertoires de notre projet :

projet_zend
├───application
│   ├───configs
│   │   └───application.ini      // Les paramètres de notre projet
│   ├───controllers              // Les contrôleurs de l'application
│   │   ├───ErrorController.php  // Le contrôleur d'erreur
│   │   └───IndexController.php  // Le contrôleur par défaut
│   ├───models                   // Les modèles de données
│   ├───views                    // Les vues de l'application
│   │   ├───helpers              // Les aides de vue
│   │   └───scripts              // Les vues
│   │       ├───error
│   │       │   └───error.phtml  // La vue d'erreur
│   │       └───index
│   │           └───index.phtml  // La vue par défaut pour le contrôleur Index
│   └───Bootstrap.php
├───docs
├───library
│   └───Zend
├───public
│   ├───index.php                // Point d'entrée de l'application
│   └───.htaccess
└───tests
    ├───application
    │   └───bootstrap.php
    ├───library
    │   └───bootstrap.php
    └───phpunit.xml     // Fichier XML de déclaration pour les tests unitaires

Nous le voyons, Zend Framework utilise le modèle de conception MVC, il est donc important de bien le maîtriser pour connaître le fonctionnement de notre projet.

MVC, Modèle-Vue-Contrôleur

Le modèle de conception est très utilisé car il permet une séparation logique dans une application. Avec Zend Framework, nous avons les fonctions suivantes :

• Le contrôleur : charge les données depuis le modèle et transmet les données à la vue, il prend aussi en charge les traitements sur les données,
• La vue : affiche les données en provenance du modèle (indirectement car c'est le contrôleur qui les lui fournit),
• Le modèle : représente les données, elles peuvent provenir de différentes sources : base de données, XML, etc.

A cela, Zend Framework ajoute :

• Le contrôleur frontal : c'est la partie centrale du Zend Framework, toutes les requêtes arrivent directement sur cet élément. Il embarque aussi un routeur, un distributeur. Il retourne la réponse à la fin du processus.
• Le routeur : c'est lui qui décompose l'URL et choisi le module, le contrôleur et l'action qui devront être exécuté en premier lieu. Le routage n'est effectué qu'une seule fois, le distributeur prend le relais.
• Le distributeur : une fois le routage effectué, c'est le processus en charge d'instancier le contrôleur et d'exécuter l'action liée à la requête. Il s'agit en fait d'une boucle de distribution. Il dispose d'un jeton isDispatched(), qui lorsqu'il est à true, indique la fin du processus : le contrôleur frontal envoie la réponse et l'affiche.

Nous approfondirons davantage ces différents points au fur et à mesure.

La prochaine étape sera l'étude du processus routage/distribution où nous suivrons le cheminement depuis la requête jusqu'à la réponse.

Le processus routage/distribution : de la requête à la réponse

Cela faisait un moment depuis le dernier post mais voilà la suite de la série de tutoriels sur Zend Framework 1.10.

Nous allons étudier le processus de routage/distribution de Zend Framework, en partant de la requête HTTP jusqu'à la réponse HTTP.

Comme nous l'avons vu, le contrôleur frontal (Zend_Controller_Front) orchestre tout cela.

• Il créé l'objet requête (Zend_Controller_Request_Http) et l'objet de réponse (Zend_Controller_Response_Http),
• Il lance le routage après avoir choisi le routeur adéquate (comme Sheila ^^),
• Il lance la distribution de la requête : il s'agit d'instancier le contrôleur choisi par le routeur et d'exécuter l'action associée,
• Il est possible qu'une action fasse un forward (on redirige vers une autre action), dans ce cas, le distributeur refait la même opération jusqu'à ce que la distribution soit effectuée (isDispatched() à true).
• Lorsque ce processus est terminé :
  
  • Il charge les scripts de vue et les charge dans l'objet de réponse
  • Il retourne la réponse HTTP dans l'objet réponse et l'affiche

Si au cours de ce processus, il y avait une exception (Zend_Exception) de levée, l'action error du contrôleur Error serait appelée.

Requête HTTP
     │ 
   ┌─v───────────────────────────────┐
   │ Routeur :                       │
   │  ├──> Plugins::routeStartup()   │
   │  ├──> [ Routage ]               │
   │  └──> Plugins::routeShutdown()  │
   └─┬───────────────────────────────┘
     │ 
   ┌─v───────────────────────────────────────┐
   │ Distributeur (dispatcher) :             │
   │  ├──> Plugins::dispatchLoopStartup()    │
   │  ├──> Plugins::preDispatch() <──────────────┐
   │  ├──> [ Dispatch ] :                    │   │
   │  │     ├──> __construct()               │   │
   │  │     ├──> init()                      │   │
   │  │     ├──> helpers::preDispatch()      │   │
   │  │     ├──> preDispatch()               │   │
   │  │     ├──> [ ACTION ]                  │   │
   │  │     ├──> postDispatch()              │   │
   │  │     └──> helpers::postDispatch()     │   │
   │  ├──> Plugins::postDispatch() ──────────────┘
   │  └──> Plugins::dispatchLookupShutdown() │
   └─┬───────────────────────────────────────┘
     │ 
     v
Réponse HTTP

• Plugins:: routeStartup() : la méthode routeStartup() est exécutée sur tous les plugins du contrôleur frontal (classe héritant de Zend_Controller_Plugin_Abstract). Même chose pour Plugins:: routeShutdown(), Plugins:: dispatchLoopStartup(), etc.
• Requête HTTP : La requête HTTP est envoyée par le navigateur au serveur.
• Routeur : Décode l'URL demandée par la requête HTTP et choisi un contrôleur et une action.
• Distributeur : Charge le contrôleur et exécute l'action.
• Réponse HTTP : La réponse HTTP qui contient les entêtes et le corps de la réponse à renvoyer au navigateur.