Introduction au Zend Framework

 Apprendre Zend Framework

appendix

 Guide de référence Zend Framework


  •  Zend_Gdata
  •  Zend_Http
  •  Zend_InfoCard
  •  Zend_Json
  •  Zend_Layout
  •  Zend_Ldap
  •  Zend_Loader
  •  Zend_Locale
  •  Zend_Log
  •  Zend_Mail
  •  Zend_Markup
  •  Zend_Measure
  •  Zend_Memory
  •  Zend_Mime
  •  Zend_Navigation
  •  Zend_Oauth
  •  Zend_OpenId
  •  Zend_Paginator
  •  Zend_Pdf
  •  Zend_ProgressBar
  •  Zend_Queue
  •  Zend_Reflection
  •  Zend_Registry
  •  Zend_Rest

  •  Zend_Search_Lucene
  •  Zend_Serializer
  •  Zend_Server
  •  Zend_Service
  •  Zend_Session
  •  Zend_Soap
  •  Zend_Tag
  •  Zend_Test
  •  Zend_Text
  •  Zend_TimeSync
  •  Zend_Tool
  •  Zend_Tool_Framework
  •  Zend_Tool_Project
  •  Zend_Translate
  •  Zend_Uri
  •  Zend_Validate
  •  Zend_Version
  •  Zend_View
  •  Zend_Wildfire
  •  Zend_XmlRpc
  • ZendX_Console_Process_Unix
  • ZendX_JQuery
  • Translation 61.2% Update 2010-11-28 - Revision 23149 - Version ZF 1.11.x

    Chapitre 24. Zend_Controller

    Table des matières

    24.1. Zend_Controller - Démarrage rapide
    24.1.1. Introduction
    24.1.2. Démarrage rapide
    24.1.2.1. Créer votre disposition de système de fichiers
    24.1.2.2. Régler votre document root
    24.1.2.3. Créer vos règles de réécriture
    24.1.2.4. Créer votre fichier d'amorçage (bootstrap)
    24.1.2.5. Créer votre contrôleur d'action par défaut
    24.1.2.6. Créer votre script de vue
    24.1.2.7. Créer votre contrôleur d'erreur
    24.1.2.8. Voir le site !
    24.2. Fondations de Zend_Controller
    24.3. Le contrôleur frontal (Front Controller)
    24.3.1. Présentation générale
    24.3.2. Méthodes principales
    24.3.2.1. getInstance()
    24.3.2.2. setControllerDirectory() et addControllerDirectory
    24.3.2.3. addModuleDirectory() et getModuleDirectory()
    24.3.2.4. dispatch()
    24.3.2.5. run()
    24.3.3. Méthodes d'accès à l'environnement
    24.3.4. Paramètres du contrôleur frontal
    24.3.5. Étendre le contrôleur frontal
    24.4. L'objet Requête
    24.4.1. Introduction
    24.4.2. Les requêtes HTTP
    24.4.2.1. Accéder aux données de la requête
    24.4.2.2. Base de l'URL et sous-dossiers
    24.4.2.3. Déterminer le type de la requête
    24.4.2.4. Détecter les requêtes AJAX
    24.4.3. Sous-classer l'objet Requête
    24.5. Routeur Standard
    24.5.1. Introduction
    24.5.2. Utilisation d'un routeur
    24.5.3. Utilisation basique du routeur de réécriture
    24.5.4. Routes par défaut
    24.5.5. Base URL et sous dossiers
    24.5.6. Paramètres globaux
    24.5.7. Types de route
    24.5.7.1. Zend_Controller_Router_Route
    24.5.7.1.1. Variables par défaut
    24.5.7.1.2. Obligations et contraintes des variables
    24.5.7.1.3. Translated segments
    24.5.7.2. Zend_Controller_Router_Route_Static
    24.5.7.3. Zend_Controller_Router_Route_Regex
    24.5.7.4. Zend_Controller_Router_Route_Hostname
    24.5.7.5. Zend_Controller_Router_Route_Chain
    24.5.7.5.1. Chainer des routes via Zend_Config
    24.5.7.6. Zend_Rest_Route
    24.5.7.6.1. Utilisation de Zend_Rest_Route
    24.5.7.6.2. Zend_Rest_Route avec Zend_Config_Ini
    24.5.7.6.3. Zend_Rest_Controller
    24.5.8. Utiliser Zend_Config avec le RewriteRouter
    24.5.9. Dérivation de l'objet Router
    24.6. Le distributeur
    24.6.1. Vue d'ensemble
    24.6.2. Sous-classer le distributeur
    24.7. Contrôleurs d'action
    24.7.1. Introduction
    24.7.2. Initialisation d'objet
    24.7.3. Détournement Pre et Post-Dispatch (Hook)
    24.7.4. Accesseurs
    24.7.5. Intégration des Vues
    24.7.5.1. Initialisation des Vues
    24.7.5.2. Effectuer le rendu des Vues
    24.7.6. Méthodes utiles
    24.7.7. Sous-classer le contrôleur d'action
    24.8. Aides d'action (Helper)
    24.8.1. Introduction
    24.8.2. Initialisation des aides
    24.8.3. Le gestionnaire d'aide (Broker)
    24.8.4. Aides d'action intégrées
    24.8.4.1. ActionStack
    24.8.4.2. AutoComplete
    24.8.4.2.1. AutoCompletion avec Dojo
    24.8.4.2.2. AutoCompletion avec Scriptaculous
    24.8.4.3. ContextSwitch et AjaxContext
    24.8.4.3.1. Contextes inclus par défaut
    24.8.4.3.2. Créer ses propres contextes
    24.8.4.3.3. Affecter des contextes par action
    24.8.4.3.4. Initialiser le Context Switch
    24.8.4.3.5. Fonctionnalités avancées
    24.8.4.3.6. Fonctionnalité AjaxContext
    24.8.4.4. FlashMessenger
    24.8.4.4.1. Introduction
    24.8.4.4.2. Exemple d'utilisation basique
    24.8.4.5. JSON
    24.8.4.6. Redirector
    24.8.4.6.1. Introduction
    24.8.4.6.2. Exemples d'utilisation basique
    24.8.4.7. ViewRenderer
    24.8.4.7.1. Introduction
    24.8.4.7.2. API
    24.8.4.7.3. Exemples
    24.8.4.7.4. Utilisation avancée
    24.8.5. Écrire vos propres aides
    24.9. Objet de réponse
    24.9.1. Utilisation
    24.9.2. Manipulation des en-têtes
    24.9.3. Segments nommés
    24.9.4. Manipulation des exceptions dans l'objet de réponse
    24.9.5. Dériver l'objet de réponse
    24.10. Plugins
    24.10.1. Introduction
    24.10.2. Écrire des plugins
    24.10.3. Utilisation des plugins
    24.10.4. Récupération et manipulations des plugins
    24.10.5. Plugins inclus dans Zend Framework
    24.10.5.1. ActionStack
    24.10.5.2. Zend_Controller_Plugin_ErrorHandler
    24.10.5.2.1. Utilisation de ErrorHandler pour gérer les erreurs 404
    24.10.5.2.2. Gestion des rendus précédants de la réponse
    24.10.5.2.3. Exemples d'utilisation
    24.10.5.2.4. Exemple de contrôleur d'erreurs
    24.10.5.3. Zend_Controller_Plugin_PutHandler
    24.11. Utilisation de conventions de dossiers modulaires
    24.11.1. Introduction
    24.11.2. Spécification des dossiers de modules
    24.11.3. Routage des modules
    24.11.4. Module ou contrôleur Default global
    24.12. Exceptions avec MVC
    24.12.1. Introduction
    24.12.2. Gestion des exceptions
    24.12.3. Différents types d'exceptions que vous pouvez rencontrer

    24.1. Zend_Controller - Démarrage rapide

    24.1.1. Introduction

    Zend_Controller est le coeur du système MVC de Zend Framework. MVC équivaut à Modèle-Vue-Contrôleuret est un motif de conception ("design pattern") visant à séparer la logique d'application de la logique d'affichage. Zend_Controller_Front implémente un modèle de contrôleur frontal ("Front Controller"), dans lequel toutes les demandes sont arrêtées par le contrôleur frontal et distribuées vers différents contrôleurs d'action ("Action Controller") basés sur l'URL demandé.

    Le système Zend_Controller a été construit dans un souci d'extensibilité, soit par sous-classement des classes existantes, en écrivant les nouvelles classes qui implémentent les diverses interfaces et les classes abstraites qui forment la base de la famille de contrôleur des classes, soit par écriture de plugins ou d'aides d'action afin d'utiliser ou d'augmenter les fonctionnalités du système.

    24.1.2. Démarrage rapide

    Si vous avez besoin d'informations plus détaillées, lisez les sections suivantes. Si vous voulez juste démarrer rapidement, lisez ce qui suit.

    24.1.2.1. Créer votre disposition de système de fichiers

    La première étape est de créer votre disposition de système de fichiers. La disposition typique est la suivante :

    application/
        
    controllers/
            
    IndexController.php
        models
    /
        
    views/
            
    scripts/
                
    index/
                    
    index.phtml
            helpers
    /
            
    filters/
    html/
        .
    htaccess
        index
    .php

    24.1.2.2. Régler votre document root

    Dans votre serveur Web, faîtes pointer votre "document root" vers le dossier html du système de fichiers ci-dessus.

    24.1.2.3. Créer vos règles de réécriture

    Éditez le fichier html/.htaccess afin de lire ceci :

    RewriteEngine On
    RewriteCond 
    %{REQUEST_FILENAME} -[OR]
    RewriteCond %{REQUEST_FILENAME} -[OR]
    RewriteCond %{REQUEST_FILENAME} -d
    RewriteRule 
    ^.*$ - [NC,L]
    RewriteRule ^.*$ index.php [NC,L]
    [Note] Connaître mod_rewrite

    Les règles de réécriture ci-dessus autorisent l'accès à tous fichiers sous la racine de votre hôte virtuel. Si vous avez des fichiers que vous ne souhaitez pas exposer, vous pouvez souhaiter restreindre ces règles. Allez sur le site d'Apache pour en apprendre davantage concernant mod_rewrite.

    Si vous avez IIS 7.0, utilisez ceci pour votre configuration de réécriture :

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
         <system.webServer>
             <rewrite>
                 <rules>
                     <rule name="Imported Rule 1" stopProcessing="true">
                         <match url="^.*$" />
                         <conditions logicalGrouping="MatchAny">
                             <add input="{REQUEST_FILENAME}"
                                 matchType="IsFile" pattern=""
                                 ignoreCase="false" />
                             <add input="{REQUEST_FILENAME}"
                                 matchType="IsDirectory"
                                 pattern="" ignoreCase="false" />
                         </conditions>
                         <action type="None" />
                     </rule>
                     <rule name="Imported Rule 2" stopProcessing="true">
                         <match url="^.*$" />
                         <action type="Rewrite" url="index.php" />
                     </rule>
                 </rules>
             </rewrite>
         </system.webServer>
    </configuration>

    Les règles ci-dessus vont redirigées toute requête vers des ressources existantes (liens symboliques, fichiers non vides, ou répertoires non-vides), tout autre requête sera renvoyée vers le contrôleur frontal.

    [Note] Note

    Les règles de réécriture ci-dessus sont pour Apache ; pour des exemples de règles de réécriture pour d'autres serveurs Web, reportez-vous à la documentation du routeur.

    24.1.2.4. Créer votre fichier d'amorçage (bootstrap)

    Le fichier d'amorçage est la page vers laquelle toutes les demandes sont dirigées -- html/index.php dans ce cas-ci. Ouvrez html/index.php dans l'éditeur de votre choix et ajouter ce qui suit :

    Zend_Controller_Front::run('/chemin/vers/application/controllers');

    Ceci va instancier et distribuer le contrôleur frontal, qui conduira les demandes vers les contrôleurs d'action.

    24.1.2.5. Créer votre contrôleur d'action par défaut

    Avant de discuter des contrôleurs d'action, vous devez d'abord comprendre comment les requêtes sont dirigées dans Zend Framework. Par défaut, le premier segment d'un chemin d'URL correspond à un contrôleur, et le second à une action. Par exemple, l'URL est http://framework.zend.com/roadmap/components, le chemin est /roadmap/components, qui correspondra au contrôleur roadmap et à l'action components. Si aucune action n'est fournie, l'action index est présumé, et si aucun contrôleur n'est fourni, le contrôleur index est présumé (suivant la convention Apache qui fait correspondre un DirectoryIndex automatiquement).

    Le distributeur du Zend_Controller prend alors la valeur du contrôleur et le fait correspondre à une classe. Par défaut, il s'agit du nom du contrôleur suivi du mot Controller. Ainsi, dans notre exemple ci-dessus, le contrôleur roadmap correspond à la classe RoadmapController.

    De la même manière, la valeur de l'action correspond à une méthode de la classe contrôleur. Par défaut, la valeur est écrit en minuscule, et le mot Action est ajouté. Ainsi, dans notre exemple ci-dessus, l'action components devient componentsAction, et la méthode finale appelée est RoadmapController::componentsAction().

    Créons maintenant un contrôleur d'action par défaut et une méthode d'action. Comme noté auparavant, le contrôleur et l'action par défaut sont tous les deux nommées index. Ouvrez le fichier application/controllers/IndexController.php, et entrez ce qui suit :

    /** Zend_Controller_Action */

    class IndexController extends Zend_Controller_Action
    {
        public function 
    indexAction()
        {
            
    $this->render();
        }
    }

    Par défaut, l'aide d'action ViewRendererest activé. Ceci signifie qu'en définissant simplement une méthode d'action et un script de vue correspondant, vous obtiendrez automatiquement le rendu du contenu. Par défaut, Zend_View est utilisé en tant que couche Vue dans le MVC. Le ViewRenderer utilise le nom du contrôleur (par exemple, index) et le nom de l'action courante (par exemple, index) pour déterminer le modèle à afficher. Par défaut, le fichier modèle se termine par l'extension .phtml, cela signifie que dans l'exemple ci-dessus, le modèle index/index.phtml sera rendu. De plus, le ViewRenderer suppose automatiquement que le dossier views situé au même niveau que le dossier des contrôleurs est le dossier de base des vues, et que les scripts de vues sont dans le sous-dossier views/scripts/. Ainsi le modèle rendu sera trouvé dans application/views/scripts/index/index.phtml.

    24.1.2.6. Créer votre script de vue

    Comme mentionné dans la section précédente, les scripts de vue sont dans application/views/scripts/ ; le script de vue pour le contrôleur et l'action par défaut est donc application/views/scripts/index/index.phtml. Créer ce fichier, et saisissez ce HTML :

    <!DOCTYPE html
    PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
    >
    <
    html>
    <
    head>
      <
    meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
      <
    title>My first Zend Framework App</title>
    </
    head>
    <
    body>
        <
    h1>HelloWorld!</h1>
    </
    body>
    </
    html>

    24.1.2.7. Créer votre contrôleur d'erreur

    Par défaut, le plugin de gestion des erreursest enregistré. Ce plugin nécessite qu'un contrôleur existe pour gérer les erreurs. Par défaut, il s'agit d'un ErrorController dans le module par défaut avec une méthode errorAction :

    /** Zend_Controller_Action */

    class ErrorController extends Zend_Controller_Action
    {
        public function 
    errorAction()
        {
        }
    }

    En considérant l'architecture des dossiers vu ci-dessus, le fichier sera dans application/controllers/ErrorController.php. Vous devez aussi créer une script de vue dans application/views/scripts/error/error.phtml ; exemple de contenu possible :

    <!DOCTYPE html
    PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
    >
    <
    html>
    <
    head>
      <
    meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
      <
    title>Erreur</title>
    </
    head>
    <
    body>
        <
    h1>Erreur apparue</h1>
        <
    p>Une erreur est apparue veuillez rééssayer plus tard.</p>
    </
    body>
    </
    html>

    24.1.2.8. Voir le site !

    Avec votre premier contrôleur et votre première vue, vous pouvez maintenant démarrer votre navigateur et aller sur votre site. En supposant que exemple.fr est votre domaine, chacun des URLs suivants vous dirigera vers la page que nous avons tout juste créée :

    • http://exemple.fr/

    • http://exemple.fr/index

    • http://exemple.fr/index/index

    Vous êtes maintenant prêt à créer de nouveaux contrôleurs et de nouvelles méthodes d'action. Félicitations !

    digg delicious meneame google twitter technorati facebook

    Comments

    Loading...