Zend Framework

38
Zend Framework & Introduction MVC Zend Framework Zend Framework est un cadre de travail open source orienté objets pour des applications web basées sur PHP 5. Zend Framework est souvent appelé une "bibliothèque de composants" car ses composants sont faiblement couplés et vous pouvez les utiliser de manière plus ou moins indépendante. Mais Zend Framework propose aussi une solution avancée Model-View- Controller (MVC) qui peut être utilisée pour monter des structures de base pour vos applications. Une liste complète des composants de Zend Framework avec une brève description peut être trouvée dans » l'aperçu des composants . Ce guide de démarrage montre les composants les plus utilisés dans Zend Framework, comme Zend_Controller, Zend_Layout, Zend_Config, Zend_Db, Zend_Db_Table, Zend_Registry, ainsi que quelques aides de vue. En utilisant ces composants nous allons construire un livre d'or reposant sur une base de données, simple, en quelques minutes. Le code source complet pour cette application est disponible dans les formats : » zip » tar.gz Model-View-Controller Qu'est ce que MVC dont tout le monde parle et pourquoi se pencher dessus ? MVC est bien plus qu'un acronyme de trois lettres (TLA) que vous pouvez sortir pour faire "élégant" ; c'est devenu un standard de conception des applications Web modernes, ceci pour de bonnes raisons. La plupart du code des application se retrouvent dans une de ces catégories : présentation, logique métier, accès aux données. Le pattern MVC modélise cette séparation à merveille. Le résultat final est qu'un code de présentation peut être travaillé à un endroit de

Transcript of Zend Framework

Page 1: Zend Framework

Zend Framework & Introduction MVC

Zend FrameworkZend Framework est un cadre de travail open source orienté objets pour des applications web basées sur PHP 5. Zend Framework est souvent appelé une "bibliothèque de composants" car ses composants sont faiblement couplés et vous pouvez les utiliser de manière plus ou moins indépendante. Mais Zend Framework propose aussi une solution avancée Model-View-Controller (MVC) qui peut être utilisée pour monter des structures de base pour vos applications. Une liste complète des composants de Zend Framework avec une brève description peut être trouvée dans » l'aperçu des composants. Ce guide de démarrage montre les composants les plus utilisés dans Zend Framework, comme Zend_Controller, Zend_Layout, Zend_Config, Zend_Db, Zend_Db_Table, Zend_Registry, ainsi que quelques aides de vue.

En utilisant ces composants nous allons construire un livre d'or reposant sur une base de données, simple, en quelques minutes. Le code source complet pour cette application est disponible dans les formats :

» zip » tar.gz

Model-View-ControllerQu'est ce que MVC dont tout le monde parle et pourquoi se pencher dessus ? MVC est bien plus qu'un acronyme de trois lettres (TLA) que vous pouvez sortir pour faire "élégant" ; c'est devenu un standard de conception des applications Web modernes, ceci pour de bonnes raisons. La plupart du code des application se retrouvent dans une de ces catégories : présentation, logique métier, accès aux données. Le pattern MVC modélise cette séparation à merveille. Le résultat final est qu'un code de présentation peut être travaillé à un endroit de l'application alors que la logique métier et l'accès aux données le sont à d'autres endroits. La plupart des développeurs ont trouvé cette séparation indispensable pour maintenir le code global organisé, particulièrement lorsque plusieurs développeurs travaillent ensemble sur la même application.

Note: Plus d'informationsCassons le pattern pour voir les pièces individuellement :

Page 2: Zend Framework

Model - C'est la partie qui définit la fonctionnalité de base de l'application derrière des abstractions. L'accès aux données et la logique métier sont définis dans cette couche.

View - La vue définit exactement ce qui sera présenté à l'utilisateur. Normalement les contrôleurs passent des données à chaque vue à rendre dans un format précis. Les vues collectent les données de l'utilisateur aussi. Ici vous trouverez principalement du HTML.

Controller - Les contrôleurs sont la colle qui lie tout. Ils manipulent les modèles, décident de la vue à rendre en fonction de la requête utilisateur et d'autres facteurs, passent les données dont chaque vue a besoin et passent éventuellement la main à un autre contrôleur. La plupart des experts MVC experts recommandent » de garder les contrôleurs les plus simples et petits possibles.

Bien sûr » on pourrait en dire plus sur ce pattern critique, mais nous avons là suffisament d'informations pour comprendre l'application de livre d'or que nous allons construire.

Créer votre projetAfin de créer un projet, vous devez d'abord télécharger et extraire Zend Framework.

Installer Zend FrameworkLa manière la plus simple d'obtenir Zend Framework avec une pile PHP complète est d'installer » Zend Server. Zend Server possède des installeurs natifs pour Mac OSX, Windows, Fedora Core, et Ubuntu, ainsi qu'un installeur universel pour la plupart des distributions Linux.

Page 3: Zend Framework

Après avoir installé Zend Server, les fichiers du Framework devraient se trouver sous /usr/local/zend/share/ZendFramework sur Mac OSX et Linux, et C:\Program Files\Zend\ZendServer\share\ZendFramework sur Windows. L'include_path aura déja été configuré pour inclure Zend Framework.

Il reste bien sûr possible » de télécharger la dernière version de Zend Framework et l'extraire; notez simplement où vous choisissez de l'extraire.

Optionellement, vous pouvez ajouter le chemin vers le sous-dossier library/ de l'archive à l'include_path de votre php.ini.

Ca y est! Zend Framework est maintenant installé et prêt à l'emploi.

Créer votre projetNote: Outil en ligne de commandes zfDans la dossier bin/ de votre installation de Zend Framework se trouvent les scripts zf.sh et zf.bat pour Unix et Windows respectivement. Notez le chemin absolu vers ces fichiers. Partout ou vous voyez uyne référence à la commande zf, utilisez le chemin absolu du script. Sur les système Unix, vous pouvez utiliser la fonctionnalité d'alias dans le shell: alias zf.sh=path/to/ZendFramework/bin/zf.sh. Si vous avez des problèmes pour configurer la commande zf, veuillez vous référer au manuel.

Ouvrez un terminal (sous Windows, Démarrer -> Exécuter, puis cmd). Naviguez vers un dossier dans lequel vous souhaitez démarrer un projet. Puis, utilisez le chemin vers le script approprié et lancez:

1. % zf create project quickstart

Cette commande crée un projet avec une structure basique incluant des contrôleurs et vues. L'arbre va ressembler à ceci:

1. quickstart2. |-- application3. |   |-- Bootstrap.php4. |   |-- configs5. |   |   `-- application.ini6. |   |-- controllers7. |   |   |-- ErrorController.php8. |   |   `-- IndexController.php9. |   |-- models10. |   `-- views11. |       |-- helpers12. |       `-- scripts13. |           |-- error14. |           |   `-- error.phtml15. |           `-- index16. |               `-- index.phtml17. |-- library

Page 4: Zend Framework

18. |-- public19. |   |-- .htaccess20. |   `-- index.php21. `-- tests22.     |-- application23.     |   `-- bootstrap.php24.     |-- library25.     |   `-- bootstrap.php26.     `-- phpunit.xml

Dès lors si vous n'avez pas ajouté Zend Framework à votre include_path, nous vous recommandons de copier ou lier celui-ci dans le dossier library/ de votre projet. Dans ce cas vous devriez copier récursivement (ou lier) library/Zend/ de l'installation de Zend Framework vers le dossier library/ de votre projet. Sur les systèmes Unix cela peut être effectué de la manière suivante:

1. # Symlink:2. % cd library; ln -s path/to/ZendFramework/library/Zend .3.  4. # Copy:5. % cd library; cp -r path/to/ZendFramework/library/Zend .

Sur Windows le plus simple sera d'utiliser l'explorateur.

Maintenant que le projet est crée, les principaux points à comprendre sont le bootstrap, la configuration, les contrôleurs d'action et les vues.

Le BootstrapVotre classe Bootstrap définit les ressources (composants) à initialiser. Par défaut, le contrôleur frontal est initialisé et il utilise application/controllers/ comme dossier de contrôleurs par défaut (nous reverrons cela). La classe ressemble à:

1. // application/Bootstrap.php2.  3. class Bootstrap extends

Zend_Application_Bootstrap_Bootstrap4. {5. }

Comme vous le voyez, rien de plus n'est nécessaire pour commencer.

ConfigurationLe Zend Framework lui-même n'a pas besoin de configuration, mais l'application oui. La configuration par défaut est placée sous application/configs/application.ini et contient des directives de base pour régler l'environnement PHP (par exemple, activer ou désactiver le

Page 5: Zend Framework

rapport d'erreurs), indiquer le chemin vers votre classe de bootstrap (ainsi que son nom) , et le chemin vers les contrôleurs d'action. Cela ressemble à:

1. ; application/configs/application.ini2.  3. [production]4. phpSettings.display_startup_errors = 05. phpSettings.display_errors = 06. includePaths.library = APPLICATION_PATH "/../library"7. bootstrap.path = APPLICATION_PATH "/Bootstrap.php"8. bootstrap.class = "Bootstrap"9. appnamespace = "Application"10. resources.frontController.controllerDirectory =

APPLICATION_PATH "/controllers"11. resources.frontController.params.displayExceptions =

012.  13. [staging : production]14.  15. [testing : production]16. phpSettings.display_startup_errors = 117. phpSettings.display_errors = 118.  19. [development : production]20. phpSettings.display_startup_errors = 121. phpSettings.display_errors = 1

Plusieurs choses sont à connaitre concernant ce fichier. D'abord, si vous utilisez une configuration basée sur des fichiers INI, vous pouvez faire usage des constantes directement; APPLICATION_PATH est ici une constante. Aussi, notez que plusieurs sections ont été définies: production, staging, testing, et development. Les trois dernières héritent de la section "production". C'est une manière utile d'organiser sa configuration et de s'assurer que les paramètres appropriés sont utilisés pour chaque étape du développement de l'application.

Contrôleurs d'actionLes contrôleurs d'action de votre application contiennent la logique 'utile' de celle-ci et font correspondre les requêtes aux bons modèles et aux bonnes vues.

Un contrôleur d'action devrait posséder une ou plusieurs méthodes se terminant par "Action"; ces méthodes sont interrogées via le web. Par défaut, les URLs de Zend Framework suivent le schéma /controller/action, où "controller" correspond à la classe de contrôleur (sans le suffixe "Controller") et "action" correspond à la méthode d'action (sans le suffixe "Action").

Typiquement, vous aurez toujours besoin d'un IndexController, qui est utilisé par défaut et servira aussi la page d'accueil, et un ErrorController, utilisé pour indiquer les erreurs HTTP 404 (contrôleur ou action introuvable) et les erreurs HTTP 500 (erreurs de l'application).

IndexController par défaut est défini comme suit:

Page 6: Zend Framework

1. // application/controllers/IndexController.php2.  3. class IndexController extends Zend_Controller_Action4. {5.  6.     public function init()7.     {8.         /* Initialisez le contrôleur et l'action ici */9.     }10.  11.     public function indexAction()12.     {13.         // corps de l'action14.     }15. }

ErrorController par défaut est défini comme suit:

1. // application/controllers/ErrorController.php2.  3. class ErrorController extends Zend_Controller_Action4. {5.  6.     public function errorAction()7.     {8.         $errors = $this->_getParam('error_handler');9.  10.         switch ($errors->type) {11.             case

Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:12.             case

Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:

13.             case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:

14.  15.                 // 404 error -- controller or action

not found16.                 $this->getResponse()-

>setHttpResponseCode(404);17.                 $this->view->message = 'Page not

found';18.                 break;19.             default:20.                 // application error21.                 $this->getResponse()-

>setHttpResponseCode(500);22.                 $this->view->message = 'Application

error';23.                 break;24.         }

Page 7: Zend Framework

25.  26.         $this->view->exception = $errors->exception;27.         $this->view->request   = $errors->request;28.     }29. }

Notez que (1) IndexController ne contient pas de code réel, et (2) ErrorController référence un attribut "view". Ceci nous mène vers la section suivante.

VuesLes vues dans Zend Framework sont écrites en PHP classique. Les scripts de vues sont placés sous application/views/scripts/, ils sont référencés plus tard dans les contrôleurs. Dans notre cas, nous avons un IndexController et un ErrorController, et nous avons ainsi des dossiers index/ et error/ correspondants dans le dossier scripts des vues. Dans ces dossiers, vous trouverez ou créerez des scripts de vue correspondants aux actions exposées par les contrôleurs; dans le cas par défaut nous avons ainsi des scripts de vue index/index.phtml et error/error.phtml.

Les scripts de vue peuvent contenir le code de présentation que vous voulez et utiliser les tags <?php ou ?> pour insérer du PHP.

Ce qui suit présente le code par défaut de index/index.phtml:

1. <!-- application/views/scripts/index/index.phtml -->2. <style>3.  4.     a:link,5.     a:visited6.     {7.         color: #0398CA;8.     }9.  10.     span#zf-name11.     {12.         color: #91BE3F;13.     }14.  15.     div#welcome16.     {17.         color: #FFFFFF;18.         background-image:

url(http://framework.zend.com/images/bkg_header.jpg);19.         width:  600px;20.         height: 400px;21.         border: 2px solid #444444;22.         overflow: hidden;23.         text-align: center;24.     }25.  

Page 8: Zend Framework

26.     div#more-information27.     {28.         background-image:

url(http://framework.zend.com/images/bkg_body-bottom.gif);29.         height: 100%;30.     }31.  32. </style>33. <div id="welcome">34.     <h1>Welcome to the <span id="zf-name">Zend

Framework!</span><h1 />35.     <h3>This is your project's main page<h3 />36.     <div id="more-information">37.         <p>38.             <img

src="http://framework.zend.com/images/PoweredBy_ZF_4LightBG.png" />

39.         </p>40.  41.         <p>42.             Helpful Links: <br />43.             <a href="http://framework.zend.com/">Zend

Framework Website</a> |44.             <a

href="http://framework.zend.com/manual/en/">Zend Framework45.                 Manual</a>46.         </p>47.     </div>48. </div>49. <="" span="">

Le script de vue error/error.phtml est plus intéréssant car il inclut des conditions écrites en PHP:

1. <!-- application/views/scripts/error/error.phtml -->2. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN";3.     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd>4. <html xmlns="http://www.w3.org/1999/xhtml">5. <head>6.   <meta http-equiv="Content-Type" content="text/html;

charset=utf-8" />7.   <title>Zend Framework Default Application</title>8. </head>9. <body>10.   <h1>An error occurred</h1>11.   <h2><?php echo $this->message ?></h2>12.  13.   <?php if ('development' == $this->env): ?>14.  15.   <h3>Exception information:</h3>16.   <p>

Page 9: Zend Framework

17.       <b>Message:</b> <?php echo $this->exception->getMessage() ?>

18.   </p>19.  20.   <h3>Stack trace:</h3>21.   <pre><?php echo $this->exception-

>getTraceAsString() ?>22.   </pre>23.  24.   <h3>Request Parameters:</h3>25.   <pre><?php echo var_export($this->request-

>getParams(), 1) ?>26.   </pre>27.   <?php endif ?>28.  29. </body>30. </html>

Creation d'un hôte virtuelPour le quickstart nous supposerons que vous utilisez le » serveur web Apacher. Zend Framework fonctionne très bien avec d'autres serveurs -- y compris Microsoft Internet Information Server, lighttpd, nginx, et plus -- mais la plupart des développeurs devraient être familiers à Apache, et cela permet d'introduire la structure de dossiers de Zend Framework et les capacités de réécriture.

Pour créer un vhost, vous devez connaitre l'emplacement du fichier httpd.conf, et les emplacements des autres fichiers de configuration protenciels. Voici quelques emplacements classiques:

/etc/httpd/httpd.conf (Fedora, RHEL, et autres) /etc/apache2/httpd.conf (Debian, Ubuntu, et autres) /usr/local/zend/etc/httpd.conf (Zend Server sur *nix) C:\Program Files\Zend\Apache2\conf (Zend Server sur Windows)

Au sein de httpd.conf (ou httpd-vhosts.conf sur certains systèmes), vous aurez besoin de deux choses. D'abord s'assurer que NameVirtualHost est défini; typiquement à une valeur de "*:80". Ensuite, définir les hôtes virtuels:

1. <VirtualHost *:80>2.     ServerName quickstart.local3.     DocumentRoot /path/to/quickstart/public4.  5.     SetEnv APPLICATION_ENV "development"6.  7.     <Directory /path/to/quickstart/public>8.         DirectoryIndex index.php9.         AllowOverride All10.         Order allow,deny11.         Allow from all

Page 10: Zend Framework

12.     </Directory>13. </VirtualHost>

Notons plusieurs points. D'abord le DocumentRoot pointe vers le dossier public du projet; ceci signifie que seuls les fichiers sous cette arborescence peuvent être servis directement par le serveur. Ensuite, AllowOverride, Order, et Allow; ces directives servent à autoriser l'utilisation de fichiers htacess dans le projet. Pendant le développement, c'est une bonne pratique car ça évite de redémarrer sans arrêt le serveur dès qu'un changement y est opéré; cependant en production le contenu de htaccess devrait être reproduit dans la configuration puis désactivé. Enfin notez SetEnv. Ici nous renseignons une variable d'environnement pour l'hôte virtuel, celle-ci sera récupérée dans index.php et utilisée pour affecter la constante APPLICATION_ENV de l'application Zend Framework. En production, vous pouvez oublier cette directive (dans un tel cas la valeur par défaut sera "production") ou la préciser explicitement à la valeur "production".

Finalement, vous devrez ajouter une entrée au DNS ou au fichier d'hôtes (hosts) pour la valeur de ServerName. Sur les systèmes *nix, il s'agit de /etc/hosts; sur Windows, vous trouverez normalement ce fichier sous C:\WINDOWS\system32\drivers\etc. Quel que soit le système, l'entrée sera de la forme:

1. 127.0.0.1 quickstart.local

Démarrez votre serveur web (ou redémarrez le), et tout devrait être prêt.

CheckpointDès lors, vous devriez pouvoir démarrer votre application Zend Framework. Faites pointer votre navigateur vers l'hôte configuré dans la section précédente et une page d'accueil devrait s'afficher.

Créer une layoutVous avez remarqué que les scripts de vue dans les sections précédentes étaient des fragments de HTML, pas des pages complètes. C'est le design : nous voulons que nos actions retournent du contenu uniquement relatif à elles mêmes et non de l'application en général.

Maintenant nous devons introduire le contenu généré dans une page entière HTML. Nous utiliserons un layout global pour tout le site dans ce but.

Il y a deux designs pattern que le Zend Framework utilise pour les layouts : » Two Step View et » Composite View. Two Step View est souvent associé au pattern » Transform View l'idée de base est que les vues de l'application créent une représentation qui est ensuite injectée dans une vue plus globale. Le pattern Composite View traite avec une vue fabriquée à partir de plusieurs vues applicatives.

Dans Zend Framework, Zend_Layout combine les idées de ces patterns. Plutôt que chaque vue inclue tout le design, chacune ne contient que ses propres données.

Page 11: Zend Framework

Par contre vous pourriez avoir besoin occasionnellement d'informations globales dans la vue générale. Heureusement, le Zend Framework propose une variété de conteneurs appelés placeholders pour permettre de stocker de telles informations depuis les scripts de vue des actions.

Pour démarrer avec Zend_Layout, nous devons d'abord informer le bootstrap de l'objet Layout (ressource). On peut activer cela au moyen de la commande zf enable layout:

1. % zf enable layout2. Layouts have been enabled, and a default layout created at3. application/layouts/scripts/layout.phtml4. A layout entry has been added to the application config

file.

Comme le suggère la commande, application/configs/application.ini est mis à jour et contient maintenant les informations suivantes dans la section production :

1. ; application/configs/application.ini2.  3. ; Add to [production] section:4. resources.layout.layoutPath = APPLICATION_PATH

"/layouts/scripts"

Le fichier INI final devrait ressembler à ceci :

1. ; application/configs/application.ini2.  3. [production]4. ; PHP settings we want to initialize5. phpSettings.display_startup_errors = 06. phpSettings.display_errors = 07. includePaths.library = APPLICATION_PATH "/../library"8. bootstrap.path = APPLICATION_PATH "/Bootstrap.php"9. bootstrap.class = "Bootstrap"10. appnamespace = "Application"11. resources.frontController.controllerDirectory =

APPLICATION_PATH "/controllers"12. resources.frontController.params.displayExceptions =

013. resources.layout.layoutPath = APPLICATION_PATH

"/layouts/scripts"14.  15. [staging : production]16.  17. [testing : production]18. phpSettings.display_startup_errors = 119. phpSettings.display_errors = 120.  21. [development : production]22. phpSettings.display_startup_errors = 123. phpSettings.display_errors = 1

Page 12: Zend Framework

Cette directive indique à l'application de chercher les scripts de layout dans application/layouts/scripts. Si vous examinez votre structure de répertoires, vous verrez que ce dossier a été créé pour vous, avec le fichier layout.phtml.

Nous voulons aussi nous assurer que nous avons une déclaration de DocType XHTML pour notre application. Pour activer cela, nous devons ajouter une ressource à notre bootstrap.

La manière la plus simple d'ajouter une ressource au bootstrap est de définir une méthode protégée qui commence par _init. Dans notre cas, nous voulons initialiser le doctype et donc nous créons une méthode _initDoctype() :

1. // application/Bootstrap.php2.  3. class Bootstrap extends

Zend_Application_Bootstrap_Bootstrap4. {5.     protected function _initDoctype()6.     {7.     }8. }

Dans cette méthode, nous devons renseigner la vue au sujet du doctype. Mais d'où va provenir notre objet de vue ? La solution simple consiste à initialiser la ressource View et la récupérer dans la méthode de bootstrap pour l'utiliser.

Pour initialiser la vue, ajoutez la ligne suivante dans le fichier application/configs/application.ini, dans la section production :

1. ; application/configs/application.ini2.  3. ; Add to [production] section:4. resources.view[] =

Ceci indique de charger la vue avec aucune option (les '[]' indiquent que la clé "view" est un tableau et nous ne lui passons rien du tout).

Maintenant que nous possédons une vue, retournons à notre méthode _initDoctype(). A l'intérieur, nous allons d'abord nous assurer que la ressource View existe, puis nous la récupèrerons et la configurerons :

1. // application/Bootstrap.php2.  3. class Bootstrap extends

Zend_Application_Bootstrap_Bootstrap4. {5.     protected function _initDoctype()6.     {7.         $this->bootstrap('view');8.         $view = $this->getResource('view');9.         $view->doctype('XHTML1_STRICT');

Page 13: Zend Framework

10.     }11. }

Maintenant que Zend_Layout est initialisé et que le Doctype est réglé, créons notre vue globale de layout :

1. <!-- application/layouts/scripts/layout.phtml -->2. <?php echo $this->doctype() ?>3. <html xmlns="http://www.w3.org/1999/xhtml">4. <head>5.   <meta http-equiv="Content-Type" content="text/html;

charset=utf-8" />6.   <title>Zend Framework Quickstart Application</title>7.   <?php echo $this->headLink()-

>appendStylesheet('/css/global.css') ?>8. </head>9. <body>10. <div id="header" style="background-color: #EEEEEE;

height: 30px;">11.     <div id="header-logo" style="float: left">12.         <b>ZF Quickstart Application</b>13.     </div>14.     <div id="header-navigation" style="float: right">15.         <a href="<?php echo $this->url(16.             array('controller'=>'guestbook'),17.             'default',18.             true) ?>">Guestbook</a>19.     </div>20. </div>21.  22. <?php echo $this->layout()->content ?>23.  24. </body>25. </html>

Nous récupérons le contenu de l'application au moyen de l'aide de vue layout() et nous accédons à la clé "content". Vous pouvez utiliser d'autres segments de l'objet de réponse, mais dans la plupart des cas ce n'est pas nécessaire.

Notez aussi l'utilisation du placeholer headLink(). C'est un moyen simple de générer du HTML pour les éléments <link> et ca permet de les garder sous le coude au travers de l'application. Si vous devez ajouter des feuilles CSS c'est aussi possible.

Note: CheckpointAllez maintenant sur "http://localhost" et regarder le code source rendu. Vous devriez voir votre entête XHTML et vos sections head, title et body.

Créer un modèle et une table en base de données

Page 14: Zend Framework

Avant de démarrer, considérons ceci: où vont se trouver ces classes et comment les retrouver? Le projet par défaut que nous avons conçu instancie un autoloader. Nous pouvons lui attacher d'autres autoloaders pour qu'il puisse trouver des classes différentes. Typiquement nous voulons que nos classes MVC soient groupées sous une même arborescence -- dans ce cas, application/ -- et nous utiliserons un préfixe commun.

Zend_Controller_Front a une notion de "modules", qui sont des mini-applications individuelles. Les modules reflètent la structure de répertoires que la commande zf crée sous application/, et toutes les classes à l'intérieur sont supposées commencer par un préfixe étant le nom du module. application/ est lui-même un module -- le module "default" ou "application". Ainsi, nous allons vouloir configurer un autoload pour les ressources sous ce dossier.

Zend_Application_Module_Autoloader propose la fonctionnalité nécessaire à la correspondance entre les ressources d'un module et ses dossiers, il propose pour cela un mécanisme de nommage standard. Une instance de la classe est créee par défaut pendant l'initialisation de l'objet de bootstrap et utilisera le préfixe de module "Application". De ce fait, nos classes de modèles, formulaires, et tables commenceront toutes par le préfixe de classe "Application_".

Maintenant voyons de quoi est fait un livre d'or. Typiquement il existe simplement une liste d'entrées avec un commentaire, timestamp, et souvent une adresse email. En supposant que nous stockons cela dans une base de données, nous aurons aussi besoin d'un identifiant unique pour chaque entrée. Nous voudrons aussi sauvegarder une entrée, récupérer une entrée individuelle ou encore récupérer toutes les entrées. De ce fait, l'API du modèle d'un simple livre d'or ressemblerait à ceci:

1. // application/models/Guestbook.php2.  3. class Application_Model_Guestbook4. {5.     protected $_comment;6.     protected $_created;7.     protected $_email;8.     protected $_id;9.  10.     public function __set($name, $value);11.     public function __get($name);12.  13.     public function setComment($text);14.     public function getComment();15.  16.     public function setEmail($email);17.     public function getEmail();18.  19.     public function setCreated($ts);20.     public function getCreated();21.  22.     public function setId($id);23.     public function getId();24. }

Page 15: Zend Framework

25.  26. class Application_Model_GuestbookMapper27. {28.     public function save(Application_Model_Guestbook

$guestbook);29.     public function find($id);30.     public function fetchAll();31. }

__get() et __set() nous simpliferons l'accès aux attributs et proxieront vers les autres getters et setters. Ils nous permettront de même de nous assurer que seuls les attributs que nous avons définis seront accessibles dans l'objet.

find() et fetchAll() permettent de récupérer une seule entrée ou toutes les entrées alors que save() offrira la possibilité de stocker une entrée dans le support de stockage.

Maintenant à partir de là, nous pouvons commecer à penser en terme de base de données.

Nous devons d'abord intialiser une ressource Db. Comme pour les ressources Layout et View, nous pouvons utiliser de la configuration pour Db. Cela est possible au moyen de la commande zf configure db-adapter:

1. % zf configure db-adapter \2. > 'adapter=PDO_SQLITE&dbname=APPLICATION_PATH

"/../data/db/guestbook.db"' \3. > production4. A db configuration for the production has been written to

the application config file.5.  6. % zf configure db-adapter \7. > 'adapter=PDO_SQLITE&dbname=APPLICATION_PATH

"/../data/db/guestbook-testing.db"' \8. > testing9. A db configuration for the production has been written to

the application config file.10.  11. % zf configure db-adapter \12. > 'adapter=PDO_SQLITE&dbname=APPLICATION_PATH

"/../data/db/guestbook-dev.db"' \13. > development14. A db configuration for the production has been

written to the application config file.

Editez maintenant le fichier application/configs/application.ini, vous verrez que les lignes suivantes ont été ajoutées dans les sections appropriées:

1. ; application/configs/application.ini2.  3. [production]4. ; ...5. resources.db.adapter = "PDO_SQLITE"

Page 16: Zend Framework

6. resources.db.params.dbname = APPLICATION_PATH "/../data/db/guestbook.db"

7.  8. [testing : production]9. ; ...10. resources.db.adapter = "PDO_SQLITE"11. resources.db.params.dbname = APPLICATION_PATH

"/../data/db/guestbook-testing.db"12.  13. [development : production]14. ; ...15. resources.db.adapter = "PDO_SQLITE"16. resources.db.params.dbname = APPLICATION_PATH

"/../data/db/guestbook-dev.db"

Votre fichier de configuration final devrait ressembler à ceci:

1. ; application/configs/application.ini2.  3. [production]4. phpSettings.display_startup_errors = 05. phpSettings.display_errors = 06. bootstrap.path = APPLICATION_PATH "/Bootstrap.php"7. bootstrap.class = "Bootstrap"8. appnamespace = "Application"9. resources.frontController.controllerDirectory =

APPLICATION_PATH "/controllers"10. resources.frontController.params.displayExceptions =

011. resources.layout.layoutPath = APPLICATION_PATH

"/layouts/scripts"12. resources.view[] =13. resources.db.adapter = "PDO_SQLITE"14. resources.db.params.dbname = APPLICATION_PATH

"/../data/db/guestbook.db"15.  16. [staging : production]17.  18. [testing : production]19. phpSettings.display_startup_errors = 120. phpSettings.display_errors = 121. resources.db.adapter = "PDO_SQLITE"22. resources.db.params.dbname = APPLICATION_PATH

"/../data/db/guestbook-testing.db"23.  24. [development : production]25. phpSettings.display_startup_errors = 126. phpSettings.display_errors = 127. resources.db.adapter = "PDO_SQLITE"28. resources.db.params.dbname = APPLICATION_PATH

"/../data/db/guestbook-dev.db"

Page 17: Zend Framework

Notez que la/les base(s) de données seront stockées sous data/db/. Créez ces dossiers et affectez leur les bons droits. Sur les systèmes Unix utilisez:

1. % mkdir -p data/db; chmod -R a+rwX data

Sur Windows, vous devrez créer le dossier avec l'explorateur et lui donner les bonnes permissions pour que tout le monde puisse y écrire.

Dès lors, nous possédons une connexion à une base de données, dans notre cas il s'agit de Sqlite et la base est placée sous le dossier application/data/. Créons maintenant une table pour stocker nos entrées de livre d'or.

1. -- scripts/schema.sqlite.sql2. --3. -- You will need load your database schema with this SQL.4.  5. CREATE TABLE guestbook (6.     id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,7.     email VARCHAR(32) NOT NULL DEFAULT '[email protected]',8.     comment TEXT NULL,9.     created DATETIME NOT NULL10. );11.  12. CREATE INDEX "id" ON "guestbook" ("id");

Puis pour ne pas travailler dans le vide, créons quelques enregistrements de départ.

1. -- scripts/data.sqlite.sql2. --3. -- You can begin populating the database with the

following SQL statements.4.  5. INSERT INTO guestbook (email, comment, created) VALUES6.     ('[email protected]',7.     'Hello! Hope you enjoy this sample zf application!',8.     DATETIME('NOW'));9. INSERT INTO guestbook (email, comment, created) VALUES10.     ('[email protected]',11.     'Baz baz baz, baz baz Baz baz baz - baz baz

baz.',12.     DATETIME('NOW'));

Maintenant que nous avons la définition de la base de données ainsi que des données, créons un script qui pourra être lancé pour entièrement initialiser la base de données de manière autonomme. Bien sûr cela ne sera pas nécessaire en production. Créez le script scripts/load.sqlite.php avec le contenu suivant:

1. // scripts/load.sqlite.php2.  3. /**4. * Script pour créer et charger la base

Page 18: Zend Framework

5. */6.  7. // Initialise le chemin vers l'application et l'autoload8. defined ('APPLICATION_PATH')9.     || define('APPLICATION_PATH',

realpath(dirname(__FILE__) . '/../application'));10. set_include_path (implode(PATH_SEPARATOR, array(11.     APPLICATION_PATH . '/../library',12.     get_include_path(),13. )));14. require_once 'Zend/Loader/Autoloader.php';15. Zend_Loader_Autoloader::getInstance();16.  17. // Definit des options CLI18. $getopt = new Zend_Console_Getopt(array(19.     'withdata|w' => 'Load database with sample data',20.     'env|e-s'    => 'Application environment for

which to create database (defaults to development)',21.     'help|h'     => 'Help -- usage message',22. ));23. try {24.     $getopt->parse();25. } catch (Zend_Console_Getopt_Exception $e) {26.     // Mauvaises options passées: afficher l'aide27.     echo $e->getUsageMessage();28.     return false;29. }30.  31. // Si l'aid eest demandée, l'afficher32. if ($getopt->getOption('h')) {33.     echo $getopt->getUsageMessage();34.     return true;35. }36.  37. // Initialise des valeurs selon la présence ou

absence d'options CLI38. $withData = $getopt->getOption('w');39. $env      = $getopt->getOption('e');40. defined ('APPLICATION_ENV')41.     || define('APPLICATION_ENV', (null === $env) ?

'development' : $env);42.  43. // Initialise Zend_Application44. $application = new Zend_Application(45.     APPLICATION_ENV,46.     APPLICATION_PATH . '/configs/application.ini'47. );48.  49. // Initialise et récupère la ressoucre DB50. $bootstrap = $application->getBootstrap();51. $bootstrap->bootstrap('db');

Page 19: Zend Framework

52. $dbAdapter = $bootstrap->getResource('db');53.  54. // Informons l'utilisateur de ce qui se passe (nous

créons une base de données55. // ici)56. if ('testing' != APPLICATION_ENV) {57.     echo 'Writing Database Guestbook in (control-c to

cancel): ' . PHP_EOL;58.     for ($x = 5; $x > 0; $x--) {59.         echo $x . "\r"; sleep(1);60.     }61. }62.  63. // Vérifions si un fichier pour la base existe déja64. $options = $bootstrap->getOption('resources');65. $dbFile  = $options['db']['params']['dbname'];66. if (file_exists($dbFile)) {67.     unlink($dbFile);68. }69.  70. // Chargement du fichier de la base de données.71. try {72.     $schemaSql =

file_get_contents(dirname(__FILE__) . '/schema.sqlite.sql');

73.     // utilise la connexion directement pour charger le sql

74.     $dbAdapter->getConnection()->exec($schemaSql);75.     chmod($dbFile, 0666);76.  77.     if ('testing' != APPLICATION_ENV) {78.         echo PHP_EOL;79.         echo 'Database Created';80.         echo PHP_EOL;81.     }82.  83.     if ($withData) {84.         $dataSql =

file_get_contents(dirname(__FILE__) . '/data.sqlite.sql');85.         // utilise la connexion directement pour

charger le sql86.         $dbAdapter->getConnection()->exec($dataSql);87.         if ('testing' != APPLICATION_ENV) {88.             echo 'Data Loaded.';89.             echo PHP_EOL;90.         }91.     }92.  93. } catch (Exception $e) {94.     echo 'AN ERROR HAS OCCURED:' . PHP_EOL;95.     echo $e->getMessage() . PHP_EOL;

Page 20: Zend Framework

96.     return false;97. }98.  99. // Ce script sera lancé depuis la ligne de commandes100. return true;

Exécutons ce script. Depuis un terminal ou un invite DOS, effectuez:

1. % php scripts/load.sqlite.php --withdata

Vous devriez voir ceci:

1. path/to/ZendFrameworkQuickstart/scripts$ php load.sqlite.php --withdata

2. Writing Database Guestbook in (control-c to cancel):3. 14. Database Created5. Data Loaded.

Nous avons maintenant une base de données et une table pour notre application de livre d'or. Les prochaines étapes seront de créer le code applicatif. Ceci incluera une source de données (dans notre cas nous utiliserons Zend_Db_Table), un datamapper pour connecter cette source à notre modèle et enfin un contrôleur pour intéragir avec le modèle et afficher du contenu divers.

Nous allons utiliser un » Table Data Gateway pour se connecter à notre source de données; Zend_Db_Table propose cette fonctionnalité. Créons les classes basées sur Zend_Db_Table. Comme nous avons opéré pour les layouts ou la base, nous pouvons utiliser la commande zf pour nous aider, avec la commande complète create db-table. Celle-ci prend deux arguments au minimum, le nom de la classe à créer et la table qui y fera référence.

1. % zf create db-table Guestbook guestbook2. Creating a DbTable at

application/models/DbTable/Guestbook.php3. Updating project profile 'zfproject.xml'

En regardant l'orborescence du projet, un nouveau dossier application/models/DbTable/ a été crée contenant le fichier Guestbook.php. Si vous ouvrez ce fichier, vous y verrez le contenu suivant:

1. // application/models/DbTable/Guestbook.php2.  3. /**4. * This is the DbTable class for the guestbook table.5. */6. class Application_Model_DbTable_Guestbook extends

Zend_Db_Table_Abstract7. {8.     /** Table name */9.     protected $_name    = 'guestbook';10. }

Page 21: Zend Framework

Notez le préfixe de classe: Application_Model_DbTable. Le premier segment est "Application", le nom du module, puis vient le nom du composant "Model_DbTable" qui est lié au dossier models/DbTable/ du module.

Pour étendre Zend_Db_Table, seuls un nom de table et éventuellement un nom de clé primaire (si ce n'est pas "id") sont nécessaires.

Créons maintenant un » Data Mapper. Un Data Mapper fait correspondre un objet métier à la base de données. Dans notre cas Application_Model_Guestbook vers la source de données Application_Model_DbTable_Guestbook. Une API typique pour un data mapper est:

1. // application/models/GuestbookMapper.php2.  3. class Application_Model_GuestbookMapper4. {5.     public function save($model);6.     public function find($id, $model);7.     public function fetchAll();8. }

En plus de ces méthodes nous allons ajouter des méthodes pour affecter/récupérer l'objet Table Data Gateway. Pour créer la classe initiale, utilsez l'outil CLI zf:

1. % zf create model GuestbookMapper2. Creating a model at application/models/GuestbookMapper.php3. Updating project profile '.zfproject.xml'

Maintenant, éditez la classe Application_Model_GuestbookMapper dans application/models/GuestbookMapper.php pour y voir ceci:

1. // application/models/GuestbookMapper.php2.  3. class Application_Model_GuestbookMapper4. {5.     protected $_dbTable;6.  7.     public function setDbTable($dbTable)8.     {9.         if (is_string($dbTable)) {10.             $dbTable = new $dbTable();11.         }12.         if (!$dbTable instanceof

Zend_Db_Table_Abstract) {13.             throw new Exception('Invalid table data

gateway provided');14.         }15.         $this->_dbTable = $dbTable;16.         return $this;17.     }18.  19.     public function getDbTable()

Page 22: Zend Framework

20.     {21.         if (null === $this->_dbTable) {22.             $this-

>setDbTable('Application_Model_DbTable_Guestbook');23.         }24.         return $this->_dbTable;25.     }26.  27.     public function save(Application_Model_Guestbook

$guestbook)28.     {29.         $data = array(30.             'email'   => $guestbook->getEmail(),31.             'comment' => $guestbook->getComment(),32.             'created' => date('Y-m-d H:i:s'),33.         );34.  35.         if (null === ($id = $guestbook->getId())) {36.             unset($data['id']);37.             $this->getDbTable()->insert($data);38.         } else {39.             $this->getDbTable()->update($data,

array('id = ?' => $id));40.         }41.     }42.  43.     public function find($id,

Application_Model_Guestbook $guestbook)44.     {45.         $result = $this->getDbTable()->find($id);46.         if (0 == count($result)) {47.             return;48.         }49.         $row = $result->current();50.         $guestbook->setId($row->id)51.                   ->setEmail($row->email)52.                   ->setComment($row->comment)53.                   ->setCreated($row->created);54.     }55.  56.     public function fetchAll()57.     {58.         $resultSet = $this->getDbTable()->fetchAll();59.         $entries   = array();60.         foreach ($resultSet as $row) {61.             $entry = new

Application_Model_Guestbook();62.             $entry->setId($row->id)63.                   ->setEmail($row->email)64.                   ->setComment($row->comment)65.                   ->setCreated($row->created);

Page 23: Zend Framework

66.             $entries[] = $entry;67.         }68.         return $entries;69.     }70. }

Maintenant il faut créer la classe de modèle. Une fois de plus, nous utiliserons la commande zf create model:

1. % zf create model Guestbook2. Creating a model at application/models/Guestbook.php3. Updating project profile '.zfproject.xml'

Nous allons modifier cette classe PHP vide pour simplifier le remplissage du modèle via un tableau dans le constructeur ou une méthode setOptions(). Le code final de la classe de modèle stockée dans application/models/Guestbook.php devrait ressembler à ceci:

1. // application/models/Guestbook.php2.  3. class Application_Model_Guestbook4. {5.     protected $_comment;6.     protected $_created;7.     protected $_email;8.     protected $_id;9.  10.     public function __construct(array $options =

null)11.     {12.         if (is_array($options)) {13.             $this->setOptions($options);14.         }15.     }16.  17.     public function __set($name, $value)18.     {19.         $method = 'set' . $name;20.         if (('mapper' == $name) || !

method_exists($this, $method)) {21.             throw new Exception('Invalid guestbook

property');22.         }23.         $this->$method($value);24.     }25.  26.     public function __get($name)27.     {28.         $method = 'get' . $name;29.         if (('mapper' == $name) || !

method_exists($this, $method)) {

Page 24: Zend Framework

30.             throw new Exception('Invalid guestbook property');

31.         }32.         return $this->$method();33.     }34.  35.     public function setOptions(array $options)36.     {37.         $methods = get_class_methods($this);38.         foreach ($options as $key => $value) {39.             $method = 'set' . ucfirst($key);40.             if (in_array($method, $methods)) {41.                 $this->$method($value);42.             }43.         }44.         return $this;45.     }46.  47.     public function setComment($text)48.     {49.         $this->_comment = (string) $text;50.         return $this;51.     }52.  53.     public function getComment()54.     {55.         return $this->_comment;56.     }57.  58.     public function setEmail($email)59.     {60.         $this->_email = (string) $email;61.         return $this;62.     }63.  64.     public function getEmail()65.     {66.         return $this->_email;67.     }68.  69.     public function setCreated($ts)70.     {71.         $this->_created = $ts;72.         return $this;73.     }74.  75.     public function getCreated()76.     {77.         return $this->_created;78.     }79.  

Page 25: Zend Framework

80.     public function setId($id)81.     {82.         $this->_id = (int) $id;83.         return $this;84.     }85.  86.     public function getId()87.     {88.         return $this->_id;89.     }90. }

Enfin, pour connecter tous ces éléments ensemble, créons un contrôleur qui listera les entrées de la base de données.

Pour créer le nouveau contrôleur, utilisez la commande zf create controller:

1. % zf create controller Guestbook2. Creating a controller at3.     application/controllers/GuestbookController.php4. Creating an index action method in controller Guestbook5. Creating a view script for the index action method at6.     application/views/scripts/guestbook/index.phtml7. Creating a controller test file at8.    

tests/application/controllers/GuestbookControllerTest.php9. Updating project profile '.zfproject.xml'

Ceci va créer GuestbookController dans application/controllers/GuestbookController.php, avec une seule action indexAction(). Un script de vue sera aussi crée pour ce contrôleur, il sera logé dans application/views/scripts/guestbook/, avec une vue pour l'action index.

Nous allons utiliser l'action "index" pour lister toutes les entrées du livre d'or.

Un aterrissage sur indexAction() devra lister toutes les entrées du livre d'or. Ceci ressemblera à ce qui suit:

1. // application/controllers/GuestbookController.php2.  3. class GuestbookController extends Zend_Controller_Action4. {5.     public function indexAction()6.     {7.         $guestbook = new

Application_Model_GuestbookMapper();8.         $this->view->entries = $guestbook->fetchAll();9.     }10. }

Et bien sûr un script de vue sera nécessaire. Editez application/views/scripts/guestbook/index.phtml pour y inclure ceci:

Page 26: Zend Framework

1. <!-- application/views/scripts/guestbook/index.phtml -->2.  3. <p><a href="<?php echo $this->url(4.     array(5.         'controller' => 'guestbook',6.         'action'     => 'sign'7.     ),8.     'default',9.     true) ?>">Sign Our Guestbook</a></p>10.  11. Guestbook Entries: <br />12. <dl>13.     <?php foreach ($this->entries as $entry): ?>14.     <dt><?php echo $this->escape($entry->email)

?></dt>15.     <dd><?php echo $this->escape($entry->comment) ?

></dd>16.     <?php endforeach ?>17. </dl>

Note: CheckpointNaviguez maintenant vers "http://localhost/guestbook". Vous devriez voir ceci apparaitre dans votre navigateur:

Note: Utiliser le script de chargement des donnéesLe script de chargement des données montré dans la section en question (scripts/load.sqlite.php) peut être utilisé pour créer une base de données pour chaque environnement défini et la remplir de données d'exemple. En interne, il utilise Zend_Console_Getopt, qui permet de préciser des options à la commande. Si vous passez "-h" ou "--help", toutes les options disponibles seront affichées:

1. Usage: load.sqlite.php [ options ]2. --withdata|-w         Load database with sample data3. --env|-e [  ]         Application environment for

which to create database4.                       (defaults to development)5. --help|-h             Help -- usage message)]]

Page 27: Zend Framework

L'option "-e" permet de préciser la valeur de la constante APPLICATION_ENV -- ce qui en effet permet de créer une base de données SQLite pour chaque environnement défini. N'oubliez pas l'envrionnement lorsque vous utilisez ce script.

Créer un formulairePour que notre livre d'or soit utile, nous allons avoir besoin d'un formulaire permettant de le remplir.

Nous devons donc créer un formulaire. Pour créer un formulaire vierge, exécutez la commande :

1. % zf create form Guestbook2. Creating a form at application/forms/Guestbook.php3. Updating project profile '.zfproject.xml'

Ceci créera le dossier application/forms/ avec un fichier de classe Guestbook.php. Ouvrez ce fichier et mettez le à jour comme suit :

1. // application/forms/Guestbook.php2.  3. class Application_Form_Guestbook extends Zend_Form4. {5.     public function init()6.     {7.         // La méthode HTTP d'envoi du formulaire8.         $this->setMethod('post');9.  10.         // Un élément Email11.         $this->addElement('text', 'email', array(12.             'label'      => 'Your email address:',13.             'required'   => true,14.             'filters'    => array('StringTrim'),15.             'validators' => array(16.                 'EmailAddress',17.             )18.         ));19.  20.         // Un élément pour le commentaire21.         $this->addElement('textarea', 'comment',

array(22.             'label'      => 'Please Comment:',23.             'required'   => true,24.             'validators' => array(25.                 array('validator' => 'StringLength',

'options' => array(0, 20))26.                 )27.         ));28.  29.         // Un captcha

Page 28: Zend Framework

30.         $this->addElement('captcha', 'captcha', array(

31.             'label'      => 'Please enter the 5 letters displayed below:',

32.             'required'   => true,33.             'captcha'    => array(34.                 'captcha' => 'Figlet',35.                 'wordLen' => 5,36.                 'timeout' => 30037.             )38.         ));39.  40.         // Un bouton d'envoi41.         $this->addElement('submit', 'submit', array(42.             'ignore'   => true,43.             'label'    => 'Sign Guestbook',44.         ));45.  46.         // Et une protection anti CSRF47.         $this->addElement('hash', 'csrf', array(48.             'ignore' => true,49.         ));50.     }51. }

Le formulaire ci-dessus définit cinq éléments : une adresse email, un champ commentaire, un CAPTCHA anti spam, un bouton d'envoi et une protection anti CSRF.

Maintenant nous allons ajouter une action signAction() à notre GuestbookController qui va s'occuper de la soumission du formulaire. Pour créer cette action et son script de vue, éxécutez :

1. % zf create action sign Guestbook2. Creating an action named sign inside controller3.     at application/controllers/GuestbookController.php4. Updating project profile '.zfproject.xml'5. Creating a view script for the sign action method6.     at application/views/scripts/guestbook/sign.phtml7. Updating project profile '.zfproject.xml'

Comme vous le voyez d'après l'affichage, ceci va créer une méthode signAction() dans notre contrôleur, ainsi que le script de vue approprié.

Ajoutons de la logique dans notre action. Nous devons d'abord vérifier le type de requête HTTP POST ou GET ; dans ce dernier cas nous affichons simplement le formulaire. Cependant, si nous recevons une requête POST, nous allons vouloir valider le formulaire par rapport aux données postées, et s'il est valide, créer une nouvelle entrée et la sauvegarder. La logique ressemble à ceci :

1. // application/controllers/GuestbookController.php2.  

Page 29: Zend Framework

3. class GuestbookController extends Zend_Controller_Action4. {5.     // indexAction() ici ...6.  7.     public function signAction()8.     {9.         $request = $this->getRequest();10.         $form    = new Application_Form_Guestbook();11.  12.         if ($this->getRequest()->isPost()) {13.             if ($form->isValid($request->getPost()))

{14.                 $comment = new

Application_Model_Guestbook($form->getValues());15.                 $mapper  = new

Application_Model_GuestbookMapper();16.                 $mapper->save($comment);17.                 return $this->_helper-

>redirector('index');18.             }19.         }20.  21.         $this->view->form = $form;22.     }23. }

Bien sur, nous devons aussi éditer le script de vue. Editez application/views/scripts/guestbook/sign.phtml avec ceci :

1. <!-- application/views/scripts/guestbook/sign.phtml -->2.  3. Utilisez le formulaire ci-après pour signer notre livre

d'or!4.  5. <?php6. $this->form->setAction($this->url());7. echo $this->form;8. <="" span="">

Note: Améliorer le rendu visuel du formulaireCe formulaire n'a pas un look terrible, peu importe : l'apparence d'un formulaire est entièrement personnalisable ! Voyez la section sur les décorateurs dans le guide de réference pour plus de détails. Aussi, vous pouvez être intéréssés par notre tutoriel sur les décorateurs de formulaires.

Note: CheckpointNaviguez maintenant sur "http://localhost/guestbook/sign". Vous devriez voir ceci dans votre navigateur :

Page 30: Zend Framework

Félicitations !Vous venez de construire une application très simple en utilisant la plupart des composants du Zend Framework. Zend Framework se compose de nombreux composants très utiles pour le développement web, comme les services webs, la recherche, la gestions des PDF, l'authentication et les listes d'autorisation, etc. Le Guide de référence possède de nombreuses d'informations sur les composants que vous avez utilisé dans le guide de démarrage (QuickStart) et ainsi que sur les autres composants. Nous espérons que vous trouverez le Zend Framework utile et plus important encore - fun !