Introduction to Zend Framework

 Learning Zend Framework

appendix

 Zend Framework Reference


  •  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 96.1% Update 2010-11-28 - Revision 23448 - Version ZF 1.11.x

    Chapter 24. Zend_Controller

    Table of Contents

    24.1. Zend_Controller Schnellstart
    24.1.1. Einführung
    24.1.2. Schnelleinstieg
    24.1.2.1. Ordnerstruktur anlegen
    24.1.2.2. Wurzelverzeichnis setzen
    24.1.2.3. Rewrite-Regeln erstellen
    24.1.2.4. Boostrap-Datei erstellen
    24.1.2.5. Den Action-Controller für die Startseite erstellen
    24.1.2.6. Das View-Script erstellen
    24.1.2.7. Fehler-Controller erstellen
    24.1.2.8. Die Seite ansehen!
    24.2. Zend_Controller Grundlagen
    24.3. Der Front Controller
    24.3.1. Übersicht
    24.3.2. Grundlegende Methoden
    24.3.2.1. getInstance()
    24.3.2.2. setControllerDirectory() und addControllerDirectory()
    24.3.2.3. addModuleDirectory() und getModuleDirectory()
    24.3.2.4. dispatch()
    24.3.2.5. run()
    24.3.3. Methoden für Umgebungszugriff
    24.3.4. Front-Controller-Parameter
    24.3.5. Erweitern des Front-Controllers
    24.4. Das Request Objekt
    24.4.1. Einführung
    24.4.2. HTTP Anfragen
    24.4.2.1. Auf Request Daten zugreifen
    24.4.2.2. Basis Url und Unterverzeichnisse
    24.4.2.3. Erkennen der Anfrage Methode
    24.4.2.4. Erkennen von AJAX Anfragen
    24.4.3. Vererben des Anfrage Objektes
    24.5. Der Standard Router
    24.5.1. Einführung
    24.5.2. Einen Router verwenden
    24.5.3. Grundsätzliche Rewrite Router Operationen
    24.5.4. Standard Routen
    24.5.5. Basis URL und Unterverzeichnisse
    24.5.6. Globale Parameter
    24.5.7. Router Typen
    24.5.7.1. Zend_Controller_Router_Route
    24.5.7.1.1. Variable Standards
    24.5.7.1.2. Variable Anforderungen
    24.5.7.1.3. Übersetzte Segmente
    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. Verkettete Routen über Zend_Config
    24.5.7.6. Zend_Rest_Route
    24.5.7.6.1. Verwendung von Zend_Rest_Route
    24.5.7.6.2. Zend_Rest_Route mit Zend_Config_Ini
    24.5.7.6.3. Zend_Rest_Controller
    24.5.8. Zend_Config mit dem RewriteRouter verwenden
    24.5.9. Erben vom Router
    24.6. Der Dispatcher
    24.6.1. Überblick
    24.6.2. Erben vom Dispatcher
    24.7. Action Controller
    24.7.1. Einführung
    24.7.2. Objekt Initialisierung
    24.7.3. Pre- und Post-Dispatch Hooks
    24.7.4. Zugriffe
    24.7.5. View Integration
    24.7.5.1. View Initialisierung
    24.7.5.2. Rendern von Views
    24.7.6. Nützliche Methoden
    24.7.7. Erweitern des Aktion Controllers
    24.8. Action Helfer
    24.8.1. Einführung
    24.8.2. Helfer Initialisierung
    24.8.3. Der Helfer Broker
    24.8.4. Eingebaute Aktions Helfer
    24.8.4.1. ActionStack
    24.8.4.2. AutoComplete
    24.8.4.2.1. AutoCompletion mit Dojo
    24.8.4.2.2. AutoCompletion mit Scriptaculous
    24.8.4.3. ContextSwitch und AjaxContext
    24.8.4.3.1. Vorhandene Standard Kontexte
    24.8.4.3.2. Eigene Kontexte erstellen
    24.8.4.3.3. Kontexte per Aktion setzen
    24.8.4.3.4. Kontext Switching initialisieren
    24.8.4.3.5. Zusätzliche Funktionalitäten
    24.8.4.3.6. AjaxContext Funktionalität
    24.8.4.4. FlashMessenger
    24.8.4.4.1. Einführung
    24.8.4.4.2. Beispiel einer standardmäßigen Verwendung
    24.8.4.5. JSON
    24.8.4.6. Redirector
    24.8.4.6.1. Einführung
    24.8.4.6.2. Beispiel für die grundsätzliche Verwendung
    24.8.4.7. ViewRenderer
    24.8.4.7.1. Einführung
    24.8.4.7.2. API
    24.8.4.7.3. Grundsätzliches Beispiel der Verwendung
    24.8.4.7.4. Erweiterte Beispiel der Verwendung
    24.8.5. Schreiben eigener Helfer
    24.9. The Response Object
    24.9.1. Usage
    24.9.2. Manipulating Headers
    24.9.3. Named Segments
    24.9.4. Testing for Exceptions in the Response Object
    24.9.5. Subclassing the Response Object
    24.10. Plugins
    24.10.1. Einführung
    24.10.2. Plugins schreiben
    24.10.3. Plugins verwenden
    24.10.4. Empfangen und Manipulieren von Plugins
    24.10.5. Plugins die in der Standard Distribution enthalten sind
    24.10.5.1. ActionStack
    24.10.5.2. Zend_Controller_Plugin_ErrorHandler
    24.10.5.2.1. Den Fehler Handler als 404 Handler verwenden
    24.10.5.2.2. Zuvor gerenderte Ausgaben erhalten
    24.10.5.2.3. Beispiele für die Verwendung des Plugins
    24.10.5.2.4. Beispiel für den Fehler Controller
    24.10.5.3. Zend_Controller_Plugin_PutHandler
    24.11. Eine konventionelle modulare Verzeichnis Struktur verwenden
    24.11.1. Einführung
    24.11.2. Verzeichnisse für Modul Controller spezifizieren
    24.11.3. Zu Modulen routen
    24.11.4. Modul oder globaler Standard Controller
    24.12. MVC Ausnahmen
    24.12.1. Einführung
    24.12.2. Behandeln von Ausnahmen
    24.12.3. MVC Ausnahme die auftreten können

    24.1. Zend_Controller Schnellstart

    24.1.1. Einführung

    Zend_Controller ist das Herz des MVC Systems des Zend Frameworks. MVC bedeutet Model-View-Controller und ist ein Entwurfsmuster, das darauf abzielt, Anwendungslogik von Anzeigelogik zu trennen. Zend_Controller_Front implementiert ein Front-Controller-Entwurfsmuster, das vorschreibt, dass alle Anfragen vom Front-Controller abgefangen und abhängig von der angeforderten URL an individuelle Action-Controller weitergeleitet werden.

    Das Zend_Controller System wurde im Sinne der Erweiterungsmöglichkeiten entwickelt, entweder durch Erstellen von Subklassen, welche die bestehenden Klassen erweitern, oder durch Erstellen neuer Klassen, welche die verschiedenen Interfaces und abstrakten Klassen implementieren, welche das Fundament der Controller Klassenfamilie bilden, oder durch das Schreiben von Plugins und Action Helper, um die Funktionalität des Systems zu erweitern oder zu verändern.

    24.1.2. Schnelleinstieg

    Wer mehr und tiefergehende Informationen benötigt, sollte die folgenden Abschnitte lesen. Dieser Abschnitt zeigt, wie man auf dem schnellsten Weg ein System lauffähig bekommt.

    24.1.2.1. Ordnerstruktur anlegen

    Der erste Schritt ist, die Ordnerstruktur für das Framework anzulegen. Typischerweise ist das die folgende:

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

    24.1.2.2. Wurzelverzeichnis setzen

    Der Webserver ist so zu konfigurieren, dass das Wurzelverzeichnis (Document Root) des Webservers im html/-Verzeichnis der obigen Ordnerstruktur liegt.

    24.1.2.3. Rewrite-Regeln erstellen

    In die Datei html/.htaccess aus der Struktur von oben gehört der folgende Code:

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

    Die obigen Rewrite Regeln erlauben es auf jede Datei im Document Root des eigenen virtuellen Host's zuzugreifen. Wenn es Dateien gibt die man auf diesem Weg nicht bereitstellen will, muss man in seinen Regeln restriktiver sein. Gehe zur Apache WebSite und lerne mehr über mod_rewrite.

    Wenn man IIS 7.0 verwendet, sollte man die folgende Rewrite Konfiguration verwenden:

    <?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>

    Die obige Regel routet Anfragen entsprechend auf existierende Ressourcen (existierende Symlinks, nicht-leere Dateien, oder nicht-leere Verzeichnisse), und alle anderen Anfragen an den Front Controller.

    [Note] Note

    Die Rewrite-Regel oben ist für den Apache-Webserver; Beispiele für andere Webserver finden sich in der Router-Dokumentation.

    24.1.2.4. Boostrap-Datei erstellen

    Die Bootstrap-Datei ist die Datei, durch die alle Anfragen geleitet werden -- html/index.php in unserem Fall. In die Datei html/index.php gehört der folgende Code:

    Zend_Controller_Front::run('/path/to/app/controllers');

    Das instanziert und führt den Front-Controller aus, der Anfragen an den Action-Controller weitergibt.

    24.1.2.5. Den Action-Controller für die Startseite erstellen

    Bevor wir von Action-Controllern reden, sollte erst verstanden werden, wie Anfragen im Zend Framework behandelt werden. Standardmäßig zeigt das erste Segment eines URL auf einen Controller und das zweite Segment auf eine Aktion, welche dieser Controller ausführen soll. Als Beispiel sei der URL http://framework.zend.com/roadmap/components gegeben. Der Pfad ist /roadmap/components, was die Anfrage zum Controller roadmap und dort in die Aktion components leitet. Wenn keine Aktion angegeben wird, wird index als Standard-Aktion angenommen, und wenn kein Controller angegeben wird, wird auch index als Standard-Controller angenommen. (Das folgt der Apache-Konvention, die einen DirectoryIndex automatisch findet).

    Der Dispatcher von Zend_Controller nimmt dann den Wert, der als Controller angegeben ist, und schließt daraus auf eine passende Klasse. In der normalen Einstellung des Dispatchers wird der erste Buchstabe jedes Wortes im Controller-Namen groß geschrieben (Title-case), und dann das Wort Controller angehängt. Das bedeutet für unser Beispiel, dass die Anfrage nach dem Controller roadmap an die Klasse RoadmapController weitergeleitet wird.

    Auf ähnliche Art wird die Methode für die Aktion bestimmt, die der Controller ausführen soll. In der Grundeinstellung wird die angefragte Aktion komplett kleingeschrieben und das Wort Action wird angehängt. In unserem Beispiel wird also die Aktion components zu componentsAction(), insgesamt wird also die Methode RoadmapController::componentsAction() aufgerufen.

    Also, weiter gehts. Jetzt wird ein Startseiten-Controller und eine dazugehörige Standard-Aktionsmethode erstellt. Wie vorhin bereits erwähnt, heißen Standard-Controller und -Aktion beide index. Also gehört in die Datei application/controllers/IndexController.php folgendes:

    /** Zend_Controller_Action */
    class IndexController extends Zend_Controller_Action
    {
        public function 
    indexAction()
        {
        }
    }

    Normalerweise ist ein Action-Helper namens ViewRenderer eingeschaltet. Das bedeutet, dass sofort, wenn eine leere Aktionsmethode und ein passendes View-Script existieren, Inhalte gerendert werden. Standardmäßig wird die Klasse Zend_View als View-Schicht im Zend-Framework MVC verwendet. Der ViewRenderer zaubert ein wenig, und benutzt Controller- (hier: index) und Aktionsname (hier: index), um herauszufinden, welches Template er rendern soll. Ohne dass man dies ändert, haben Templates die Dateiendung .phtml, das heißt also für unser Beispiel, dass das Template index/index.phtml gerendert wird. Zusätzlich nimmt der ViewRenderer automatisch an, dass das Verzeichnis views/ auf der selben Ebene wie das Controller Verzeichnis das View-Basisverzeichnis ist, und dass die eigentlichen View-Scripts in dessen Unterverzeichnis views/scripts/ liegen. Insgesamt hat also das Template, das gerendert wird, den Pfad application/views/scripts/index/index.phtml.

    24.1.2.6. Das View-Script erstellen

    Wie oben beschrieben, werden View-Scripts im Verzeichnis application/views/scripts/ abgelegt; das View-Script für den Starseiten-Controller und dessen Standard-Aktion hat den Pfad application/views/scripts/index/index.phtml. Da hinein kommt das folgende 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>Meine erste Zend Framework-Seite</title>
    </
    head>
    <
    body>
        <
    h1>Hallo Welt!</h1>
    </
    body>
    </
    html>

    24.1.2.7. Fehler-Controller erstellen

    Standardmäßig ist das Error-Handler-Plugin registriert. Dieses Plugin erwartet, dass ein Controller existiert, der Fehler behandelt. Ohne weitere Einstellungen erwartet es einen ErrorController im Default-Modul mit einer Methode namens errorAction():

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

    In der bereits angesprochenen Ordnerstruktur gehört dieser Code in die Datei application/controllers/ErrorController.php. Außerdem muss auch ein View-Script application/views/scripts/error/error.phtml erstellt werden; Beispielhaft könnte sein Inhalt so aussehen:

    <!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>Fehler</title>
    </
    head>
    <
    body>
        <
    h1>Ein Fehler ist aufgetreten</h1>
        <
    p>Ein Fehler ist aufgetreten;
           
    bitte versuchen Sie es später noch einmal.</p>
    </
    body>
    </
    html>

    24.1.2.8. Die Seite ansehen!

    Jetzt, wo der erste Controller und das erste View-Script geschrieben sind, kann der Browser aufgerufen und die Seite angesehen werden. Wäre example.com die Domain der Zend Framework-Installation, dann würde jeder der folgenden URLs auf die Seite zeigen, die wir gerade erstellt haben:

    • http://example.com/

    • http://example.com/index

    • http://example.com/index/index

    Herzlichen Glückwunsch, Sie sind jetzt bereit, weitere Controller und Aktionsmethoden zu erstellen und Ihrer Seite damit Leben einzuhauchen.

    digg delicious meneame google twitter technorati facebook

    Comments

    Loading...