Welcome to The Cookbook

1. U bezoekt de site en ontdekt een fout, iets dat onvolledig is, iets dat in zijn geheel niet genoemd wordt of iets dat niet geformuleerd is zoals u dit zou willen.
2. Log in Cookbook met uw Bakery login.
3. Stuur toevoegingen/bewerkingen in met behulp van valide, semantische HTML.
4. Kom een andere dag terug om te zien of uw wijzigingen zijn goedgekeurd.
5. Lees de richtlijnen voor het leveren van een bijdrage om consistentie (samenhang) te waarborgen. (Binnenkort in het Nederlands)

Stuur een e-mail naar John David Anderson (docs at cakephp dot org) of contacteer hem op het IRC kanaal (te vinden als _psychic_ in #cakephp op freenode) om te bespreken met welke taken op vertaalgebied je wilt meewerken.

Tips voor vertalers:

• Gebruik geen html entiteiten voor karakters met een accent, want de handleiding gebruikt UTF-8.
• Gebruik de informele vorm.
• Vertaal de inhoud en de titel tegelijkertijd.
• Browse en bewerk de handleiding in de taal waar naar vertaald wordt - anders worden wijzigingen opgeslagen als Engelstalige bewerkingen met slechts een kleine kans dat de reviewer weet in welke taal je schrijft.
• Verander de opmaak niet significant en voeg geen nieuwe inhoud toe. Als het origineel informatie mist, voeg deze dan eerst toe.
• Wijzig interne links zodat verwezen wordt naar de vertaalde taal.
• Als je een Engelse term moet gebruiken, schrijf deze dan in <em> tags. Bijv. "asdf asdf Controller asdf" of "asdf asdf Kontroller (Controller) asfd".

We hebben ons tot doel gesteld om de documentatie voor CakePHP beter te maken dan het ooit is geweest. We hope dat je met ons mee zult werken door het Cookbook te gebruiken en iets terug te geven aan een project waar we allemaal veel voordeel van hebben gehad.

Patty-cake, patty-cake...

CakePHP is een vrij, open-source, rapid development framework voor PHP. Het is een fundamentele structuur voor programmeurs om webapplicaties te bouwen. Ons primaire doel is om het u mogelijk te maken te werken op een snelle en gestructureerde manier,zonder verlies van flexibiliteit.

CakePHP neemt de monotonie van webontwikkeling weg. Wij bieden u alle tools die u nodig hebt zodat u meteen kunt beginnen met schrijven van hetgeen het om draait: de logica die specifiek is voor uw applicatie. In plaats van het wiel steeds opnieuw uit te vinden wanneer je aan een nieuw project begint, haal CakePHP op en ga aan de slag gaan met het echte werk van uw applicatie.

CakePHP heeft een actief ontwikkelingsteam en gemeenschap, die van grote waarde zijn voor het project. Naast het voorkomen van het wiel opnieuw uitvinden, betekent het gebruiken van CakePHP dat de kern van uw applicatie goed is getest en constant wordt verbeterd.

Hier vindt u een kort overzicht van de functies waarvan u kunt profiteren bij het gebruik van CakePHP:

• Actieve, vriendelijke gemeenschap
• Flexibele licentie
• Compatibel met PHP4 en PHP5
• Geintegreerde CRUD (create, read, update en delete) voor database interactie
• Applicatie scaffold (tijdelijk raamwerk/steiger)
• Code genereren
• Model View Controller (MVC) architectuur
• Request verwerking met vriendelijke URL's en aangepaste routes
• Ingebouwde validatie
• Snelle en flexibele templates (PHP syntax, met helpers)
• View Helpers voor AJAX, JavaScript, HTML-formulieren en meer
• Email, Cookie, Security, Session, en Request componenten \
• Flexibel toegangsbeheer (ACL, access control lists)
• Gegevens zuivering (Sanatization)
• Flexibele Caching
• Localisatie
• Werkt onder elke website subdirectory, met weinig tot geen Apache configuratie aanpassingen

Het Kookboek (The Cookbook)

http://book.cakephp.org

U bent op de juiste plaats begonnen. Deze handleiding (en de API) is waarschijnlijk de eerste plaats om antwoorden te vinden. Zoals vele andere open source projecten, krijgen we regelmatig nieuwe mensen. Probeer eerst om zelf uw antwoorden te vinden. Wellicht kost dit meer tijd, maar de antwoorden blijven langer hangen en het is minder belastend voor onze support . Zowel de handleiding als de API hebben een online component.

De API

http://api.cakephp.org/1.2

Recht op het doel af en direct van de kern-ontwikkelaars. De API (Applicatie Programmeer Interface) van CakePHP is de meest uitgebreide documentatie die beschikbaar is voor alle kleine details van de interne werking van het framewerk. Het is een recht-door-zee referentie van de code, dus wees niet bang voor wat zweet.

Het IRC kanaal

#cakephp @ irc.freenode.net

Als u er niet uitkomt, geef dan een gil in het CakePHP IRC kanaal. Meestal is er wel iemand van het development team , vooral overdag (Amerika). We horen graag van u, of u nou hulp nodig heeft, gebruikers bij u in de buurt zoekt, of ons uw gloednieuwe sportwagen wilt doneren.

De Bakkerij (The Bakery)

http://bakery.cakephp.org

De CakePHP Bakery is een verzamelplaats voor alle CakePHP aangelegenheden. Kijk hier voor tutorials, case studies en code voorbeelden. Zodra u bekend met CakePHP, meldt u aan. Deel uw kennis met de gemeenschap en verkrijg direct roem en fortuin.

CakeForge

http://www.cakeforge.org

CakeForge is een andere ontwikkelaars resource waar u uw CakePHP projecten kunt hosten, om deze te kunnen delen met anderen. Als u op zoek bent naar een geweldig component of een prijzenswaardige plugin (of wilt delen), kijk dan op CakeForge.

De officiële CakePHP website

http://www.cakephp.org

De officiële CakePHP website is altijd een geweldige plaats om te bezoeken. Het bevat links naar veel gebruikte developer tools, screencasts, donatie mogelijkheden en downloads.

De Google Groep

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

CakePHP heeft ook een zeer actieve Google Group. Dit is een goede bron voor het vinden van gearchiveerde antwoorden, veelgestelde vragen en om antwoorden te ontvangen op 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.

Correct geschreven CakePHP applicaties volgen het MVC (Model-View-Controller) software ontwerp patroon. Programmeren met MVC scheidt uw applicatie in drie delen:

1. De Model representeert de applicatie data
2. De View maakt een presentatie van de model gegevens
3. De Controller handelt de requests van gebruikers af.

Figuur 1: Een standaard MVC Request

Figuur 1 geeft een voorbeeld van een simpel MVC request in CakePHP. Ter illustratie, doen we alsof een gebruiker genaamd Ricardo heeft geklikt op de “Buy A Custom Cake Now!” link op de startpagina van uw applicatie.

1. Ricardo klikt op de link die verwijst naar http://www.example.com/cakes/buy, en zijn browser maakt een request naar uw web server.
2. De dispatcher controleert de request URL (/cakes/buy), een geeft de request door aan de juiste controller.
3. De controller voert de applicatie specifieke logica uit. Bijvoorbeeld, controleert deze of Ricardo is ingelogd.
4. Daarnaast gebruikt de controller een of meerdere modellen om toegang tot de applicatie data te krijgen. Meestal representeert een model een database tabel, maar dit zou net zo goed LDAP , RSS , of bestanden op het systeem kunnen zijn. In dit voorbeeld gebruikt de controller een model om Ricardo zijn laatste aankopen uit de database op te halen.
5. Zodra de controller zijn trucje heeft gedaan met de data, wordt deze doorgegeven naar een view. De view pakt deze data op en maakt deze klaar voor presentatie aan de gebruiker. Views in CakePHP zijn meestal in HTML format, maar dit zou evengoed een PDF, XML document of een JSON object kunnen zijn, afhankelijk van uw wensen.
6. Als de view de data van de controller heeft gebruikt om een volledige view op te bouwen, wordt de inhoud van die view teruggestuurd naar Ricardo’s browser.

Bijna elke request naar uw applicatie volgt dit basispatroon. We zullen later nog wat meer Cake-specifieke details geven, dus houdt dit in gedachten terwijl we verdergaan

Waarom gebruik maken van MVC? Omdat het een bewezen software design patroon blijkt te zijn dat van een applicatie, een goed onderhoudbaar, modulair en snel te ontwikkellen pakket maakt. De taken van uw toepassing onderverdelen in aparte modellen, views en controllers maakt uw applicatie zeer lichtvoetig. Nieuwe functies zijn eenvoudig toe te voegen, en bestaande functies een nieuw uiterlijk geven is een fluitje van een cent. Door het modulaire en gescheiden ontwerp kunnen ontwikkelaars en ontwerpers tegelijkertijd werken, waaronder de mogelijkheid om snel een prototype te maken. Deze scheiding stelt ontwikkelaars ook in staat om veranderingen in een deel van de toepassing te maken zonder invloed op de andere delen.

Als u nog nooit een applicatie op deze manier hebt gebouwd is het wel even wennen, maar we zijn ervan overtuigd dat als u eenmaal uw eerste CakePHP toepassing hebt gebouwd, u niet meer anders zult willen.

De start van een slimme bakker

CakePHP bevat Controller, Model en View klassen, maar ook een aantal extra klassen en objecten die de ontwikkeling in MVC sneller en leuker maken. Componenten, Behaviors, en Helpers zijn klassen zorgen voor uitbreidings- en hergebruikmogelijkheden, zodat je snel extra functionaliteit kunt toevoegen aan standaard MVC klassen in je toepassingen. Voor nu blijven we hierover even op de oppervlakte, de details van hoe je deze tools kunt gebruiken komen we later op terug.

Een Component is een klasse die de controller logica ondersteunt. Als u bepaalde logica wilt delen met verschillende controllers controllers (of applicaties), dan is een component meestal een goede oplossing. Bijvoorbeeld met het EmailComponent in de core, is het maken en versturen van emails een fluitje van een cent. In plaats van een controller methode die deze logica uitvoert voor een enkele controller te schrijven, kun je deze logica bundelen zodat deze gedeeld kan worden.

Controllers zijn ook voorzien van callbacks. Deze callbacks zijn door u te gebruiken, voor het geval dat u bepaalde logica wilt invoegen in CakePHP’s core uitvoeringen. Beschikbare Callbacks zijn:

• beforeFilter(), deze wordt uitgevoerd voor alle logische controller acties
• beforeRender(), deze wordt uitgevoerd na alle controller logica, maar voordat de view gerendered wordt
• afterFilter(), deze wordt uitgevoerd na alle controller logica, inclusief de view rendering. Het kan zijn dat er geen verschil is tussen afterRender() en afterFilter() tenzij u handmatig een render() aanroep in uw controlleractie hebt gemaakt en nog enige logica hebt toevoegd na die aanroep.

Een Helper is een klasse die de view logica ondersteunt. Zoals componenten gebruikt worden door verschillende controllers, zorgen helpers ervoor dat bepaalde presentatie logica toegankelijk is voor en gedeeld kunnen worden door verschillende views. Een van de core helpers, de AjaxHelper, maakt Ajax requests binnen de views een stuk makkelijker.

De meeste applicaties hebben stukken code voor de view die herhaaldelijk gebruikt worden. CakePHP faciliteert hergebruik van view code met layouts en elementen. Elke view die door een controller wordt gerendered wordt standaard binnen een layout geplaatst. Elementen worden gebruikt wanneer korte stukken content in meerdere views opnieuw gebruikt moeten worden.

Op een zelfde manier werken Behaviors als een manier om gemeenschappelijke functionaliteit tussen modellen toe te voegen. Bijvoorbeeld, als u gebruikersgegevens opslaat in een boomstructuur, kunt u uw User model instellen zodat deze zich zal gedragen als een boom en u extra functionaleit verkrijgt voor het verwijderen, toevoegen en verschuiven van knooppunten in uw onderliggende boomstructuur.

Modellen worden ook ondersteund door een andere klasse genaamd DataSource. DataSources zijn een abstractie die het mogelijk maken dat modellen verschillende typen van data op een consistente wijze kunnen manipuleren. Terwijl de belangrijkste bron van gegevens in een CakePHP toepassing vaak een database is, zou u wellicht toch nog additionele DataSources willen schrijven zodat uw modellen ook RSS feeds, CSV bestanden, LDAP entries, of iCal events kunnen vertegenwoordigen. DataSources maken het mogelijk om records uit verschillende bronnen met elkaar te associeren: in plaats van te worden beperkt door SQL joins, kunnen DataSources uw LDAP model zeggen dat het verbonden is met meerdere iCal events.

Net zoals controllers, zijn modellen ook uitgerust met callbacks:

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

De namen van deze methoden zouden beschrijvend genoeg moeten zijn om u te laten weten wat ze doen. Kijk voor de details in het hoofdstuk "Modellen".

Zowel controllers, helpers en modellen hebben een parent klasse die u kunt gebruiken om applicatie-brede wijzigingen te definieren. AppController (vindbaar in /app/app_controller.php), AppHelper (vindbaar in /app/app_helper.php) en AppModel (vindbaar in /app/app_model.php) zijn een goeie plaats om methoden te plaatsen die u wilt delen tussen alle controllers, helpers of modellen.

Alhoewel ze geen klasse of een bestand zijn, spelen routes een rol in de requests naar CakePHP. Route definities vertellen CakePHP hoe URLs naar controller acties verwijzen moeten worden. Het standaard gedrag gaat ervan uit dat de URL “/controller/action/var1/var2” verwijst naar Controller::action($var1, $var2), maar u kunt routes gebruiken om URLs aan te passen en hoe ze geinterpreteerd worden door uw applicatie.

Sommige functies in een toepassing zijn het waard om als geheel in een pakket gestopt te worden. Een plugin is een pakket van modellen, controllers en views die een specifiek doel dienen dat over meerdere applicaties gebruikt kan worden. Een user management system of een eenvoudig blog zouden wellicht een goede toepassing zijn voor CakePHP plugins.

We hebben de basis ingrediënten van CakePHP besproken, dus laten we nu kijken naar hoe elk object samenwerkt om een standaard request* af te handelen. We gaan door met het oorspronkelijk voorbeeld van een request: bedenk dat onze vriend Ricardo zojuist geklikt heeft op de link "Koop Nu Jouw Eigen Taart!" op één van de pagina's van uw CakePHP applicatie.

* request is een technische term en wordt derhalve niet in Nederlands vertaald.

Figuur 2. Een Typisch CakePHP Request.

Zwart= verplicht element, Grijs= optioneel element, Blauw = callback

• Ricardo klikt op de link die verwijst naar http://www.example.com/cakes/buy en zijn browser verzoekt de webserver om de pagina te laden.
• De Router haalt de link uit elkaar en zoekt naar de volgende parameters: de controller, action en eventuele argumenten die meegegeven zijn
• Door middel van routes is de URL omgezet naar controllers en actions. In dit geval wordt de action buy() aangeroepen in de controller CakesController. Als er een beforeFilter() bestaat voor deze controller, wordt deze nu aangeroepen.
• De controller kan gebruik maken van modellen (Models) om toegang te krijgen tot de data van de applicatie. In dit geval zal de controller aan een model vragen om de data van Ricardo's laatste aankoop op te vragen uit de database. Indien aanwezig, zullen er callbacks, behaviours en dataSources aangeroepen worden tijdens deze aanvraag van data. Hoewel het gebruik van een model niet noodzakelijk is, vereisen alle controllers wel ten minste een model.
• Nadat het model de data heeft opgevraagd, wordt het terug gestuurd naar de controller. Eventuele gedefinieerde callbacks worden eerst uitgevoerd.
• De conroller kan eventueel gebruik maken van componenten (components) om de data aan te passen of andere acties uit te voeren. (denk hierbij aan data manipulatie, authenticatie, het verzenden van e-mails en gebruik maken van sessie data)
• Zodra de controller de data van de model heeft ontvangen en de componenten hun werk gedaan hebben, wordt de data overgestuurd naar de view. Dit gebeurt doormiddel van de set() functie. Controller callbacks kunnen uitgevoerd worden, mits gedefinieerd.
• De view gaat nu aan de slag met de data, gebruik makend van elementen (elements) of helpers. Standaard wordt de view weergegeven in een layout bestand.
• De laatste controller callbacks (zoals afterFilter) worden nu uitgevoerd en alle data wordt naar de browser gestuurd.

Laten we een kijkje nemen naar hoe de standaard installatie van CakePHP eruit ziet. U weet nu hoe CakePHP eruit ziet vanuit het standpunt van een standaard MVC request, maar u zult ook moeten weten hoe de bestanden van CakePHP georganiseerd zijn.

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

Wanneer u CakePHP download, zult u vier mappen zien. De app map zal de plek zijn waar u uw toverkunsten beoefent: het is de plaats waar de bestanden van uw applicatie worden geplaatst. De cake map is de plaats waar wij onze toverkunsten hebben uitgevoerd. Maak er een persoonlijke beslissing van om de bestanden in deze map niet te bewerken. Wij kunnen het niet verhelpen als u de core heeft gewijzigd. De docs map is voor de essentiële informatie zoals de readme, wijzigingen sinds de laatste veranderingen en de licentie. Tenslotte is de vendors map de plaats waar u externe PHP bibliotheken, die u nodig heeft in uw CakePHP applicaties, plaatst.

De app map van CakePHP is de plaats waar u het meeste van uw ontwikkeling uitvoert. Laten we wat meer in detail kijken naar de mappen die zich onder de app map bevinden.

config

Bevat de (weinige) configuratie bestanden die CakePHP gebruikt. Gegevens voor databaseverbindingen, opstarten (bootstrapping), kern configuratie bestanden en nog meer zal hier opgeslagen moeten worden.

controllers

Bevat de controllers van uw applicatie en hun componenten.

locale

Slaat bestanden met tekenreeksen (strings) op voor internationalisering.

models

Bevat de models, behaviors en datasources voor uw applicatie.

plugins

Bevat de plugin pakketten.

tmp

Hier slaat CakePHP tijdelijke gegevens op. De werkelijke gegevens die worden opgeslagen hangen af van hoe u CakePHP heeft geconfigureerd, maar deze map wordt gewoonlijk gebruikt om model beschrijvingen, logboeken en soms sessie informatie op te slaan.

vendors

Elke externe klasse of bibliotheek moet hier worden geplaatst. Door dit te doen maakt u het makkelijk om er toegang tot te krijgen met de vendors() functie. Oplettende lezers zullen opmerken dat dit enigszins overbodig lijkt, aangezien zich er ook een vendors map in de bovenliggende map bevindt. We zullen verder ingaan op de verschillen tussen deze twee wanneer we het beheren van meerdere applicaties en de configuratie voor complexere systemen bespreken.

views

Bestanden voor de presentatie worden hier geplaatst: elementen, pagina's voor foutmeldingen, helpers, layouts en view bestanden.

webroot

In een productie configuratie, is dit de map die dienst doet als document root (of webroot) van uw applicatie. Mappen die zich in deze map bevinden zijn de juiste plaats voor CSS stylesheets, afbeeldingen en JavaScript bestanden.

Wij zijn grote fans van conventie over configuratie. Hoewel het misschien iets langer duurt om de conventies van CakePHP te leren, bespaart het tijd als je er aan gewent raakt. Als de conventie gevolgd wordt, krijg je gratis functionaliteit en bespaar je jezelf de nachtmerrie van het onderhouden en opzoeken van configuratie bestanden. Conventies zorgen er ook voor dat andere CakePHP ontwikkelaars zo verder kunnen gaan met de code, of andersom natuurlijk.

De conventies van CakePHP komen voort uit jarenlange ervaring met het ontwikkelen voor het web. Hoewel wij aanraden om de conventies te volgen, is het meestal mogelijk om deze conventies te overschrijven. Iets wat van pas kan komen wanneer er gewerkt wordt met code van oudere systemen.

Over het algemeen zijn bestandsnamen met een underscore en klassenamen CamelCased. De klasse KissesAndHugsController is bijvoorbeeld terug te vinden in het bestand met de naam kisses_and_hugs_controller.php.

De naam van de klasse in een bestand is echter niet per definitie gelijk aan de bestandsnaam. De klasse EmailComponent is terug te vinden in het bestand email.php en de klasse HtmlHelper is terug te vinden in het bestand html.php.

Model klassenamen zijn enkelvoudig en CamelCased. Person, BigPerson en ReallyBigPerson zijn allemaal voorbeelden van conventionele model namen.

Tabel namen die refereren aan CakePHP models zijn meervoudig en met underscores. De onderliggende tabellen voor de hierboven genoemde models zouden respectievelijk zijn: people, big_people en really_big_people.

Foreign keys in hasMany, belongsTo of hasOne relationships zijn standaard te herkennen als de (enkelvoudige) naam van het gerelateerde model gevolgd door _id. Dus als een baker hasMany cakes, zal de tabel cakes refereren aan de baker in de tabel bakers via een foreign key genaamd baker_id.

Join tabellen, gebruikt in hasAndBelongsToMany (HABTM) relationships tussen modellen moeten genoemd worden naar de modellen van de join in alfabetische volgorde (apples_zebras in plaats van zebras_apples).

Alle tabellen waarmee de CakePHP models opereren (met uitzondering van de join tabellen), vereisen een enkele primary key om elke unieke rij te indentificeren. Als u een model wilt koppelen aan een tabel die geen single-field primary key hebben, zoals de rijen van de posts_tags join tabel, CakePHP's conventie is dat er een single-field primary key wordt toegevoegd aan de tabel.

CakePHP ondersteunt geen samengestelde primary keys. In het geval dat je de data van de join tabel direct wilt bewerken, betekent dit dat je of gebruik maakt van directe query calls, of een primary key field toevoegt om ermee te werken alsof het een normaal model is. Bijv:

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.

Het bakken kan beginnen!

• HTTP Server. Apache met mod_rewrite heeft de voorkeur, maar is zeker niet vereist.
• PHP 4.3.2 of hoger. Ja, CakePHP werkt perfect op PHP 4 en 5.

Technisch gezien is een databasemanagementsysteem niet nodig, maar we verwachten dat de meeste applicaties er één zullen gebruiken. CakePHP ondersteund een aantal databasemanagementsystemen:

• MySQL (4 of hoger)
• PostgreSQL
• Firebird DB2
• Microsoft SQL Server
• Oracle
• SQLite
• ODBC
• ADOdb

Voordat we CakePHP kunnen installeren, zijn er nog een paar punten waar op gelet moet worden, namelijk het verkrijgen van de juiste versie en en rechten op bepaalde mappen op de server.

Er zijn twee eenvoudige manieren om een recente versie van CakePHP te verkrijgen. Ten eerste, kun je een archive(zip/tar.gz/tar.bz2) downloaden, of je kunt de code uit onze repository (SVN) halen.

Voor een actuele archive, bezoek je onze website op http://www.cakephp.org. Volg de grote “Download Now!” link naar het paradijs. CakePHP downloads worden gehost op CakeForge. Je kunt de project web site ook bezoeken op http://cakeforge.org/projects/cakephp.

Als je net iets meer wilt bekijk dan onze nightly downloads op http://cakephp.org/downloads/index/nightly. CakePHP nightlies zijn stabiel en bevatten fixes tussen de releases.

Voor een recente versie uit onze SVN repository, ga je naar https://svn.cakephp.org/repo/branches/1.2.x.x .

CakePHP gebruikt de /app/tmp directory voor een aantal verschillende operaties. Model beschrijvingen, cached views en sessie informatie zijn slechts enkele voorbeelden.

Zodoende moet je ervoor zorgen de web server user schrijfrechten heeft in de /app/tmp directory in je cake installatie.

Het installeren van CakePHP kun je net zo makkelijk, of moeilijk maken als je zelf wilt. Standaard is het uploaden van de bestanden voldoende voor een wekende installatie, maar er zijn nog veel meer mogelijkheden.

In dit hoofdstuk behandelen we drie verschillende installaties, namelijk: ontwikkeling, productie en geavanceerd.

• Ontwikkeling: makkelijk om aan de praat te krijgen, URLs voor de applicatie gaan via de CakePHP installatie, minder veilig.
• Productie: Toegang tot de configuratie van de webserver is noodzakelijk, mooiere URLs, erg veilig.
• Geavanceerd: Met enige configuratie is het mogelijk om de verschillende mappen van CakePHP dusdanig te plaatsen dat meerdere applicaties van dezelfde basis gebruik maken.

Plaats de bestanden van CakePHP in de webroot van de webserver. Als de webroot bijvoorbeeld /var/ww/html is, dan ziet de mappenstructuur er als volgt uit:

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

Om de CakePHP applicatie te zien ga je naar je webserver en de map /cake_1_2/ (bijvoorbeeld: http://www.example.com/cake_1_2/)

Om een productie opstelling te maken, heb je rechten nodig om de webroot van je server aan te passen. Bij een productie opstelling is het hele domein één CakePHP applicatie.

De productie opstelling ziet er als volgt uit:

• /pad_naar_cakephp_installatie/
  • /app
    • /webroot (Deze map moet als webroot aangegeven worden in de configuratie van de server)
  • /cake
  • /docs
  • /index.php
  • /vendors

Zou deze opstelling op een Apache webserver draaien, dan zou de DocumentRoot moeten verwijzen naar:

Documentroot /pad_naar_cakephp_installatie/app/webroot

Om de applicatie te bezoeken ga je naar het geconfigureerde domein. (bijvoorbeeld http://www.example.com)

Soms zijn er situaties waarbij het noodzakelijk of makkelijker is om de mappen van CakePHP op andere plaatsen op de server te plaatsen. Dit kan zijn doordat de applicatie op een gedeelde hosting draait, of omdat meerdere applicaties op dezelfde CakePHP installatie moeten draaien. Dit hoofdstuk gaat dieper in op het verplaatsen van de CakePHP mappen.

Het is belangrijk om te weten dat CakePHP globaal uit drie onderdelen bestaat, namelijk:

1. De kernbestanden van cake in de map /cake.
2. De applicatie code in /app.
3. De webroot van de applicatie in /app/webroot.

Bijna elk van deze mappen kan op iedere wensbare plek op de server staan. De uitzondering is de webroot map, deze moet toegankelijk zijn voor de webserver. Je kunt de webroot map wel uit de applicatie map halen, zolang je CakePHP maar laat weten waar je hem gelaten hebt.

Om de CakePHP installatie te configureren voor deze opstelling, moet je wat waardes aanpassen in /app/webroot/index.php. Er zijn drie constanten die aangepast moeten worden, namelijk: ROOT, APP_DIR en CAKE_CORE_INCLUDE_PATH.

• ROOT moet verwijzen naar het pad waarin de app map staat.
• APP_DIR moet verwijzen naar het pad van de app map.
• CAKE_CORE_INCLUDE_PATH moet verwijzen naar naar de CakePHP map.

Onderstaand voorbeeld van een geavanceerde opstelling zou het een en ander wat duidelijker moeten maken. Stel dat ik een CakePHP opstelling zou willen met de volgende configuratie:

• The CakePHP core wordt geplaatst in /usr/lib/cake.
• De webroot directory wordt /var/www/mysite/.
• En mijn applicatie plaats ik in /home/me/mysite.

Bij deze opstelling moet ik mijn webroot/index.php (welke staat in /var/www/mysite/index.php) bestand wijzigen naar het volgende:

// /app/webroot/index.php (Gedeeltelijk, commentaar verwijderd) 

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 (Gedeeltelijk, commentaar verwijderd)
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. }

Het is aan te raden om de DS (Directory Separator, of map scheiding teken) constante te gebruiken, op deze manier hoef je geen zorgen te maken over het besturingsysteem of de omgeving waarin CakePHP draait.

Soms is het makkelijk om MVC klassen te delen tussen verschillende applicaties op het zelfde systeem. Als je bijvoorbeeld dezelfde controller wilt gebruiken in twee aplicaties, kun je dit aangeven in het bestaand bootstrap.php in de map /app/config.

Gebruik onderstaande voorgedefinieerde variabelen om CakePHP te laten weten op welke plaats het moet zoeken naar de MVC klassen.

	$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();

Elk van deze variabelen kan een array bevatten met absolute paden waar extra klassen gevonden kunnen worden. Let wel op dat het pad een slash op het eind bevat.

Hoewel CakePHP is gebouwd zodat het werkt met mod_rewrite bij een standaard installatie (en dat is meestal ook het geval), zien wij toch regelmatig dat gebruikers moeite hebben om alles goed in te stellen. Hieronder staan een paar tips om mod_rewrite aan de praat te krijgen.

• Zorg ervoor dat een .htaccess bestand de standaard configuratie van apache mag overschrijven. In de apache configuratie staat als het goed is de variabele AllowOverride bij de opties voor een webroot map. Deze AllowOverride moet op all staan.
• Zorg ervoor dat je de httpd.conf van het gehele systeem wijzigt in plaats van een gebruiker- of site-specifieke httpd.conf.
• Zijn de .htaccess bestanden wel geupoad? Bij sommige ftp software worden bestanden die beginnen met een punt overgeslagen, omdat deze verborgen zijn. Zorg ervoor dat de .htaccess bestanden geupload zijn op de server.
• Is mod_rewrite wel geladen? In de configuratie van apache staat ergens LoadModule rewrite_module libexec/httpd/mod_rewrite.so en bij Linux/Unix gebruikers staat er ook AddModule mod_rewrite.c. Zorg dat er geen # of ander commentaar teken voorstaat en probeer apache te herstarten.
• Heb je CakePHP in een gebruiker map geinstalleerd (bijvoorbeeld http://examplecom/~username), pas dan het .htaccess bestand aan in de hoofdmap van je CakePHP installatie. De volgende regel moet toegevoegd worden: "RewriteBase /~username"

Het is zover, tijd om CakePHP in actie te zien. Afhankelijk van de gekozen opstelling kun je de browser openen en gaan naar http://example.com of http://example.com/cake_install, waarbij je example.com vervangt door je eigen domeinnaam. Als alles goed gaat, wordt er een standaard CakePHP homepagina weergegeven. Op deze pagina staan eventuele meldingen met betrekking tot de configuratie en de status van de database connectie.

Gefeliciteerd! Nu kun je aan de slag om je eerste CakePHP applicatie te schrijven.

CakePHP verwacht dat de database configuratie in het bestand app/config/database.php. Een voorbeeld van deze configuratie kan gevonden worden in app/config/database.php.default. De uiteindelijke configuratie kan er als volgt uitzien.

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' => '');

De array met de naam $default wordt standaard gebruikt, tenzij een andere verbinding is gespecificeerd door middel van $useDbConfig in een model. Als er bijvoorbeeld gebruik gemaakt wordt van een nieuwe($default) en een oude($oud) database, kan door middel van $useDbConfig = 'oud'; contact gemaakt worden met de oude database.

De volgende opties zijn beschikbaar voor een database connectie.

De prefix optie is alleen voor tabelnamen en niet voor models. Bijvoorbeeld: als er een koppeltabel is tussen appel en smaak, dan heet de koppeltabel prefix_appels_smaken.(en niet prefix_appels_prefix_smaken)

Het kan handig zijn om een blik te werpen op de CakePHP Conventies. Als de tabellen (en sommige kolomnamen) de correcte naamgeving hebben, zal CakePHP veel taken automatisch overnemen en zorgt voor minder configuratie in de applicatie. Als bijvoorbeeld de tabel naam grote_appels is, moet de model GroteAppels heten en de controller GroteAppelsController. Op deze manier kan CakePHP zelf de relatie tussen de models, controllers en tabellen uitvinden.

Het is aan te raden om engelse naamgeving te gebruiken voor tabelnamen. CakePHP probeert namelijk zelf het enkelvoud en meervoud te bepalen van modellen en dit gaat het beste met engelse woorden.

Het configuratie bestand van CakePHP kan gevonden worden in /app/config/core.php. Dit bestand is een collectie van verschillende definities en constantes die het gedrag van de applicatie bepalen. Voordat we verder gaan in de specifieke variabelen, zal je eerst bekend moeten raken met Configure, CakePHP's configuratie klasse.

Ondanks dat er weinig zaken geconfigureerd moeten worden in CakePHP is het soms handig om voor je applicatie je eigen configuratie regels te hebben. In het verleden heb je misschien eigen configuratie waarden gedefinieerd door variabelen of constanten te declareren in bepaalde bestanden. Door dit te doen was je verplicht om elke keer dat de waarden nodig waren het configuratiebestand te includen.

De nieuwe Configure klasse van CakePHP kan gebruikt worden voor het opslaan en lezen van applicatie- of runtime specifieke waarden. Wees voorzichtig, deze klasse staat je toe om er alles in op te slaan en het dan te gebruiken in elk ander deel van je code: dit is een zekere verleiding tot het breken met het MVC patroon waar CakePHP voor ontwikkeld is. Het hoofddoel van de Configure klasse is om variabelen die tussen vele objecten gedeeld worden centraal te bewaren. Onthoud dat je probeert te leven volgens het principe "conventie boven configuratie" en dat je niet eindigt met het verbreken van de MVC structuur die we op zijn plek hebben gezet.

Deze klasse werkt als een singleton en zijn methoden kunnen aangeroepen worden vanuit elke plek in je applicatie, in een statische context.

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

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

write(string $key, mixed $value)

Gebruik write() om data op te slaan in de configuratie van de applicatie.

Configure::write('Company.name','Pizza, Inc.');
Configure::write('Company.slogan','Pizza for your body and soul');

1. Configure::write('Company.name','Pizza, Inc.');
2. Configure::write('Company.slogan','Pizza for your body and soul');

het gebruik van de punt-notatie in de $key parameter. Je kunt deze notatie gebruiken om je configuratie in te delen in logische groepen.

Het bovenstaande voorbeeld kan ook in één aanroep geschreven worden:

Configure::write(
    'Company',array('name'=>'Pizza, Inc.','slogan'=>'Pizza for your body and soul')
);

1. Configure::write(
2. 'Company',array('name'=>'Pizza, Inc.','slogan'=>'Pizza for your body and soul')
3. );

Je kunt Configure::write('debug', $int) gebruiken om te wisselen tussen de debug en de productie modus wanneer je maar wilt. Dit is vooral handig voor AMF of SOAP interacties waar debug informatie een probleem kan veroorzaken bij het parsen.

read(string $key = 'debug')

Gebruik read om configuratie gegevens van de applicatie te lezen. Standaard wordt CakePHP's belangrijke debug waarde geretourneerd. Als een sleutel is gespecificeerd, dan worden de betreffende gegevens geretourneerd. Wanneer we het bovenstaande voorbeeld van write() gebruiken, dan kunnen we die data als volgt terugleven:

Configure::read('Company.name');    //levert: 'Pizza, Inc.'
Configure::read('Company.slogan');  //levert: 'Pizza for your body and soul'
 
Configure::read('Company');
 
//levert: 
array('name' => 'Pizza, Inc.', 'slogan' => 'Pizza for your body and soul');

1. Configure::read('Company.name'); //levert: 'Pizza, Inc.'
2. Configure::read('Company.slogan'); //levert: 'Pizza for your body and soul'
4. Configure::read('Company');
6. //levert:
7. array('name' => 'Pizza, Inc.', 'slogan' => 'Pizza for your body and soul');

delete(string $key)

Wordt gebruikt om informatie te verwijderen uit de configuratie van de applicatie.

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

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

load(string $path)

Gebruik deze methode om configuratie informatie te laden uit een specifiek bestand.

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

merk op dat ieder key-value is gerepresenteerd in het bestand met de $config array. Elke andere variabele in dat bestand wordt genegeerd door de load() functie.

version()

Retourneert de CakePHP versie voor de huidige applicatie.

De Configure klasse wordt gebruikt om een set van kern CakePHP configuratie variabelen te beheren. Deze variabelen kunnen worden gevonden in app/config.core.php. Hieronder staat een beschrijving van elke variabele en hoe deze je CakePHP applicatie beïnvloedt.

Cache configuratie is ook te vinden in core.php — Dit zal later worden behandelt, dus houd deze pagina in de gaten.

De Configure klasse kan gebruikt worden om kern configuratie instellingen te wijzigen wanneer je dat wilt. Dit kan bijvoorbeeld vooral handig zijn als je debug instellingen aan wilt zetten voor een bepaald stuk logica in je applicatie.

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

Het laden van aanvullende klassen is gestroomlijnder gemaakt in CakePHP. In vorige versies waren er verschillende functies, gebaseerd op het type klasse dat je wilde laden, voor het laden van een benodigde klasse. Deze functies zijn nu allemaal afgekeurd (deprecated). Alle klassen en bibliotheken dienen nu te worden geladen met App::import(). App::import() verzekert dat een klasse slechts eenmaal geladen wordt, dat de juiste ouderklasse geladen is en vindt het pad automatisch in de meeste gevallen.

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

Op het eerste gezicht ziet App:import er complex uit, maar in de meeste gevallen zijn slechts 2 argumenten benodigd.

Kern bibliotheken zoals Sanitize en Xml kunnen worden geladen door:

<?php App:import('Core', 'Sanitize'); ?>

1. <?php App:import('Core', 'Sanitize'); ?>

Het bovenstaande zou de Sanitize klasse beschikbaar maken voor gebruik.

Alle applicatie gerelateerde klassen behoren ook te worden geladen met App:import(). De volgende voorbeelden illustreren hoe dit gedaan wordt.

App::import('Controller', 'MijnController')

App::import('Model', 'MijnModel')

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

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

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

Het laden van klassen uit plugins werkt vrijwel hetzelfde als het laden van app en kern (core) klassen, behalve dat je de plugin moet specificeren waaruit geladen wordt.

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

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

De vendor() functie is nu afgekeurd (deprecated). Vendor bestanden behoren ook te worden geladen door App:import(). De syntax en aanvullende argumenten zijn enigszins verschillend, omdat de structuur van vendor bestanden zeer kan verschillen en niet alle vendor bestanden klassen bevatten.

De volgende voorbeelden illustreren hoe vendor bestanden geladen worden vanuit een aantal verschillende pad structuren. Deze vendor bestanden kunnen in elk van de vendor mappen geplaatst zijn.

Om vendors/geshi.php te laden

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

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

Om vendors/flickr/flickr.php te laden

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

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

Om vendors/some.name.php te laden

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

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

Om vendors/services/well.named.php te laden

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

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

Routing is a feature that maps URLs to controller actions. It was added to CakePHP to make pretty URLs more configurable and flexible. Using Apache’s mod_rewrite is not required for using routes, but it will make your address bar look much more tidy.

As will be explained later, routes in CakePHP 1.2 have been expanded and are now very powerful.

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 if the URL is correctly formed or not.

Router::connect(
    '/:controller/:id',
    array('action' => 'view'),
    array('id' => '[0-9]+')
);

1. Router::connect(
2. '/:controller/:id',
3. array(