Welcome to The Cookbook

1. Ihr geht auf eine bestimmte Seite und entdeckt einen Fehler, bemerkt, daß etwas unvollständig ist, daß etwas noch überhaupt nicht erklärt wird oder es einfach nicht so vorliegt, wie ihr es gerne hättet.
2. Logt euch in das "Kochbuch" mit Hilfe eures "Bakery" Zuganges ein.
3. Editiert (oder schlagt vor) Abschnitte mit Hilfe einfachen HTMLs
4. Schaut in den nächsten Tagen vorbei um eure Änderungen zu sehen

Diese Anwendung is absolut neu, deshalb habt bitte ein wenig Geduld weil wir gerade ein paar letzte Dinge in Vorbereitung auf das CakePHP 1.2 Release ausarbeiten

Wenn ihr mit Übersetzungen aushelfen wollt, schickt bitte eine Email an John David Anderson (docs at cakephp punkt org) oder kontaktiert ihn via IRC (#cakephp bei freenode, unter dem Namen _psychic_).

Hinweise für Übersetzer:

• Bitte keine HTML Zeichenreferenzen für Umlaute u.ä. verwenden. Im Cookbook ist alles UTF-8 kodiert, sodass dies Dinge nur unnötig verkomplizieren würde.
• Haltet den Schreibstil locker, nicht übermäßig formell.
• Übersetzt bitte die Überschrift und den Inhalt.
• Bitte setzt die Sprache in eurem Browser auf die Sprache in die ihr übersetzt, sonst werden die Änderungen als englische Änderung gespeichert und der Korrekturleser weiß ggf. nicht, um welche Sprache es sich handelt soll.
• Bitte ändert das Markup nicht zu doll oder stellt übermäßig viele neue Inhalte ein. Wenn es etwas zu ergänzen gibt, tut dies bitte zuerst in der Originalfassung.
• Wenn Ihr einen englischen Begriff verwenden müßt, klammert ihn bitte in <em> Tags. Z.B. "im Controller werden..." oder "in der Kontrollklasse (Controller) werden...".

Wir arbeiten ständig an der Verbesserung der CakePHP Dokumentation und hoffen, daß ihr uns bei unseren Bemühungen mit Hilfe des Cookbooks unterstützen werdet. Jeder kann etwas zum Projekt beisteuern und wir wären froh, wenn ihr etwas an die Community zurückgeben würdet.

Willkommen im Kochbuch, dem Handbuch für das CakePHP web application framework das die Entwicklung in PHP zum Kinderspiel macht! (Im Englischen werden einfache Aufgaben oft als 'piece of cake' bezeichnet.)

Dieses Handbuch setzt ein allgemeines Verständnis der Sprache PHP und Grundlagenwissen im Bereich Objektorientierter Programmierung (OOP) voraus. Die verschiedenen Funktionalitäten des Frameworks verwenden unterschiedlichste Technologien — wie z.b. SQL, JavaScript, und XML — dieses Handbuch geht nicht im Detail auf die Funktionsweisen dieser Technologien ein, sondern beschreibt nur wie sie im Umfeld des Frameworks eingesetzt werden.

CakePHP is ein freies, open-source-basiertes, rapides Entwicklungsframework für PHP. Es ist eine Grundlage für das Programmieren von Web-Applikationen. Unser primäres Ziel ist, in einer strukturierten und rapiden Umgebung zu arbeiten - ohne die Flexiblität zu verlieren.

CakePHP lässt das Eintönige der Web-Entwicklung links liegen. Wir stellen alle Werkzeuge zur Verfügung, die man wirklich braucht, wenn man zum Programmieren beginnt: Die logische Struktur in Ihrer Applikation. Anstatt immer wieder das Rad neu zu erfinden, probieren Sie CakePHP und starten Sie mit den wichtigen Sachen Ihrer Applikation.

CakePHP hat ein aktives Entwicklungsteam und eine Community, die zum Erfolg des Projekts beiträgt. Im Gegensatz zu einer 0815-Kopie, finden Sie mit CakePHP eine Applikation, die ausreichlich getestet wurde und laufend erweitert wird.

Hier ist eine Liste von Features, die Sie beim Benutzen von CakePHP sicherlich genießen werden:

• Aktive, freundliche Community
• Flexible Lizenz
• Kompatibel mit PHP4 und PHP5
• Integrierte CRUD für Datenbank-Interkationen
• Scaffolding
• Code-Generierung
• "Model-View-Controller (MVC)"-Architektur
• Automatische Erstellung von "schönen" URLs
• Integrierte Validierung
• Schnelle und flexible Template-Erstellung (PHP-Syntax, mit "Helferleins")
• "Helferleins" für AJAX, JavaScript, HTML Formulare und mehr
• E-Mail-, Cookie-, Sicherheit-, Sitzung- (Session-) und Anfrage-Management-Komponenten
• Flexible Benutzerrechteverwaltung
• Automatische Daten-Transformierung
• Flexibles Caching
• Mulitilingual (lokalisiert)
• Funktioniert in jedem Verzeichnis und nur mit wenigen bis gar nicht notwendige Apache-Konfigurationen

The Cookbook

http://book.cakephp.org

Sie sind bereits am richtigen Platz. Das Manual sollte normalerweise immer die erste Anlaufstelle für Ihre Probleme sein. Genauso wie viele andere Open-Source-Projekte, steigen die Userzahlen immer höher. Versuchen Sie Ihr bestes, um Ihre Fragen zuerst selber zu beantworten. Die Antworten kommen dadurch vielleicht etwas langsamer, dafür bleiben Sie aber länger in Erinnerung - und Sie entlasten dadurch das Support-Team. Das Handbuch sowie die API haben eine Online-Komponente.

The API

http://api.cakephp.org/1.2

Direkt von den Core-Entwicklern kommt die CakePHP API (Application Programming Interface), sie ist die umfangreichste Dokumentation für all diese kleinen Details beim Arbeiten mit einem Framework. Die API ist eine einheitliche und strukturierte Code-Referenz und somit ein wichtiges Entwicklungswerkzeug.

The IRC channel

#cakephp @ irc.freenode.net

Wenn Sie richtig genervt sind, geben Sie uns doch eine Chance im CakePHP IRC-Channel. Normalerweise ist immer jemand vom Entwicklungs-Team dort, speziell in den Tageszeiten für Nord- und Südamerikanische User. Wir würden uns freuen, von Ihnen zu hören, egal ob Sie Hilfe benötigen, andere User in Ihrer Nähe finden wollen oder Sie einfach ein wenig Geld für Ihr neues Sport-Auto benötigen.

The Bakery

http://bakery.cakephp.org

Die CakePHP Bakery ist ein aufgeräumter Sammelort für alle Dinge rund um CakePHP. Durchsuchen Sie die Tutorials, Testberichte und Code-Beispiele. Wenn Sie sich einmal in CakePHP eingearbeitet haben, können Sie sich registrieren und Ihr Wissen mit der Community teilen, somit ist Ihnen Beliebtheit und Zukunft gesichert.

CakeForge

http://www.cakeforge.org

CakeForge ist eine Entwicklungs-Plattform, wo Sie Ihre CakePHP-Projekte hosten lassen können und somit diese teilen können. Wenn Sie nach einer richtigen Killer-Komponente oder nach einem richtigen Killer-Plugin suchen (oder diese/dieses teilen wollen), registrieren Sie sich auf CakeForge.

The Official CakePHP website

http://www.cakephp.org

Die offizielle CakePHP-Webseite ist immer eine gute Anlaufsstelle. Sie bietet wichtige Links zu oft benutzten Entwicklungswerkzeugen, zu Screencasts, zu Spendenseiten und zu Downloads.

The Google Group

http://groups.google.com/group/cake-php

CakePHP besitzt außerdem eine sehr aktive Google Group (Google-Gruppe). Diese ist eine großartige Ressource, um nach alten Fragen, häufig gefragten Fragen zu suchen. Außerdem bekommen sie dort Antworten zu Ihren Problemen.

http://www.cakephp.org

The Official CakePHP website is always a great place to visit. It features links to oft-used developer tools, screencasts, donation opportunities, and downloads.

http://book.cakephp.org

This manual should probably be the first place you go to get answers. As with many other open source projects, we get new folks regularly. Try your best to answer your questions on your own first. Answers may come slower, but will remain longer–and you'll also be lightening our support load. Both the manual and the API have an online component.

http://bakery.cakephp.org

The CakePHP Bakery is a clearing house for all things CakePHP. Check it out for tutorials, case studies, and code examples. Once you’re acquainted with CakePHP, log on and share your knowledge with the community and gain instant fame and fortune.

http://api.cakephp.org/1.2

Straight to the point and straight from the core developers, the CakePHP API (Application Programming Interface) is the most comprehensive documentation around for all the nitty gritty details of the internal workings of the framework. Its a straight forward code reference, so bring your propeller hat.

http://www.cakeforge.org

CakeForge is another developer resource you can use to host your CakePHP projects to share with others. If you’re looking for (or want to share) a killer component or a praiseworthy plugin, check out CakeForge.

http://api.cakephp.org/tests

If you ever feel the information provided in the API is not sufficient, check out the code of the test cases provided with CakePHP 1.2. They can serve as practical examples for function and data member usage for a class. In your CakePHP distribution package the test cases are located under

cake/tests/cases

1. cake/tests/cases

#cakephp @ irc.freenode.net

If you’re stumped, give us a holler in the CakePHP IRC channel. Someone from the development team is usually there, especially during the daylight hours for North and South America users. We’d love to hear from you, whether you need some help, want to find users in your area, or would like to donate your brand new sports car.

http://groups.google.com/group/cake-php

CakePHP also has a very active Google Group. It can be a great resource for finding archived answers, frequently asked questions, and getting answers to immediate problems.

Gut geschriebene CakePHP Anwendungen folgen dem MVC (Model-View-Controller) Software Entwurfsmuster. Programmierungen nach MVC teilen die Anwendung in drei Haupt Bestandteile. Das Model präsentiert die Anwendungsdaten, die View generiert eine Präsentation der Model-Daten, und der Controller behandelt und steuert Benutzeranfragen.

Abbildung 1: Eine elementare MVC Anfrage

Abbildung 1 zeigt ein Beispiel einer einfachen MVC Anfrage in CakePHP. Zur Veranschaulichung nehmen wir an, ein Benutzer namens Ricardo hat gerade auf den "Kaufe einen eigenen Kuchen!"-Link deiner Webanwendung geklickt.

1. Ricardo klickt auf den Link der zur Adresse http://www.example.com/cakes/buy führt, und der Browser sendet eine Anfrage an Deinen Webserver.
2. Der Dispatcher überprüft die angeforderte URL (/cakes/buy) und leitet die Anfrage zum zuständigen Controller weiter.
3. Der Controller verarbeitet Anwendungsspezifische Abläufe. Zum Beispiel überprüft die Anwendnung ob Ricardo eingeloggt ist.
4. Der Controller benutzt die Models um Zugang zu den Anwendungsdaten zu bekommen. In den meisten Fällen präsentieren Models die verschiedenen Tabellen einer Datenbank, aber es könnten genau so gut LDAP Einträge, RSS Feeds oder Dateien sein. In unserem Beispiel wird das Model benutzt um Ricardo's letzte Einkäufe aus der Datenbank auszulesen.
5. Sobald der Controller die Daten verarbeitet hat, werden diese an die View weitergeleitet. Die View formatiert die Daten und bereitet Sie zur Ausgabe vor. Views in CakePHP sind meistens im HTML Format. Es könnte aber auch einfach ein PDF, XML Dokument oder ein JSON Objekt, je nach Anforderung, ausgegeben werden.
6. Sobald die View die Ausgabe vorbereitet hat, wird der Inhalt an Ricardos Browser ausgegeben.

Fast jede Anfrage deiner Anwendung folgt diesem Grundmuster. Es kommen später noch einige Cake-spezifische Details hinzu.

Weil es ein bewährtes und effektives Software Entwurfsmuster ist, das eine Webanwendung in eine wartbare, modulare und effizient entwickelte Anwendung verwandelt. Anwendungsaufgaben in Models, Views und Controllers zu teilen macht Deine Anwendung sehr schlank. Neue Features sind einfach hinzugefügt, alte Features schnell in einer neuen Oberfläche verpackt. Die modular und unterteilte Logik erlaubt Entwicklern und Designern gleichzeitig an der Anwendung zu arbeiten. Dies beinhaltet ebenso die schnelle Entwicklung eines ersten Prototyps. Dadurch ist es ebenso möglich einen Teil der Anwenung zu verändern, ohne einen anderen Teil zu beeinflussen.

Wenn Du noch nie eine Anwendung mit dieser Methode entwickelt hast, wird es eine Weile dauern. Aber wir sind sehr zuversichtlich, dass wenn Du Deine erste CakePHP Anwendung erstellt hast, Du nie wieder anders Arbeiten möchtest.

The Start of Becoming a Smart Cookie

CakePHP verfügt über Controller-, Model- und View-Klassen, bietet aber darüber hinaus auch einige zusätzliche Klassen und Objekte, um die Entwicklung mittels des MVC-Entwurfsmuster zu beschleunigen und zu erleichtern. Komponenten, Behaviors und Helper sind erweiterbare und wiederverwendbare Klassen, die es ermöglichen die MVC Basis-Klassen schnell um eine gewünschte Funktionalität zu erweitern. Details zur Benutzung dieser Werkzeuge befinden sich in den nachfolgenden Kapiteln. In diesem wollen wir uns zunächst einen Überblick verschaffen.

Eine Komponente ist eine Klasse, die uns bei der Controller-Logik unterstützt. Soll eine Programm-Logik von verschiedenen Controllern (oder Applikationen) gemeinsam benutzt werden, ist eine Komponente in der Regel die richtige Wahl. Als Beispiel sei die Core-Klasse EmailComponent erwähnt, mit der das Erstellen und Versenden von E-Mails ein Kinderspiel ist. Anstatt eine Methode die diese Aufgabe erfüllt in einem Controller zu implementieren, kann diese Logik gebündelt werden um sie gemeinsam benutzen zu können.

Controller verfügen des Weiteren über Callback-Routinen. Diese Callbacks sind für den Fall gedacht, daß Programmlogik zwischen CakePHP's internen Transaktionen eingefügt werden soll. Verfügbare Callbacks sind:

• beforeFilter(), wird vor jeglicher Controller-Aktion ausgeführt
• beforeRender(), wird nach der Controller-Logik, aber vor dem Rendern des Views ausgeführt
• afterFilter(), wird nach allen Controller-Aktionen einschließlich dem Rendern des Views ausgeführt. Zwischen afterRender() und afterFilter() gibt es keinen Unterschied, außer wenn die Funktion render() manuell in einer Controller-Methode aufgerufen wurde und anschließend noch Code ausgeführt wird.

Ein Helper ist eine Klasse die die Ansichtslogik unterstützt. Ähnlich wie eine Komponente in einem Controller verwendet wird, ermöglichen Helfer den Zugriff und Aufteilung der Präsentations-Logik zwischen den Views. Eine der Haupthelfer, AjaxHelper, macht Ajax requests innerhalb der Views viel einfacher.

Viele Programme haben Teile von View code die wiederholt verwendet werden. CakePHP erleichtert die Wiederverwendung von View Code mit Layouts und Elementen. Normalerweise wird jeder View der von einem Controller erstellt wird in ein Layout eingefügt. Elemente werden verwendet wenn kleine Teile von Inhalten in mehreren Views wiederverwendet werden sollen.

In ähnlicher weise arbeiten Behaviors als der Weg gemeinsame Funktionalitäten zwischen den Modellen hinzuzufügen. Wenn du zum Beispiel Nutzerdaten in einer Baumstruktur speicherst, kannst du das Verhalten deines Nutzer-Modell wie ein Baum definieren und freie Funktionalitäten für das Entfernen, Einfügen und Verlagerung der Knoten in deiner zugrundeliegenden Baumstruktur hinzufügen.

Modelle werden auch von einer anderen Klasse genannt DataSource verwendet. DataSources sind Abstraktionen, die es Modellen ermöglichen, verschiedene Arten von Daten konsistent zu verändern. Während die Hauptquelle der Daten in einer CakePHP Anwendung oft eine Datenbank ist, könntest du auch weitere DataSources schreiben, die es deinen Modellen ermöglichen RSS feeds, CSV files, LDAP entries, oder iCal events darzustellen. DataSources erlaubt es dir aus verschiedenen Quellen Datensätze zu assoziieren: anstatt auf SQL-Joins beschränkt zu sein, ermöglichen es dir die DataSources festzulegen, daß dein LDAP model mit vielen iCal events verbunden ist.

Genau wie bei den Kontrollern, sind Modelle mit Call-Back Funktionalitäten ausgestattet:

• beforeFind()
• afterFind()
• beforeValidate()
• beforeSave()
• afterSave()
• beforeDelete()
• afterDelete()

Die Namen dieser Methoden sollte beschreibend genug sein, um zu wissen, was sie tun. Die weiteren Details werden im Kapitel über die Modelle behandelt.

Controllers, helpers and models each have a parent class you can use to define application-wide changes. AppController (located at /app/app_controller.php), AppHelper (located at /app/app_helper.php) and AppModel (located at /app/app_model.php) are great places to put methods you want to share between all controllers, helpers or models.

Although they aren’t classes or files, routes play a role in requests made to CakePHP. Route definitions tell CakePHP how to map URLs to controller actions. The default behavior assumes that the URL “/controller/action/var1/var2” maps to Controller::action($var1, $var2), but you can use routes to customize URLs and how they are interpreted by your application.

Some features in an application merit packaging as a whole. A plugin is a package of models, controllers and views that accomplishes a specific purpose that can span multiple applications. A user management system or a simplified blog might be a good fit for CakePHP plugins.

Wir haben uns die grundlegenden Bestandteile von CakePHP angesehen. Nun laßt uns gemeinsam anschauen, wie die Objekte bei einer normalen Anfrage zusammenarbeiten. Nehmen wir unser ursprüngliches Beispiel wieder auf und erinnern uns, dass unser Freund Ricardo gerade auf den “Buy A Custom Cake Now!” Link der Seite einer CakePHP Anwendung geklickt hat.

Figure 2. Standardmässige Cake Anfrage.

Schwarz = benötiges Element, Grau = optionales Element, Blau = callback

1. Ricardo klickt auf den Link der nach http://www.example.com/cakes/buy verweist und sein Browser startet eine Anfrage zu deinem Webserver.
2. Der Router analysiert die URL um die Parameter der Anfrage zu bestimmen: Den controller, action, und alle anderen arguments die in dieser Anfrage Auswirkung auf die Business-Logik haben.
3. Using routes, a request URL is mapped to a controller action (a method in a specific controller class). In this case, it’s the buy() method of the CakesController. The controller’s beforeFilter() callback is called before any controller action logic is executed.
4. The controller may use models to gain access to the application’s data. In this example, the controller uses a model to fetch Ricardo’s last purchases from the database. Any applicable model callbacks, behaviors, and DataSources may apply during this operation. While model usage is not required, all CakePHP controllers initially require at least one model.
5. After the model has retrieved the data, it is returned to the controller. Model callbacks may apply.
6. The controller may use components to further refine the data or perform other operations (session manipulation, authentication, or sending emails, for example).
7. Once the controller has used models and components to prepare the data sufficiently, that data is handed to the view using the controller’s set() method. Controller callbacks may be applied before the data is sent. The view logic is performed, which may include the use of elements and/or helpers. By default, the view is rendered inside of a layout.
8. Additional controller callbacks (like afterFilter) may be applied. The complete, rendered view code is sent to Ricardo’s browser.

Lass uns einen Blick auf CakePHP werfen wie es ganz am Anfang aussieht. Du weist schon wie CakePHP es aus dem Standpunkt einer Basis-MVC-Anforderung sieht, aber du musst auch wissen wie seine Dateien organisiert sind.

• app
• cake
• docs
• index.php
• vendors

Wenn du CakePHP herunterlädst, wirst du 4 Hauptordner sehen. Der app Ordner, ist der Ordner, in dem du deine Wunder wirkst: Hier werden deine Anwendungsdateien abgelegt.
Der cake Ordner ist der Ordner in dem wir unsere Magie wirken lassen. Treffe mit dir persönlich die Absprache, in diesem Ordner keine Dateien oder Ordner zu verändern. Wenn du in diesem Kernbereich Veränderungen vornimmst, können wir dir bei der Lösung von Problemen nicht mehr weiterhelfen!
Der docs Ordner ist für die readme, changelog, und Lizens- Information.
Zu letzt, der vendors Ordner. Dies ist der Platz in dem du die, von dir, für dein CakePHP benötigte third-party PHP libraries (Dritt-Anbieter PHP-Bibliotheken) ablegst.

Der CakePHP’s app Ordner ist der Ort, in dem du den größten Teil deiner Anwendungsentwicklung vornimmst. Lass uns einen genaueren Blick in den Ordner werfen.

config

Enthält die (wenigen) Konfigurationsdateien die CakePHP benötigt. Details der Datenbankverbindung, bootstrapping, Hauptkonfigurationsdateien und weiteres mehr sollte hier gespeichert sein.

controllers

Enthält deine Anwendungscontroller und ihre Komponenten.

locale

Beinhaltet Textdateien für die Internationalisierung (I18N).

models

Enthält deine Anwendungsmodelle, behaviors und Datenquellen.

plugins

Enthält plugin Pakete.

tmp

Dies ist der Ort an dem CakePHP temporäre Daten ablegt. Wo aktuell die Daten gespeichert werden hängt davon ab, wie du CakePHP konfiguriert hast, aber dieser Ordner wird normalerweise dazu verwendet, um Modellbeschreibungen, Logdateien und manchmal auch Sessioninformationen zu speichern.

vendors

Jede third-party Klasse oder Bibliothek kann hier abgelegt werden. Dies vereinfacht den Zugriff durch die Nutzung der App::import('vendor', 'name') Funktion. Einigen Beobachtern wird die als scheinbar überflüssig erscheinen, da es auf der obersten Verzeichnissebene bereits einen vendors Ordner in der Verzeichnisstruktur gibt. Wir werden später die Unterschiede dieser Ordner näher beleuchten, wenn wir über die Verwaltung mehrerer Anwendungen und komplexeren System-Setups sprechen.

views

Präsentationsdatein sind hier abgelegt: Elemente, error pages, helpers, layouts und view Dateien.

webroot

In einer Produktionsumgebung wird dieser Ordner für die Bereitstellung des Stammordners für deine Anwendung dienen. Weitere darin enthaltene Ordner dienen als Platzhalter für die Bereitstellung von CSS stylesheets, Bildern und JavaScript Dateien.

Wir sind große Fans von festen Vereinbarungen über die Konfiguration. Zwar dauert es ein bisschen mehr Zeit die Konventionen von CakePHP kennen zu lernen, auf lange Sicht sparst du dir damit aber eine menge Zeit: Wenn du dich an die Konventionen hältst, kannst du frei erhältliche Funktionalitäten nutzen, und du befreist dich selbst von der alptraumhaften Wartung die Übersicht über die Konfigurationsdateien zu behalten. Konventionen erlauben auch eine sehr einheitliche System Entwicklung, die Entwicklern den Einstieg und die Unterstützung erleichtert.

Die CakePHP’s Konventionen entstanden aus aus jahrelanger Erfahrungen in der Web-Entwicklung und bewährten Praktiken. Obwohl wir empfehlen diese Konventionen bei der Entwicklung mit CakePHP zu verwenden, wollen wir nicht unerwähnt lassen, dass viele dieser Grundsätze auch einfach außer Kraft gesetzt werden können. Dies kann insbesondere bei der Arbeit mit Legacy Systemen nützlich sein.

Üblicherweise werden in Dateinamen unterstriche verwendet, während Klassennamen zusammenhängend Gross/Klein geschrieben sind. Die Klasse KissesAndHugsController kann zum Beispiel in der Datei kisses_and_hugs_controller.php gefunden werden.

Der Name der Klasse die sich in einer Datei befindet, muss sich nicht zwangsweise in dem Dateinamen wiederfinden. Die Klasse EmailComponent befindet sich in der Datei mit dem Namen email.php, und die Klasse HtmlHelper befindet sich in der Datei html.php.

Model classnames are singular and CamelCased. Person, BigPerson, and ReallyBigPerson are all examples of conventional model names.

Table names corresponding to CakePHP models are plural and underscored. The underlying tables for the above mentioned models would be people, big_people, and really_big_people, respectively.

Foreign keys in hasMany, belongsTo or hasOne relationships are recognized by default as the (singular) name of the related model followed by _id. So if a baker hasMany cakes, the cakes table will refer to the baker in the bakers table via a baker_id foreign key.

Join tables, used in hasAndBelongsToMany (HABTM) relationships between models should be named after the model tables they will join in alphabetical order (apples_zebras rather than zebras_apples).

All tables with which CakePHP models interact (with the exception of join tables), require a singular primary key to uniquely identify each row. If you wish to model a table which does not have a single-field primary key, such as the rows of your posts_tags join table, CakePHP's convention is that a single-field primary key is added to the table.

CakePHP does not support composite primary keys. If you want to directly manipulate your join table data, use direct query calls or add a primary key to act on it as a normal model. E.g.:

CREATE TABLE posts_tags (
id INT(10) NOT NULL AUTO_INCREMENT,
post_id INT(10) NOT NULL,
tag_id INT(10) NOT NULL,
PRIMARY KEY(id)); 

Controller classnames are plural, CamelCased, and end in Controller. PeopleController and LatestArticlesController are both examples of conventional controller names.

The first function you write for a controller might be the index() function. When a request specifies a controller but not an action, the default CakePHP behavior is to execute the index() function of that controller. For example, a request for http://www.example.com/apples/ maps to a call on the index() function of the ApplesController, whereas http://www.example.com/apples/view/ maps to a call on the view() function of the ApplesController.

You can also change the visibility of controller functions in CakePHP by prefixing controller function names with underscores. If a controller function has been prefixed with an underscore, the function will not be accessible directly from the web but is available for internal use. For example:

<?php
class NewsController extends AppController {

	function latest() {
		$this->_findNewArticles();
	}
	
	function _findNewArticles() {
		//Logic to find latest news articles
	}
}

?>

1. <?php
2. class NewsController extends AppController {
3. function latest() {
4. $this->_findNewArticles();
5. }
7. function _findNewArticles() {
8. //Logic to find latest news articles
9. }
10. }
11. ?>

While the page http://www.example.com/news/latest/ would be accessible to the user as usual, someone trying to get to the page http://www.example.com/news/_findNewArticles/ would get an error, because the function is preceded with an underscore.

As you've just seen, single word controllers map easily to a simple lower case URL path. For example, ApplesController (which would be defined in the file name 'apples_controller.php') is accessed from http://example.com/apples.

Multiple word controllers can be any 'inflected' form which equals the controller name so:

• /redApples
• /RedApples
• /Red_apples
• /red_apples

will all resolve to the index of the RedApples controller. However, the convention is that your urls are lowercase and underscored, therefore /red_apples/go_pick is the correct form to access the RedApplesController::go_pick action.

View template files are named after the controller functions they display, in an underscored form. The getReady() function of the PeopleController class will look for a view template in /app/views/people/get_ready.ctp.

The basic pattern is /app/views/controller/underscored_function_name.ctp.

By naming the pieces of your application using CakePHP conventions, you gain functionality without the hassle and maintenance tethers of configuration. Here’s a final example that ties the conventions

• Database table: "people"
• Model class: "Person", found at /app/models/person.php
• Controller class: "PeopleController", found at /app/controllers/people_controller.php
• View template, found at /app/views/people/index.ctp

Using these conventions, CakePHP knows that a request to http://example.com/people/ maps to a call on the index() function of the PeopleController, where the Person model is automatically available (and automatically tied to the ‘people’ table in the database), and renders to a file. None of these relationships have been configured by any means other than by creating classes and files that you’d need to create anyway.

Now that you've been introduced to CakePHP's fundamentals, you might try a run through the CakePHP Blog Tutorial to see how things fit together.

Jetzt bäckst du.

• HTTP Server. Apache mit mod_rewrite wird bevorzugt, ist aber keineswegs notwendig.
• PHP 4.3.2 oder neuer. Ja, CakePHP arbeitet großartig mit PHP 4 und 5.

Technisch ist ein Datenbanksystem nicht erforderlich, aber wir vermuten, dass die meisten Anwendungen eines benutzen. CakePHP unterstützt eine Vielzahl von Datenbanksystemen:

• MySQL (4 oder höher)
• PostgreSQL
• Firebird DB2
• Microsoft SQL Server
• Oracle
• SQLite
• ODBC
• ADOdb

CakePHP lässt sich schnell und einfach installieren. Die Mindestvorraussetzungen sind nur ein Webserver und eine Kopie von Cake, das wars schon! Während diese Anleitung auf einen Apache Webserver ausgelegt ist (weil dies meistens der Fall ist), lässt sich Cake auch für die Verwendung auf einer Vielzahl anderer Webserversysteme wie LightHTTPD oder Microsoft IIS konigurieren.

Die Installationsvorbereitung besteht aus folgenden Schritten:

• Download einer aktuellen Version von CakePHP (Hier zu finden)
• Den Webserver für die Ausführung von PHP konfigurieren
• Benutzerrechte auf dem Server checken

Es gibt zwei Wege, eine frische Kopie von CakePHP zu erhalten. Zunächst kannst Du Dir ein Archiv herunterladen (zip/tar.gz/tar.bz2), oder Du kannst den Code aus unserem Repository auschecken (SVN).

Um ein frisches Archiv zu erhalten, besuche unsere Website unter http://www.cakephp.org. Folge dem großen “Download Now!” link zum Paradies. CakePHP Downloads werden bei CakeForge gehosted, Du kannst aber auch unsere Projektwebsite besuchen, unter http://cakeforge.org/projects/cakephp.

Wenn Du immer das Neueste haben willst, checke unsere nightly downloads aus unter http://cakephp.org/downloads/index/nightly. CakePHP nightlies sind stabil, und beinhalten Korrekturen bis zum nächsten Release.

Um eine frische Kopie aus unserem SVN-Repository zu erhalten, gehe zu https://svn.cakephp.org/repo/branches/1.2.x.x .

CakePHP benutzt das /app/tmp Verzeichnis für eine Vielzahl verschiedener Operationen. Model-Beschreibungen, gecachte views, und Sessioninformationen sind nur einige wenige Beispiele.

Daher stelle sicher, dass das /app/tmp Verzeichnis in Deiner cake-Installation vom Benutzer, der für den Webserver angelegt ist, beschreibbar ist.

Die Installation von CakePHP kann so einfach sein, es einfach in das Dokumentenvereichnis Deines Webservers zu schieben, oder so komplex und flexibel, wie Du es gerne hättest. Dieser Abschnitt deckt die drei Hauptarten einer CakePHP-Installation ab: development (Entwicklungsumgebung), production (Produktionsumgebung), und advanced (erweitert).

• Entwicklung: Einfach zum Laufen zu bekommen, URLs für die Applikation beinhalten den Namen des Installationsverzeichnisses von CakePHP, weniger sicher.
• Production: Erfordert die Möglichkeit, das Haupt-Dokumentenverzeichnis des Webservers einzustellen, saubere URLs, sehr sicher.
• Advanced: Viel Konfiguration, die Schlüsselverzeichnisse von CakePHP können an verschiedenen Stellen im Dateisystem liegen, hierdurch kann ein zentrales Verzeichnis mit den CakePHP Kerndateien für mehrere Applikationen verwendet werden.

Kopiere Deine Cake-Installation einfach ins Wurzelverzeichnis Deines Webservers. Wenn Dein Wurzelverzeichnis zum Beispiel /var/www/html lautet, sähe Deine Entwicklungsumgebung auf dem Dateisystem wie folgt aus:

• /var/www/html
  • /cake_1_2
    • /app
    • /cake
    • /docs
    • /index.php
    • /vendors

Um Deine CakePHP-Applikation im Browser sehen zu können, öffne die URL http://www.example.com/cake_1_2/

Um eine Produktivinstallation verwenden zu können, benötigst Du das Recht, das Wurzelverzeichnis Deines Webservers ändern zu dürfen. Wenn Du eine Produktivinstallation einsetzt, fungiert die gesamte Domain als eine einzige CakePHP-Applikation.

Eine Produktivinstallation basiert auf folgendem Aufbau:

• /path_to_cake_install/
  • /app
    • /webroot (dieses Verzeichnis wird als Wurzelverzeichnis verwendet)
  • /cake
  • /docs
  • /index.php
  • /vendors

Wenn die Applikation auf einem Apache gehostet werden soll, sieht die Konfigurationsdirektive DocumentRoot für diese Domain wie folgt aus:

DocumentRoot /path_to_cake_install/app/webroot

1. DocumentRoot /path_to_cake_install/app/webroot

Deine CakePHP-Applikation erreichst Du über die Adresse http://www.example.com.

Unter Umständen willst du die CakePHP-Verzeichnisse an anderen Stellen im Dateisystem ablegen. Dies könnte aufgrund von Einschränkungen auf Shared-Host-Servern sein oder weil du einfach einige Cake-Bibliotheken mit verschiedenen Anwendnungen verwenden willst. Dieser Abschnitt beschreibt, wie du die CakePHP-Verzeichniss über das Dateisystem verteilen kannst.

Zuerst musst du verstehen, dass es drei Hauptteile einer Cake-Anwendnung gibt:

1. Die CakePHP-Kernbibliotheken in /cake.
2. Deinen Anwendungscode in /app.
3. Das Webroot der Anwendnung, normalerweise in /app/webroot.

Jedes dieser drei Verzeichnisse kann überall im Dateisystem liegen, lediglich das Webroot muss vom Webserver zugreifbar sein. Du kannst sogar das Webroot-Verzeichnis aus dem app-Verzeichnis verschieben, solange du Cake informierst, wohin.

Um deine Cake-Installation zu konfigurieren, musst du ein paar Änderungen in /app/webroot/index.php vornehmen. Es gibt dort drei Konstanten, die du bearbeiten musst: ROOT, APP_DIR, und CAKE_CORE_INCLUDE_PATH.

• ROOT muss auf das Verzeichnis verweisen, dass deinen app-Ordner enthält.
• APP_DIR musst auf dein app-Verzeichnis verweisen
• CAKE_CORE_INCLUDE_PATH muss auf die CakePHP-Libraries verweisen.

Lass uns nun an einem Beispiel durchgehen, wie eine solche Installation in der Praxis aussehen könnte. Nehmen wir an, wir wollen, dass CakePHP wie folgt funktioniert:

• Die CakePHP-Kernbibliotheken liegen in /usr/lib/cake.
• Das Webroot liegt untern /var/www/mysite/.
• Das Anwenundsverzeichnis lautet /home/me/mysite.

Unter diesen Bedinungen, würde die Datei webroot/index.php wie folgt aussehen:

// /app/webroot/index.php (Auschnitt, Kommentare entfernt) 

if (!defined('ROOT')) {
    define('ROOT', DS.'home'.DS.'me');
}

if (!defined('APP_DIR')) {
    define ('APP_DIR', 'mysite');
}

if (!defined('CAKE_CORE_INCLUDE_PATH')) {
    define('CAKE_CORE_INCLUDE_PATH', DS.'usr'.DS.'lib'.DS.'cake');
}

1. // /app/webroot/index.php (Auschnitt, Kommentare entfernt)
2. if (!defined('ROOT')) {
3. define('ROOT', DS.'home'.DS.'me');
4. }
5. if (!defined('APP_DIR')) {
6. define ('APP_DIR', 'mysite');
7. }
8. if (!defined('CAKE_CORE_INCLUDE_PATH')) {
9. define('CAKE_CORE_INCLUDE_PATH', DS.'usr'.DS.'lib'.DS.'cake');
10. }

Es wird empfohlen, die Konstante DS (directory separator) statt Schrägstrichen zu verwenden. Dies beugt Fehlern wegen nicht gefundenen Dateien vor, die bei Verwendung der falschen Pfadtrennzeichen entstehen könnten und macht deinen Code portabler.

Manchmal ist es sinnvoll MVC Klassen zwischen unterschiedlichen Anwendungen zu teilen. Wenn Du in zwei Deiner Anwendungen den gleichen Controller benutzen möchtest, kannst Du die bootstrap.php Datei dazu benutzen, diese mit ins Spiel zu bringen.

In der Datei bootstrap.php müssen dazu nur bestimmte Variablen definiert werden, damit CakePHP die Pfade zu den anderen MVC Klassen erkennt und nutzen kann:

$viewPaths        = array();
$controllerPaths  = array();
$modelPaths       = array();
$helperPaths      = array();
$componentPaths   = array();
$behaviorPaths    = array();

1. $viewPaths = array();
2. $controllerPaths = array();
3. $modelPaths = array();
4. $helperPaths = array();
5. $componentPaths = array();
6. $behaviorPaths = array();

Jede dieser besonderen Variablen kann ein Array mit weiteren, absoluten Pfaden zu Klassen beinhalten. Beachte hierbei, dass Du das letzte Slash mit angibst.

Während CakePHP so gebaut ist, dass es „out of the box“ mit dem Apache Modul mod_rewrite zusammenarbeitet –was normal auch funktioniert– haben wir festgestellt, dass einige Nutzer kämpfen müssen, um alles zum Laufen zu bekommen. Hier sind einige Dinge, die Du beachten solltest, wenn Du es korrekt zum Laufen bringen willst:

• Stelle sicher, dass das Überschreiben mittels .htaccess erlaubt ist. In Deiner httpd.conf solltest Du eine Sektion haben, welche das Verzeichnis auf deinem Server definiert. Stelle auch sicher, dass AllowOverride für den korrekten DocumentRoot auf All gesetzt wurde.
• Stelle sicher, dass Du die httpd.conf des Systems und nicht die, eines Benutzers, oder eine seitenspezifische Datei bearbeitest.
• Vermisst CakePHP seine benötigten .htaccess Dateien? Das kann beim kopieren oder verschieben vorkommen, da bei manchen Betriebssystemen Dateien, welche mit einem '.' anfangen, versteckt sind. Stelle sicher, dass deine CakePHP Kopie von der Downloadsektion auf unserer Seite oder aus unserem SVN-Repository stammen und richtig entpackt wurden.
• Stelle sicher, dass Du mod_rewrite korrekt lädst. Du solltest in Deiner httpd.conf Datei, etwas ähnliches wie LoadModule rewrite_module libexec/httpd/mod_rewrite.so sehen (Unix/Linux Nutzer sollten ebenfalls etwas wie AddModule mod_rewrite.c sehen). Stelle auch sicher, dass diese Zeilen nicht auskommentiert wurden (das ist der Fall, wenn Du eine # voranstellst). Starte Deinen Apache neu, um sicherzustellen, dass die neue Konfiguration geladen wurde.
• Wenn Du CakePHP in ein Benutzerverzeichnis installierst (http://example.com/~username), musst Du Deine .htaccess Datei des Hauptverzeichnisses Deiner CakePHP Installation anpassen. Füge einfach die Zeile "RewriteBase /~myusername/" hinzu.

Alles klar, lass uns CakePHP mal in Aktion sehen. Je nachdem, welche Einstellungen Du gewählt hast, findest Du auf http://example.de/ oder http://example.de/cake_install/ die Standard CakePHP-Startseite. Auf dieser wird Dir auch der Status der Datenbank-Verbindung angezeigt.

Glückwunsch! Du bist bereit, Deine eigene CakePHP-Anwendung zu kreieren!

CakePHP geht davon aus, dass Datenbank-Konfigurations-Details in einer Datei unter app/config/database.php enthalten sind. Eine Beispiel-Kofigurations-Datei kann unter app/config/database.php.default gefunden werden. Eine fertige Konfig-Datei sollte in etwa folgendermassen aussehen:

var $default = array('driver'      => 'mysql',
                     'persistent'  => false,
                     'host'        => 'localhost',
                     'login'       => 'cakephpuser',
                     'password'    => 'c4k3roxx!',
                     'database'    => 'my_cakephp_project',
                     'prefix'      => '');

1. var $default = array('driver' => 'mysql',
2. 'persistent' => false,
3. 'host' => 'localhost',
4. 'login' => 'cakephpuser',
5. 'password' => 'c4k3roxx!',
6. 'database' => 'my_cakephp_project',
7. 'prefix' => '');

Der $default-Verbindung-Datensatz wird gebraucht, solange keine weitere Verbindung durch $useDbConfig-Inhalte in ein Model spezifiziert wurde.
Zum Beispiel, wenn meine Anwendungen eine zweite Datenbank zusätzlich zur Standart-DB verwenden, dann könnte man diese in den Models verwenden in dem man einen neuen $legacy-Datensatz zum $default-Datensatz hinzu fügt und die Einstellung var $useDbConfig = ‘legacy’; in den entsprechenden Models.

Passe die folgenden Parameter/Schlüssel in Deinen Konfigurations-Datensatz an Deine optimalen Anforderungen an:

Die prefix-Einstellung ist nur für Tabellen(tables) und nicht für Models. Zum Beispiel, wenn Du eine Zugangs-Tabelle für Deine "apfel" und "birne" Models erstellst, dann sollte es prefix_apfel_birne (nicht prefix_apfel_prefix_birne) heißen, und setze Deine prefix-Einstellung auf 'prefix_'.

An diesem Punkt solltest Du einen Blick auf CakePHP Gepflogenheiten werfen. Die korrekte Benennung der Datensätze (und einiger zugehöriger Sparten) kann Dich durch einige zusätzliche Funktionen belohnen und hilft Dir, Konfiguration zu vermeiden.
Zum Beispiel wenn Du Deine Datenbank big_boxes nennst, Dein Model BigBox, Deinen Controller BigBoxesController, dann arbeiten alle automatisch zusammen. Falls möglich, nutze Unterstriche, Einzahl(Singular) und Mehrzahl(Plural) für Deine Datensatz(table)-Namen - zum Beispiel: baecker, konditor_laden und leckere_kuchen.

Anwendungs-Einstellungen bei CakePHP können in der Datei /app/config/core.php gefunden werden. Diese Datei ist eine Ansammlung von Einstellungs-Klassen für variable Definitionen und konstante Definitionen welche bestimmen, wie Deine Anwendung sich verhält. Bevor wir jetzt in diese Variablen abtauchen, solltest Du Dich erst mit der Einstellung von CakePHPs Einstellungs-Registry-Klassen vertraut machen.

Trotz weniger Dinge, die in CakePHP konfiguriert werden müssen, ist es manchmal nützlich, Deine eigenen Konfigurationsregeln für Deine Anwendung zu haben. In der Vergangenheit magst Du zwar einige benutzerdefinierte Einstellungen durch das definieren von Variablen und Konstanten in einigen Dateien eingestellt haben. Diese Vorgehensweise zwingt Dich allerdings dazu, diese Konfigurations-Dateien immer wieder einzufügen, wenn Du diese Angaben brauchst.

CakePHP’s neue Konfig-Klasse kann dazu genutzt werden um Anwendungs- oder Laufzeitspezifische Angaben zu speichern oder abzurufen. Sei vorsichtig - diese Klasse erlaubt es Dir darin alles abzulegen und überall im Code anzuwenden: Eine klare Versuchung, das MVC-Muster zu unterwandern - und damit das, wozu CakePHP eigentlich gemacht wurde. Das Primärziel der Konfigurations-Klassen liegt darin, zentralisierte Variablen bereitzustellen, die von vielen Objekten geteilt werden. Versuche Dir das Konzept der "Konvention vor Konfiguration" immer im Hinterkopf zu behalten und Du wirst die MVC-Struktur beibehalten, die wir entworfen haben.

Die folgende Klasse fungiert als einzellige Menge (singleton) und ihre Methoden können von überall aus Deiner Anwendung in einem festen Zusammenhang aufgerufen werden.

<?php Configure::read('debug'); ?>

1. <?php Configure::read('debug'); ?>

write(string $key, mixed $value)

Nutze write(), um Daten in der Konfiguration Deiner Anwendung zu speichern.

Configure::write('Company.name','Pizza GmbH');
Configure::write('Company.slogan','Pizza für den Körper und die Seele');

1. Configure::write('Company.name','Pizza GmbH');
2. Configure::write('Company.slogan','Pizza für den Körper und die Seele');

Die Verwendung der Punkt Notation im $key Parameter. Nutze diese Notation um Deine Konfiguration in logischen Gruppen zu verwalten.

Das obige Beispiel könnte auch mit einem einzigen Aufruf geschrieben werden:

Configure::write(
    'Company',array('name'=>'Pizza GmbH','slogan'=>'Pizza für den Körper und die Seele')
);

1. Configure::write(
2. 'Company',array('name'=>'Pizza GmbH','slogan'=>'Pizza für den Körper und die Seele')
3. );

Du kannst Configure::write('debug', $int) benutzen, um zwischen Debugmodus und Produktivumgebung zu wechseln. Das ist besonders praktisch bei AMF- oder auch SOAP-Interaktion, bei welchen die Debugging-Information Probleme verursachen kann.

read(string $key = 'debug')

Wird benutzt, um Daten aus der Konfiguration der Anwendung zu lesen. Enthält standardmäßig CakePHP’s wichtigen "debug"-Wert. Wird ein Schlüssel übergeben, werden dessen Daten zurückgegeben. Wenn wir unser Beispiel zu write() von oben verwenden, können wir die Daten so wieder auslesen:

Configure::read('Company.name');    //yields: 'Pizza GmbH'
Configure::read('Company.slogan');  //yields: 'Pizza for your body and soul'
 
Configure::read('Company');
 
//Rückgabewert: 
array('name' => 'Pizza GmbH', 'slogan' => 'Pizza for your body and soul');

1. Configure::read('Company.name'); //yields: 'Pizza GmbH'
2. Configure::read('Company.slogan'); //yields: 'Pizza for your body and soul'
4. Configure::read('Company');
6. //Rückgabewert:
7. array('name' => 'Pizza GmbH', 'slogan' => 'Pizza for your body and soul');

delete(string $key)

Wird benutzt, um Informationen aus der Konfiguration Deiner Anwendung zu löschen.

Configure::delete('Company.name');

1. Configure::delete('Company.name');

load(string $path)

Use this method to load configuration information from a specific file.

// /app/config/messages.php:
<?php
$config['Company']['name'] = 'Pizza, Inc.';
$config['Company']['slogan'] = 'Pizza for your body and soul';
$config['Company']['phone'] = '555-55-55';
?>
 
<?php
Configure::load('messages');
Configure::read('Company.name');
?>

1. // /app/config/messages.php:
2. <?php
3. $config['Company']['name'] = 'Pizza, Inc.';
4. $config['Company']['slogan'] = 'Pizza for your body and soul';
5. $config['Company']['phone'] = '555-55-55';
6. ?>
8. <?php
9. Configure::load('messages');
10. Configure::read('Company.name');
11. ?>

Every configure key-value pair is represented in the file with the $config array. Any other variables in the file will be ignored by the load() function.

version()

Gibt die Version der aktuell installierten CakePHP Version zurück.

The Configure class is used to manage a set of core CakePHP configuration variables. These variables can be found in app/config/core.php. Below is a description of each variable and how it affects your CakePHP application.

Cache configuration is also found in core.php — We’ll be covering that later on, so stay tuned.

The Configure class can be used to read and write core configuration settings on the fly. This can be especially handy if you want to turn the debug setting on for a limited section of logic in your application, for instance.

While most configuration options are handled by Configure, there are a few constants that CakePHP uses during runtime.

Loading additional classes has become more streamlined in CakePHP. In previous versions there were different functions for loading a needed class based on the type of class you wanted to load. These functions have been deprecated, all class and library loading should be done through App::import() now. App::import() ensures that a class is only loaded once, that the appropriate parent class has been loaded, and resolves paths automatically in most cases.

App::import($type, $name, $parent, $search, $file, $return);

At first glance App::import seems complex, however in most use cases only 2 arguments are required.

Core libraries such as Sanitize, and Xml can be loaded by:

App::import('Core', 'Sanitize');

1. App::import('Core', 'Sanitize');

The above would make the Sanitize class available for use.

All application related class should also be loaded with App::import(). The following examples illustrate how to do so.

App::import('Controller', 'MyController');

App::import('Model', 'MyModel');

App::import('Component', 'Auth');

App::import('Behavior', 'Tree');

App::import('Helper', 'Html');

Loading classes in plugins works much the same as loading app and core classes except you must specify the plugin you are loading from.

App::import('Model', 'PluginName.Comment');

1. App::import('Model', 'PluginName.Comment');

The vendor() function has been deprecated. Vendor files should now be loaded through App::import() as well. The syntax and additional arguments are slightly different, as vendor file structures can differ greatly, and not all vendor files contain classes.

The following examples illustrate how to load vendor files from a number of path structures. These vendor files could be located in any of the vendor folders.

To load vendors/geshi.php

App::import('Vendor', 'geshi');

1. App::import('Vendor', 'geshi');

To load vendors/flickr/flickr.php

App::import('Vendor', 'flickr/flickr');

1. App::import('Vendor', 'flickr/flickr');

To load vendors/some.name.php

App::import('Vendor', 'SomeName', array('file' => 'some.name.php'));

1. App::import('Vendor', 'SomeName', array('file' => 'some.name.php'));

To load vendors/services/well.named.php

App::import('Vendor', 'WellNamed', array('file' => 'services'.DS.'well.named.php'));

1. App::import('Vendor', 'WellNamed', array('file' => 'services'.DS.'well.named.php'));

Routing ist eine Funktion die URLs schneller zum controller führt. Sie wurde hinzugefügt zu CakePHP um "schmutzige" URL`s konfigurierbarer und flexibler zu machen. Apache’s mod_rewrite wird nicht gebraucht um Routen zu benutzen, aber dadurch wird deine Adresszeile deutlich aufgeräumter.

Routen wurde in CakePHP 1.2 ausgebaut und kann sehr stark sein.

Before you learn about configuring your own routes, you should know that CakePHP comes configured with a default set of routes. CakePHP’s default routing will get you pretty far in any application. You can access an action directly via the URL by putting its name in the request. You can also pass parameters to your controller actions using the URL.

    URL pattern default routes: 
    http://example.com/controller/action/param1/param2/param3

The URL /posts/view maps to the view() action of the PostsController, and /products/viewClearance maps to the view_clearance() action of the ProductsController. If no action is specified in the URL, the index() method is assumed.

The default routing setup also allows you to pass parameters to your actions using the URL. A request for /posts/view/25 would be equivalent to calling view(25) on the PostsController, for example.

New in CakePHP 1.2 is the ability to use named parameters. You can name parameters and send their values using the URL. A request for /posts/view/title:first+post/category:general would result in a call to the view() action of the PostsController. In that action, you’d find the values of the title and category parameters inside $this->passedArgs[‘title’] and $this->passedArgs[‘category’] respectively.

Some summarizing examples for default routes might prove helpful.

URL to controller action mapping using default routes:  
    
URL: /monkeys/jump
Mapping: MonkeysController->jump();
 
URL: /products
Mapping: ProductsController->index();
 
URL: /tasks/view/45
Mapping: TasksController->view(45);
 
URL: /donations/view/recent/2001
Mapping: DonationsController->view('recent', '2001');

URL: /contents/view/chapter:models/section:associations
Mapping: ContentsController->view();
$this->passedArgs['chapter'] = 'models';
$this->passedArgs['section'] = 'associations';

Defining your own routes allows you to define how your application will respond to a given URL. Define your own routes in the /app/config/routes.php file using the Router::connect() method.

The connect() method takes up to three parameters: the URL you wish to match, the default values for custom route elements, and regular expression rules to help the router match elements in the URL.

The basic format for a route definition is:

Router::connect(
    'URL',
    array('paramName' => 'defaultValue'),
    array('paramName' => 'matchingRegex')
)

1. Router::connect(
2. 'URL',
3. array('paramName' => 'defaultValue'),
4. array('paramName' => 'matchingRegex')
5. )

The first parameter is used to tell the router what sort of URL you're trying to control. The URL is a normal slash delimited string, but can also contain a wildcard (*) or custom route elements (URL elements prefixed with a colon). Using a wildcard tells the router what sorts of URLs you want to match, and specifying route elements allows you to gather parameters for your controller actions.

Once you've specified a URL, you use the last two parameters of connect() to tell CakePHP what to do with a request once it has been matched. The second parameter is an associative array. The keys of the array should be named after the route elements in the URL, or the default elements: :controller, :action, and :plugin. The values in the array are the default values for those keys. Let's look at some basic examples before we start using the third parameter of connect().

Router::connect(
    '/pages/*',
    array('controller' => 'pages', 'action' => 'display')
);

1. Router::connect(
2. '/pages/*',
3. array('controller' => 'pages', 'action' => 'display')
4. );

This route is found in the routes.php file distributed with CakePHP (line 40). This route matches any URL starting with /pages/ and hands it to the display() method of the PagesController(); The request /pages/products would be mapped to PagesController->display('products'), for example.

Router::connect(
    '/government',
    array('controller' => 'products', 'action' => 'display', 5)
);

1. Router::connect(
2. '/government',
3. array('controller' => 'products', 'action' => 'display', 5)
4. );

This second example shows how you can use the second parameter of connect() to define default parameters. If you built a site that features products for different categories of customers, you might consider creating a route. This allows you link to /government rather than /products/display/5.

Another common use for the Router is to define an "alias" for a controller. Let's say that instead of accessing our regular URL at /users/someAction/5, we'd like to be able to access it by /cooks/someAction/5. The following route easily takes care of that:

Router::connect(
    '/cooks/:action/*', array('controller' => 'users', 'action' => 'index')
);

1. Router::connect(
2. '/cooks/:action/*', array('controller' => 'users', 'action' => 'index')
3. );

This is telling the Router that any url beginning with /cooks/ should be sent to the users controller.

When generating urls, routes are used too. Using array('controller' => 'users', 'action' => 'someAction', 5) as a url will output /users/someAction/5 if the above route is the first match found

For additional flexibility, you can specify custom route elements. Doing so gives you the power to define places in the URL where parameters for controller actions should lie. When a request is made, the values for these custom route elements are found in $this->params of the controller. This is different than named parameters are handled, so note the difference: named parameters (/controller/action/name:value) are found in $this->passedArgs, whereas custom route element data is found in $this->params. When you define a custom route element, you also need to specify a regular expression - this tells CakePHP how to know