ACHTUNG:
Dieses Tutorial wird nicht mehr weitergeführt, da es auf ältere Versionen des Zend Frameworks aufbaut. Das neue Projekt ist hier:
Zend Framework Tutorial - Wir bauen ein Content Management System (CMS)

Im dritten Teil meines Zend Framework Tutorials habe ich kurz das Model-View-Controller Konzept erläutert. Nach einer Einführung in die Zend_Controller Komponente haben wir den IndexController erstellt. Wenn du die ersten vier Teile noch nicht gelesen hast, hole dies bitte schnell nach.

In diesem vierten Teil des Tutorials werden wir einige Aktions-Methoden anlegen und uns den Einsatz von Zend_Tool anschauen und damit arbeiten. Nach einer kurzen Einführung in Zend_View werden wir die Templates für die erstellten Aktionsmethoden für die Ausgabe erstellen. Dabei werden wir auch die grundlegende Interaktion zwischen Controller und View kennen lernen.

Wenn du über neue Tutorial Teile informiert werden möchtest, abonniere am besten den Feed dieses Blogs. Dann verpasst du garantiert keinen Teil des Tutorials. Es gibt auch Übersicht mit den bisher erschienen Teilen des Tutorials.

Inhaltsverzeichnis

• Benötigte Controller und Aktionen ermitteln
• Weitere Controller Dateien
• ArticleController
• Zend_Tool im Einsatz
• Download
• Zusammenfassung
• Changelog
• Navigation
• Kommentare

Benötigte Controller und Aktionen ermitteln

Es stellt sich zunächst mal die Frage, welche Controller und welche dazugehörigen Aktionen wir denn für unser TravelloBlog überhaupt benötigen. Um nicht blind in der Gegend herum zu raten, ziehen wir an dieser Stelle die Liste mit den Anforderungen aus dem ersten Teil des Tutorials zu Rate.

Im ersten Schritt gehen wir jede der Anforderungen durch und notieren uns die benötigten Entitäten. Dabei kommt diese Liste heraus (in Klammern die jeweilige Nummer aus unserer Anforderungsliste = Entität):

• Beitrag (1, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14)
• Benutzer (1, 2, 11)
• Kommentar (3, 11)
• Kategorie (4, 7)
• Tag (4, 7)
• Suchindex (13)

Wir sehen also, dass die Entität "Beitrag" der Kern unserer Bloganwendung werden wird, was dich nicht überraschen sollte. Am zweitwichtigsten scheint danach die Entität "Benutzer" zu sein. Wir benötigen somit fürs Erste insgesamt sechs Controller.

Im zweiten Schritt analysieren wir nun, welche Aktionen für die einzelnen Controller benötigt werden. Dies gestaltet sich ein wenig schwieriger, da nicht jede Aktion sofort ersichtlich ist.

In der folgenden Tabelle habe ich in der ersten Spalte die Controller und in der zweiten Spalte die entsprechenden Aktionen notiert (in Klammern steht wieder bei jeder Aktion die Nummer der Anforderung).

Die mit (1*) markierten Aktionen werden zwar nicht explizit in den Anforderungen genannt. Ich denke aber, dass man davon ausgehen kann, dass diese Aktionen für das Handling eines Benutzer wichtig sein werden.

Zu (4*) ist zu sagen, dass diese Aktionen auch nur indirekt zu erkennen sind. Wenn ein Beitrag einer Kategorie und/oder einem Tag zugeordnet werden können soll, müssen Kategorien und Tags natürlich auch angelegt, geändert und gelöscht werden können.

Bei (13*) gilt ähnliches. Auch diese Aktionen resultieren indirekt aus der entsprechenden Anforderung. Ohne eine vorhandenen Index kann selbiger auch nicht durchsucht werden.

Nach dieser ersten Analyse haben wir nun einen ersten Überblick, welche Controller und welche Aktionen wir benötigen werden.

Weitere Controller Dateien

Nach der theoretischen Einführung in das MVC-Konzept und der Ermittlung aller benötigten Controller und Aktionen gibt es nun endlich Butter bei die Fische. Mit Hilfe der Zend_Controller Komponente hatten wir ja unsere erste Controller Klasse bereits geschrieben, den IndexController.

Du erinnerst dich: Die Controller Klasse muss mit dem Namen des Controllers starten und auf "Controller" enden, wobei der Name mit einem Großbuchstaben beginnen muss. Für unser TravelloBlog würde dies folgende Controller Namen ergeben:

• IndexController
• ArticleController
• UserController
• CommentController
• CategoryController
• TagController
• SearchController

Den IndexController wurde ja schon beim Erstellen des Projekts automatisch angelegt, im nächsten Schritt definieren wir nun unseren ArticleController mit allen notwendigen Methoden.

ArticleController

Wir erstellen im Verzeichnis "/travelloblog/application/controllers" eine Datei mit Namen ArticleController.php und folgendem Code:

Was wird passieren, wenn du jetzt "http://localhost/travelloblog/public/" aufrufst? Du bekommst unsere Startseite. Wie kommen wir nun an die Article(-Seite) ran? Ganz einfach: Du musst die Seite mit Angabe des Controllernamens aufrufen, also: "http://localhost/travelloblog/public/article".
Probier es aus und schau, was passiert.

Du hast es vielleicht schon geahnt - es gibt eine Fehlermeldung:
article/index.phtml' not found in path (..\application\views\scripts\)
Das Problem: Wir brauchen eine Datei index.phtml im Verzeichnis "/article/".

Also lege bitte das Verzeichnis "views/scripts/article" an und erstelle dort eine Datei index.phtml mit dem Inhalt:

Und wenn du jetzt "http://localhost/travelloblog/public/article" in deinem Browser aufrufst, siehst du "Artikel Index-Seite".

Soweit so gut. Wenn du dir oben nochmals die gewünschten Aktionen anschaust, dann siehst du, dass wir mit den Artikeln ja einiges machen wollen, uA:
Einen Artikel anzeigen, einen neuen Artikel anlegen und einen bestehenden Artikel ändern oder löschen.
Alles Aktionen, die einen Artikel betreffen, also müssen wir den Article-Controller (ArticleController.php) um diese Aktionen (Methoden = Funktionen) erweitern. Von diesen Aktionen legen wir jetzt nur noch die showAction an:

Wenn du jetzt einen Artikel anzeigen möchtest, musst du "http://localhost/travelloblog/public/article/show" aufrufen. Dir ist ja inzwischen klar, dass das wieder eine Fehlermeldung geben würde, da wir ja noch kein View-Skript mit dem Namen Show angelegt haben (wenn du es nicht glaubst, probier es einfach mal aus ).

Also erstelle bitte im Verzeichnis "/view/scripts/article" eine Datei show.phtml und schreibe dort rein:

Wenn du jetzt "http://localhost/travelloblog/public/article/show" aufrust, bekommst du die Show-Seite angezeigt.

Das Prinzip ist dir inzwischen klar?
Wir haben eine bestimmte Aufgabe bzw. einen Aufgabenbereich. Um die Verwaltung der Aufgaben kümmert sich der Controller. Also legen wir im Verzeichnis controllers einen Controller an. Dieser Controller heißt so, wie unsere Aufgabe. In unserem Fall ist der erste Aufgabenbereich erstmal alles, was mit der Verwaltung von Artikeln zu tun hat. Also nennen wir unseren Controller ArticleController.

In diesem Controller werden nun die gewünschten Aufgaben als Aktionen eingetragen. Aktionen sind Methoden mit Namen ...Action(). Eine Methode ist nichts anderes als eine Funktion. Funktionen werden bei Klassen jedoch Methoden genannt - also lass dich nicht verwirren.

Eine Methode sollte/muss immer eine indexAction() sein. Das hat den Vorteil, dass eine Defaultaufgabe übernommen wird, wenn der Controller ohne weitere Angaben aufgerufen wird. Du kennst das Prinzip ja schon von vom default-Eintrag bei einer switch-Anweisung. Ich hatte das ja schon im letzten (3.) Teil unseres Tutorials genauer erläutert. Zur Auffrischung lies dir das Routing nochmals durch.

Um die jeweiligen Aktion aufrufen und optisch darstellen zu können brauchen wir ein Skript. Dieses liegt in einem Unterverzeichnis im Pfad "/views/scripts/". Das Unterverzeichnis heißt immer so, wie der jeweilige Controller, also z.B. index. article, user, error usw.

In dem entsprechenden Unterverzeichnis müssen wir dann das Skript erstellen. Der Name des Skripts ist identisch mit dem der jeweiligen Methode, also index, show, create usw. Die Endung ist immer .phtml.

Du siehst, es ist alles sehr logisch aufgebaut und, wenn man mal das Prinzip des Aufbaus verstanden hat, ist es doch wirklich einfach, oder?

Hier das Ganze noch mal zum anschauen

    /application
        /controllers
            IndexController.php
                public function indexAction()
            ArticleController.php
                public function indexAction()
                public function showAction()
                public function createAction()
                public function changeAction()
                public function deleteAction()
        /views
            /scripts
                /index
                    index.phtml
                /article
                    index.phtml
                    show.phtml
                    create.phtml
                    change.phtml
                    delete.phtml

Zend_Tool im Einsatz

Erste Berührungen mit Zend_Tool hatten wir ja schon beim Erstellen unseres TravelloBlog Projektes. Wir wollen es uns nun etwas genauer anschauen und auch zum Einsatz bringen. Leute, es ist ne feine Sache und spart wirklich einen Haufen Tipperei.
Es schadet auch nichts, sich das im Handbuch (nochmals) durchzulesen.

Wenn du dir oben nochmals die gewünschten Aktionen anschaust, dann siehst du, dass wir ja noch einiges machen müssen. Du kannst die ganzen Controller, Aktionen und Skripte natürlich per Hand anlegen - wie das geht, weisst du ja jetzt - schneller und komfortabler ist es jedoch mit Zend_Tool.

Gehe jetzt erstmal auf Kommandozeilen-Ebene (unter Windows: Start->Ausführen->cmd). Dort angekommen gehe bitte in das Verzeichnis "travelloblog", also cd \xampp\htdocs\travelloblog oder \programme\zend\apache2\htdocs\travelloblog oder wo immer dein TravelloBlog-Projekt liegen mag.

Wenn du jetzt zf aufrufst bekommst du eine Fehlermeldung:
An Error Has Occured
An action and provider is required
Im Anschluss daran bekommst du (als Hilfe) jedoch auch eine Anwendungshilfe, bei der alle möglichen Eingabemöglichkeiten aufgelistet werden.

So, was müssen wir jetzt tun? Zunächst einmal die weiteren Controller anlegen. Index- und ArticleController haben wir ja bereits, also kümmern wir uns als nächstes um den UserController.
Schauen wir uns die Anwendungshilfe an um herauszufinden, wie das geht:

Controller
   zf create controller name index-action-included[=1] module

Das index-action-included[=1] module interessiert uns zunächst mal nicht. Das brauchen wir erst viel später, wenn wir uns mit Modulen beschäftigen.
Also bleibt zf create controller name übrig.

Gut, dann gib bei dir bitte ein:
zf create controller user

Es dauert einen kurzen Moment und dann erscheinen folgende Meldungen:

Creating a controller at ...
Creating an index action method in controller user
Creating a view script for the index action method at ...
Creating a controller test file at ...
Updating project profile ...

Die Pfade habe ich jeweils durch ... ersetzt.

Was ist also passiert?
- ein Controller mit Namer User wurde angelegt (UserController.php)
- dort wurde die indexAction Methode reingeschrieben (public function indexAction())
- das Verzeichnis "user" wurde bei den view Skripten angelegt (/views/scripts/user)
- ein index Skript wurde im user Verzeichnis angelegt (index.phtml)
(den Rest lass ich jetzt mal weg, interessiert uns momentan nicht)

Glaubst du nicht? Dann schau nach.

Hausaufgabe: Lege die anderen Controller in gleicher Weise an.

HINWEIS:
Am Besten ist es, wenn du - wie im Teil 2 beschrieben - den Pfad zu den zf Dateien gesetzt hast. Damit beugst du eventuellen Problemen vor und musst nicht immer den kompletten Pfad zu zf.bat mit angeben.

Wir sind jedoch noch nicht ganz fertig.
Du erinnerst dich, dass wir beim ActionController nur die Action-Methoden index und show angelegt haben? Es fehlen noch create, change, delete.
Die legen wir jetzt an - und ebenfalls mit Hilfe von Zend_Tool.

Schau dir nochmals bei der Eingabehilfe an, wie das funktioniert.
Es ist ähnlich wie beim Anlegen eines Controllers:
Erstelle | eine Aktions-Methode (action) | mit Namen create | im Controller article
Also gib bitte bei dir ein:
zf create action create article

Ratter, ratter, ratter und dann:

Creating an action named create inside controller at ...
Updating project profile ...
Creating a view script for the create action method at ...
Updating project profile ...

Schau nach und du wirst feststellen:
- die Aktions-Methode createAction wurde im ActionController angelegt
- die Datei create.phtml wurde im Verzeichnis "/views/scripts/article/" hinzugefügt

Als Hausaufgabe legst du jetzt noch auf gleiche Weise die beiden fehlenden Aktions-Methoden change und delete an.

Download

Der aktuelle Stand des Tutorials nach diesem vierten Teil kann auch herunter geladen werden.
So lange das Tutorial noch nicht komplett auf die Version ab 1.8 umgeschrieben ist, werden die Sourcen für beide Versionen angeboten:

• Source Zend Framework Tutorial - Teil 4 - ZF ab v1.8
• Source Zend Framework Tutorial - Teil 4 - ZF bis v1.7.8

Die Zip Datei enthält nicht die Bibliotheken (libraries) der aktuellen Version des Zend Frameworks. Die musst du bitte selber in das entsprechende Verzeichnis kopieren.

Zusammenfassung

In diesem Teil meines Zend Framework Tutorials haben wir die benötigten Controller und Aktionen anhand unserer Anforderungsliste ermittelt. Wir haben den ArticleController erstellt, Aktionsmethoden angelegt, die grundlegende Interaktion zwischen Controller und View kennengelernt und die Anwendung von Zend_Tool gelernt.

In nächsten Teil des Tutorials werden wir uns um die View und Layout Komponenten unseres Projektes kümmern. Nach einer kurzen Einführung in Zend_View werden wir die Templates für die erstellten Aktionsmethoden für die Ausgabe erstellen sowie einige Hilfsmethoden für die Ausgabe kennen lernen. Das alles wird dann noch mit Zend_Layout verfeinert.

Fragen, Probleme und Anregungen bitte nicht per E-Mail senden, sondern hier in die Kommentare stellen. Dann haben alle etwas davon.

Changelog

• 11.10.2009 - Anpassung an Version 1.8 und höher
• 11.10.2009 - Einsatz von Zend_Tool hinzugefügt
• 09.11.2009 - Hinweis zur Pfadangabe zum Zend_Tool hinzugefügt

Navigation

• Zend Framework Tutorial Übersicht
• Zurück zu Teil 3: MVC Design Pattern und Zend_Controller
• Weiter zu Teil 5: Ansichtssache: Zend_View und Zend_Layout

Kommentare