Rapid Web Development mit dem MVC-Framework

Dirk Ammelburger & Robert SchererO’Reilly

CakePHPWebentwicklung mit

Deckt

PHP 5.1 ab

2. Auflage

Aktuell zu CakePHP 1.3

Beijing · Cambridge · Farnham · Köln · Sebastopol · Tokyo

Webentwicklungmit CakePHP

Dirk Ammelburger & Robert Scherer

2. Auflage

Die Informationen in diesem Buch wurden mit größter Sorgfalt erarbeitet. Dennoch können Fehler nicht vollständig ausgeschlossen werden. Verlag, Autoren und Übersetzer übernehmen keine juristische Verantwortung oder irgendeine Haftung für eventuell verbliebene Fehler und deren Folgen.Alle Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt und sind möglicherweise eingetragene Warenzeichen. Der Verlag richtet sich im Wesentlichen nach den Schreibweisen der Hersteller. Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung,Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.

Kommentare und Fragen können Sie gerne an uns richten:O’Reilly VerlagBalthasarstr. 8150670 Köln

E-Mail: kommentar@oreilly.de

© 2011 by O’Reilly Verlag GmbH & Co. KG2. Auflage 2011

Die Darstellung eines Mauergeckos im Zusammenhang mit dem Thema CakePHP ist ein Warenzeichen von O’Reilly Media, Inc.

Bibliografische Information Der Deutschen NationalbibliothekDie Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.

Lektorat: Volker BombienKorrektorat: Friederike Daenecke, ZülpichSatz: III-satz, Husby; www.drei-satz.deUmschlaggestaltung: Michael Oreal, KölnProduktion: Susanne Lukoschek und Andrea Miß, KölnBelichtung, Druck und buchbinderische Verarbeitung: Druckerei Kösel, Krugzell; www.koeselbuch.de

ISBN 978-3-89721-659-4

Dieses Buch ist auf 100% chlorfrei gebleichtem Papier gedruckt.

| V

Inhalt

Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IX

Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XI

1 CakePHP kennenlernen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1Was ist ein Framework? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2Grundprinzipien des CakePHP-Frameworks . . . . . . . . . . . . . . . . . . . . . . . . . . 3Das Model-View-Controller-Pattern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6Das Zusammenspiel der CakePHP-Komponenten . . . . . . . . . . . . . . . . . . . . . . 9CakePHP-Entwicklung Schritt für Schritt . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11CakeJobs – die Beispielanwendung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2 Installation und Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Installation des Webservers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17Installation von CakePHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24Installation der CakePHP-Konsole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3 Schnell zum Erfolg – Ihre erste Webapplikation mit CakePHP . . . . . . . . . . . . . . . . 33Die Datenbank als Grundlage der Applikation . . . . . . . . . . . . . . . . . . . . . . . . 33Die Anwendung starten und Gerüste bauen . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

4 Der Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43Aufbau des Controllers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43Attribute und Methoden im Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55CakePHP-Konventionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

5 Das Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63Was ist ein Model? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63Validierung im Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

VI | Inhalt

Ein zweites Model einbinden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71Model-Relationen herstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73Retrieve: Daten finden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77Create und Update: Daten speichern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83Delete: Daten löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86Model-Methoden und -Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

6 Das View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93Was ist ein View? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93Die Template-Engine in CakePHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94Nützliche Helfer im View: Die Helper-Klassen . . . . . . . . . . . . . . . . . . . . . . . . 110Die Mini-Views: Elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

7 Helper – Lassen Sie CakePHP für sich arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . 127Die Standard-Helper von CakePHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128Der HTML-Helper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129Der Text-Helper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141Der Time-Helper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144Der Number-Helper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148Der Cache-Helper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151Der Paginator-Helper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155JavaScript und CakePHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165Eigene Helper entwickeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

8 Session-Handling mit CakePHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171Session-Konfiguration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171Die Session-Component verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173Der Session-Helper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176Beispiel: Ein Merkzettel für Jobanzeigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180Kekse zum Kuchen – Der Einsatz von Cookies . . . . . . . . . . . . . . . . . . . . . . . . 183

9 Die CakePHP-Konsole und die Bake-Shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189Shells starten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190Die Console-Shell kennenlernen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191Baking: Code automatisch generieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192Eigene Shells programmieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

10 Der Controller reloaded – Callbacks, Routes & Co. . . . . . . . . . . . . . . . . . . . . . . . . . 213Die Controller-Funktionalität erweitern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213Controller-Callbacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215URLs und Routes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216Statische Seiten in CakePHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

Inhalt | VII

11 Components verwenden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223Die Core-Components von CakePHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224Die Email-Component . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227Components selbst entwickeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236

12 Das Model reloaded – Bindings, Behaviors & Co. . . . . . . . . . . . . . . . . . . . . . . . . . . 241HABTM – hasAndBelongsToMany-Associations . . . . . . . . . . . . . . . . . . . . . . 241Model-Bindings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248Model-Callbacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249Die AppModel-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252Models durch Behaviors erweitern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253

13 Ajax und DHTML mit CakePHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259Der Js-Helper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260JQuery, Mootools oder Prototype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261Den JS-Helper einsetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262

14 Sicherheit, Authentifizierung und Autorisierung . . . . . . . . . . . . . . . . . . . . . . . . . . 283Zugriffsschutz mit der Security-Component . . . . . . . . . . . . . . . . . . . . . . . . . . 283Authentifizierung mit der Auth-Component . . . . . . . . . . . . . . . . . . . . . . . . . . 290Autorisierung mit der Auth-Component . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296ACL – Access Control Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

15 Lokalisierung und Internationalisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317Mehrsprachigkeit einrichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320Dynamische Daten internationalisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328Die Klasse i18n einsetzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334

16 Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339Die Test-Suite installieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341Tests schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342Tests zusammenfassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354Browsersimulation mit Web Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355

17 Weitere Kernfunktionalitäten von CakePHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359Plugins erstellen und einbinden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359Fehlerbehandlung in CakePHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361Ein eigener ErrorHandler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364Debugging in CakePHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365Die CakePHP-Core-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366

VIII | Inhalt

18 Tipps und Tricks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377RSS-Feeds erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377Routes dynamisch aus der Datenbank generieren . . . . . . . . . . . . . . . . . . . . . . 379Zugriff auf die Datenbank ohne Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383

| IX

Vorwort

In March 2005, a small MVC framework was released in the public domain called Cake.Seeing the value in work that had been done, Larry Masters joined with the original deve-loper and began working on CakePHP, which was soon released under an MIT license.In July 2005, the original developer left the project and Larry continued developingCakePHP with a new team. This team set out to finish CakePHP 1.0, with the goals ofmaking the lives of developers easier through the creation of a framework focused onextensibility, flexibility and maintainability. Today these developers, along with somehelp from other community members, continue to make CakePHP the best PHP frame-work for rapid development.

The CakePHP core team is driven by the goal of making a fast, secure, and extensible fra-mework with the ability to code less and do more. This same team has been dedicated tothe project since September 2005 and plans on being around for a lot longer. The CakeSoftware Foundation was formed in December 2005 to promote and support develop-ment related to CakePHP. The Cake Software Foundation ensures that CakePHP will bea viable, long term solution for many developers and companies looking to rapidly deve-lop PHP applications.

Today the CakePHP team has expanded to meet the demands of a growing community.With the release of 1.2, CakePHP continues to prove that it is the framework that makesthe lives of PHP developers easier. With more new features and a strong commitment toproducing the best framework possible, CakePHP is growing as fast as ever.

The Cake Software Foundation and CakePHP core team would like to extend its war-mest welcome to its German friends.

Garrett J. WoodworthProjektmanager und Mitgründer der Cake Software Foundation

| XI

Einleitung

Mit CakePHP können Sie schnell und einfach dynamische Anwendungen für das Internetentwickeln. Um es mit den Worten der CakePHP-Entwickler zu sagen: »Welcome to webdevelopment heaven.« In dieser Aussage schwingt nicht nur auf den ersten Blick rechtviel Selbstbewusstsein mit, sie legt auch die Messlatte für das Framework, das diesesBuch zum Thema hat, sehr hoch. Doch wir hätten dieses Buch sicher nicht mit diesemZitat eröffnet, wenn wir nicht davon überzeugt wären, dass CakePHP dieses Versprechennicht nur halten wird, sondern darüber hinaus selbst sehr erfahrenen Webentwicklernnoch den ein oder anderen staunenden Blick entlocken wird.

Aber vorweg: Um was geht es denn hier eigentlich genau? CakePHP ist ein kostenlosesOpen Source-Framework für die Entwicklung von Webapplikationen in PHP. Es bieteteine grundlegende Rahmenstruktur für Entwickler, die es erlaubt, immer wiederkeh-rende Funktionalitäten zu kapseln, ohne dass die Flexibilität dadurch verloren geht.CakePHP gibt keine Logik in seiner Anwendung vor, sondern sorgt dafür, dass Sie sich in90% der Fälle fast nur auf die Umsetzung des logischen Aufbaus der Applikation konzen-trieren können, ohne dabei Zeit für Standardfunktionalitäten zu verschwenden.

Der ursprüngliche Hintergrund des CakePHP-Frameworks ist das Rails-Framework, dasfür die Sprache Ruby entwickelt worden ist. Den meisten Entwicklern wird Ruby on Railsein Begriff sein, da dieses Framework seit seiner Veröffentlichung für einigen Wirbel inder großen Gemeinschaft der Webentwickler gesorgt hat. Ruby, eine Sprache, die bisdahin eher eine Randerscheinung gewesen war, hat durch Rails großen Aufschwungerfahren und erfreut sich inzwischen einer wachsenden Entwicklergemeinde.

Im Gegensatz dazu war PHP spätestens seit der Version 4 die Sprache der Wahl für sehrviele große und kleine Projekte. Es ist mehr oder weniger der Standard auf Apache, demwohl am weitesten verbreiteten Webserver im Netz. Seit PHP 5 hat dieses Werkzeug, dasfrüher oft als kleine »Skriptsprache« belächelt wurde, die Kinderkrankheiten hinter sichgelassen und ist in der Lage, durch den vernünftigen Einsatz von objektorientierten Tech-niken übersichtlichen, schnellen und vor allem skalierbaren Code zu schaffen.

XII | Einleitung

Vor diesem Hintergrund hat der naheliegende Gedanke, ein Framework wie Rails fürPHP zu adaptieren, den Anstoß zur Entwicklung von CakePHP gegeben. Inzwischen hateine sehr aktive Gruppe von Entwicklern CakePHP weit über den Zustand einer reinenAdaption von Rails hinausgehoben und ein sehr mächtiges und durchdachtes Werkzeugfür die Entwicklung von Webapplikationen geschaffen. Im Folgenden sehen Sie einekleine Auswahl der Features, die die aktuelle Version 1.3 bietet:

• Application Scaffolding

• Automatische Codegenerierung

• Kompatibel mit PHP 4, PHP 5 und PHP 5.3

• Model-View-Controller-Architektur (MVC)

• Automatische Datenvalidierung

• Schnelles und einfaches Template-System

• Integrierte Helper für Ajax, JavaScript, HTML-Formulare etc.

• E-Mail-, Cookie-, Security-, Session- und Request-Handling-Components

• Access Control Lists (ACL)

• Automatische Datenbereinigung

• Caching

• Localization

Sie halten mit diesem Buch eine komplette Einführung in die Welt von CakePHP in denHänden, mit der Sie innerhalb weniger Kapitel in der Lage sind, sich ein Bild von denMöglichkeiten und vor allem von den gedanklichen Konzepten dieses Frameworks zumachen. Unser Ziel ist es, über einen sehr praxisnahen Einstieg bei Ihnen schnell einGefühl für die Art und Weise der Webentwicklung mit CakePHP zu wecken, damit Siedas Gelernte auf eigene Projekte übertragen können.

Voraussetzung dafür sind neben Kenntnissen in PHP ein grundlegendes Verständnis derobjektorientierten Programmierung und Erfahrungen in der Webentwicklung. DiesesBuch ist also kein klassisches Einsteigerwerk in die Programmierung, sondern vielmehreine Weiterführung für Entwickler, die neue Konzepte ausprobieren wollen und die Vor-teile von erprobten Lösungen mit Entwurfsmustern nutzen möchten.

Unterschiede von CakePHP 1.2 zu Version 1.3Seit dem Erscheinen der ersten Auflage dieses Buchs und dem darin behandelten Frame-work in der Version 1.2 hat sich viel getan. Die vorliegende Ausgabe behandelt die Ver-sion 1.3 von CakePHP.

An wesentlichen Stellen werden wir auf Versionsunterschiede hinweisen, allerdings istdie Kenntnis von CakePHP 1.2 nicht notwendig, um mit diesem Buch zu arbeiten.

Für wen ist dieses Buch gedacht? | XIII

Falls Sie bereits mit CakePHP gearbeitet haben oder gar eine Anwendung von 1.2 auf 1.3migrieren möchten, finden Sie alle API-Änderungen online unter der folgenden, ständigaktuell gehaltenen deutschen Cookbook-Seite:

• http://book.cakephp.org/de/view/1561/Migrating-from-CakePHP-1-2-to-1-3

Mit der Version 1.3 ist CakePHP kompatibel mit PHP 5.3 geworden. Das haben wir zumAnlass genommen, alle unsere Codebeispiele, sei es im Buch als auch in der Download-Version, auf PHP 5 umzustellen.

Für wen ist dieses Buch gedacht?Wenn Sie jetzt die ersten Absätze dieses Buches überflogen haben, werden Sie sichbestimmt fragen, ob die folgenden Kapitel das sind, wonach Sie suchen. Die Entwicklungvon Webapplikationen ist sehr vielschichtig und bietet eine Menge Facetten, die es oftschwierig machen, die richtigen Werkzeuge im riesigen Meer von Angeboten zu finden.Die folgenden Zeilen sollen Ihnen eine Orientierung bieten, was Sie in diesem Bucherwartet und welche Voraussetzungen Sie mitbringen sollten, um mit CakePHP den Spaßzu haben, den auch wir hatten.

Dieses Buch richtet sich an Entwickler, die schon Erfahrung mit der Entwicklung vonWebanwendungen haben. Konkret bedeutet das, dass Sie schon dynamische Webseitenentwickelt haben und wissen, was in einer serverseitigen Applikation passiert und wie einBrowser mit der Antwort eines Servers umgeht. Da CakePHP, wie der Name schonandeutet, ein Framework für PHP ist, werden Kenntnisse in PHP 4 oder PHP 5 vorausge-setzt. Darüber hinaus ist es hilfreich, wenn Sie sich schon einmal mit den Konzepten derobjektorientierten Programmierung beschäftigt haben und wissen, was PHP 4 von derVersion 5 unterscheidet. CakePHP ist zwar abwärtskompatibel und läuft auf beiden Ver-sionen, aber erstens wird langfristig die PHP 4-Kompatibilität verschwinden, und zwei-tens ist PHP 5 schlicht die bessere Programmiersprache und bietet mehr Möglichkeiten.Alle Beispiele in diesem Buch sind mit PHP 5 entstanden. Im Laufe dieses und der nächs-ten Kapitel werden wir noch einmal genauer auf die Unterschiede zwischen den Versio-nen mit CakePHP eingehen.

Im Laufe des Buches werden wir auch auf die Möglichkeiten verschiedener Helper undComponents des Frameworks eingehen, die es ermöglichen, HTML-Ausgaben zu gestal-ten oder Schnittstellen in XML, RSS oder anderen Formaten zu generieren. Darüber hin-aus bietet CakePHP auch flexible und einfache Möglichkeiten, mit JavaScript, DHTMLund Ajax dynamisch Oberflächen zu gestalten, so dass diese sauber in das Konzept vonCakePHP passen. Kenntnisse in diesen Bereichen werden also dafür sorgen, dass Sie dieVorteile und vor allem den Geschwindigkeitsgewinn im Entwicklungsprozess zu schät-zen wissen.

Die Grundlage einer jeden Webapplikation ist in der Regel eine relationale Datenbankwie beispielsweise MySQL, die in Kombination mit PHP eine der am weitesten verbreite-

XIV | Einleitung

ten Datenbankanwendungen im Internet ist. Der Datenaustausch mit einer Datenbankerfolgt in SQL, das wir auch als in Grundzügen bekannt voraussetzen. CakePHP kapseltzwar sehr viele SQL-Zugriffe durch die Strukturen des Frameworks, aber der Aufbau undvor allem die relationalen Verknüpfungen zwischen den Tabellen müssen natürlich vomEntwickler festgelegt werden.

Es erwartet Sie ein Buch, in dem das Framework von CakePHP ausführlich und vonGrund auf besprochen wird. Wenn Sie schon einmal mit einem Framework wie Strutsoder natürlich Ruby on Rails gearbeitet haben, wird Ihnen bestimmt einiges bekannt vor-kommen. Kenntnisse dieser Art sind allerdings nicht notwendig, um mit CakePHP zuarbeiten. In den folgenden Kapiteln werden alle nötigen Grundlagen ausführlich bespro-chen.

Da wir Freunde des praxisbezogenen Lernens sind, werden wir Sie nicht mit langatmigentheoretischen Grundlagen »langweilen«, sondern so schnell wie möglich zum Kern derSache kommen. CakePHP bietet dank seiner Struktur einen einfachen Einstieg in dieMaterie, so dass wir schnell zu lauffähigen Ergebnissen kommen. Nichts macht den Ein-stieg in ein neues Thema schöner als Erfolgserlebnisse, die das Gelernte untermauern. Indiesem Sinne ist es unser Ziel, mit vielen kleinen und auch großen Beispielen die Mög-lichkeiten von CakePHP auszuloten und über den direkten Praxisbezug die verschiede-nen Themen zu erläutern.

Als roten Faden für dieses Buch werden wir ein imaginäres Projekt für einen Kunden ent-wickeln, das im Laufe der Kapitel Stück für Stück um diverse Features erweitert wird. DieBeispielapplikation wird auf diese Weise von einem Projekt zu einer komplexen Anwen-dung, die alle Kernbereiche von CakePHP verwendet. Der Projektcharakter erlaubt esdarüber hinaus, die Planung einer CakePHP-Anwendung zu erläutern und die Prinzipiendes Rapid Development über Prototypen und Scaffolding darzustellen.

Im Gegensatz zu anderen Sprachen setzt CakePHP kein bestimmtes Betriebssystem undauch keine Werkzeuge oder Applikationen voraus, die über die Anforderungen hinausge-hen, die PHP und eine Datenbank stellen. Die Einrichtung einer einfachen Umgebung, inder Sie die Beispiele nachvollziehen können und auch eigene Anwendungen entwickeln,werden wir in Kapitel 2, Installation und Konfiguration, sowohl für Windows und Linuxals auch für den Mac erläutern. Dabei handelt es sich aber auch nur um einen Vorschlagund nicht um eine zwingend erforderliche Konfiguration.

Zusammenfassend kann man sagen, dass dieses Buch sich an fortgeschrittene Program-mierer richtet, die ein neues Werkzeug kennenlernen wollen, um intelligente, stabile,leicht skalierbare, sehr einfach wartbare und strukturierte Software zu entwickeln, dienach dem Best Practice-Prinzip der Design-Pattern aufgebaut ist. Dieses Buch richtet sichaber auch an passionierte Einsteiger mit den oben genannten Vorkenntnissen, die sichmit der Entwicklung professioneller Software im Enterprise-Bereich auseinandersetzenwollen.

Aufbau dieses Buchs | XV

Aufbau dieses BuchsDie Kapitel dieses Buchs bauen sowohl inhaltlich als auch didaktisch aufeinander auf.Nach dieser Einleitung werden in einem Überblickskapitel zunächst die Grundbegriffeund verschiedenen Elemente des CakePHP-Frameworks vorgestellt und das Zusammen-spiel der CakePHP-Komponenten erläutet. Das Kapitel beschäftigt sich mit der grund-sätzlichen Denkweise, die hinter CakePHP steckt, und dem damit verbundenen MVC-Design-Pattern, nach dem dieses Framework aufgebaut ist. Das Kapitel 2 beschreibt dieInstallation und Konfiguration von CakePHP, so dass Sie für alle folgenden Kapitelgerüstet sind – unabhängig davon, auf welchem System Sie arbeiten. Das darauffolgendeKapitel 3, Schnell zum Erfolg – Ihre erste Webapplikation mit CakePHP, bietet Ihnen danneinen praktischen Schnelleinstieg in die Arbeit mit CakePHP.

Es ist also sehr empfehlenswert, als kompletter Neueinsteiger in die Entwicklung mitCakePHP das Buch und insbesondere die Kapitel 1 bis 3 in der angebotenen Reihenfolgezu lesen. Alle anderen Kapitel und Beispiele bauen auf diesen Informationen auf.

Unser Ziel war es, dieses Buch möglichst praxisnah aufzubauen, um den Leser nicht mitendloser Theorie zu erschlagen, sondern vielmehr direkt in die Welt von CakePHP vor-zustoßen und lauffähige Beispiele zu präsentieren. Als roter Faden wird durch das kom-plette Buch eine Applikation mit dem Namen CakeJobs entwickelt und für bestimmteProblemfälle und Anforderungen erweitert. So wird auf der einen Seite gezeigt, wie einklassisches Projekt mit CakePHP realisiert wird, und auf der anderen Seite die Flexibilitätdes Frameworks durch sich ändernde Anforderungen auf die Probe gestellt.

Alle Kapitel nach dem dritten sind an sich ebenfalls logisch aufeinander abgestimmt,können aber auch unabhängig voneinander gelesen werden. Es besteht also die Möglich-keit, das Buch zu bestimmten Themen wie ein Nachschlagewerk zur Hand zu nehmen,ohne es komplett gelesen haben zu müssen. Verweise im Text werden auf korrespondie-rende Bereiche im Buch hinweisen, so dass logische Zusammenhänge gewahrt bleiben.Die einzelnen Kapitel dieses Buches gliedern sich wie folgt:

In Kapitel 1, CakePHP kennenlernen, wird die Frage geklärt, was überhaupt ein Frame-work ist, und welche Vorteile es bietet. Danach werden die Grundbegriffe des Cake-PHP-Frameworks erläutert. Sie erfahren also, welche Vorteile es hat, mit CakePHP zuarbeiten.

Kapitel 2, Installation und Konfiguration, beschreibt die grundlegenden Einstellungen aufIhrem System, die notwendig sind, um mit CakePHP zu entwickeln. Dieses Kapitel ist alsEinstieg in dieses Buch sehr wichtig, damit Sie unabhängig von Ihrem BetriebssystemIhren Rechner so konfigurieren können, dass Sie mit CakePHP beginnen können.

Kapitel 3, Schnell zum Erfolg – Ihre erste Webapplikation mit CakePHP, zeigt Ihnen aneinem konkreten Beispiel, wie schnell Sie mit dem Framework von CakePHP Softwareentwickeln können. Das Kapitel macht dabei ausgiebig Gebrauch von den intelligentenAutomatismen von CakePHP, die auf der Einhaltung von bestehenden Konventionen

XVI | Einleitung

basieren. Auf diese Weise ist es möglich, die ersten Funktionalitäten der Beispielapplika-tion CakeJobs innerhalb von 20 Minuten zu erstellen.

In Kapitel 4, Der Controller, werden Sie den Controller als »Motor« der Anwendung ken-nenlernen. Er ist die Schnittstelle zwischen dem Model und der eigentlichen Ausgabe derDaten im View, und in ihm werden alle wichtigen Entscheidungen für den Ablauf unddie Logik der Applikation getroffen. Eine gute Struktur und die Verwendung von aus-gelagerter Logik sind dabei Grundlage für sauberen und übersichtlichen Code. Einewesentliche Eigenschaft des Controllers besteht darin, dass er als Schnittstelle zwischendem User und der Applikation dient. Jeder Zugriff erfolgt über eine von Ihnen definierteMethode, die von außen angesprochen werden kann.

Kapitel 5, Das Model, widmet sich der Model-Klasse von CakePHP, die für die Abstrak-tion der Daten und der Logik des Daten-Handlings verantwortlich ist. Es hat seinenGrund, dass M (für »Model«) im Namen des MVC-Pattern an erster Stelle steht: DasModel repräsentiert die Daten eines Systems, die der Mittelpunkt der meisten Applikati-onen sind. Auf den ersten Blick mag das Model wie eine einfache Abstraktionsschicht füreine Datenbank wirken, da alle Zugriffe über die Methoden dieser Klasse gekapselt sind.Das Model ist aber viel mehr, da neben den Daten auch der logische Umgang mit diesendefiniert wird, beispielsweise die Validierung von Daten oder die Verknüpfung vonabhängigen Tabellen in der Datenbank.

Kapitel 6, Das View, präsentiert die Ausgabelogik von CakePHP und damit das V imMVC-Pattern. Konkret bedeutet dies, dass im View der Teil implementiert wird, den derUser zu sehen bekommt. Der Aufbau dieses Kapitels behandelt dabei zwei Bereiche: zumeinen den eigentlichen Aufbau des View in CakePHP, bestehend aus dem Rahmenlayoutund dem dynamisch erzeugten View, abhängig von einer Action. Zum anderen behan-deln wir die Helper, die CakePHP Ihnen zur Verfügung stellt. Helper dienen dazu, dyna-mische Bereiche in das View einzufügen, ohne die Trennung von Layout und Logikaufzuheben. Unter anderem wird durch Helper die dynamische Befüllung von Formula-ren ermöglicht.

Kapitel 7, Helper – Lassen Sie CakePHP für sich arbeiten, ist im Prinzip eine Fortsetzungdes View-Kapitels, in dem nun der Schwerpunkt auf die Core-Helper des Frameworksgelegt wird. Dieses Kapitel widmet sich deshalb der konkreten Anwendung von Helpernaus der CakePHP-API, um bestimmte Probleme in der Entwicklung zu lösen. Beispielehierfür sind dynamisches HTML, die Erstellung von komplexen Formularen oder dieAusgabe von Datenformaten wie XML, RSS etc.

In Kapitel 8, Session-Handling mit CakePHP, widmen wir uns dem Session-Handling,also der persistenten Speicherung von Daten über einen Browser-Request hinaus. Da fastkeine Webanwendung mehr ohne ein vernünftiges Session-Handling auskommt, ist esnaheliegend, dass das Framework unserer Wahl den Umgang mit Sessions kapselt undauf eine Cake-typische Weise implementiert.

Aufbau dieses Buchs | XVII

In Kapitel 9, Die CakePHP-Konsole und die Bake-Shell, wird die Konsole behandelt, dieseit Version 1.2 ein wichtiger Bestandteil von CakePHP geworden ist. Die prominentesteFunktionalität der Konsole ist das sogenannte »Baking«, also das automatische Generie-ren von Code. So kann Ihnen als Entwickler viel Arbeit abgenommen werden. »Baking«kommt zum Einsatz, um immer wiederkehrenden Quelltext (wie beispielsweise dengrundlegenden Aufbau der Model-, View- und Controller-Klassen) automatisch zu erstel-len.

In Kapitel 10, Der Controller reloaded – Callbacks, Routes & Co., tauchen wir noch ein-mal in das Thema des Controllers ein und besprechen eine Reihe von weitergehendenFeatures, etwa die Verwendung mehrerer Models und die Verwendung von Callbacks,um den Ablauf eines Requests zu beeinflussen. Damit wird es Ihnen ermöglicht, das Fra-mework in Ihrem Sinne zu beeinflussen, um beispielsweise sicherheitsrelevante Zugriffebesser steuern zu können.

Kapitel 11, Components verwenden, widmet sich den Components. Das sind in sichgeschlossene Bereiche innerhalb einer Applikation, die eine bestimmte Funktionalitätkapseln und diese über die Grenzen eines Controllers hinaus verfügbar machen. Im Sinnedes »Don’t repeat yourself«-Prinzips ist der Einsatz von Components in CakePHP einewesentliche Grundlage, um beispielsweise Funktionalitäten wie das Session-Handling zurealisieren.

Kapitel 12, Das Model reloaded – Bindings, Behaviors & Co., nimmt sich noch einmal derThematik des Models an und gibt einen tiefer gehenden Einblick in den Aufbau und dieweiterführenden Möglichkeiten dieser Klasse. Sie werden erfahren, wie CakePHP kom-plexe Relationen in der Datenbank abbildet und in der Applikation kapselt.

Kapitel 13, Ajax und DHTML mit CakePHP, zeigt, wie CakePHP diese relativ jungeTechnologie verwendet. Die Grundlage dafür ist die Schnittstelle zwischen der BibliothekPrototype und dem Ajax-Helper, der von dieser Bibliothek Gebrauch macht. Darüberhinaus werden wir einen Blick auf die Möglichkeiten des Event-Handlings über CakePHPim Browser werfen.

Kapitel 14, Sicherheit, Authentifizierung und Autorisierung, beschreibt die Möglichkeiten,die Sie haben, um eine Anwendung mit den Mitteln von CakePHP sicherer zu gestalten.In diesem Kapitel erläutern wir Ihnen zunächst die Security-Component von CakePHPund zeigen Ihnen dann mit der Auth-Component, wie einfach sich ein Loginsystem inCakePHP implementieren lässt. Außerdem gehen wir auf die Verwaltung der Zugriffs-rechte mit Access Control Lists ein.

Kapitel 15, Lokalisierung und Internationalisierung, ist der Mehrsprachigkeit gewidmetund zeigt, wie Sie diese in einer Applikation realisieren.

In Kapitel 16, Testing, werden Sie die Möglichkeiten des Test Driven Development mitCakePHP kennenlernen. Die testgetriebene Entwicklung dreht den gewohnten Entwick-lungsprozess um: Man schreibt Tests schon vor dem Implementieren der gewünschtenWeiterentwicklung oder neuen Funktionalität. CakePHP verwendet dazu SimpleTest.

XVIII | Einleitung

In Kapitel 17, Weitere Kernfunktionalitäten von CakePHP, werden wir auf die wichtigstenKomponenten von CakePHP eingehen, die nicht direkt in das MVC-Schema gehören,aber trotzdem nicht unerwähnt bleiben sollten. Dazu gehören zum Beispiel der Umgangmit Fehlern, Konfigurationen und die Kernstruktur der Cake-Module.

In Kapitel 18, Tipps und Tricks, werden wir Ihnen eine Reihe von kleinen Anwendungs-beispielen vorstellen, die CakePHP zu bieten hat, die aber in keinem der vorherigen Kapi-tel Platz gefunden haben. Dabei handelt es sich um kleine Tricks und interessanteFeatures, die von CakePHP als Teil des Frameworks zur Verfügung gestellt werden, aberwenig dokumentiert sind.

Typografische KonventionenDie folgenden typografischen Konventionen werden in diesem Buch verwendet:

KursivWird für URLs, die Namen von Verzeichnissen und Dateien, Optionen, Menüs undzur Hervorhebung verwendet.

NichtproportionalschriftWird für Codebeispiele, den Inhalt von Dateien sowie für die Namen von Variablen,Befehlen und anderen Codeabschnitten verwendet.

Nichtproportionalschrift fettWird in Codebeispielen verwendet, um wichtige Codeteile hervorzuheben.

Verwendung der CodebeispieleDieses Buch soll Ihnen bei Ihrer Arbeit helfen. Es ist allgemein erlaubt, den Code aus die-sem Buch in Ihren Programmen und Dokumentationen weiterzuverwenden. Sie müssenuns dafür nicht um Erlaubnis bitten, es sei denn, es handelt sich um eine größere MengeCode. So ist es beim Schreiben eines Programms, das einige Codeschnipsel aus diesemBuch verwendet, nicht nötig, sich mit uns in Verbindung zu setzen; beim Verkauf oderVertrieb einer CD-ROM mit Beispielen aus O’Reilly-Büchern dagegen schon. Das Beant-worten einer Frage durch das Zitieren von Beispielcode erfordert keine Erlaubnis. Ver-wenden Sie einen erheblichen Teil des Beispielcodes aus diesem Buch in Ihrer Dokumen-tation, ist dagegen unsere Erlaubnis nötig.

Eine Quellenangabe ist zwar erwünscht, aber nicht obligatorisch. Zu ihr gehört in derRegel die Erwähnung von Titel, Autor, Verlag und ISBN, zum Beispiel so: »Webentwick-lung mit CakePHP von Dirk Ammelburger & Robert Scherer. Copyright 2008 O’ReillyVerlag, ISBN 978-3-89721-863-5.«

Falls Sie sich nicht sicher sind, ob die Nutzung der Codebeispiele außerhalb der hiererteilten Erlaubnis liegt, nehmen Sie bitte unter der Adresse kommentar@oreilly.de Kon-takt mit uns auf.

Die CakePHP-Welt | XIX

Die Codebeispiele zu diesem BuchZu Webentwicklung mit CakePHP gibt es eine Website der Autoren, auf der Sie die Code-beispiele sowie Errata und weitere Informationen zum Buch finden. Das hier ist dieAdresse:

http://webentwicklung-mit-cakephp.de/

Die Codebeispiele zum Buch und weitere Informationen finden Sie auch auf der Websitedes O’Reilly Verlags unter

http://www.oreilly.de/catalog/cakephpwebentw2ger/

Die CakePHP-WeltCakePHP ist ein Open Source-Projekt und wird von einer großen Entwicklergemeindeunterstützt und weiterentwickelt. In diesem Abschnitt möchten wir Ihnen einen kurzenÜberblick darüber geben, welche Organisationen, Menschen und Ressourcen für Cake-PHP relevant sind.

Die Cake Software FoundationDie Cake Software Foundation (CSF) ist eine Non-Profit-Organisation, die Ende 2005gegründet wurde, um CakePHP zu unterstützen. Diese Organisation koordiniert die Wei-terentwicklung, die Verbreitung und die Pressearbeit für CakePHP und kümmert sich umdie Server und die für ein Open Source-Projekt dieser Größe nötige Infrastruktur.

Die CSF bietet Unternehmen die Ausbildung ihrer Entwickler zu CakePHP-Profis an –auch als Vor-Ort-Training. Die offizielle Website der Cake Software Foundation findenSie unter http://www.cakefoundation.org/.

Die CSF freut sich über jede Form von Unterstützung unter http://www.cakefoundation.org/pages/donations.

Die Cake Development CorporationDie Cake Development Corporation (CDC) ist eine Agentur, die vom CakePHP-Kernteambetrieben wird. Diese Agentur bietet Unternehmen professionelle Dienste im Zusammen-hang mit CakePHP an. Die CDC beschäftigt hochqualifizierte CakePHP-Entwickler, dieUnternehmen in Hinblick auf die Konzeption und Planung ihrer Anwendungen in Cake-PHP beraten, die Anwendungen entwickeln und diese kontinuierlich auf Skalierbarkeit,Performance und Wartbarkeit prüfen.

Zusammenfassend kann man sagen, dass die Cake Development Corporation von derBeratung über die Konzeption und Entwicklung bis hin zum Deployment einen komplet-ten Service rund um CakePHP anbietet.

XX | Einleitung

Weitere Informationen finden Sie unter http://www.cakedevelopment.com/.

Weiterführende QuellenIm Folgenden haben wir die wichtigsten Ressourcen für CakePHP aufgelistet:

• Die offizielle, mehrsprachige und ständig wachsende Dokumentation, das Cook-Book: http://book.cakephp.org

• Die CakePHP-API: http://api.cakephp.org/

• Die Bakery: Hier gibt es von der Community und dem Core-Team geschriebeneArtikel zu diversen Themen, Codeschnipsel und News aus der CakePHP-Welt: http://bakery.cakephp.org

• Der #cakephp-IRC-Channel in irc.freenode.net

• Die internationale Google Group für CakePHP finden Sie unter http://groups.google.com/group/cake-php.

• Die deutsche Google Group: http://groups.google.com/group/cakephp-de

• CakeForge, die Plattform für Open Source-Projekte, die auf CakePHP basieren: http://cakeforge.org/

DanksagungenCakePHP wird von einer motivierten und hilfsbereiten Community entwickelt, die unsbeim Schreiben dieses Buchs sehr geholfen hat. Unser Dank gilt insbesondere natürlichdem Kernteam von CakePHP:

• Garret J. Woodworth, Projektleiter von CakePHP

• Larry E. Masters, ehemaliger Hauptentwickler

• Nate Abele, derzeitiger Hauptentwickler

• Mariano Iglesias, Entwickler

• Felix Geisendörfer, Entwickler

• John David Anderson, Dokumentation

Und natürlich gilt den vielen Bloggern Dank, die ihr Wissen über CakePHP unermüdlichweitervermitteln, insbesondere Felix Geisendörfer und Tim Koschützki von DebuggableLtd. (debuggable.com), Daniel Hofstetter (cakebaker.42dh.com), Mariano Iglesias (www.marianoiglesias.com.ar), Geoff Ford (lemoncake.wordpress.com), Andy Dawson (ad7six.com), Chris Hartjes (littlehart.net/atthekeyboard) und Jonathan Snook (snook.ca).

| 1

Kapitel 1 KAPITEL 1

CakePHP kennenlernen

Dieses Buch wird Ihnen im Laufe seiner Kapitel das Framework CakePHP mit all seinenMöglichkeiten näherbringen, wodurch Sie in die Lage versetzt werden, mit diesem wun-derbaren Stück Software Webseiten und andere Webapplikationen zu entwickeln. Siewerden feststellen, dass nach einer kurzen Eingewöhnungszeit CakePHP Ihre Arbeitspürbar beschleunigen wird, so dass die Entwicklung von Standardanwendungen plötz-lich nur noch einen kleinen Teil der Zeit benötigt, die Sie früher dazu aufgewendethaben. Aber wir möchten an dieser Stelle nicht zu weit vorgreifen.

Wenn Sie noch nie mit einem Framework gearbeitet haben, klingen unsere Worte andieser Stelle vermutlich eher wenig glaubhaft. Falls Sie bereits die Möglichkeiten einesFrameworks kennen – sei es für PHP oder eine andere Programmiersprache –, dann dür-fen Sie gespannt sein, wie gut die Konzepte auch für eine Websprache funktionieren.Eines möchten wir auf jeden Fall jetzt schon klarstellen: CakePHP ist keine simpleSammlung von Klassen und Funktionen, die einem lediglich eine Hand voll Werkzeugebereitstellt. Es ist viel mehr. Wir würden sogar so weit gehen zu sagen, dass CakePHPeine eigene Philosophie des Entwickelns mit sich bringt, die dank ihrem logischen Auf-baus und der in sich geschlossenen Struktur jeden Entwickler während seiner Arbeitmerklich und unmerklich unterstützt.

Das soll nicht heißen, dass es jetzt nur noch einen richtigen Weg gibt, um Vorhabenumzusetzen. Es gibt immer viele Möglichkeiten, die auch gern von CakePHP-Entwick-lern in Foren und Blogs ausführlich diskutiert werden. Aber es gibt immer eine gedank-liche Grundlinie, den »Cake-Way«, der die Philosophie des Frameworks repräsentiert.

Doch bevor wir den CakePHP-Weg beschreiten, möchten wir ein paar grundsätzlicheFragen beantworten, die im Zusammenhang mit Frameworks oft gestellt werden. DieFrage nach dem Sinn eines derartigen programmiersprachlichen Overheads ist sicherberechtigt – vor allem, wenn Sie bisher noch nie mit einem Framework (in welcher Spra-che auch immer) gearbeitet haben.

2 | Kapitel 1: CakePHP kennenlernen

Was ist ein Framework?Ein Framework, frei übersetzt eine »Rahmenstruktur«, ist im Prinzip eine Art Codege-rüst, das für die Entwicklung von Applikationen verwendet wird. Ein Framework selbstist kein fertiges Programm, sondern stellt vielmehr eine Art Grundlage dar, auf der einneues Programm entwickelt wird. In der Regel wird durch ein Framework ein bestimmterStil oder ein bestimmter Aufbau vorgegeben, nach dem sich der Entwickler richten sollte.In der Regel liegt dieser Struktur ein bestimmtes Entwurfsmuster zugrunde, beispiels-weise das Model-View-Controller-Pattern, das bei CakePHP Anwendung findet.

Der Begriff des Frameworks ist relativ ungenau definiert und umfasst im Prinzip alleArten von programmiertechnischen Vorarbeiten, die ein Entwickler nutzen kann. Vonschlichten Werkzeugsammlungen bis hin zur kompletten Abstraktion eines Workflowsin Applikationen ist alles unter dem Begriff »Framework« zu finden. Bekannte Frame-works neben CakePHP sind beispielsweise Struts für Java, das MFC von Microsoft für dieWindows-Entwicklung und natürlich Ruby on Rails, dessen grundlegende Konzepte fürCakePHP adaptiert wurden.

In der Regel werden Frameworks für bestimmte Arten von Applikationen bzw. be-stimmte Problembereiche definiert, um dem Entwickler einen Best Practice-Ansatz be-reitzustellen, mit dem er das entsprechende Problem lösen kann. Es liegt nahe, für dieEntwicklung von Webanwendungen diesen Denkansatz zu verfolgen, da bestimmte Pro-blemstellungen und Lösungsansätze zwangsläufig immer wieder auftauchen. So gleichteine Webapplikation der anderen schon auf so fundamentaler Ebene, dass der Daten-strom zwischen User und der Logikschicht über das HTTP-Protokoll zwischen demBrowser und dem entfernten Rechner ausgetauscht wird. In der Regel gibt es auch nichtnur einen User, der diese Anwendung benutzt und auf die Ressourcen des Servers zu-greift, sondern eine ganze Menge, so dass man auch eine Funktion haben sollte, um dieZugriffe verschiedener User voneinander zu unterscheiden.

Eines der wesentlichen Merkmale des HTTP-Protokolls ist die Tatsache, dass es verschie-dene Aufrufe des Users innerhalb eines Zeitrahmens nicht miteinander in Bezug setzenkann. Das Protokoll ist also zustandslos. Um die Sitzung eines Users verfolgen zu können,muss innerhalb der Logikschicht also noch einiges passieren (Session-Handling usw.).Darüber hinaus ist allen Applikationen gemein, dass Daten in einem bestimmten Formatüber ein Netzwerk vom Browser an den Server gesendet werden. Eine angesprocheneApplikation verarbeitet diese Daten und reagiert in einer bestimmten Form auf dieAnfrage – in der Regel so, dass weitere modifizierte Daten an den User zurückgeschicktwerden und im Browser über HTML dargestellt werden. Die Ausgabe beim User wie-derum kann aus weiteren Eingabeelementen bestehen, die neue Daten anfordern oderschlicht in einem bestimmten Format ausgeben.

Die Darstellung, der Datenaustausch, die Useridentifizierung und die Verwaltung vonSessions sind nur einige Beispiele, die standardmäßig in fast jeder Webanwendung vor-

Grundprinzipien des CakePHP-Frameworks | 3

kommen, so dass ein Framework sie kapseln kann, um dem Entwickler das Leben zuerleichtern.

Das CakePHP-Framework nutzt das Model-View-Controller-Entwurfsmuster, das fürden Aufbau stark oberflächenorientierter Software geschaffen wurde. Dabei ist es egal,ob es sich um eine verteilte Anwendung handelt, die auf einem entfernten Server läuftund deren Darstellung beim User lokal gerendert wird, oder um eine simple Fensterappli-kation. Der Ansatz ist derselbe, und er sieht eine strikte Trennung von Datenhaltung,Darstellung und Logik vor. Das MVC-Pattern werden wir später in diesem Kapitel nochgenauer betrachten.

Grundprinzipien des CakePHP-FrameworksDas CakePHP-Framework basiert auf einer Reihe von Konzepten, die Sie kennen müs-sen, um CakePHP zu verstehen und mit ihm arbeiten zu können. Im Folgenden möchtenwir die wichtigsten Begriffe kurz anreißen, um dann später im Laufe des Buches näherdarauf einzugehen.

DRY – Don't Repeat YourselfEiner der wesentlichsten Grundsätze von CakePHP kann in dem Akronym DRY zusam-mengefasst werden. Diese drei Buchstaben stehen für das simple Statement Don’t repeatyourself – »Wiederhol dich nicht«. Im Prinzip muss dazu nichts weiter gesagt werden,denn die Bedeutung ist klar: Es geht um die Vermeidung unnötiger Redundanzen imQuelltext bzw. in der Datenhaltung. Das Ziel besteht darin, eine schlanke Applikation zuschaffen, die einfach zu warten ist, ohne dass gleiche oder ähnliche logische Bereichenebeneinander existieren. Wenn das DRY-Prinzip erfolgreich umgesetzt wird, kann manals Entwickler sicher sein, dass durch Änderungen am Quelltext keine Nebenwirkungenfür logisch unabhängige Bereiche der Anwendung entstehen. Gleichzeitig müssen dieTeile der Applikation, die logisch auf dem geänderten Bereich beruhen, synchron undvor allem vorhersehbar reagieren.

CakePHP unterstützt dieses Prinzip dadurch, dass Standardaktionen im Frameworkabgewickelt werden und der Entwickler durch den Einsatz wesentlicher Design-Patternseine saubere Struktur der Applikation vorgesetzt bekommt. Das Prinzip wird also nichtnur innerhalb eines einzelnen Projektes berücksichtigt, sondern auch projektübergrei-fend, da bestimmte Logiken direkt von CakePHP implementiert sind und so direkt vomEntwickler genutzt werden können. Gerade für die Entwicklung von Prototypen ist die-ses Default-Verhalten nützlich, da grundsätzliche Funktionalitäten direkt zur Verfügungstehen und später in der Entwicklung einfach im Sinne der Objektorientierung über-schrieben werden.

4 | Kapitel 1: CakePHP kennenlernen

Rapid Development Das Entwickeln von Applikationen besteht klassischerweise aus mehreren Phasen, vondenen das reine Programmieren nur eine ist. Neben der Analyse der Anforderungen undAnwendungsfälle gehört nach der Implementierung auch das Testen gegen diese Anfor-derungen zu den wesentlichen Schritten. Der Entwicklungsprozess ist damit einer linea-ren Ordnung unterworfen und wird in der Regel chronologisch durchlaufen. Späterauftretende Änderungen an den Anforderungen können oft nur schwer berücksichtigtwerden, wenn die Analyse- und Planungsphase schon abgeschlossen ist. Der Begriff Fea-ture Freeze ist ein typisches Merkmal für diese Art des Denkens.

Strukturiertes Vorgehen dieser Art hat sicher viele Vorteile, führt aber auf der anderenSeite zu einer unflexiblen Haltung, die hoch variable Konzepte oft schwer umsetzbarmacht.

Rapid Development basiert auf der Idee, die Planungsphase bei der Entwicklung einerSoftware kurz zu halten und möglichst schnell ausführbaren Code in Form von Prototy-pen zu erstellen. Ein Prototyp ist ein Stück Software, das die wesentlichen Funktionalitä-ten einer Anwendung repräsentiert. Konzepte können auf diese Weise unkompliziertgetestet werden, damit man eventuell notwendige Änderungen gleich realisieren kann.Das Ziel ist es, dem Kunden möglichst früh ein funktionsfähiges Modell zeigen zu kön-nen, um vielleicht bestehende Missverständnisse auszuräumen. Wenn der Prototyp vomKunden abgesegnet worden ist, wird auf Basis dieses Modells die eigentliche Applikationentwickelt.

Das Konzept des Rapid Development kommt der Praxis der Webentwicklung sehr nahe,da an dieser Stelle oft keine fertigen Konzepte vonseiten des Auftraggebers vorliegen,sondern viele Applikationen erst während der Entwicklung durchdacht werden und nachdem Prinzip »Versuch und Irrtum« wachsen. Prototyping erspart dem Entwickler hierviel Zeit und Ärger.

CakePHP trägt dieser Tatsache Rechnung, indem die Techniken des Prototyping imFramework »nativ« hinterlegt wurden: Es existiert für fast alle Aktionen ein Default-Ver-halten, das vom Entwickler genutzt werden kann oder für die eigenen Anforderungenüberschrieben wird. Standardfunktionen im Umgang mit Daten wie CRUD (siehe nächs-ter Absatz) sind durch die Möglichkeiten des Scaffolding von Anfang an gegeben. So rei-chen beispielsweise die Informationen einer Datenbanktabelle aus, um ein komplettesFormular zu erzeugen. Es muss keine Zeile Code geschrieben werden, und man hat trotz-dem eine funktionierende Applikation auf Basis einer Datenbank, die als Grundlage füreinen Prototyp verwendet werden kann.

CRUD – CREATE, READ, UPDATE und DELETEEin weiteres Prinzip aus der CakePHP-Welt ist CRUD – vier Buchstaben, die auf den ers-ten Blick relativ fürchterlich aussehen, aber für die vier wesentlichen Aktionen im

Grundprinzipien des CakePHP-Frameworks | 5

Umgang mit persistenten Daten stehen: CREATE, READ, UPDATE und DELETE.Nahezu jede Anwendung im Bereich der Datenverarbeitung basiert auf mindestens einerdieser Funktionen, und dynamische Webapplikationen sind dabei keine Ausnahme. Eherim Gegenteil: Die meisten Webanwendungen basieren im Wesentlichen auf der Darstel-lung von Daten, die über Formulare durch den User modifiziert werden können. Miteiner entsprechenden Datenbank im Hintergrund kann jede dieser Aktionen ganz einfachauf einen SQL-Befehl übertragen werden:

CakePHP hat dieses Prinzip konsequent verinnerlicht und bietet im Framework für jededieser Standardaktionen eine reichhaltige Anzahl an Werkzeugen. Gerade im Bezug aufdie dynamische Selektion von Daten nach bestimmten Kriterien, die erst zur Laufzeitbekannt sind, ist das Framework sehr mächtig. Man kann sogar noch einen Schritt weitergehen und das Standardverhalten einer Applikation im Umgang mit Daten einer Daten-bank automatisch generieren lassen. Auf diese Weise kann für jede Datenbanktabelleund entsprechend verknüpfte Felder dynamisch Quelltext erzeugt werden, der für jededer genannten Aktionen eine lauffähige Methode erstellt.

Konvention über Konfiguration Ein weiterer wesentlicher Aspekt, den CakePHP von Ruby on Rails übernommen hat, istdie Philosophie »Konvention über Konfiguration« (engl. Convention over Configuration).Im Wesentlichen bedeutet dieser Ansatz, dass der Entwickler nur die Bereiche einerApplikation konfigurieren muss, die sich nicht aus dem logischen Zusammenhang bzw.den festgelegten Konventionen ergeben – also den »unkonventionellen« Teil der Anwen-dung. Ein typisches Beispiel für die Anwendung von Konventionen in CakePHP ist dieVerknüpfung der Models mit Datenbanktabellen, des Controllers mit dem Model oderdie Verknüpfung eines einzelnen View-Template mit einer Action im Controller. Gibt eszum Beispiel eine Tabelle namens posts in der Datenbank, dann wird diese durch dieModel-Klasse post.php repräsentiert. Die entsprechende Controller-Klasse liegt in derDatei posts_controller.php und arbeitet mit den Templates innerhalb des Ordners posts.

Für den Entwickler bedeuten diese Konventionen eine Arbeitserleichterung, da er, wenner sich an die Konventionen hält, keine Zeile Code schreiben muss, um dem Frameworkdie oben genannten Zusammenhänge mitzuteilen. CakePHP sucht automatisch nach denentsprechenden Dateien und geht davon aus, dass laut Konvention die entsprechendenKlassen zusammengehören und -arbeiten.

CRUD-Aktion SQL-Befehl

CREATE INSERT

READ SELECT

UPDATE UPDATE

DELETE DELETE

6 | Kapitel 1: CakePHP kennenlernen

Damit fällt die für viele Frameworks und auch Applikationen typische Menge an Konfi-gurationsdateien zu einem großen Teil weg, und als Entwickler läuft man nicht Gefahr,durch eine »Überkonfiguration« Fehler zu machen, die sich vermeiden lassen würden.Gerade sehr große Projekte leiden oft an riesigen Konfigurationen, die schnell unüber-sichtlich werden.

Das Model-View-Controller-PatternNun ein wenig Theorie für alle, die es interessiert. CakePHP basiert auf einem Design-Pattern mit dem Namen Model-View-Controller, dessen Grundlage für das Verständnisdes Frameworks sehr wichtig ist. Das Model-View-Controller-Modell, kurz MVC, wurdeursprünglich für die Erstellung von Benutzeroberflächen mit Smalltalk-80 verwendet.Das Ziel des Modells ist die logische Trennung der Funktionalitäten in einer interaktivenApplikation in abgegrenzte Teilsysteme. Auf diese Weise wird eine hohe Flexibilität fürdie Darstellung der Daten garantiert, sowie ein hoher Grad an Wiederverwendbarkeiteinzelner Bereiche.

Model-View-Controller, wörtlich etwa »Modell-Präsentations-Steuerung«, inzwischenein weit verbreiteter Standard, ist als Entwurfsmuster im maßgeblichen Werk der Gangof Four1 beschrieben worden. Nicht nur CakePHP arbeitet mit diesem Muster, sondernauch viele andere Frameworks, zum Beispiel Struts für Java oder das bekannte Ruby onRails.

Das MVC-Modell sieht eine genaue Aufgabenteilung innerhalb einer oberflächenorien-tierten Applikation vor. Das Softwaresystem wird dazu in drei Einheiten aufgeteilt:Datenmodell (engl. model), Präsentation (engl. view) und Programmsteuerung (engl. con-troller). Als Model wird die Datenquelle bezeichnet, die Daten unabhängig vom Erschei-nungsbild liefert (also beispielsweise aus einer relationalen Datenbank), bzw. ihresoftwaretechnische Kapselung in der Applikation. Das View formatiert und zeigt dieseDaten, wobei die Darstellung derselben Daten durch die Wahl bzw. Anpassung desViews geändert werden kann. Es ist also nicht das Model, das die Ausgabe der Datenbeeinflusst, sondern das View, das weitgehend unabhängig vom Model ist. Ein Modelkann beliebig viele Views haben.

Der Controller kontrolliert die Interaktion mit dem Benutzer und somit das Verhaltender Komponente oder, anders ausgedrückt, die Applikationslogik. Informationen wer-den durch den Controller vom View zum Model übertragen, um Änderungen an denDaten oder der Datenselektion zu ermöglichen. Beim Controller handelt es sich also umeinen Vermittler, der nicht nur Daten selektiert, sondern auch das entsprechende Viewfür die Darstellung der Daten. Abbildung 1-1 zeigt das MVC-Modell als Diagramm.

1 Entwurfsmuster: Elemente wiederverwendbarer objektorientierter Software, von Erich Gamma, Richard Helm,Ralph Johnson und John Vlissides, Addison-Wesley.

Das Model-View-Controller-Pattern | 7

Der Vorteil dieser Aufgabenverteilung innerhalb einer Applikation ist offensichtlich:Zum einen können logisch unabhängige Bereiche geschaffen werden, die ausgetauschtbzw. geändert werden können, ohne dass die korrespondierenden Teile der Applikationberührt werden müssen. Auf den konkreten Fall einer Webapplikation bezogen, ist eszum Beispiel möglich, ein View-Template von einem Webdesigner anpassen zu lassen,ohne dass er den Controller oder das Model kennen muss. Er muss lediglich auf diedynamischen Werte im Template achten und diese im neuen Kontext darstellen. Zumanderen ist die Aufteilung der Applikation für das Debugging hilfreich, da Fehler schnel-ler lokalisiert werden können. Jeder einzelne Bereich kann von einem entsprechendenEntwickler betreut werden, der seine Kenntnisse schwerpunktmäßig einsetzen kann.

Es folgen kurze Beschreibungen der drei Komponenten Model, View und Controller imKontext einer Webapplikation, wie Sie sie mit CakePHP entwickeln werden.

Das ModelDas Model repräsentiert die Daten einer Anwendung und enthält in den meisten Imple-mentierungen die Geschäftslogik der Anwendung, womit alle Datenmanipulationen unddatenrelevanten Aktionen gemeint sind. Die Model-Klasse stellt eine Reihe von Metho-den zur Verfügung, über die es möglich ist, den Zustand der Daten abzufragen, die Datenzu filtern und natürlich zu verändern. Die CRUD-Funktionalität ist so direkt im Model

Abbildung 1-1: Das MVC-Pattern

Model View

Controller

Dispatcher

Webserver

Browser

Router

8 | Kapitel 1: CakePHP kennenlernen

hinterlegt. Das Model kennt kein konkretes View, sondern bekommt es zur Laufzeit überden Controller zugewiesen.

Ein Model ist nicht mit einer Datenbankabstraktion zu verwechseln. Die Datenquelleeines Models kann genauso gut eine XML-Datei sein. Es ist wichtig zu verstehen, dassdas Model unabhängig von der Datenquelle schlicht die Daten und deren Eigenschaftenund Eigenheiten repräsentiert. Dazu gehört beispielsweise auch die Information, welcheTabellen in einer relationalen Datenbank wie mit dem Model zusammenhängen und wel-che Abhängigkeiten in der Datenbank herrschen. Das Model enthält auch Informationenüber einzelne Felder, beispielsweise Validierungsregeln, die festlegen, welche Werte Gül-tigkeit haben und welche nicht.

Das ViewDas View übernimmt die Darstellung der Daten in der Applikation und entspricht derPräsentationsschicht. Ein View ist dabei immer auf ein bestimmtes Model bezogen undwird nicht für die Darstellung anderer Daten verwendet. Die Daten werden allerdingsnicht direkt vom View aus dem Model gezogen, sondern in der Regel über den Controllerselektiert und weitergereicht.

In der Welt der Webapplikationen entspricht ein View immer der Darstellung in einembestimmten HTML-Template bzw. einer Datenausgabe in XML oder einer anderen Aus-zeichnungssprache für die Übermittlung an definierte Schnittstellen. In CakePHP bein-haltet das View-Layer allerdings nicht nur rudimentäre Template-Funktionen, sonderndarüber hinaus auch noch Komponenten, die es erweitern und dem Entwickler diverseHilfestellungen geben.

In der Entwicklungsphase kann auf die manuelle Erstellung von Views auch verzichtetwerden, indem man im Controller die Scaffolding-Option nutzt, die Sie in Kapitel 3,Schnell zum Erfolg – Ihre erste Webapplikation mit CakePHP, kennenlernen werden. Aufdiese Weise werden dynamisch Views auf Basis der im Model definierten Daten erstellt.

Der ControllerDer Controller enthält die Anwendungslogik der Applikation und kontrolliert denAblauf der Benutzerinteraktion. Ein Controller definiert eine Reihe von möglichenActions gegenüber einer oder mehreren Model-Klassen und bietet zu diesem Zweck eineReihe von Schnittstellen, die in der Regel über ein View (in Form eines Links oder einesFormulars) angesprochen werden. Ein Controller regelt also die Zusammenarbeit vonModel und View, indem er die Anfragen an die Schnittstellen verwaltet und entspre-chend an das Model weiterleitet. Das Ergebnis einer Anfrage wird dann in einem neugenerierten View an den User zurückgeschickt.

Der Controller ist bei einer Webanwendung ein Stück PHP-Code, der über eine HTTP-Anfrage aufgerufen wird. Jede Schnittstelle, in CakePHP Action genannt, entspricht einer

Das Zusammenspiel der CakePHP-Komponenten | 9

Methode in der Controller-Klasse, die über eine URL direkt angesprochen werden kann.Das Framework routet diese Anfrage automatisch an den korrekten Controller weiterund sorgt dafür, dass eventuelle Parameter in der Funktion zur Verfügung stehen.

Das Zusammenspiel der CakePHP-KomponentenDieser Abschnitt bietet Ihnen einen Überblick über CakePHP, seine Komponenten undden Zusammenhang mit den soeben besprochenen Konzepten und Theorien.

CakePHP baut auf dem Model-View-Controller-Pattern auf und setzt dabei auf eigeneImplementierungen von Model, View und Controller, die als Basisklassen zur Verfügungstehen. Diese drei Fundamente von CakePHP erweitern Sie dann durch Ihre eigenenImplementierungen. Zusätzlich dazu stehen weitere Klassen zur Verfügung, um verschie-dene Aufgaben zu erleichtern, Ihren Code besser wiederverwendbar zu machen und dieEntwicklung innerhalb des MVC-Patterns zu beschleunigen.

MVC in CakePHPIn Abbildung 1-2 sehen Sie die grundlegende Struktur von CakePHP. Wie schon imAbschnitt über das MVC-Pattern erläutert wurde, kapselt das Model den Datenzugriffund die Daten. Dort wird auch die Geschäftslogik implementiert. Der Controller steuertdie Benutzerinteraktion und die Abläufe der Anwendung und greift auf die Daten ausdem Model zu. Diese werden dann im Controller an die View-Ebene übergeben, in derdie Präsentationslogik implementiert ist.

Abbildung 1-2: Die Komponenten von CakePHP und ihr Zusammenspiel

erweitern Model umFunktionalitäten

erlauben den Eingriffin die Abläufe im

CakePHP-Kern

ModelDataSources

Behaviors

Callbacks

abstrahierenDatenquellen

ControllerComponents Callbacks

kapseln wieder-verwendbare

Controller-Logik

erlauben den Eingriffin die Abläufe im

CakePHP-Kern

ViewHelper Layouts, Elements

kapselnPräsentationslogik

erleichtern dieWiederverwendung vonFrontend-Bestandteilen

10 | Kapitel 1: CakePHP kennenlernen

Das Model holt sich seine Daten über die DataSource-Klassen, um konsistent mit ver-schiedensten Datenquellen arbeiten zu können – von Datenbanken über LDAP-Server bishin zu Daten im XML-Format. Mit Behaviors lassen sich Models um Funktionalitäterweitern. Beispielsweise können Sie ein Model durch das Zuweisen von TreeBehaviordazu ermächtigen, mit Nested-Set-Baumstrukturen spielend leicht zu arbeiten. Die ge-samte Logik dafür ist hierbei im Behavior gekapselt und steht dem Model ohne weitereUmschweife zur Verfügung.

Um die Standardabläufe von CakePHP um weitere Logik zu erweitern, bieten Model undController verschiedene Callback-Funktionen, damit Sie möglichst einfach Code zwi-schen die aufeinanderfolgenden Schritte einfügen können.

CakePHP-Controller werden von Components unterstützt. Diese könnte man als »kleine«Controller bezeichnen, denn sie kapseln Logik, die normalerweise in die Controller gehö-ren würde, aber wiederverwendbar sein muss. Ein Beispiel dafür ist die Email-Compo-nent, die den Versand von E-Mails und allem, was dazugehört, kapselt.

Am Ende einer CakePHP-Anfrage kommt das View. Es zeigt die im Controller aufbereite-ten Daten an und wird dabei von Helper-Klassen unterstützt. Helper kapseln wieder-verwendbare Präsentationslogik und stellen Helferlein zur Verfügung, die die View-Pro-grammierung erleichtern. Dazu gehören beispielsweise Funktionen für die Anzeige vonPaginierungslinks, aber auch die Kapselung von Ajax-Funktionalitäten und des zugehöri-gen JavaScript. In CakePHP gibt es drei Arten von View-Templates: das View an sich, alsodas Template der aktuellen Action, das Layout, also den Container der Website, undElements. Diese können an verschiedenen Stellen wiederverwendet werden. Eine klassi-sche Anwendung für Elements sind Menüs oder immer wiederkehrende Sidebars.

Weitere KomponentenDass CakePHP nicht bloß eine starre Implementierung des MVC-Patterns in PHP ist,haben Sie sicher bereits gemerkt. Durch DataSources, Behaviors, Components und Hel-per werden die drei Grundsäulen des Patterns unterstützt. Doch es gibt noch einigeModule in CakePHP, die erwähnt werden sollten.

Plugins

Ein Plugin in CakePHP ist eine fast eigenständige Applikation mit ihren eigenen Control-lern, Models, Views, Helpers und was sonst noch so dazugehört, die in eine bestehendeAnwendung integriert werden kann. Dazu verschiebt man einfach den Ordner mit demPlugin in das Pluginverzeichnis von CakePHP. So installierte Plugins greifen dann auf denCakePHP-Kern der Anwendung und auch auf ihre Layouts zu.

Routes und der Dispatcher

Mit Routes können Sie die URLs Ihrer Applikation gestalten. Sie definieren damit, wieCakePHP URLs auf die zugehörigen Controller und Actions leiten soll. Routes sind einsehr flexibles Werkzeug, um Ihre URLs zu verschönern und Ihre Applikation für Suchma-