Das Projekt erstellen

Um das eigene Projekt zu erstellen muss man zuerst Zend Framework herunterladen und extrahieren.

Zend Framework installieren

Der einfachste Weg um Zend Framework zusammen mit einem kompletten PHP Stack zu erhalten ist durch die Installation von » Zend Server. Zend Server hat native Installationsroutinen für Mac OSX, Windows, Fedora Core und Ubuntu, sowie ein universelles Installationspaket das mit den meisten Linux Distributionen kompatibel ist.

Nachdem Zend Server installiert wurde, können die Framework Dateien bei Max OSX und Linux unter /usr/local/zend/share/ZendFramework, und bei Windows unter C:\Program Files\Zend\ZendServer\share\ZendFramework gefunden werden. Der include_path ist dann bereits konfiguriert um Zend Framework zu verwenden.

Alternativ kann man » die letzte Version vom Zend Framework downloaden und dessen Inhalt extrahieren; man sollte sich notieren wo man das tut.

Optional kann der Pfad zum Unterverzeichnis library/ des Archivs den eigenen include_path Einstellung in der php.ini hinzugefügt werden.

Das ist es! Zend Framework ist jetzt installiert und bereit zur Verwendung.

Das Projekt erstellen

Note: zf Kommandozeilen Tool
In der eigenen Zend Framework Installation ist ein Unterverzeichnis bin/ welches die Skripte zf.sh und zf.bat, für Unix-basierende und Windows-basierende Benutzer enthält. Der absolute Pfad zu diesem Skript sollte notiert werden.
Wo immer man einer Referenz auf den Befehl zf sieht, sollte der absolute Pfad zum Skript substituiert werden. Auf Unix-basierenden Systemen, könnte man die Alias Funktionalität der Shell verwenden: alias zf.sh=path/to/ZendFramework/bin/zf.sh.
Wenn man Probleme hat das zf Kommandozeilen Tool zu konfigurieren sollte man in das Handbuch sehen.

Ein Terminal öffnen (in Windows, Start -> Run und anschließend cmd verwenden). Zum Verzeichnis in dem man das Projekt beginnen will navigieren. Anschließend den Pfad zum richtigen Skript verwenden und eines der folgenden ausführen:

  1. % zf create project quickstart

Die Ausführung dieses Kommandos erstellt die grundsätzliche Site Struktur, inklusive den initialen Controllern und Views. Der Baum sieht wie folgt aus:

  1. quickstart
  2. |-- application
  3. |   |-- Bootstrap.php
  4. |   |-- configs
  5. |   |   `-- application.ini
  6. |   |-- controllers
  7. |   |   |-- ErrorController.php
  8. |   |   `-- IndexController.php
  9. |   |-- models
  10. |   `-- views
  11. |       |-- helpers
  12. |       `-- scripts
  13. |           |-- error
  14. |           |   `-- error.phtml
  15. |           `-- index
  16. |               `-- index.phtml
  17. |-- library
  18. |-- public
  19. |   |-- .htaccess
  20. |   `-- index.php
  21. `-- tests
  22.     |-- application
  23.     |   `-- bootstrap.php
  24.     |-- library
  25.     |   `-- bootstrap.php
  26.     `-- phpunit.xml

Wenn man an diesem Punkt, Zend Framework dem eigenen include_path nicht hunzugefügt hat, empfehlen wir Ihn entweder in das eigene library/ Verzeichnis zu kopieren oder zu symlinken. In jedem Fall sollte man entweder das library/Zend/ Verzeichnis der Zend Framework Installation rekursiv in das library/ Verzeichnis des Projekts kopieren oder symlinken. Auf unix-artigen Systemen würde das wie folgt aussehen:

  1. # Symlink:
  2. % cd library; ln -s path/to/ZendFramework/library/Zend .
  3.  
  4. # Copy:
  5. % cd library; cp -r path/to/ZendFramework/library/Zend .

Auf Windows Systemen ist es am einfachsten das vom Explorer zu tun.

Jetzt da das Projekt erstellt wurde, sind die hauptsächlichen Artefakte die man verstehen sollte, die Bootstrap, die Konfiguration, die Action Controller und die Views.

Die Bootstrap

Die Bootstrap Klasse definiert welche Ressourcen und Komponenten zu initialisieren sind. Standardmäßig wird Zend Framework's Front Controller initialisiert und er verwendet application/controllers/ als Standardverzeichnis in dem nach Action Controllern nachgesehen wird (mehr davon später). Die Klasse sieht wie folgt aus:

  1. // application/Bootstrap.php
  2.  
  3. class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
  4. {
  5. }

Wie man sieht ist nicht viel notwendig um zu beginnen.

Konfiguration

Wärend Zend Framework selbst konfigurationslos ist, ist es oft notwendig die eigene Anwendung zu konfigurieren. Die Standardkonfiguration wird in application/configs/application.ini platziert und enthält einige grundsätzliche Direktiven für die Einstellung der PHP Umgebung (zum Beispiel ein- und ausschalten der Fehlermeldungen), zeigt den Pfad zur eigenen Bootstrap Klasse (wie auch dessen Klassenname), und den Pfad zu den eigenen Action Controllern. Das sieht wie folgt aus:

  1. ; application/configs/application.ini
  2.  
  3. [production]
  4. phpSettings.display_startup_errors = 0
  5. phpSettings.display_errors = 0
  6. includePaths.library = APPLICATION_PATH "/../library"
  7. bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
  8. bootstrap.class = "Bootstrap"
  9. appnamespace = "Application"
  10. resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
  11. resources.frontController.params.displayExceptions = 0
  12.  
  13. [staging : production]
  14.  
  15. [testing : production]
  16. phpSettings.display_startup_errors = 1
  17. phpSettings.display_errors = 1
  18.  
  19. [development : production]
  20. phpSettings.display_startup_errors = 1
  21. phpSettings.display_errors = 1

Verschiedene Dinge sollten über diese Datei gesagt werden. Erstens kann man, wenn INI-artige Konfigurationen verwendet werden, direkt auf Konstanten referenzieren und Sie erweitern; APPLICATION_PATH selbst ist eine Konstante. Zusätzlich ist zu beachten das es verschiedene definierte Sektionen gibt: production, staging, testing, und development. Die letzten drei verweisen auf Einstellungen der "production" Umgebung. Das ist ein nützlicher Weg die Konfiguration zu organisieren und stellt sicher das die richtigen Einstellungen in jeder Stufe der Anwendungsentwicklung vorhanden sind.

Action Controller

Die Action Controller der Anwendung enthalten den Workflow der Anwendung und mappen eigene Anfragen auf die richtigen Modelle und Views.

Ein Action Controller sollte ein oder mehrere Methoden haben die auf "Action" enden; diese Methoden können über das Web abgefragt werden. Standardmäßig folgen Zend Framework URL's dem Schema /controller/action wobei "controller" auf den Namen des Action Controllers verweist (ohne den "Controller" Suffix) und "action" auf eine Action Methode verweist (ohne den "Action" Suffix).

Typischerweise benötigt man immer einen IndexController, der ein Fallback Controller ist und auch als Homepage der Site arbeitet, und einen ErrorController der verwendet wird um Dinge wie HTTP 404 Fehler zu zeigen (wenn der Controller oder die Action nicht gefunden wird) und HTTP 500 Fehler (Anwendungsfehler).

Der standardmäßige IndexController ist wie folgt:

  1. // application/controllers/IndexController.php
  2.  
  3. class IndexController extends Zend_Controller_Action
  4. {
  5.  
  6.     public function init()
  7.     {
  8.         /* Den Action Controller hier initialisieren */
  9.     }
  10.  
  11.     public function indexAction()
  12.     {
  13.         // Action Body
  14.     }
  15. }

Und der standardmäßige ErrorController ist wie folgt:

  1. // application/controllers/ErrorController.php
  2.  
  3. class ErrorController extends Zend_Controller_Action
  4. {
  5.  
  6.     public function errorAction()
  7.     {
  8.         $errors = $this->_getParam('error_handler');
  9.  
  10.         switch ($errors->type) {
  11.             case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:
  12.             case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
  13.             case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
  14.  
  15.                 // 404 Fehler -- Controller oder Action nicht gefunden
  16.                 $this->getResponse()->setHttpResponseCode(404);
  17.                 $this->view->message = 'Page not found';
  18.                 break;
  19.             default:
  20.                 // Anwendungsfehler
  21.                 $this->getResponse()->setHttpResponseCode(500);
  22.                 $this->view->message = 'Application error';
  23.                 break;
  24.         }
  25.  
  26.         $this->view->exception = $errors->exception;
  27.         $this->view->request   = $errors->request;
  28.     }
  29. }

Es ist zu sehen das (1) der IndexController keinen echten Code enthält, und (2) der ErrorController auf eine "view" Eigenschaft verweist. Das führt schon zu unserem nächsten Subjekt.

Views

Views werden im Zend Framework in reinem alten PHP geschrieben. View Skripte werden unter application/views/scripts/ platziert, wo Sie weiters kategorisiert werden indem der Name des Controllers verwendet wird. In unserem Fall haben wir einen IndexController und einen ErrorController, und deshalb haben wir entsprechende index/ und error/ Unterverzeichnisse in unserem View Skript Verzeichnis. In diesem Unterverzeichnissen finden und erstellen wir anschließend View Skripte die jeder ausgeführten Controller Action entsprechen; im Standardfall haben wir die View Skripte index/index.phtml und error/error.phtml.

View Skripte können jedes Markup enthalten das man haben will, und verwenden das öffnende <?php Tag und das schließende ?> Tag um PHP Direktiven einzufügen.

Das folgende wird standardmäßig für das index/index.phtml View Skript installiert:

  1. <!-- application/views/scripts/index/index.phtml -->
  2. <style>
  3.  
  4.     a:link,
  5.     a:visited
  6.     {
  7.         color: #0398CA;
  8.     }
  9.  
  10.     span#zf-name
  11.     {
  12.         color: #91BE3F;
  13.     }
  14.  
  15.     div#welcome
  16.     {
  17.         color: #FFFFFF;
  18.         background-image: url(http://framework.zend.com/images/bkg_header.jpg);
  19.         width:  600px;
  20.         height: 400px;
  21.         border: 2px solid #444444;
  22.         overflow: hidden;
  23.         text-align: center;
  24.     }
  25.  
  26.     div#more-information
  27.     {
  28.         background-image: url(http://framework.zend.com/images/bkg_body-bottom.gif);
  29.         height: 100%;
  30.     }
  31.  
  32. </style>
  33. <div id="welcome">
  34.     <h1>Willkommen zum <span id="zf-name">Zend Framework!</span><h1 />
  35.     <h3>Das ist die Hauptseite unseres Projekts<h3 />
  36.     <div id="more-information">
  37.         <p>
  38.             <img src="http://framework.zend.com/images/PoweredBy_ZF_4LightBG.png" />
  39.         </p>
  40.  
  41.         <p>
  42.             Hilfreiche Links: <br />
  43.             <a href="http://framework.zend.com/">Zend Framework Website</a> |
  44.             <a href="http://framework.zend.com/manual/en/">Zend Framework
  45.                 Handbuch</a>
  46.         </p>
  47.     </div>
  48. </div>

Das error/error.phtml View Skript ist etwas interessanter da es einige PHP Konditionen verwendet:

  1. <!-- application/views/scripts/error/error.phtml -->
  2. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN";
  3.     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd>
  4. <html xmlns="http://www.w3.org/1999/xhtml">
  5. <head>
  6.   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  7.   <title>Zend Framework Standardanwendung</title>
  8. </head>
  9. <body>
  10.   <h1>Ein Fehler ist aufgetreten</h1>
  11.   <h2><?php echo $this->message ?></h2>
  12.  
  13.   <?php if ('development' == $this->env): ?>
  14.  
  15.   <h3>Information der Exception:</h3>
  16.   <p>
  17.       <b>Nachricht:</b> <?php echo $this->exception->getMessage() ?>
  18.   </p>
  19.  
  20.   <h3>Stack Trace:</h3>
  21.   <pre><?php echo $this->exception->getTraceAsString() ?>
  22.   </pre>
  23.  
  24.   <h3>Anfrage Parameter:</h3>
  25.   <pre><?php echo var_export($this->request->getParams(), 1) ?>
  26.   </pre>
  27.   <?php endif ?>
  28.  
  29. </body>
  30. </html>

Einen virtuellen Host erstellen

Für die Zwecke dieses Quickstarts nehmen wir an das der » Apache Web Server verwendet wird. Zend Framework arbeitet auch perfekt mit anderen Web Server -- inklusive Microsoft Internet Information Server, Lighttpd, Nginx und andere -- aber die meisten Entwickler sollten zumindest mit Apache umgehen können, und es bietet eine einfache Einführung in Zend Framework's Verzeichnisstruktur und die Möglichkeiten des Rewritings.

Um den eigenen VHost zu erstellen muss man den Ort der eigenen httpd.conf Datei kennen und potentiell auch wo andere Konfigurationsdateien platziert sind. Einige übliche Orte sind:

  • /etc/httpd/httpd.conf (Fedora, RHEL, und andere)

  • /etc/apache2/httpd.conf (Debian, Ubuntu, und andere)

  • /usr/local/zend/etc/httpd.conf (Zend Server auf *nix Maschinen)

  • C:\Program Files\Zend\Apache2\conf (Zend Server auf Windows Maschinen)

In der eigenen httpd.conf (oder httpd-vhosts.conf auf anderen Systemen) muss man zwei Dinge tun. Erstens sicherstellen das der NameVirtualHost definiert ist; typischerweise wird man Ihn auf einen Wert von "*:80" setzen. Zweitens einen virtuellen Host definieren:

  1. <VirtualHost *:80>
  2.     ServerName quickstart.local
  3.     DocumentRoot /path/to/quickstart/public
  4.  
  5.     SetEnv APPLICATION_ENV "development"
  6.  
  7.     <Directory /path/to/quickstart/public>
  8.         DirectoryIndex index.php
  9.         AllowOverride All
  10.         Order allow,deny
  11.         Allow from all
  12.     </Directory>
  13. </VirtualHost>

Es gilt verschiedene Dinge zu beachten. Erstens ist zu beachten dass die DocumentRoot Einstellung das Unterverzeichnis public des eigenen Projekts spezifiziert; dies bedeutet das nur Dateien in diesem Verzeichnis jemals direkt vom Server serviert werden. Zweitens sind die Direktiven AllowOverride, Order, und Allow zu beachten; diese erlauben uns htacess Dateien in unserem Projekt zu verwenden. Wärend der Entwicklung ist das eine gute Praxis, da es verhindert den Web Server konstant zurücksetzen zu müssen wenn man Änderungen in den Site Direktiven macht; trotzdem sollte man in der Produktion den Inhalt der htacess Datei in die Server Konfiguration verschieben und diese deaktivieren. Drittens ist die SetEnv Direktive zu beachten. Was wir hier erledigen ist das Setzen einer Umgebungsvariable für den eigenen virtuellen Host; diese Variable wird in der index.php geholt und verwendet um die Konstante APPLICATION_ENV für unsere Zend Framework Anwendung zu setzen. In der Produktion kann diese Direktive unterdrückt werden (in diesem Fall wird es auf den Standardwert "production" verweisen) oder Sie explizit auf "production" setzen.

Letztendlich muss man einen Eintrag in der eigenen hosts Datei hinzufügen welche mit dem Wert korrespondiert der in der ServerName Direktive plaziert wurde. Auf *nix-artigen Systemen ist das normalerweise /etc/hosts; auf Windows findet man typischerweise C:\WINDOWS\system32\drivers\etc in Ihm. Unabhängig vom System sieht der Eintrag wie folgt aus:

  1. 127.0.0.1 quickstart.local

Den Webserver starten (oder ihn Restarten), und man sollte bereit sein weiterzumachen.

Checkpoint

An diesem Punkt sollte man in der Lage sein die initiale Zend Framework Anwendung auszuführen. Der Browser sollte auf den Servernamen zeigen welcher im vorherigen Abschnitt konfiguriert wurde; ab diesem Zeitpunkt sollte man in der Lage sein die Startseite zu sehen.

blog comments powered by Disqus