Débuter avec le Zend Framework 1.5

Ce tutoriel est destiné à donner une introduction basique d'utilisation du Zend Framework pour écrire une application connectée à une base de données.

NOTE: Ce tutoriel as été testé sur les versions 1.5 du Zend Framework. Il y a de grandes chances qu'il fonctionne avec les versions ultérieures de la série 1.5.x, mais il ne fonctionne pas avec les versions antérieures à 1.5.

MVC : L'architecture Modèle-Vue-Contrôleur

La voie traditionnelle de création d'application PHP est de faire quelque chose qui ressemble à ce qui suit :

<?php 
include "common-libs.php"; 
include "config.php"; 
mysql_connect($hostname, $username, $password); 
mysql_select_db($database); 
?> 
 
<?php include "header.php"; ?> 
<h1>Home Page</h1> 
 
<?php  
$sql = "SELECT * FROM news"; 
$result = mysql_query($sql); 
?> 
<table> 
<?php 
while ($row = mysql_fetch_assoc($result)) { 
?> 
<tr> 
    <td><?php echo $row['date_created']; ?></td> 
    <td><?php echo $row['title']; ?></td> 
</tr> 
<?php  
} 
?> 
</table> 
<?php include "footer.php"; ?>

Au fil du temps, une application de ce type devient impossible à maintenir lorsque le client demande des modifications qui sont (aléatoirement) réparties à divers endroits de votre code source.

Une méthode d'amélioration de la maintenabilité de l'application est de séparer le code sur la page en trois parties distinctes (et généralement des fichiers séparés):

Modèle (Model)

Le partie modèle de l'application est la partie qui concerne les spécificités des données devant être affichées. Dans l'exemple ci-dessus le code c'est la notion de "news". Ainsi, le modèle est généralement préoccupé par la partie logique "Métier (ou Business)" de l'application et a tendance à charger et sauvegarder des bases de données.

Vue (View)

La vue est composée de bouts d'application qui sont concernés par l'affichage destiné à l'utilisateur. Habituellement, c'est le rendu HTML.

Contrôleur (Controller)

Le contrôleur associe les spécificités du modèle et la vue pour veiller à ce que les données correctes sont affichées sur la page.

Zend Framework utilise l'architecture Model-View-Controller (MVC) . Elle est utilisée pour séparer les différentes parties de votre application pour rendre le développement et la maintenance plus facile.

Pré-requis

Zend Framework nécessite :

PHP 5.1.4 (or plus)
Un serveur web qui supporte la fonctionnalité mod_rewrite (réécriture des URL à la volée)

Tutorial Assumptions

J'ai supposé que vous utilisez PHP 5.1.4 ou supérieur avec le serveur web Apache. Votre installation d'Apache doit avoir le mod_rewrite extension installé et configuré. Dans la configuration d'Apache : httpd.conf

LoadModule rewrite_module modules/mod_rewrite.so

Vous devez également faire en sorte qu'Apache soit configuré pour supporter les fichiers .htaccess. Cela se fait habituellement en modifiant le paramètre:

AllowOverride None

AllowOverride All

toujours dans votre fichier httpd.conf. Vérifiez auprès de la documentation de votre distribution les détails exacts. Vous ne serez pas en mesure de naviguer vers aucune autre page autre que la page d'accueil de ce tutoriel, si vous n'avez pas configuré mod_rewrite et .htacess correctement.

Obtenir le Framework

Zend Framework est téléchargeable depuis http://framework.zend.com/download dans les deux formats .zip et .tar.gz

Structure des répertoires

Alors que le Zend Framework ne prévoit pas une structure de répertoires, le manuel recommande une structure de répertoire commune, donc c'est ce que nous allons utiliser. Cette structure suppose que vous avez le contrôle complet sur votre configuration d'Apache, afin d'utiliser des fichiers en dehors de votre répertoire web racine.

Commencez par créer un répertoire appelé zf-tutorial dans la racine de votre serveur web (ou de votre hôte virtuel (virtual host)) et ensuite créez les sous-répertoires suivants pour gérer les les fichiers du site web :

zf-tutorial/
   application/
       controllers/
       models/
       views/
           filters/
           helpers/
           scripts/
       library/
       public/
           css/
           images/
           js/

Comme vous pouvez le constater, nous avons séparé les répertoires pour le modèle, la vue et le contrôleur des fichiers de notre application. Le public/ est le répertoire racine du site Web, ce qui signifie que l'adresse (URL) pour accéder à l'application sera http://localhost/zf-tutorial/public/. Ainsi, la plupart des fichiers de l'application ne sont pas accessibles directement par Apache, et cela est plus sécurisé.

Note : Sur un site Web en ligne, vous devrez créer un hôte virtuel pour le site Web et de configurer le document root (racine web) directement mappé sur le dossier public. Par exemple vous pouvez créer un hôte virtuel appelé zf-tutorial.localhost qui ressemblait à quelque chose comme ceci:

<VirtualHost *:80> 
   ServerName zf-tutorial.localhost 
   DocumentRoot /var/www/html/zf-tutorial/public 
   <Directory "/www/cs"> 
       AllowOverride All 
   </Directory> 
</VirtualHost>

Le site sera alors accessible en utilisant http://zf-tutorial.localhost/ (assurez-vous que vous mettez à jour votre fichier /etc/hosts (linux) ou c:\windows\system32\drivers\etc\hosts (windows) afin que zf-tutorial.localhost soit mappé sur 127.0.0.1)

Les images, les fichiers CSS et JavaScript sont stockés dans des dossiers distincts sous le dossier public. Les fichiers téléchargés du Zend Framework seront placés dans le dossier library. Si nous avons besoin d'utiliser toutes les autres bibliothèques, ils peuvent aussi être placés ici. Vous pouvez également copier ces fichiers dans le PATH de votre PHP configuré dans le fichier php.ini :

; UNIX: "/path1:/path2"
;include_path = ".:/php5/includes/:/var/www/html/ZendFramework-1.5.0/library/"
;
; Windows: "\path1;\path2"
include_path = ".;C:/Program Files/EasyPHP 2.0b1\php5\ZendFramework-1.5.0\library\"

Extraire le fichier d'archive téléchargée, ZendFramework-1.5.0.zip dans mon cas, vers un répertoire temporaire. Tous les fichiers de l'archive sont placées dans un sous-répertoire appelé ZendFramework-1.5.0. Copiez le sous-répertoire library/Zend dans zf-tutorial/library/. Votre zf-tutorial/library/ devrait maintenant contenir un sous-répertoire appelé Zend.

Bootstrapping (amorçage)

Le contrôleur du Zend Framework, Zend_Controller est conçu pour supporter des sites web avec urls propres. Pour atteindre cet objectif, toutes les demandes doivent passer par un seul fichier index.php. C'est ce qu'on appelle le Front Controller design pattern. Cela nous fournit un point central pour toutes les pages de l'application et assure que l'environnement est correctement configuré pour exécuter l'application. Nous réalisons ceci en utilisant un fichier .htaccess dans le répertoire zf-tutorial/public :

zf-tutorial/public/.htaccess

# Rewrite rules for Zend Framework 
RewriteEngine on 
RewriteCond %{REQUEST_FILENAME} !-f 
RewriteRule .* index.php 

# Security: Don't allow browsing of directories 
Options -Indexes 

# PHP settings 
php_flag magic_quotes_gpc off 
php_flag register_globals off 
php_flag short_open_tag on

Le RewriteRule est très simple et peut être interprété comme "pour que toutes les url ne soient pas liée à des fichiers existants sur le disque, mais qui, à la place utilisent index.php". Nous avons définis des paramètres PHP de sécurité et de santé dans pour PHP et activé le short_open_tag pour l'utilisation dans les vue de scripts. Ceux-ci devraient déjà être positionné correctement, mais nous voulons en être sûr ! Notez que les réglages de php_flag dans le fichier .htaccess ne fonctionne que si vous utilisez mod_php. Si vous utilisez CGI/FastCGI, alors vous devez faire en sorte que votre php.ini soit correcte. Notez que pour les fichiers .htaccess soient utilisé par Apache, la directive de configuration AllowOverride doit être réglé sur All dans votre fichier httpd.conf.

Bootstrap file: index.php

zf-tutorial/public/index.php est votre fichier bootstrap et il nous commencerons par ce qui suit :

zf-tutorial/public/index.php

<?php 
 
error_reporting(E_ALL|E_STRICT); 
ini_set('display_errors', 1); 
date_default_timezone_set('Europe/London'); 
 
// directory setup and class loading 
set_include_path('.' . PATH_SEPARATOR . '../library/' 
     . PATH_SEPARATOR . '../application/models' 
     . PATH_SEPARATOR . get_include_path()); 
include "Zend/Loader.php"; 
Zend_Loader::registerAutoload(); 
 
// setup controller 
$frontController = Zend_Controller_Front::getInstance(); 
$frontController->throwExceptions(true); 
$frontController->setControllerDirectory('../application/controllers'); 
 
// run! 
$frontController->dispatch();

Notez que nous ne mettons pas le ?> À la fin du fichier, car il n'est pas nécessaire et cela simplifie certains cas difficiles à déboguer tels que les erreurs lors de la réorientation via la fonction header() si d'autres espaces qui intervient après les ?>.

Détaillons le fichier.

error_reporting(E_ALL|E_STRICT); 
ini_set('display_errors', 1); 
date_default_timezone_set('Europe/London');

Ces lignes assurent que nous allons voir toutes les erreurs que nous faisons. Nous avons également mis en place notre fuseau horaire actuel comme l'exige PHP 5.1+. Évidemment, vous devrez choisir votre propre fuseau horaire.

// directory setup and class loading
set_include_path('.' . PATH_SEPARATOR . '../library/' 
     . PATH_SEPARATOR . '../application/models' 
     . PATH_SEPARATOR . get_include_path()); 
include "Zend/Loader.php"; 
Zend_Loader::registerAutoload();

Zend Framework est conçu de telle sorte que ses fichiers doivent être dans chemin d'inclusion. Nous plaçons notre répertoire de modèles dans chemin d'inclusion afin que nous puissions facilement charger notre modèle classes plus tard. Le coup d'envoi, nous devons inclure le fichier Zend/Loader.php nous donne accès à la classe Zend_Loader et ensuite appeler sa méthode registerAutoload() dans le but de charger automatiquement tous les fichiers Zend Framework que nous avons instancié.

// setup controller 
$frontController = Zend_Controller_Front::getInstance(); 
$frontController->throwExceptions(true); 
$frontController->setControllerDirectory('../application/controllers');

Nous avons besoin de configurer le contrôleur frontal pour qu'il sache dans quel dossier se trouve nos contrôleurs.

$frontController = Zend_Controller_Front::getInstance(); 
$frontController->setControllerDirectory('./application/controllers'); 
$frontController->throwExceptions(true);

Comme il s'agit d'un tutoriel et que nous executons sur un système de test, j'ai décidé de déléguer au contrôleur frontal la récupération de toutes les exceptions qui se produisent. Par défaut, le contrôleur frontal les intercepte pour nous et leur achemine à un contrôleur ErrorController pour nous. Cela peut être très déroutant pour les personnes nouvelles au Zend Framework, et il est donc plus simple de remonter toutes les exceptions de sorte qu'elles soient facilement visibles. Bien sûr, sur un serveur de production, vous ne devriez pas affichager les erreurs aux utilisateurs !

Le contrôleur frontal utilise une classe routeur pour lier l'URL demandée à la bonne fonction PHP destiné à être utilisé pour l'affichage de la page. Pour que le routeur puisse fonctionner, il a besoin de travailler sur une partie de l'URL qui est le chemin de notre index.php pour qu'il puisse regarder les éléments URI après ce point. Ceci est fait par l'objet Request (demande). Il fait un assez bon travail d'auto-détection de l'URL de base, mais si cela ne marche pas pour configuration, vous pouvez le surcoucher à l'aide de la fonction $frontController->setBaseUrl().

Enfin, nous arriverons au coeur du sujet et nous lançons notre application :

// run! 
$frontController->dispatch();

Si vous allez sur http://localhost/zf-tutorial/public/ pour tester, vous devriez voir une erreur fatale qui commence avec :

Fatal error: Uncaught exception 'Zend_Controller_Dispatcher_Exception' with message 'Invalid controller specified (index)' in

Cela nous dit que nous n'avons pas mis en place notre application pour le moment. Avant que nous puissions faire, devrions mieux discuter de ce que nous allons construire, c'est que nous allons faire.

Le site Web

Nous allons construire un système d'inventaire très simple permettant d'afficher notre collection de CD. La page principale devra lister notre collection et nous permetre d'ajouter, modifier et supprimer des disques. Nous allons conserver notre liste dans une base de données avec le schéma suivant :

Fieldname  Type         Null?  Notes 
id         Integer      No     Primary key, Autoincrement 
artist     Varchar(100) No   
title      Varchar(100) No

Pages requises

Les pages suivantes seront nécessaires.

Accueil                 Ce dernier affichera la liste des albums et fournira les liens d'édition et de suppression. De plus, un lien pour permettre l'ajout de nouveaux albums sera fournis.
Ajouter un nouvel album Cette page fournira un formulaire pour ajouter un nouvel album
Modifier l'album        Cette page fournira un formulaire pour l'édition d'un album
Supprimer l'album       Cette page vous confirmera que nous voulons supprimer un album, puis le supprimera.

Organisation des pages

Avant que nous avons mettions en place nos fichiers, il est important de comprendre la façon dont le Zend Framework s'attend à une organisation des pages. Chaque page de l'application est connu comme une "action" et les actions sont regroupées en "contrôleurs". Par exemple, pour une URL http://localhost/public/zf-tutorial/news/view, le contrôleur est news et l'action est view. Ceci permet le regroupement d'actions connexes. Par exemple, le contrôleur news pourraient avoir comme actions de list, archived and view. Le système Zend Framework MVC supporte également des modules pour grouper des contrôleurs entre eux, mais cette application n'est pas assez grande pour m'en inquiéter !

Par défaut, le contrôleur Zend Framework réserve une action spéciale appelée index, c'est l'action par défaut. C'est, pour une URL telle que http://localhost/zf-tutorial/public/news/ l'index qui sera executée avec le contrôleur news. Il ya aussi un nom de contrôleur par défaut. On ne s'étonne donc pas qu'il soit également appelé index. Ainsi, le Web http://localhost/zf-tutorial/public/ provoquera l'éxecution de l'action index du contrôleur index.

Comme il s'agit d'un simple tutoriel, nous n'allons pas être dérangé par les choses "compliqués" tels que l'authentification ! Cela peut attendre un autre tutoriel Comme nous avons quatre pages qui s'appliquent à tous les albums, nous allons les regrouper en un seul contrôleur composé de quatre actions. Nous allons utiliser le contrôleur par défaut et les quatre actions seront :

Page           Controller  Action 
Home page      Index       index 
Add New Album  Index       add 
Edit Album     Index       edit 
Delete Album   Index       delete

Mettre en place le Controller

Nous sommes maintenant prêts pour mettre en place notre contrôleur. Dans le Zend Framework, le contrôleur est une classe qui doit être appelée {Controller name}Controller. Notez que {Controller name} doit commencer par une majuscule. Cette classe doit vivre dans un fichier nommé {Controller name}Controller.php au sein du répertoire application/controllers. De nouveau {Controller name} doit commencer par une majuscule et tout autre lettre doit être minuscule. Chaque action est une fonction publique au sein de la classe du contrôleur, qui doit être nommé {action name}Action. Dans ce cas, {action name} devrait commencer par une lettre minuscule et de nouveau doit être complètement minuscules. Mélanger majuscules et miniscules dans le nom du contrôleur et de l'action est autorisé, mais il y a des règles spéciales que vous devez comprendre avant de les utiliser. Consultez la d'abord documentation !

Ainsi, notre classe contrôleur est appelé IndexController qui est défini dans zf-tutorial/application/controllers/IndexController.php. Créer ce fichier pour créer le squelette:

zf-tutorial/application/controllers/IndexController.php

<?php 
 
class IndexController extends Zend_Controller_Action  
{ 
    function indexAction() 
    { 
    } 
 
    function addAction() 
    { 
    } 
 
    function editAction() 
    { 
    } 
 
    function deleteAction() 
    { 
    } 
}

Nous avons maintenant mis en place les quatre actions que nous voulons utiliser. Elles ne fonctionneront pas tant que nous n'ayons mis en place les vues. Les URL de chaque action sont:

URL                                               Action 
http://localhost/zf-tutorial/public/              IndexController::indexAction() 
http://localhost/zf-tutorial/public/index/add     IndexController::addAction() 
http://localhost/zf-tutorial/public/index/edit    IndexController::editAction() 
http://localhost/zf-tutorial/public/index/delete  IndexController::deleteAction()

Nous avons maintenant un routeur fonctionnel et les actions sont mises en place pour chaque page de notre application.

Il est temps de construire les vues.

Configuration de la vue

Le composant Vue du Zend Framework est appelé, un peu sans surprise, Zend_View. Le composant vue va nous permettre de séparer le code qui affiche la page du code des fonctions de l'action.

Les bases de l'utilisation de Zend_View est:

$view = new Zend_View(); 
$view->setScriptPath('/path/to/view_files'); 
echo $view->render('viewScipt.php');

Il peut très facilement être considéré que si nous devions mettre ce squelette directement dans chacune des fonctions de notre action, il serait très ennuyeux de répéter ce code "structurel" qui est sans intérêt pour l'action. Nous devrions plutôt faire l'initialisation de la vue à un autre endroit, puis accéder à notre objet vue déjà initialisé à l'intérieur de chaque fonction de l'action.

Les concepteurs de Zend Framework prévoyait ce type de problème, la solution est intégrée dans une "action d'aide (action helper)". Zend_Controller_Action_Helper_ViewRenderer prend soin d'initialiser la propriété de la vue ($this->view) pour nous, pour utiliser et rendre une vue de script. Pour le rendu, il met en place l'objet Zend_View pour examiner views/scripts/{controller name} de la vue des scripts qui peuvent être rendus, et (par défaut, au moins) de rendre le script qui doit son nom à l'action avec l'extension phtml . C'est là, la vue script est rendue views/scripts/{controller name}/{action_name}.phtml et le rendu du contenu est ajouté au corps (body) de l'objet Response. L'objet de réponse est utilisé pour rassembler l'ensemble des entêtes HTTP, le contenu du corps et les exceptions générés à la suite de l'utilisation du système MVC. Le contrôleur frontal envoie automatiquement les en-têtes suivie le contenu du body à la fin de l'expédition (dispatch).

Pour intégrer la vue dans notre application tout ce que nous devons faire, c'est créer quelques fichiers de vue et de prouver que cela fonctionne, nous ajoutons des actions spécifiques de contenu (la page de titre) dans le contrôleur d'actions.

Les modifications apportées à l'IndexController :

zf-tutorial/application/controllers/IndexController.php

<?php 
 
class IndexController extends Zend_Controller_Action  
{ 
    function indexAction() 
    { 
        $this->view->title = "My Albums"; 
    } 
 
    function addAction() 
    { 
        $this->view->title = "Add New Album"; 
    } 
 
    function editAction() 
    { 
        $this->view->title = "Edit Album"; 
    } 
 
    function deleteAction() 
    { 
        $this->view->title = "Delete Album"; 
    } 
}

Dans chaque fonction, nous assignons une variable de titre pour la propriété de la vue, c'est tout ! Notez que l'affichage réel ne se fait pas à ce moment - il est effectué par le contrôleur frontal à la fin du processus de rendu.

Nous devons maintenant ajouter quatre fichiers de vues à notre application. Ces fichiers sont appelés scripts de vue ou modèles comme noté ci-dessus, chaque fichier modèle doit son nom à son action et a l'extension .phtml pour montrer qu'il s'agit d'un fichier modèle. Le fichier doit être dans un sous-répertoire qui porte le nom du contrôleur, les quatre fichiers sont :

zf-tutorial/application/views/scripts/index/index.phtml

<html> 
<head> 
 <title><?php echo $this->escape($this->title); ?></title> 
</head> 
<body> 
 <h1><?php echo $this->escape($this->title); ?></h1> 
</body> 
</html>

zf-tutorial/application/views/scripts/index/add.phtml

<html> 
<head> 
 <title><?php echo $this->escape($this->title); ?></title> 
</head> 
<body> 
 <h1><?php echo $this->escape($this->title); ?></h1> 
</body> 
</html>

zf-tutorial/application/views/scripts/index/edit.phtml

<html> 
<head> 
 <title><?php echo $this->escape($this->title); ?></title> 
</head> 
<body> 
 <h1><?php echo $this->escape($this->title); ?></h1> 
</body> 
</html>

zf-tutorial/application/views/scripts/index/delete.phtml

<html> 
<head> 
 <title><?php echo $this->escape($this->title); ?></title> 
</head> 
<body> 
 <h1><?php echo $this->escape($this->title); ?></h1> 
</body> 
</html>

Testez chaque contrôleur/action en naviguant avec les url citées précédemment, cela devraient afficher les quatre titres dans le navigateur Web.

Code HTML commun

Il devient très vite évident qu'il existe de nombreux points communs de code HTML dans nos vues. Il s'agit d'un problème très courant et le composant Zend_Layout est conçu pour résoudre ce problème. Zend_Layout nous permet de déplacer tous les en-têtes et pieds de page communs dans une zone du script de vue qui inclut la vue alors que le code est spécifique à l'action en cours d'exécution.

Les modifications suivantes sont nécessaires. Tout d'abord, nous devons décider où garder notre layout vue de scripts. L'endroit recommandé est le répertoire application, donc créez un répertoire appelé layouts dans le répertoire zf-tutorial/application.

We need to tell start the Zend_Layout system in the bootstrap file, so we add to public/index.php like this : Nous avons besoin de demarer le Zend_Layout système dans le fichier d'amorçage (bootstrap), donc nous nous ajoutons à public/index.php ceci:

zf-tutorial/public/index.php

... 
$frontController->throwExceptions(true); 
$frontController->setControllerDirectory('../application/controllers'); 
Zend_Layout::startMvc(array('layoutPath'=>'../application/layouts')); 
 
// run! 
$frontController->dispatch();

La fonction startMvc() fait quelques travaux dans les coulisses pour mettre en place un plugin du contrôleur frontal qui fera en sorte que le composant Zend_Layout rende la mise en page avec le script vue de l'action, à la fin du processus d'envoi (dispatch).

Nous avons maintenant besoin d'une mise en page de script. Par défaut, ce qu'on appelle layout.phtml et vit dans le répertoire layouts. Cela ressemble à ceci :

zf-tutorial/application/layouts/layout.phtml

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">  
<head> 
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> 
    <title><?php echo $this->escape($this->title); ?></title> 
</head> 
<body> 
<div id="content"> 
    <h1><?php echo $this->escape($this->title); ?></h1> 
    <?php echo $this->layout()->content; ?> 
</div> 
</body> 
</html>

Notez que nous avons rendu notre code compatible XHTML qui est un standard HTML l'affichage d'une page. Comme le titre de la page affiché dans la balise <h1> est affiché sur toutes les pages, nous l'avons déplacé dans la mise en page de ce fichier et utilisons l'aideur de vue (view helper) escape() afin de s'assurer qu'elle est correctement encodés.

Pour obtenir le script de vue de l'action en cours d'affichage, nous utilisons l'aideur de vue : echo $this->layout()->content; qui fait le travail pour nous. Cela signifie que les scripts de vue de l'action sont exécutés avant la rendu du script de vue.

Nous avons maintenant 4 actions scripts qui n'ont rien de spécifiques, alors allez-y et vider les fichiers index.phtml, add.phtml, edit.phtml et delete.phtml.

Vous pouvez maintenant tester les 4 URL à nouveau et vous ne devriez voir aucune différence depuis la dernière fois que vous l'aviez tester ! La principale différence est que cette fois-ci, tout le travail se fait dans la mise en page.

Mise en forme (Styling)

Même si cela est "juste" un tutoriel, nous aurez besoin d'un fichier CSS afin de rendre à notre application un look présentable ! Ceci cause un problème mineur dans la mesure où nous ne savons pas vraiment comment référencer le fichier CSS parce que l'URL ne pointe pas vers le bon répertoire racine. Pour résoudre ce problème, nous créons notre propre aideur de vue, appelé baseUrl(), qui recueille les renseignements dont nous avons besoin sous forme de l'objet de requête. Cela nous fournit la base de l'URL que nous ne connaissons pas.

Les aideurs de vue sont localisés dans application/views/helpers et sont nommés {Helper name}.php (la première lettre doit être en majuscules) et la classe à l'intérieur doit être appelée Zend_Controller_Helper_{Helper name} (encore une fois, première lettre en majuscule). Il doit y avoir une fonction a l'intérieur de la classe appelée helper {helper name}() (première lettre en minuscule - ne pas oublier!). Dans notre cas, le fichier s'appelle BaseUrl.php et ressemble à ceci :

zf-tutorial/application/views/helpers/BaseUrl.php

<?php 
 
class Zend_View_Helper_BaseUrl 
{ 
    function baseUrl() 
    { 
        $fc = Zend_Controller_Front::getInstance(); 
        return $fc->getBaseUrl(); 
    } 
}

Une fonction pas compliquée. Nous avons tout simplement récupérer une instance du contrôleur frontal et retourner sa fonction membre getBaseUrl().

Nous avons besoin d'ajouter le fichier CSS dans la section <head> du fichier application/layouts/layout.phtml :

zf-tutorial/application/layouts/layout.phtml

... 
<head> 
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> 
    <title><?php echo $this->escape($this->title); ?></title> 
    <link rel="stylesheet" type="text/css" media="screen" 
             href="<?php echo $this->baseUrl();?>/css/site.css" /> 
</head> 
...

Enfin, nous avons besoin de quelques styles CSS :

zf-tutorial/public/css/site.css

body,html { 
    margin: 0 5px; 
    font-family: Verdana,sans-serif; 
} 
h1 { 
    font-size:1.4em; 
    color: #008000; 
} 
a { 
    color: #008000; 
} 
 
/* Table */ 
th { 
    text-align: left; 
} 
td, th { 
    padding-right: 5px; 
} 
 
/* style form */ 
form dt { 
    width: 100px; 
    display: block; 
    float: left; 
    clear: left; 
} 
form dd { 
    margin-left: 0; 
    float: left; 
 
} 
form #submitbutton { 
    margin-left: 100px; 
}

Cela devrait embellir, mais comme vous pouvez le voir, je ne suis pas un designer!

La base de données

Maintenant que nous avons séparé le contrôle de l'application de la vue, il est temps de regarder le modèle de notre application. Rappelez-vous que le modèle est la partie qui traite avec la base del'application de but (la soi-disant «business rules») et, dans notre cas, traite avec la base de données. Nous allons utiliser la classe Zend Framework Zend_Db_Table qui est utilisé pour trouver, ajouter, mettre à jour et supprimer des lignes d'une table d'une base de données.

Configuration

Pour utiliser Zend_Db_Table, nous avons besoin de préciser quelle base de données utiliser avec un nom d'utilisateur et mot de passe. Comme nous préfèrerions pas inclure en dur cette information dans le code de notre application, nous allons utiliser un fichier de configuration à gérer cette information.

Zend Framework provides Zend_Config to provide flexible object oriented access to configuration files. The configuration file can either an INI file or an XML file. We will use an INI file called config.ini and store it in the application/ directory: Zend Framework fournit Zend_Config pour offrir un objet flexible orienté vers l'accès à des fichiers de configuration. Le fichier de configuration peut être un fichier INI ou un fichier XML. Nous allons utiliser un fichier INI appellé config.ini et l'enregistrer dans le répertoire application application/ :

zf-tutorial/application/config.ini

[general] 
db.adapter = PDO_MYSQL 
db.params.host = localhost 
db.params.username = rob 
db.params.password = 123456 
db.params.dbname = zftest

Évidemment, vous devez utiliser votre nom d'utilisateur, mot de passe et nom de la base, pas les miens ! Pour les grandes applications avec de nombreux fichiers de configuration, vous pouvez créer un répertoire distinct, comme application/config et stocker tous vos fichiers de configuration ensemble.

Utiliser Zend_Config est vraiment simple :

$config = new Zend_Config_Ini('config.ini', 'section');

Notez que dans ce cas, Zend_Config_Ini charge une section du fichier INI, et non toutes les sections (bien que chaque section peuvent être chargés si vous le vouliez). Il supporte une notation dans le nom de la section afin de permettre le chargement de nouvelles sections. Zend_Config_Ini traite également le "point" dans le paramètre comme séparateurs hiérarchiques pour permettre le groupement des paramètres de configuration. Dans notre config.ini, les paramètres hôte, identifiant, mot de passe et base de données seront regroupés en $config->params->config.

Nous allons charger notre fichier de configuration dans notre fichier d'amorçage (public/index.php) :

zf-tutorial/public/index.php partie pertinente

... 
include "Zend/Loader.php"; 
Zend_Loader::registerAutoload(); 
 
// load configuration 
$config = new Zend_Config_Ini('../application/config.ini', 'general'); 
$registry = Zend_Registry::getInstance(); 
$registry->set('config', $config); 
 
// setup controller 
$frontController = Zend_Controller_Front::getInstance(); 
...

Nous chargeons les classes que nous allons utiliser (Zend_Config_Ini et Zend_Registry) et puis chargeons la section "general" de application/config.ini dans notre objet $config. Enfin, nous assignons l'objet $config de la base de registre de sorte qu'il puisse être récupéré ailleurs dans l'application.

A suivre 11/19...

Billet