FAQ Zend Framework
FAQ Zend FrameworkConsultez toutes les FAQ
Nombre d'auteurs : 16, nombre de questions : 39, dernière mise à jour : 15 juin 2021
- Qu'est-ce que ZF ?
- Quelle arborescence adopter pour mon application ?
- Comment utiliser le Zend Framework sur un hébergement mutualisé ?
- J'ai une erreur 404 en chargeant une page URL rewritée
- Comment utiliser Zend Framework sur un hébergement Free.fr ?
- Comment gérer les erreurs serveur (404, 500, etc.) ?
- Comment charger automatiquement les classes ?
- Où dois-je modifier ma variable d'environnement pour dire si je suis en dev ou en prod ?
Zend Framework est un framework de développement d'applications PHP. Il se situe au même niveau que symfony, CakePHP et d'autres frameworks. C'est un framework de type "glue" avec des tendances "full-stack".
Zend Framework est résolument orienté vers un développement à base de PHP5 et de ses capacités Objet. L'équipe de développement en construit tous les composants selon une procédure qualité exemplaire (validations, standards de codage, documentation, tests...). Les développeurs utilisent des design patterns où leur utilisation est judicieuse (décision collégiale), par exemple MVC (Zend_Controller), Singleton (Zend_Registry) etc.
Pour contribuer à ZF, il faut signer un CLA (Contributor Licence Agreement) qui permet de protéger les contributions de tous les auteurs.
Pour utiliser Zend Framework, il faut avoir au moins PHP 5.1 et il est fortement recommandé d'avoir la main sur la configuration du serveur Web (serveur dédié).
Le Zend Framework est souple sur l'arborescence des applications qui l'utilisent. Cependant, certaines solutions sont plus ou moins recommandées et recommandables.
La structure basique, que l'on utilise généralement pour débuter, est celle-ci :
/
application // Comporte les fichiers relatifs à votre application
/
config // Les fichiers de configuration de votre application
/
controllers // Les contrôleurs de votre application
/
models // Les modèles de votre application
/
views // Les vues (.phtml)
/
library // Les bibliothèques externes que votre application utilise
/
Zend // La bibliothèque du Zend Framework bien sûr
/
(autres bibliothèques)// Éventuellement d'autres bibliothèques
/
public // Les ressources "publiques" de votre application
/
images // Les images
/
scripts // Les scripts (javascript)
/
styles // Les feuilles de style (CSS)
/
tmp // Un dossier pour les données temporaires que va utiliser votre appli.
/
sessions // Les sessions PHP éventuellement
/
cache // Le cache pour les requêtes SQL ou pour les vues
/
view_compiles // Les vues compilés (pour un moteur de template par ex.)
index.
php // Le fichier bootstrap de votre application
Bien que cette arborescence soit simple pour les petites applications, cela devient compliquer à gérer lorsque l'application devient conséquente. Généralement, on sépare dans ce cas les contrôleurs/modèles/vues en modules. La nouvelle arborescence devient donc :
/
application // Comporte les fichiers relatifs à votre application
/
config // Les fichiers de configuration de votre application
/
models // Les modèles utilisés par plusieurs modules
/
modules // Les modules de l'application
/
(module 1
) // Le dossier pour le module 1 (par ex. forum)
/
config // Éventuellement les fichiers de configuration du module
/
controllers // Les contrôleurs spécifiques au module
/
models // Les modèles spécifiques au module
/
views // Les vues spécifique au module
/
(module 2
) // Le dossier pour le module 2 (par ex. blog)
/
controllers // Les contrôleurs spécifiques au module
/
models // Les modèles spécifiques au module
/
views // Les vues spécifique au module
/
(module n) // De même pour tous les autres modules
/
controllers // Les contrôleurs spécifiques au module
/
models // Les modèles spécifiques au module
/
views // Les vues spécifique au module
/
public
/
images
/
scripts
/
styles
/
library
/
Zend
/
(autres)
/
tmp
/
sessions
/
cache
/
view_compiles
index.
php
Si vous utilisez une arborescence en modules, vous devrez spécifier les dossiers des modules dans le fichier bootstrap :
$controller
->
addModuleDirectory('
path/to/application/modules/
'
);
Zend Framework ne vous fige pas à une seule arborescence, vous pouvez très bien faire un mélange des différentes arborescences disponibles pour arriver à la structure la plus efficace pour votre application.
Lien : Choisir son arborescence (Wiki du Zend Framework Anglais)
Lien : http://framework.zend.com/wiki/display/ZFPROP/Zend+Framework+Default+Project+Structure+-+Wil+Sinclair
Le Zend Framework a besoin de PHP >= 5.1.4, n'importe quel hébergeur mutualisé proposant cette version de PHP permet d'utiliser le Zend Framework.
À noter que ce framework est à vocation professionnelle et qu'il est préférable d'avoir la main sur son hébergement, sans quoi il n'est pas possible d'en profiter pleinement.
Si vous envisagez d'utiliser des URLs réécrites (URL Rewriting), assurez-vous que votre hébergeur mette à disposition mod_rewrite sous Apache. Son absence n'empêche pas l'utilisation de ZF mais complique largement l'utilisation du pattern MVC.
Lien : Comment utiliser PHP5 avec un hébergeur qui ne le propose pas par défaut ?
Lien : Comment utiliser la réécriture d'URL avec un hébergeur qui n'a pas mod_rewrite ?
Lien : Le modèle MVC et le contrôleur sous PHP
Lien : [Récapitulatif] Zend Framework sur serveurs mutualisés
Erreur 404 veut dire que le mod_rewrite d'apache n'est pas entré en fonction.
Il faut activer le mod_rewrite d'apache, ou alors utiliser l'URL http://myhost.tld/index.php/admin/ (avec AcceptPathInfo à On dans la conf d'apache).
Il faut passer de PHP4 à PHP5 au moyen d'un fichier .htaccess et ajouter un répertoire "include" à la racine du site, en y copiant le Zend Framework.
À noter que Free.fr n'autorise pas le mod_rewrite sous Apache, ce qui empêche d'utiliser le MVC.
Lien : Comment utiliser le Zend Framework sur un hébergement mutualisé ?
S'il existe, Zend Framework va utiliser par défaut le contrôleur ErrorController et son action errorAction() pour gérer les erreurs (contrôleur introuvable, action introuvable, erreur 500, etc.).
Il vous suffit donc de créer ce contrôleur pour gérer ces erreurs.
class ErrorController
{
public
function
errorAction()
{
$this
->
view->
message =
"Erreur !"
;
}
}
Avec ce contrôleur et la vue qui va avec, vous aurez le message "Erreur !" si vous allez sur un lien inexistant.
<?php
/**
* Cette classe gère les erreurs de navigation (page inexistante, etc).
* Une partie du code est tiré d'un exemple de Julien Pauli (http://julien-pauli.developpez.com).
*/
class
ErrorController
{
private
$_exception
;
private
static
$errorMessage
;
private
static
$httpCode
;
public
function
preDispatch()
{
$this
->
_exception =
$this
->
_getParam('error_handler'
);
switch
($this
->
_exception->
type) {
case
Zend_Controller_Plugin_ErrorHandler::
EXCEPTION_NO_CONTROLLER:
case
Zend_Controller_Plugin_ErrorHandler::
EXCEPTION_NO_ACTION:
self
::
$httpCode
=
404
;
self
::
$errorMessage
=
'Page introuvable'
;
break
;
case
Zend_Controller_Plugin_ErrorHandler::
EXCEPTION_OTHER:
switch
(get_class($this
->
_exception->
exception
)) {
case
'Zend_View_Exception'
:
self
::
$httpCode
=
500
;
self
::
$errorMessage
=
'Erreur de traitement d
\'
une vue'
;
break
;
case
'Zend_Db_Exception'
:
self
::
$httpCode
=
503
;
self
::
$errorMessage
=
'Erreur de traitement dans la base de données'
;
break
;
case
'Metier_Exception'
:
self
::
$httpCode
=
200
;
self
::
$errorMessage
=
$this
->
_exception->
exception
->
getMessage();
break
;
default
:
self
::
$httpCode
=
500
;
self
::
$errorMessage
=
'Erreur inconnue : '
.
$this
->
_exception->
exception
->
getMessage();
break
;
}
break
;
}
}
public
function
errorAction()
{
$this
->
view->
message =
self
::
$errorMessage
;
$this
->
view->
httpCode =
self
::
$httpCode
;
// Affiche la vue.
echo $this
->
view->
render("erreur/erreur.tpl"
);
}
}
La solution la plus classique est d'utiliser la méthode statique registerAutoload() de la classe Zend_Loader :
require_once '
Zend/Loader.php
'
;
Zend_Loader::
registerAutoload();
Il est recommandé d'utiliser la technique ci-dessus. Pour information, voici le code utilisé en interne :
spl_autoload_register(array('
Zend_Loader
'
,
'
autoload
'
));
Vos classes seront alors automatiquement chargées, et vous n'aurez plus besoin de le faire "manuellement", à partir d'appels à require_once par exemple.
Notez que l'autoloading du Zend_Loader suit la nomenclature recommandée par le Zend Framework concernant le nom des classes.
Ainsi, avec l'appel suivant :
$classe
=
new Application_Member_Abstract();
La classe sera recherchée dans le script Application/Member/Abstract.php.
À noter également que l'autoloading peut avoir un impact négatif sur les performances de l'application.
Depuis la version 1.8 , la méthode à quelque peu changée, il faut maintenant appeler la méthode getInstance();
require_once '
Zend/Loader/Autoloader.php
'
;
Zend_Loader_Autoloader::
getInstance();
Si vous avez utiliser le Quick Start de Zend Framework ou les outils permettant de créer une architecture de projet, cette variable d'environnement se trouve dans le fichier .htaccess