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.

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.

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.

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