Manual CakePHP 1.2

1. MANUAL CAKEPHP 1.2
Juan Basso
3 de março de 2008

2. Sumário
PARTE I. COMEÇANDO COM CAKEPHP ......................................................................7
Prefácio ................................................................................................................................................. 7
Requisitos do leitor .................................................................................................................................. 7
Introdução ao CakePHP ......................................................................................................................... 7
O que é CakePHP? Por que usar? ............................................................................................................. 7
Onde obter ajuda? ................................................................................................................................... 8
Entendendo o Model-View-Controller (MVC) ........................................................................................ 9
Introdução ................................................................................................................................................ 9
Benefícios ............................................................................................................................................... 10
PARTE II. PRINCÍPIOS BÁSICOS DO CAKEPHP ....................................................... 11
Estrutura CakePHP ............................................................................................................................... 11
Extensões de controller ......................................................................................................................... 11
Extensões de view .................................................................................................................................. 11
Extensões do model ............................................................................................................................... 11
Extensões de aplicação .......................................................................................................................... 12
Estrutura de arquivos do CakePHP ....................................................................................................... 12
Estrutura do diretório App ..................................................................................................................... 13
Requisição típica do CakePHP .............................................................................................................. 13
Convenções CakePHP ........................................................................................................................... 15
Convenções de arquivos e nome de classes .......................................................................................... 15
Convenções de modelos ........................................................................................................................ 15
Convenções de controladores................................................................................................................ 15
Convenções de visões ............................................................................................................................ 16
PARTE III. DESENVOLVENDO COM CAKEPHP ...................................................... 17
Requisitos ............................................................................................................................................ 17
Preparativos para instalação................................................................................................................ 17
Baixando o CakePHP .............................................................................................................................. 17
Permissões ............................................................................................................................................. 17
Instalação ............................................................................................................................................ 18
Desenvolvimento ................................................................................................................................... 18
Produção ................................................................................................................................................ 18
Instalação avançada ............................................................................................................................... 19
Caminho de classes adicionais ........................................................................................................... 20
i

3. Apache e mod_rewrite .......................................................................................................................... 20
Comece agora! ....................................................................................................................................... 20
Configuração........................................................................................................................................ 21
Configuração da base de dados ............................................................................................................. 21
Configuração do núcleo ......................................................................................................................... 22
As classes de configuração ..................................................................................................................... 22
Classes de configuração ..................................................................................................................... 22
Variáveis de configuração do núcleo ................................................................................................. 22
Constantes de configuração .............................................................................................................. 22
Configuração de rotas (Routes) ............................................................................................................. 22
Inflexão personalizada ........................................................................................................................... 23
Configuração de inicialização (bootstrap) .............................................................................................. 24
Controllers (Controladores) ................................................................................................................. 24
Introdução .............................................................................................................................................. 24
Atributos ................................................................................................................................................ 25
$name ................................................................................................................................................ 25
$components, $helpers e $uses ........................................................................................................ 25
Relativo à página: $layout e $pageTitle ............................................................................................. 26
Atributos dos parâmetros ($params) ................................................................................................ 26
Outros atributos ................................................................................................................................ 27
Métodos ................................................................................................................................................. 28
Interagindo com as visões ................................................................................................................. 28
Fluxo de controle ............................................................................................................................... 29
Callbacks ............................................................................................................................................ 29
Outros métodos ................................................................................................................................. 30
Components (Componentes) ............................................................................................................... 33
Introdução .............................................................................................................................................. 33
Construindo componentes personalizados............................................................................................ 33
Acessando classes do MVC de dentro dos componentes ...................................................................... 34
Models (Modelos)................................................................................................................................ 34
Introdução .............................................................................................................................................. 34
Campos mágicos .................................................................................................................................... 34
Atributos ................................................................................................................................................ 34
Métodos ................................................................................................................................................. 34
Associações ............................................................................................................................................ 34
Introdução ......................................................................................................................................... 34
hasOne ............................................................................................................................................... 35
belongsTo .......................................................................................................................................... 37
hasMany ............................................................................................................................................ 38
hasAndBelongsToMany (HABTM) ...................................................................................................... 41
Salvando dados em tabelas relacionadas (hasOne, hasMany, belongsTo) ....................................... 43
Salvando dados em tabelas relacionadas (HABTM) .......................................................................... 44
Criando e removendo relações durante execução ............................................................................ 45
DataSources ........................................................................................................................................... 47
Behaviors................................................................................................................................................ 47
ii

4. Introdução ......................................................................................................................................... 47
Usando Behaviors .............................................................................................................................. 47
TreeBehavior ..................................................................................................................................... 47
TranslateBehavior .............................................................................................................................. 47
ACLBehavior ....................................................................................................................................... 47
Views (Visões)...................................................................................................................................... 47
Templates / Skin ..................................................................................................................................... 47
Layouts ................................................................................................................................................... 48
Elements (Elementos) ............................................................................................................................ 50
Helpers (Ajudantes) ............................................................................................................................. 50
Introdução .............................................................................................................................................. 50
Helpers do CakePHP ............................................................................................................................... 51
Criando helpers ...................................................................................................................................... 52
Incluindo outros helpers .................................................................................................................... 52
Usando seus helpers personalizados ................................................................................................. 53
Contribuindo ...................................................................................................................................... 53
Scaffolding ........................................................................................................................................... 53
Introdução .............................................................................................................................................. 53
Personalizando os scaffolds ................................................................................................................... 54
CakePHP Console ................................................................................................................................. 55
Introdução .............................................................................................................................................. 55
Criando Shells e Tasks ............................................................................................................................ 55
Criando suas Shells ............................................................................................................................ 55
Tasks .................................................................................................................................................. 55
Gerando código com Bake ................................................................................................................... 55
Plugins ................................................................................................................................................. 55
Criando um plugin .................................................................................................................................. 55
Plugin de controladores ..................................................................................................................... 55
Plugin de modelos ............................................................................................................................. 55
Plugin de visões ................................................................................................................................. 55
Plugin de informações ....................................................................................................................... 55
Constantes e funções globais ............................................................................................................... 55
Funções globais ...................................................................................................................................... 55
Constantes do núcleo ............................................................................................................................. 58
Constantes do diretório ......................................................................................................................... 58
PARTE IV. TAREFAS COMUNS COM CAKEPHP ......................................................... 60
Validação de dados .............................................................................................................................. 60
Regras simples ....................................................................................................................................... 60
Uma regra por campo ............................................................................................................................ 60
rule ..................................................................................................................................................... 60
iii

5. required ............................................................................................................................................. 60
allowEmpty ........................................................................................................................................ 60
on ....................................................................................................................................................... 60
message ............................................................................................................................................. 60
Múltiplas regras por campo ................................................................................................................... 60
Construindo regras de validação ............................................................................................................ 60
alphaNumeric .................................................................................................................................... 60
between ............................................................................................................................................. 60
blank .................................................................................................................................................. 60
cc ........................................................................................................................................................ 60
comparison ........................................................................................................................................ 60
date .................................................................................................................................................... 60
email .................................................................................................................................................. 60
ip ........................................................................................................................................................ 60
minLength .......................................................................................................................................... 60
maxLength ......................................................................................................................................... 60
numeric .............................................................................................................................................. 60
phone ................................................................................................................................................. 60
postal ................................................................................................................................................. 60
ssn ...................................................................................................................................................... 60
url ....................................................................................................................................................... 60
Regras de validação personalizada ........................................................................................................ 60
Validação por expressões regulares personalizadas ......................................................................... 61
Validação por métodos personalizados ............................................................................................. 61
Limpeza de dados ................................................................................................................................ 61
Manipulação de erros .......................................................................................................................... 61
Debugando .......................................................................................................................................... 61
Gerando caches ................................................................................................................................... 61
Logando ............................................................................................................................................... 61
Introdução .............................................................................................................................................. 61
Usando as funções de log ...................................................................................................................... 61
Testando .............................................................................................................................................. 62
Internacionalizando ............................................................................................................................. 62
Definindo o locale da sua aplicação ....................................................................................................... 62
Internacionalizando em CakePHP .......................................................................................................... 63
Paginação ............................................................................................................................................ 64
Configurando os controladores ............................................................................................................. 64
Paginando nas visões ............................................................................................................................. 64
Paginando com AJAX .............................................................................................................................. 64
Alterações no layout .......................................................................................................................... 64
Alterações nas visões ......................................................................................................................... 64
iv

6. PARTE V. COMPONENTES INTERNOS ....................................................................... 65
Lista de controle de acessos (ACL)........................................................................................................ 65
Autenticação........................................................................................................................................ 65
Sessões ................................................................................................................................................ 65
Manipulando requisições ..................................................................................................................... 65
Segurança ............................................................................................................................................ 65
E-mail .................................................................................................................................................. 65
Cookies ................................................................................................................................................ 65
Introdução .............................................................................................................................................. 65
Configurando os controladores ............................................................................................................. 65
Usando o componente ........................................................................................................................... 65
PARTE VI. HELPERS INTERNOS .................................................................................... 66
Formulários ......................................................................................................................................... 66
Criando formulários ............................................................................................................................... 66
$options['type'].................................................................................................................................. 66
$options['action'] ............................................................................................................................... 67
$options['url'] .................................................................................................................................... 67
$options['default'] ............................................................................................................................. 67
Fechando formulários ............................................................................................................................ 68
Elemento de formulário mágico ............................................................................................................ 68
$options['type'].................................................................................................................................. 69
$options['before'], $options['between'] e $options['after'].............................................................. 69
$options['options']............................................................................................................................. 69
$options['multiple'] ........................................................................................................................... 70
$options['maxLength'] ....................................................................................................................... 70
$options['div'] .................................................................................................................................... 70
$options['label'] ................................................................................................................................. 70
$options['id'] ...................................................................................................................................... 70
$options['error'] ................................................................................................................................ 70
$options['selected'] ........................................................................................................................... 70
$options['rows'], $options['cols'] ...................................................................................................... 70
$options['empty'] .............................................................................................................................. 70
$options['timeFormat'] ...................................................................................................................... 70
$options['dateFormat'] ...................................................................................................................... 71
Métodos específicos do elemento de formulário .................................................................................. 71
HTML ................................................................................................................................................... 73
Inserindo elementos bem-formados ..................................................................................................... 73
JavaScript............................................................................................................................................. 73
v

7. AJAX ....................................................................................................................................................... 73
Opções do AjaxHelper ............................................................................................................................ 73
Opções gerais..................................................................................................................................... 73
Opções de callback ............................................................................................................................ 73
Métodos ................................................................................................................................................. 73
Cache ................................................................................................................................................... 73
Form .................................................................................................................................................... 73
Number ............................................................................................................................................... 73
Text ..................................................................................................................................................... 73
Time..................................................................................................................................................... 73
PARTE VII. EXEMPLOS .................................................................................................. 74
Tutorial de como fazer um blog em CakePHP ....................................................................................... 74
Sistema simples de autenticação de usuários ...................................................................................... 74
PARTE VIII. APÊNDICES ................................................................................................. 75
Escritores da versão inglesa ................................................................................................................. 75
Tradutores para língua portuguesa ...................................................................................................... 75
Apoio e revisão da versão traduzida ...................................................................................................... 75
Inflexão em português ......................................................................................................................... 75
vi

8. Começando com CakePHP 7
Parte I. Começando com CakePHP
Prefácio
Bem vindo ao paraíso de desenvolvimento web.
Se você está lendo o prefácio de um manual técnico, é porque está lhe sobrando bastante
tempo. Não somos celebridades e o material é o que vem depois. Você pode pular estes
capítulos supérfluos e ir direto ao ponto nas seções que você quer.
Requisitos do leitor
Para ler este manual, você já deve estar familiarizado com o PHP. Conhecer de programação
orientada a objeto irá lhe ajudar bastante, porém eu suponho que as seções de introdução
deste manual servirão como um bom exemplo do que vem pela frente. Com isso, este material
é escrito para desenvolvedores de todos os níveis de habilidade que desejam criar algo
robusto, sustentável, rápido e agradável.
Devo alertar que haverá seções que abordam tecnologias que estão realmente fora do âmbito
deste manual. Administração de servidor Web, AJAX e JavaScript, por exemplo, podem ser
mencionados em partes do texto, mas na maior parte do texto nós estaremos focado no
CakePHP.
Introdução ao CakePHP
O que é CakePHP? Por que usar?
CakePHP é gratuito, de código aberto, uma framework em PHP para desenvolvimento ágil. É
uma estrutura fundamental para programadores criarem aplicações web. Nosso principal
objetivo é permitir que você trabalhe em uma estrutura que possa programar de forma rápida
e sem a perda de flexibilidade.
CakePHP joga fora a monotonia do desenvolvimento web. Nós oferecemos todas as
ferramentas que você precisa para começar programando o que realmente deseja: a lógica
específica da sua aplicação. Em vez de reinventar a roda cada vez que se constrói um novo
projeto, pegue uma cópia do CakePHP e comece a construir sua carruagem real da sua
aplicação.
CakePHP tem uma equipe de desenvolvedores e uma grande comunidade, trazendo grande
valor ao projeto. Além de manter você fora do reinvento da roda, usando CakePHP significa
que o núcleo da sua aplicação é bem testado e constantemente aperfeiçoado.
Abaixo segue uma pequena lista dos recursos que você poderá desfrutar no CakePHP:
 Ativo e com comunidade amigável;
 Licença flexível;
 Compatibilidade com PHP 4 e PHP 5;
 Integrando funcionalidade CRUD (Create, Read, Update and Delete, ou Criar, Ler,
Atualizar e Excluir) para interagir com o banco de dados;

9. Começando com CakePHP 8
 Aplicações scaffolding;
 Geração de código;
 Arquitetura MVC (Model, View, Controller, ou Modelo, Visões, Controlador);
 Requisições ao expedidor com clareza, URLs personalizáveis e rotas;
 Validações internas;
 Templates rápidos e flexíveis (Sintaxe PHP e com ajudantes);
 Ajudantes para usar AJAX, JavaScript, HTML, formulários e outros nas visões;
 Componentes de E-mail, Cookie, Segurança, Sessões, Manipulação de Requisições e
outros;
 Lista de controle de acessos flexível;
 Limpeza de dados;
 Flexibilidade com cache;
 Internacionalização;
 Funciona em qualquer subdiretório do seu website, com poucas configurações do
Apache.
Onde obter ajuda?
Você começou no lugar certo. Este manual (e a API) deve ser provavelmente o primeiro lugar
que você vá para procurar as respostas das suas dúvidas. Assim como acontece com muitos
outros projetos de código aberto, nós obtemos novos usuários regularmente. Tentamos ser os
melhores para responder seus questionamentos em primeiro lugar. As respostas podem
demorar a chegar, mas permanecerá por tempos e ajudará a esclarecer outras pessoas. Tanto
o manual, quanto a API podem ser encontradas online.
http://manual.cakephp.com.br (em português)
http://manual.cakephp.org (em inglês)
http://api.cakephp.org/1.2 (em inglês)
Se você estiver assustado, dê um grito pelo canal de IRC internacional ou entre no grupo da
comunidade luso-brasileira. Além da equipe de desenvolvimento do núcleo do CakePHP no
canal, principalmente durante o dia. Se você precisar de alguma ajuda, deseja encontrar
usuários na sua área ou gostaria de doar o novo carro esportivo, gostaríamos de falar com
você.
Grupo da comunidade luso-brasileira: http://groups.google.com/group/cake-php-pt
#cakephp-pt @ irc.freenode.net (em português)
#cakephp @ irc.freenode.net (em inglês)
O CakePHP Bakery é uma casa para todas as coisas de CakePHP. Visite este site para ver
tutoriais, estudos de caso e exemplos de código. Assim que estiver familiarizado com o
CakePHP, faça o login e compartilhe seus conhecimentos com a comunidade para ganhar fama
e fortuna.
http://bakery.cakephp.org

10. Começando com CakePHP 9
O CakeForge é outro recurso que os desenvolvedores podem usar para hospedar seus projetos
usando CakePHP e compartilhar com outras pessoas. Se você está olhando para achar projetos
existentes, ou querendo compartilhar, acesso o CakeForge.
http://www.cakeforge.org
O site oficial do CakePHP está sempre esperando sua visita. Ele tem links para sites de outros
desenvolvedores, screencasts, oportunidade para doar ao projeto e downloads.
http://www.cakephp.org
Entendendo o Model-View-Controller (MVC)
Introdução
Aplicações bem escritas em CakePHP segue o design pattern MVC (Model-View-Controller ou
Modelo-Visão-Controlador). Programando em MVC separa sua aplicação em três partes
principais. O model representa os dados, a view representa a visualização dos dados e o
controller manipula e roteia as requisições dos usuários.
Figura 1. Requisição típica do CakePHP
A Figura 1 mostra um exemplo de uma simples requisição MVC em CakePHP. Para fins
ilustrativos, digamos que um usuário chamado Ricardo apenas clicou no link “Comprar um
bolo personalizado agora!” da sua aplicação.
1. Ricardo clica no link apontando para http://www.exemplo.com.br/cakes/comprar e
seu navegador faz uma requisição ao site;
2. O dispatcher (expedidor) verifica a URL requisitada (/cakes/comprar) e redireciona ao
controller correto;
3. O controller executa a lógica específica da aplicação. Por exemplo, verifica se o Ricardo
está logado;
4. O controller também usa os models para acessar os dados da sua aplicação. Muitas
vezes, os models representam as tabelas do banco de dados, mas podem representar
registros LDAP, feeds de RSS ou até mesmo arquivos do sistema. Neste exemplo, o
controller usa o model para trazer ao Ricardo as últimas compras do banco de dados;
5. Depois que o controller fez sua mágica sobre os dados, ele repassa para a view. A view
faz com que os dados fiquem prontos para a representação do usuário. As views em
CakePHP normalmente vem no formato HTML, mas pode ser facilmente exibidas em

11. Começando com CakePHP 10
PDF, documento XML, um objeto JSON ou outro formato qualquer, dependendo da
sua necessidade;
6. Uma vez que a visão tenha usado os dados provenientes do controller para construir a
página, o conteúdo é retornado ao browser do Ricardo.
Aproximadamente toda requisição da sua aplicação seguirá o modelo básico do modelo. Nós
vamos especificar os detalhes mais adiante, mas mantenha essa visão geral no seu
pensamento.
Benefícios
Por que usar MVC? Porque é um verdadeiro padrão de desenvolvimento (design pattern) e
torna fácil a manutenção da sua aplicação, com pacotes modulares de rápido
desenvolvimento. Elaborar tarefas divididas entre models, views e controllers, faz com que sua
aplicação fique leve e independente. Novas funcionalidades são facilmente adicionadas e dar
nova cara nas características antigas pode ser feitas num piscar de olhos. O design modular e
separado também permite aos desenvolvedores e designers trabalhem simultaneamente,
incluindo a habilidade de um construir um rápido protótipo. A separação também permite que
os desenvolvedores alterem uma parte da aplicação sem afetar outras.
Se você nunca desenvolveu uma aplicação neste sentido, isso vai lhe agradar muito, mas
estamos confiantes que depois de construir sua primeira aplicação em CakePHP, você não vai
querer voltar atrás.

12. Princípios básicos do CakePHP 11
Parte II. Princípios básicos do CakePHP
Estrutura CakePHP
CakePHP possui a característica de usar as classes de Controller, Model e View, mas também
possui classes e objetos adicionais que fazem o desenvolvimento em MVC mais rápido e
agradável. Components, Behaviors e Helpers são classes que proporcionam extensibilidade e
reuso para adicionar funcionalidades rapidamente à base MVC das suas aplicações. Agora
vamos começar a subir um pouco o nível para analisar os detalhes de como usar estas
ferramentas mais tarde.
Extensões de controller
O Component (Componente) é uma classe que ajuda na lógica do controller. Se você tem a
mesma lógica e quer compartilhar entre controllers (ou aplicações), o component é uma boa
saída. Por exemplo, o component interno EmailComponent cria e envia e-mails em segundo
plano. Ao invés de escrever um método em cada controller que utiliza esta lógica, pode-se criar
um component que empacote esta funcionalidade e seja compartilhado entre os controllers.
Controllers também são equipados com callbacks. Estes callbacks estão disponíveis para que
você possa utilizar, apenas se você precisar inserir uma lógica entre operações do núcleo do
CakePHP. Os callbacks disponíveis incluem:
 beforeFilter(), executado antes de qualquer ação do controller;
 beforeRender(), executado depois da lógica do controller, mas antes da view ser
renderizada;
 afterFilter(), executado depois de todas as lógicas do controller, incluindo a
renderização da view. Não há diferença entre afterRender() e afterFilter(), exceto que
você tenha feito uma chamada manualmente para render() no seu método do
controller e tenha incluído alguma lógica depois dessa chamada.
Extensões de view
O Helper (Ajudante) é a classe que ajuda na lógica da view. Assim como o component ajuda o
controller, os helpers permitem a apresentação lógica ser acessada e compartilhada entre as
views. AjaxHelper é um dos principais helpers. Ele faz requisições AJAX facilmente de dentro
das views.
A maioria das aplicações tem partes do código que são usados repetidamente nas views.
CakePHP facilita o reuso de código na view com a utilização de layouts e elements (elementos).
Por padrão, toda view é renderizada por um controller seguindo algum layout. Os elements são
como pequenos trechos de código necessários que podem ser reutilizados em diversas views.
Extensões do model
Assim como as outras extensões, os Behaviors funcionam do mesmo modo, adicionando
funcionalidades entre os models. Por exemplo, se você armazenar os dados do usuário em
uma estrutura de árvore, você pode especificar o model User como comportamento de árvore
e ganhar funcionalidades para remover, adicionar e alterar nós em sua estrutura de árvore
fundamental.

13. Princípios básicos do CakePHP 12
Os models também são suportados por outra classe chamada DataSource. DataSources são
abstrações que permitem os models manipularem diferentes tipos de dados
consistentemente. Enquanto a principal fonte de dados numa aplicação CakePHP é via banco
de dados, você pode escrever DataSources adicionais que permitem seu model representar um
feed RSS, arquivo CSV, entidades LDAP ou eventos iCal. DataSources permite você associar
registros de diferentes fontes: ao invés de limitar em joins do SQL, DataSources permitem você
chamar seu model de LDAP que está associada a vários eventos iCal.
Assim como nos controllers, models têm recursos de callback como:
 beforeFind()
 afterFind()
 beforeValidate()
 beforeSave()
 afterSave()
 beforeDelete()
 afterDelete()
Os nomes desses métodos devem ser descritivos o bastante para que você saiba o que eles
fazem. Certifique-se de pegar os detalhes no capítulo sobre model.
Extensões de aplicação
Tanto os controllers, helpers e models têm uma classe pai que você pode usar para definir
modificações na aplicação. AppController (localizado em “/app/app_controller.php”),
AppHelper (localizado em “/app/app_helper.php”) e AppModel (localizado em
“/app/app_model.php”) são bons lugares para colocar métodos que você precisa para acessar
entre todos os controllers, helpers e models.
Embora não sejam classes ou arquivos, as rotas definem regras na requisição feita para o
CakePHP. As definições das rotas definem como o CakePHP deve mapear uma URL para um
método do controller. O behavior padrão assume que a URL “/controller/action/var1/var2”
mapeia para Controller::action($var1, $var2), mas você pode usar rotas para personalizar URLs
e como elas devem ser interpretadas pela sua aplicação.
Alguns recursos na sua aplicação podem ser empacotados com mérito. Um plugin é um pacote
de model, controller e view que realiza um objetivo específico que pode abranger vários
aplicativos. Um sistema de gestão de usuários ou um blog simplificado podem ser bons
exemplos de plugins para CakePHP.
Estrutura de arquivos do CakePHP
Vamos dar uma olhada o que é o CakePHP fora da caixa. Você que o CakePHP utiliza-se da
requisição básica do MVC, mas não sabe como que os arquivos são organizados.
 app
 cake
 docs
 index.php

14. Princípios básicos do CakePHP 13
 vendors
Quando você faz o download do CakePHP, você verá que possui quatro pastas principais. A
pasta app será o lugar da sua mágica: aqui serão guardados os arquivos da sua aplicação. A
pasta cake é onde a mágica acontece. Faça um compromisso pessoal de não editar os arquivos
desta pasta! Nós não ajudamos você se você modificá-la. A pasta docs contém as informações
de alterações, licença, etc. Finalmente, a pasta vendors é onde você colocará aplicativos de
terceiros para utilizar na aplicação, por exemplo, jQuery, prototype, FCKEditor, etc.
Estrutura do diretório App
A pasta app do CakePHP é onde normalmente você colocará sua aplicação em
desenvolvimento, Vamos dar uma olhada mais de perto dentro desta pasta.
Tabela 1. Descrição dos diretórios de app
Diretório Descrição
config Contém os arquivos de configuração. Detalhes das conexões ao banco de dados,
bootstrapping, arquivos de configuração do núcleo e outros devem ser
armazenados aqui.
controllers Contém os controllers da sua aplicação e seus components.
locale Guarda os arquivos com as strings para internacionalizaçao.
models Contém os models, behaviors e datasources da sua aplicação.
plugins Contém os pacotes de plugins.
tmp Aqui é onde o CakePHP armazena os arquivos temporários. Os dados atuais são
armazenados onde você tenha configurado o CakePHP, mas esta pasta
normalmente é usada para guardar a descrição dos models, logs e outras
informações, como as das sessões.
vendors Qualquer classe ou biblioteca de terceiro deve ser armazenada aqui. Para fazer
um acesso rápido e fácil, use a função vendors(). Você pode achar que esta
pasta é redundante, já que existe uma pasta com mesmo nome no nível
superior da estrutura. Nós vamos ver diferenças entre estas duas pastas quando
discutirmos sobre manipulação de múltiplas aplicações e sistemas mais
complexos.
views Arquivos de apresentação devem vir aqui: elements, páginas de erro, helpers,
layouts e arquivos de views.
webroot No modo de produção, esta pasta deve servir como a pasta raiz da sua
aplicação. Dentro desta pastas são guardados os arquivos públicos, como estilos
CSS, imagens e arquivos de JavaScript.
Requisição típica do CakePHP
Nós cobrimos os ingredientes básicos no CakePHP, então vamos ver como cada objeto
funciona em uma completa requisição. Continuando com nossa requisição original de
exemplo, vamos imaginar que nosso amigo Ricardo tenha clicado no link em “Comprar um
bolo personalizado agora!” da sua aplicação CakePHP.

15. Princípios básicos do CakePHP 14
Figura 2. Requisição típica no CakePHP. Em preto, elemento necessário; Em cinza, elemento opcional;
Em azul, callback
1. Ricardo clica no link apontando para http://www.exemplo.com.br/cakes/buy, e seu
navegador faz a requisição ao seu servidor de web;
2. O roteador processa a URL, extraindo os parâmetros desta requisição: o controller,
action (ação) e qualquer outro argumento que vai afetar na lógica do negócio durante
esta requisição;
3. Usando rotas, a requisição da URL é mapeada para a action do controller (um método
específico da classe do controller). Neste caso, o método buy() do CakesController. O
callback beforeFilter() do controller é chamado antes de qualquer action do controller
ser executada;
4. O controller pode usar métodos para ter acesso aos dados da aplicação. Neste
exemplo, o controller usa o model para ver no banco de dados as últimas compras de
Ricardo. Qualquer callback aplicável do modelo, behaviors e DataSources podem ser
aplicados durante esta operação. Enquanto um model não é necessário, todos os
controllers do CakePHP inicialmente requisitam de pelo menos um model;
5. Depois do model ter adquiridos os dados, ele retorna-os ao controller. Podem ser
aplicados callbacks no model;
6. O controller pode usar components para refinar os dados ou efetuar outras operações
(manipular sessões, autenticação ou enviar e-mails, por exemplo);
7. Uma vez que o controller tenha usado os models e os components para preparado os
dados suficientemente, estes dados são repassados as views usando o método set() do
controller. Callbacks dos controllers podem ser aplicados antes dos dados serem
enviados. A lógica da view é efetuada, podendo incluir elements ou helpers. Por
padrão, as views são sempre renderizadas dentro de um layout;
8. Além disso, callbacks dos controllers (como afterFilter) pode ser aplicado. Para
completar, o código renderizado pela view vai para o navegador do Ricardo.

16. Princípios básicos do CakePHP 15
Convenções CakePHP
Nós somos grandes fãs de convenções nas configurações. Enquanto isso toma um pouco de
tempo para aprender as convenções do CakePHP, você ganha tempo em um longo processo:
seguindo as convenções, você ganha funcionalidades gratuitamente e livra-sede madrugas de
manutenção de arquivos de configuração. Convenções também fazem com que o sistema
fique uniformemente desenvolvido, permitindo outros desenvolvedores o ajudem mais
facilmente.
Convenções no CakePHP tem sido produzida por anos de experiência em desenvolvimento
web e boas práticas. Enquanto nós sugerimos você a usar essas convenções enquanto
desenvolve em CakePHP, nós devemos mencionar que muitos desses princípios são facilmente
sobrescritos por alguma coisa que é especialmente passado quando trabalha-se com sistemas
legados.
Convenções de arquivos e nome de classes
Em geral, nome dos arquivos são sublinhados, enquanto nome de classes são CamelCased, ou
seja, primeiras letras das palavras em maiúsculo. A classe KissesAndHugsController pode ser
encontrada no arquivo kisses_and_hugs_controller.php, por exemplo.
Porém, o nome da class e seu tipo não são necessariamente encontrados no nome do arquivo.
A classe EmailComponent é encontrada no arquivo chamado email.php e a classe HtmlHelper
é encontrada no arquivo html.php.
Convenções de modelos
Nome das classes de modelo devem ser no singular e CamelCased. Person, BigPerson e
ReallyBigPerson são todos os exemplos de nomes convencionados para modelos.
Os nomes das tabelas correspondem ao nome do modelo do CakePHP, mas no plural e
sublinhados. As tabelas para os modelos mencionados anteriormente devem ser people,
big_people e really_big_people, respectivamente.
Tabelas associadas, usadas em relações hasAndBelongsToMany entre modelos, devem ser
nomeadas depois dos modelos das tabelas que a compõem, em ordem alfabética
(apples_zebras em vez de zebras_apples). Se sua aplicação possui esse tipo de relação entre os
modelos Tag e Post, o nome deve ser posts_tags.
Convenções de controladores
O nome das classes de controladores são no plural, CamelCased e no final “Controller”.
PeopleController, BigPeopleController e ReallyBigPeopleController são todos os exemplos
convencionais para nome de controladores.
A primeira função que você deve escrever em um controlador deve ser o método index().
Quando alguém requisita um controlador sem ação, o behavior padrão é renderizar o método
index() do controlador. Por exemplo, a requisição para http://www.exemplo.com.br/apples/
mapeia para a chamada da função index() do ApplesController, assim como
http://www.exemplo.com.br/apples/view mapeia para a chamada da função view() no
ApplesController.

17. Princípios básicos do CakePHP 16
Você também pode alterar a visibilidade das funções do controlador em CakePHP colocando
sublinhados na frente do nome das funções. Se a função do controlador estiver com
sublinhado na frente, a função não será disponibilizada para acesso da web através do
dispatcher, mas estará disponível para uso interno.
Convenções de visões
Os arquivos de template das visões são chamados depois das funções que os controladores
mostram, na forma com sublinhados. A função getReady() da classe PeopleController irá
procurar pelo template da visão em /app/views/people/get_ready.ctp.
O modelo básico é /app/views/controller/underscored_function_name.ctp.
Nomeando os pedaços da aplicação usando as convenções do CakePHP, você ganha
funcionalidades sem luta e proteção configuração. Aqui o exemplo final que vincula as
associações:
 Tabela no banco de dados: “people”
 Classe do Modelo: “Person”, encontrada em /app/models/person.php
 Classe do Controlador: “PeopleController”, encontrado em
/app/controllers/people_controller.php
 Template da Visão: encontrado em /app/views/people/index.ctp
Usando estas convenções, CakePHP sabe que a requisição para
http://www.exemplo.com.br/people/ mapeia para a chamada da função index() do
PeopleController, onde o modelo Person é automaticamente disponibilizado (e
automaticamente associado a tabela “people” no banco de dados), e renderiza isso para o
arquivo. Nenhuma destas relações foram configuradas por qualquer meio que não seja através
da criação de classes e arquivos que você precise criar em algum lugar.
Agora que você leu os fundamentos do CakePHP, você pode tentar seguir o Tutorial de como
fazer um blog em CakePHP, disponível na parte de Exemplos deste manual.

18. Desenvolvendo com CakePHP 17
Parte III. Desenvolvendo com CakePHP
Requisitos
 Servidor HTTP. Apache com mod_rewrite é preferido, mas não é obrigatório.
 PHP 4.3.2 ou superior. Sim! CakePHP funciona com PHP 4 e PHP 5.
Tecnicamente um banco de dados não é obrigatório, mas nós imaginamos que a maioria das
aplicações irão utilizar um. CakePHP suporte uma variedade de banco de dados:
 MySQL (4 ou superior);
 PostgreSQL;
 Firebird DB2;
 Microsoft SQL Server;
 Oracle;
 SQLite;
 ODBC;
 ADOdb.
Preparativos para instalação
Baixando o CakePHP
Há duas maneiras de pegar uma cópia do CakePHP, Primeiro: você pode baixar o arquivo
(zip/tar.gz/tar.bz2) ou você pode baixar o código do repositório SVN.
Para pegar a cópia estável, visite o site http://www.cakephp.org. Lá haverá um link chamado
“Download Now!” para baixar. Os arquivos do CakePHP também são armazenados no
CakeForge e você pode visitar a página do projeto no site
http://cakeforge.org/projects/cakephp.
Se você quer os arquivos mais atuais, verifique no site
http://cakephp.org/downloads/index/nightly e verás a última versão estável, porém nem
sempre a última release. Nestas versões incluem correções entre releases. Ou seja, são versões
intermediárias entre releases, mas que são estáveis.
Para pegar os arquivos direto do repositório SVN, conecte-se em
https://svn.cakephp.org/repo/branches/1.2.x.x.
Permissões
O CakePHP usa o diretório /app/tmp para diversas operações. Descritivos dos modelos, fazer
cache de visões e informações das sessões são alguns exemplos.
Assim, tenha certeza que o diretório /app/tmp na instalação do seu cake permite escrita pelo
usuário do servidor de web.

19. Desenvolvendo com CakePHP 18
Instalação
Instalando o CakePHP pode ser feito simplesmente descompactando o conteúdo no seu
servidor web ou de forma mais complexa e flexível, do jeito que você preferir. Esta seção vais
falar de três maneiras de instalar o CakePHP: desenvolvimento, produção e avançada.
 Desenvolvimento: fácil para começar, URL dos seus aplicativos incluem o diretório de
instalação do CakePHP e é menos seguro;
 Produção: Requer maior habilidade para configurar o servidor web, porém mais
seguro e com URLs mais amigáveis;
 Avançada: Com algumas configurações, permite você colocar os diretórios do CakePHP
em diferentes locais do sistema, possibilitando compartilhar o núcleo do CakePHP
entre diversas aplicações.
Desenvolvimento
Apenas coloque seus arquivos do CakePHP no diretório público do seu servidor web
(normalmente htdocs, www, public_html). Por exemplo, assumindo que o diretório público do
seu servidor web seja /var/www/html, os arquivos devem ficar desta maneira:
 /var/www/html
o /cake_1_2
 /app
 /cake
 /docs
 /index.php
 /vendors
Para ver a sua aplicação CakePHP, entre no link http://www.exemplo.com/cake_1_2/.
Produção
Para utilizar-se do modelo de produção, você precisará ter privilégios de acessar o diretório
público do servidor web. Escolhendo o modo de produção significa que todo o domínio age
como um único pedido CakePHP.
A disposição dos arquivos no modo de produção fica da seguinte maneira:
 /pasta_para_o_cake/
o /app
 /webroot (este diretório deve ser seu diretório público do servidor
web)
o /cake
o /docs
o /index.php
o /vendors
Se sua aplicação está hospedada no Apache, a diretiva DocumentRoot para seu domínio deve
ficar assim:
DocumentRoot /pasta_para_o_cake/app/webroot

20. Desenvolvendo com CakePHP 19
Para ver sua aplicação CakePHP, entre no link http://www.exemplo.com.br.
Instalação avançada
Aqui estão algumas situações que você escolhe o lugar onde os diretórios do CakePHP vão ficar
no seu sistema. Isto pode ser por causa de uma restrição do sistema ou para compartilhar as
bibliotecas entre diferentes aplicações. Esta seção descreve como espalhar seus diretórios dos
CakePHP no sistema.
Primeiro, note que há três partes principais da sua aplicação CakePHP:
1. As bibliotecas do núcleo do CakePHP, em /cake;
2. O código da sua aplicação, em /app;
3. Os arquivos públicos da sua aplicação, normalmente em /app/webroot.
Cada um desses diretórios pode ser colocado em qualquer lugar do seu sistema, com exceção
do webroot, que precisa estar acessível pelo servidor web. Você pode mover a pasta webroot
para fora do diretório da sua aplicação (app), desde que informe ao Cake onde você vai colocá-
la.
Para configurar sua instalação do Cake, nós vamos ter que fazer algumas alterações no arquivo
/app/webroot/index.php. Aqui existem três constantes que precisaremos editar: ROOT,
APP_DIR e CAKE_CORE_INCLUDE_PATH.
 ROOT deve ser configurada para informar o diretório onde sua aplicação se encontra,
ou seja, onde está a pasta app;
 APP_DIR deve ser configurada para informar qual a pasta app;
 CAKE_CORE_INCLUDE_PATH deve ser configurada para informar o diretório onde
estão as bibliotecas do CakePHP (a pasta cake).
Vamos fazer um exemplo para que você veja como funciona a instalação avançada na prática.
Imagine que eu quero que a aplicação funcione como segue:
 As bibliotecas do CakePHP deverão ser colocadas em /usr/lib/cake;
 O diretório público da minha aplicação (webroot) deve ser em /var/www/meusite;
 O diretório da aplicação deve ser /home/eu/meusite.
Com estas configurações, eu preciso editar o meu arquivo webroot/index.php (que no final
deve estar em /var/www/meusite/index.php, neste exemplo) e ver o seguinte:
if (!defined('ROOT')) {
define('ROOT', DS.'home'.DS.'eu');
}
if (!defined('APP_DIR')) {
define ('APP_DIR', 'meusite');
}
if (!defined('CAKE_CORE_INCLUDE_PATH')) {
define('CAKE_CORE_INCLUDE_PATH', DS.'usr'.DS.'lib'.DS.'cake');
/app/webroot/index.php (parcialmente, comentários foram removidos)

21. Desenvolvendo com CakePHP 20
É recomendado que você use a constante DS no lugar das barras para entre os diretórios. Isso
previne que não cause erro quando se use a aplicação em sistemas operacionais diferentes,
tornando seu código mais portável.
Caminho de classes adicionais
Em algumas ocasiões é interessante você compartilhar as classes do MVC entre as aplicações
no mesmo sistema. Se você quer um mesmo controller para mesma aplicação, você pode usar
o arquivo bootstrap.php do CakePHP para adicionar estas classes adicionais.
No bootstrap.php, defina algumas variáveis com nomes especiais para fazer com que o
CakePHP olhe nestes diretórios a procura da sua classe:
$viewPaths = array();
$controllerPaths = array();
$modelPaths = array();
$helperPaths = array();
$componentPaths = array();
$behaviorPaths = array();
Cada um dessas variáveis especiais pode ser um conjunto na array com o diretório absoluto
onde estão às classes que você desejar. Tenha certeza que cada diretório especificado inclua
as barras com DS.
Apache e mod_rewrite
Enquanto o CakePHP é construído para trabalhar com o mod_rewrite e vimos que muitos
usuários apanham para conseguir fazer isto funcionar nos seus sistemas, nós lhe daremos
algumas dicas que você pode tentar para tentar rodar corretamente:
 Tenha certeza que o override está habilitado no .htaccess. Em seu httpd.conf, você
deve olhar na seção que define seu Directory no servidor. Tenha certeza que
AllowOverride está configurado como All para o diretório correto de DocumentRoot;
 Tenha certeza que você está editando o httpd.conf do sistema antes da configuração
do usuário ou do site em específico;
 Tenha certeza que o arquivo .htacess está na pasta do CakePHP. Em alguns sistemas
operacionais ele pode ficar oculto na hora de mover devido a interpretarem o “.”
como sinônimo de ocultamento. Tenha certeza que sua cópia do CakePHP é do site ou
repositório oficial do CakePHP e que foi extraído corretamente;
 Tenha certeza que você está carregando o mod_rewrite corretamente. Você pode ver
algo como LoadModule rewrite_module libexec/httpd/mod_rewirte.so e AddModule
mod_rewrite.c no seu httpd.conf;
 Se você está instalando no diretório do usuário (http://exemplo.com.br/~username),
você terá que modificar o arquivo .htaccess no diretório da base da instalação do
CakePHP. Apenas adicione a linha “RewriteBase /~meuusername/”.
Comece agora!
Tudo bem, vamos ver o CakePHP em ação. Dependendo de qual opção de instalação você
utilizou, acesse no seu navegador o link http://exemplo.com.br ou
http://exemplo.com.br/cake_instalado/. Neste ponto, você verá a página padrão do CakePHP
e a mensagem do estado da configuração do seu banco de dados.

22. Desenvolvendo com CakePHP 21
Parabéns! Você já pode criar sua primeira aplicação CakePHP.
Configuração
Configuração da base de dados
O CakePHP espera que os detalhes de configuração da base de dados estejam no arquivo
“app/config/database.php”. Um exemplo de configuração da base de dados pode ser
encontrado em “app/config/database.php.default”.
A configuração final deve ser parecida com o exemplo abaixo.
var $default = array('driver' => 'mysql',
'persistent' => false,
'host' => 'localhost',
'login' => 'usuarioDB',
'password' => 'senhaDB',
'database' => 'basededados',
'prefix' => '');
Exemplo de configuração da base de dados
A conexão $default é usada a menos que outra configuração seja especificada pela
propriedade $useDbConfig em um model. Por exemplo, se minha aplicação tiver uma base de
dados adicional do legacy além do padrão, eu poderia usá-la em meus models criando uma
nova conexão da base de dados de $legacy similar a configuração $default, e ajustando a var
$useDbConfig = 'legacy'; nos models apropriados.
Preencha corretamente os pares de chave/valor na configuração para atender melhor às suas
necessidades.
Tabela 2. Configurações da base de dados
Chave Valor
driver O nome do driver da base de dados para esta configuração. Exemplos: mysql,
postgres, sqlite, pear-drivername, adodb-drivername, mssql, oracle, ou odbc.
persistent Se usará ou não uma conexão persistente com a base de dados.
host O nome do servidor da base de dados (ou endereço IP).
login O usuário desta conta.
password A senha desta conta.
database O nome da base de dados que esta conexão irá usar.
prefix Esta string será adicionada como prefixo no nome de todas tabelas de sua base
(opcional) de dados.Se suas tabelas não possuem prefixo, deixe esta string vazia.
port A porta TCP ou socket Unix usado para conectar com o servidor.
(opcional)
enconding Indica qual caractere definido será usado para enviar indicações SQL ao servidor.
schema Usado em instalações de base de dados PostgreSQL para especificar qual schema
usar.
Note que as configurações de prefixo são para as tabelas, não para os models. Por exemplo, se
você criou um relacionamento entre as tabelas Apple e Flavor, o nome será
prefixo_apples_flavors (não prefixo_apples_prefixo_flavors), isso se sua opção de prefixo
estiver como 'prefixo_'.

23. Desenvolvendo com CakePHP 22
A partir deste ponto, você deve dar uma olhada nas Convenções CakePHP, mostradas neste
manual. A nomenclatura correta para suas tabelas (e o nome de algumas colunas) pode livrar
de algumas implementações e configurações desnecessárias.
Configuração do núcleo
As classes de configuração
Classes de configuração
Variáveis de configuração do núcleo
Constantes de configuração
Configuração de rotas (Routes)
Routes é uma funcionalidade que mapeia URLs em ações do controller. Foi adicionado ao
CakePHP para tornar URL amigáveis mais configuráveis e flexíveis. Não é obrigatório o uso do
mod_rewrite para usar routes, mas usando-o fará sua barra de endereços muito mais limpa e
arrumada.
Routes no CakePHP 1.2 foi ampliada e pode ser muito mais poderosa.
Antes de você aprender sobre como configurar suas próprias rotas, você deveria saber que o
CakePHP vem configurado com um conjunto de rotas padrão. A configuração padrão de rotas
do CakePHP deixará as URLs mais bonitas para qualquer aplicação. Você pode acessar
diretamente uma ação via URL colocando seu nome na requisição. Você pode também passar
parâmetros para suas ações no controller usando a própria URL.
URL para a rota padrão:
http://examplo.com/controller/action/param1/param2/param3
A URL /noticias/ler mapeia para a ação ler() do controller Noticias (NoticiasController), e
/produtos/verInformacoes mapeia para a ação view_informacoes() do controller Produto
(ProdutosController). Se nenhuma ação é especificada na URL, a ação index() será chamada.
A rota padrão também permite passar parâmetros para as ações usando a URL. Uma
requisição /noticias/ler/12 seria equivalente a chamar o método ler(12) no controller Noticias
(NoticiasController), por exemplo.
Uma novidade no CakePHP 1.2 é a possibilidade de usar parâmetros nomeados. Você pode
nomear parâmetros e enviar seus valores usando a URL. Uma requisição
/noticias/ler/titulo:primeira+noticia/categoria:esportes teria como resultado uma chamada a
ação ler() do controller Noticias (NoticiasController). Nesta ação, você encontraria os valores
dos parâmetros título e categoria dentro de $this->passedArgs['titulo'] e $this-
>passedArgs['categoria'] respectivamente.
Alguns exemplos para a rota padrão:
URL mapeadas para as ações dos controladores, usando rotas padrão:
URL: /monkeys/jump

24. Desenvolvendo com CakePHP 23
Mapeado para: MonkeysController->jump();
URL: /products
Mapeado para: ProductsController->index();
URL: /tasks/view/45
Mapeado para: TasksController->view(45);
URL: /donations/view/recent/2001
Mapeado para: DonationsController->view('recent', '2001');
URL: /contents/view/chapter:models/section:associations
Mapeado para: ContentsController->view();
$this->passedArgs['chapter'] = 'models';
$this->passedArgs['section'] = 'associations';
Definindo suas próprias rotas permite você definir como sua aplicação irá responder a uma
dada URL. Defina suas próprias rotas no arquivo “/app/config/routes.php” usando o método
Router::connect().
O método connect() recebe três parâmetros: a URL que você deseja casar, o valor padrão para
os elementos de rota, e regras de expressões regulares para ajudar a encontrar elementos na
URL.
O formato básico para uma definição de rota é:
Router::connect(
'URL',
array('paramName' => 'defaultValue'),
array('paramName' => 'matchingRegex')
)
Inflexão personalizada
As convenções de nomenclatura do Cake podem ser realmente legais. Você pode nomear sua
tabela big_boxes, seu model BigBox, seu controller BigBoxesController e tudo isso funciona em
conjunto automaticamente. A maneira que o CakePHP usa para associar todas juntas é através
da utilização de inflections (inflexões), que transformam as palavras do singular em plural e
vice-versa.
Existem ocasiões (especialmente para nossos amigos que não falam inglês - nosso caso), onde
você pode rodar o inflector do CakePHP (a classe que pluraliza, singulariza, camelCases e
under_scores) e não funcionar como você gostaria. Se o CakePHP não reconhecer seu Foci ou
Fish, editando o arquivo de configuração personalizada de inflexões você poderá indicar seus
casos especiais. O arquivo de configuração é encontrado em /app/config/inflections.php.
Neste arquivo, você irá encontrar seis variáveis. Cada uma permite você fazer o ajuste fino das
inflections do CakePHP.
Variáveis do inflections.php Descrição
$pluralRules Este array contém regras de expressões regulares para
pluralizar casos especiais. A chave do array são os patterns e o
valor são as substituições.

25. Desenvolvendo com CakePHP 24
$uninflectedPlural Um array que contém palavras que não precisam ser alteradas
quando passadas para o plural (lápis, etc.).
$irregularPlural Um array que contém palavras e seus plurais. A chave do array
contém a forma no singular e o valor a forma no plural. Este
array deve ser usado para guardar palavras que não seguem as
definições em $pluralRules.
$singularRules Similar a $pluralRules, contém as regras para singularizar as
palavras.
$uninflectedSingular Similar a $uninflectedPlural, contém as palavras que não
contém forma no singular. Por padrão, este array tem o
mesmo valor de $uninflectedPlural.
$irregularSingular Similar a $irregularPlural, contém as palavras que possuem
apenas a forma singular.
A versão para língua portuguesa do inflections.php pode ser encontrada nos apêndices, com o
título Inflexão em português.
Configuração de inicialização (bootstrap)
Controllers (Controladores)
Introdução
Um controller (ou controlador) é usado para gerenciar a lógica para uma parte de sua
aplicação. Mais comumente, controllers são usados para gerenciar a lógica de um único model.
Por exemplo, se você está construindo um site para uma padaria online, você pode ter um
ReceitasController e um IngredientesController gerenciando suas receitas e seus ingredientes.
No CakePHP, controllers são nomeados de acordo com o model que manipulam, no plural.
O model Receita é manipulado pelo ReceitasController, o model Produto é manipulado pelo
ProdutosController, e por aí vai.
Seus controllers de aplicação são classes que estendem a classe CakePHP AppController, a qual
por sua vez estende a classe núcleo Controller. A classe AppController pode ser definida em
app/app_controller.php e deve conter métodos que são compartilhados entre todos os seus
controllers. A classe AppController estende o Controller que é uma classe padrão da biblioteca
CakePHP.
Controllers podem incluir qualquer número de métodos que são geralmente referidos como
actions (ações). Actions são métodos do controlador usados para mostrar views (visões). Uma
action é um único método de um controller. O dispatcher (despachante) do CakePHP chama
actions quando uma requisição casa uma URL com uma action do controller. Retornando ao
nosso exemplo da padaria online, nosso ReceitasController pode conter as actions ver(),
compartilhar() e buscar(). O controller poderia ser encontrado em
app/controllers/receitas_controller.php e poderia conter:
<?php
class ReceitasController extends AppController {
function ver($id) {
// a lógica da action vai aqui...
}

26. Desenvolvendo com CakePHP 25
function compartilhar($cliente_id, $receita_id) {
// a lógica da action vai aqui...
}
function buscar($busca) {
// a lógica da action vai aqui...
}
}
?>
app/controllers/receitas_controller.php
Para que você possa usar o controller de forma mais efetiva em sua aplicação, vamos cobrir
alguns dos principais atributos e métodos fornecidos pelos controllers do CakePHP.
Atributos
Para uma lista completa de atributos do controller e suas descrições visite a API do CakePHP.
Dê uma olhada http://api.cakephp.org/1.2/classController.html.
$name
Usuários PHP4 devem iniciar suas definições de controllers usando o atributo $name. O
atributo $name deve conter o nome do controller. Geralmente é apenas a forma plural do
nome do model. Isso cuida de alguns dos problemas de nomes de classe do PHP4 e ajuda o
CakePHP a encontrar os nomes das coisas.
<?php
class ReceitasController extends AppController {
var $name = 'Receitas';
}
?>
Exemplo de uso do atributo $name do controller
$components, $helpers e $uses
Os próximos atributos de controller usados com maior freqüência dizem ao CakePHP que
helpers (ajudantes), components (componentes), e models você usará junto com o controller
atual. Usar esses atributos disponibiliza essas classes MVC para o controller como variáveis de
classe ($this->NomeDoModel, por exemplo).
Por favor, perceba que cada controller tem algumas dessas classes disponíveis por padrão,
então você pode nem mesmo ter que configurar o seu controller.
Controllers tem por padrão seu model principal disponível. Nosso ReceitasController terá o
model Receita disponível em $this->Receita, e nosso ProdutosController também tem acesso
ao model Produto em $this->Produto.
Os helpers Html e Session estão sempre disponíveis por padrão, assim como o component
Session. Para aprender mais sobre essas classes, lembre-se de dar uma olhada em suas
repectivas sessões mais a frente nesse manual.

27. Desenvolvendo com CakePHP 26
Vamos ver como chamar um controller CakePHP no qual você planeja usar classes MVC
adicionais.
<?php
class ReceitasController extends AppController {
var $name = 'Receitas';
var $uses = array('Receita', 'Usuário');
var $helpers = array('Html', 'Ajax');
var $components = array('Session', 'Email');
}
?>
Quando estiver definindo esses atributos, tenha certeza de incluir as classes padrão (como
Html no array $helpers, por exemplo) se você pretende usá-los.
Relativo à página: $layout e $pageTitle
Alguns poucos atributos existem nos controllers CakePHP que dão maior controle sobre como
suas views são embutidas em um layout.
O atributo $layout pode conter o nome do layout salvo em /app/views/layouts. Você
especifica um layout atribuindo ao atributo $layout o nome do arquivo de layout menos a
extensão .ctp. Se esse atributo não for definido, o CakePHP renderiza o layout default
(padrão). Se você não definiu um em /app/views/default.ctp, o layout default do núcleo do
CakePHP será renderizado.
<?php
class RecipesController extends AppController {
function quickSave() {
$this->layout = 'ajax';
}
}
?>
Usando $layout para definir um layout alternativo
O atributo $pageTitle do controller torna possível definir o título da página renderizada. Para
que isso funcione apropriadamente, seu layout precisa ter embutido a variável
$title_for_layout entre as tags <title> no cabeçalho do documento HTML.
Apenas atribua à $pageTitle a string que você quer ver no <title> do seu documento.
Atributos dos parâmetros ($params)
Parâmetros do controller estão disponíveis em $this->params no seu controller CakePHP. Essa
variável é usada para dar acesso à informação sobre a requisição atual. O uso mais comum do
$this->params é obter acesso à informação que foi enviada ao controller via operações POST
ou GET.
 $this->params['form']

28. Desenvolvendo com CakePHP 27
o Qualquer dado do POST de qualquer formulário é guardado aqui, incluindo
também informação encontrada em $_FILES.
 $this->params['bare']
o Guarda 1 se o layout atual está vazio, 0 se não.
 $this->params['isAjax']
o Guarda 1 se o layout atual é 'ajax', 0 se não. Essa variável só é configurada se o
component RequestHandler está sendo usado no controller.
 $this->params['controller']
o Guarda o nome do controller atual manipulando a requisição. Por exemplo, se
a URL /posts/ver/1 foi requisitada, $this->params['controller'] será igual à
'posts'.
 $this->params['action']
o Guarda o nome da action atual manipulando a requisição. Por exemplo, se a
URL /posts/ver/1 é requisitada, $this->params['action'] será igual 'ver'.
 $this->params['pass']
o Guarda a query string GET passada com a requisição atual. Por exemplo, se a
URL /posts/ver/?var1=3&var2=4 foi requisitada, $this->params['pass'] será
igual à '?var1=3&var2=4'.
 $this->params['url']
o Guarda a URL atual requisitada, com os pares chave-valor das variáveis GET.
Por exemplo, se a URL /posts/view/?var1=3&var2=4 foi chamada, $this-
>params['url'] conterá:
[url] => Array
(
[url] => posts/view
[var1] => 3
[var2] => 4
)
 $this->data
o Usado para manipular os dados POST enviados dos formulários FormHelper ao
controller.
// O FormHelper é usado para criar um elemento form:
$form->text('Usuario.primeiro_nome');
// Quando rederizado, se parece com:
<input name="data[Usuario][primeiro_nome]" value="" type="text" />
// Quando o formulário é enviado para o controller via POST,
// os dados são mostrados em $this->data
// O primeiro nome pode ser encontrado aqui:
$this->data['Usuario']['primeiro_nome'];
Outros atributos
Ainda que você possa dar uma olhada nos detalhes de todos os atributos de controllers na API,
existem outros atributos de controllers que merecem suas próprias sessões no manual.

29. Desenvolvendo com CakePHP 28
O atributo $cacheAction serve para criar cache das views, e o atributo $paginate é usado para
criar a paginação padrão para o controller. Para mais informação sobre como usar esses
atributos, dê uma olhada em suas respectivas sessões mais a frente nesse manual.
Métodos
Para uma lista completa de métodos do controller e suas descrições visite a API CakePHP. Dê
uma olhada http://api.cakephp.org/1.2/class_controller.html.
Interagindo com as visões
 set(string $var, mixed $value)
O método set() é a principal forma de enviar dados do seu controller para sua view. Uma vez
que você usou set(), a variável pode ser acessada na sua view.
// Primeiro você passa os dados do controller:
$this->set('cor', "pink");
// Então, na view, você pode utilizar os dados:
<p>Você selecionou a cor <?php echo $cor; ?> para colorizar o cake.</p>
Exemplo de uso do set()
O método set() também pega um array associativo como seu primeiro parâmetro. Esse pode
ser geralmente um caminho rápido para atribuir um grupo de informações para a view.
Perceba que os índices de seu array sofrerão inflection antes de serem atribuídos à view
('indice_com_underline' se torna 'indiceComUnderline', etc.):
$dados = array(
'cor' => 'pink',
'tipo' => 'açucar',
'preco_base' => 23.95
);
// fazem $cor, $tipo, e $precoBase
// disponíveis na view:
$this->set($dados);
 render(string $action, string $layout, string $file)
O método render() é automaticamente chamado ao final de cada action do controller
requisitada. Esse método executa toda a lógica da view (usando dados que você forneceu
usando o método set()), insere a view dentro do layout e o serve de volta para o usuário final.
O arquivo de view padrão renderizado é determinado por convenção. Se a action buscar() do
ReceitasController é requisitada, o arquivo de view /app/views/receitas/buscar.ctp será
renderizado.

30. Desenvolvendo com CakePHP 29
Ainda que o CakePHP vá automaticamente chamá-lo (a menos que você configure $this-
>autoRender para false) depois de cada lógica de action, você pode usá-lo para especificar um
arquivo de view alternativo configurando o nome da action no controller usando $action. Você
pode também especificar um arquivo alternativo um terceiro parâmetro, $file. Quando usar
$file, lembre-se de utilizar um pouco das constantes globais do CakePHP (como a VIEWS).
O parâmetro $layout permite especificar o layout na qual a view é renderizada.
Fluxo de controle
 redirect(string $url, integer $status, boolean $exit)
O método de controle de fluxo que você vai usar com maior freqüência é o redirect(). Esse
método pega seu primeiro parâmetro na forma de uma URL relativa CakePHP. Quando um
usuário fez uma compra com sucesso, você provavelmente irá redirecioná-lo para a tela de
recibo.
function comprar() {
// A lógica para finalizar a compra vai aqui...
if($sucesso) {
$this->redirect('/compras/obrigado');
} else {
$this->redirect('/compras/confirmar');
}
}
Exemplo de uso do redirect()
O segundo parâmetro do redirect() lhe permite definir um código de status HTTP para
acompanhar o redirecionamento. Você pode querer usar 301 (movido permanentemente) ou
303 (veja outro), dependendo da natureza do redirecionamento.
Esse método não chama exit() depois de redirecionar a menos que você configure o terceiro
parâmetro para true.
 flash(string $message, string $url, integer $pause)
Similarmente, o método flash() é usado para direcionar o usuário para uma nova página depois
de uma operação. O método flash() é diferente pelo fato de mostrar uma mensagem antes de
passar o usuário para uma outra URL.
O primeiro parâmetro deve guardar a mensagem a ser mostrada, e o segundo parâmetro é
uma URL relativa CakePHP. CakePHP vai mostrar a mensagem na variável $message, por um
tempo definido em segundos na variável $pause antes de direcionar o usuário.
Para mensagens flash dentro da página, dê uma olhada no método setFlash() do component
Session.
Callbacks
Controllers CakePHP vem com callbacks para inserir lógica exatamente antes ou depois das
actions serem rederizadas.

31. Desenvolvendo com CakePHP 30
 beforeFilter()
Essa função é executada antes de qualquer action no controller. É o lugar ideal para checar
uma sessão ativa ou inspecionar permissões.
 beforeRender()
Chamada após a lógica da action do controller, mas antes da view ser renderizada. Esse
callback não é usado geralmente, mas pode ser necessário se você está chamando render()
manualmente antes do final de uma dada action.
 afterFilter()
Chamada depois de toda action do controller.
 afterRender()
Chamada depois que uma action tiver sido renderizada.
Outros métodos
 constructClasses()
Esse método carrega os models requeridos pelo controller. Esse processo de carregamento é
feito pelo CakePHP normalmente, mas o método é uma boa quando estiver acessando
controllers de diferentes perspectivas. Se você precisa do CakePHP em um script de linha de
comando ou outro uso de fora, constructClasses() pode ser uma boa.
 referrer()
Retorna a URL referida pela requisição atual.
 disableCache()
Usado para dizer ao navegador do usuário não fazer cache dos resultados na requisição atual.
Isso é diferente do cache da view, coberto no capítulo anterior.
 postConditions(array $data, mixed $op, string $bool, boolean $exclusive)
Use esse método para tornar um grupo de dados enviados por POST (de inputs compatíveis
com o helper Html) em um grupo de condições de busca para o model. Essa função oferece um
atalho rápido para criar lógica de busca. Por exemplo, um usuário administrativo pode querer
ser capaz de buscar compras para saber quais itens precisam ser enviados. Você pode criar um
rápido formulário baseado no model Compra. Então a action do controller pode usar os dados
enviados do formulário para criar as condições de busca.
function index() {
$c = $this->Compras->findAll($this->postConditions($this->data));
$this->set('compras', $c);
}

32. Desenvolvendo com CakePHP 31
Se $this->data['Compra']['destino'] é igual a “Padaria da Cidade Velha”, postConditions
converte essa condição para um array compatível para uso no método NomeDoModel-
>findAll(). Nesse caso, array(“Compra.destino” => “Padaria da Cidade Velha”).
Se você quer usar um operador SQL diferente entre os termos, forneça-os usando o segundo
parâmetro.
/*
Conteúdo de $this->data
array(
'Compra' => array(
'num_de_itens' => '4',
'fornecedor' => 'Trigo Integral LTDA'
)
)
*/
// Vamos pegar compras que tem ao menos 4 itens e contém 'Trigo Integral
LTDA'
$c = $this->Compra->findAll($this->postConditions(
$this->data,
array('>=', 'LIKE')
));
O índice nas especificações de operadores é a ordem das colunas no array $this->data. Já que
num_de_itens é o primeiro, o operador >= aplica-se a ele.
O terceiro parâmetro lhe permite dizer ao CakePHP que operador booleano SQL usar entre as
condições de busca. Strings com 'AND', 'OR', e 'XOR' são todos valores válidos.
Finalmente, se o último parâmetro está configurado para true, e o parâmetro $op é um array,
os campos não incluídos em $op não serão incluídos nas condições retornadas.
 cleanUpFields(string $modelClass = null)
Esse método de conveniência concatena as várias partes de datas em $this->data antes de
salvar. Se você tem inputs de data do helper Form, esse método concatena o ano, mês, dia e
hora em uma string mais compatível com banco de dados.
Esse método usa o model padrão do controller (por ex.: o model Cookie para o controller
CookiesController) como alvo para a concatenação, mas uma classe alternativa pode ser usada
como primeiro parâmetro.
 paginate()
Esse método é usado para paginar os resultados divididos pelos seus models. Você pode
especificar tamanhos de páginas, condições de busca do model e mais. Detalhes sobre esse
método mais a frente. Dê uma olhada no capítulo de paginação mais a frente nesse manual.
 requestAction(string $url, array $options)
Essa função chama uma action de controller de qualquer lugar e retorna os dados dessa action.
A $url passada é uma URL relativa ao CakePHP

33. Desenvolvendo com CakePHP 32
(/nomedocontroller/nomedaaction/parametros). Se o array $options incluir um valor de
returno. AutoRender é automaticamente configurada para true para a action do controller,
tendo a requestAction te levando para a view totalmente renderizada.
Nota: apesar de ser possível usar requestAction() para pegar uma view totalmente
renderizada, a perda performance que você obtém passando por toda a camada da view
novamente na realidade não faz valer a pena. O método requestAction() é melhor usado em
conjunto com elements - como um caminho para enviar lógica de negócio para um element
antes da renderização.
Primeiro, vamos ver como pegar dados da action do controller. Primeiro, nós precisamos criar
a action do controller que retorna algum dado que precisamos em vários lugares através da
aplicação:
// Aqui está nosso controller simples:
class UsuariosController extends AppController {
function pegarListaDeUsuarios() {
return $this->Usuario->findAll("Usuario.ativo = 1");
}
}
Imagine que nós precisamos criar uma simples tabela mostrando os usuários ativos no
sistema. Ao invés de duplicar o código de geração de lista em outro controller, nós podemos
pegar dados do UsuariosController->pegarListaDeUsuarios() ao invés de usar requestAction();
class ProdutosController extends AppController {
function mostrarProdutosDoUsuario() {
$this->set(
'usuarios',
$this->requestAction('/usuarios/pegarListaDeUsuarios')
);
// Agora a variável $usuarios na view vai ter dados do
// UsuariosController::pegarListaDeUsuarios().
}
}
Se você tem um element na sua aplicação que não é estático, você pode querer usar
requestAction() para enviar lógica equivalente à do controller para o element a medida em que
você o injeta nas suas views. Apesar de elements sempre tem acesso a qualquer variável da
view que o controller passou, essa é uma forma de passar dados para o element vindos de
outro controller.
Se você criou uma action do controller que fornece a lógica necessária, você pode pegar dados
e passá-lo para o segundo parâmetro do método renderElement() da view usando
requestAction().
<?php
echo $this->renderElement(
'usuarios',
$this->requestAction('/usuarios/pegarListaDeUsuarios')
);

34. Desenvolvendo com CakePHP 33
?>
Se o array '$options' contiver um valor “return”, a action do controller será renderizada dentro
de um layout vazio e retornada. Dessa forma, a função requestAction() é útil também em
situações Ajax onde um pequeno elemento de uma view precisa ser preenchido antes ou
durante uma atualização Ajax.
Components (Componentes)
Introdução
Components (Componentes) são pacotes com funções lógicas que são usadas para serem
compartilhadas entre os controllers. Se você está querendo copiar e colar coisas entre os
controllers, você pode criar funcionalidades em components para isso.
O CakePHP já vem com um conjunto de components para os mais diversos usos, por exemplo:
 Segurança
 Sessões
 Lista de controle de acessos (ACL)
 E-mails
 Cookies
 Autenticação
 Manipulação de requisições
Cada um dos components será explicado em outros capítulos. Por enquanto, mostraremos
apenas como criar seus próprios components. Criando components ajuda a manter o código do
controller limpo e permite que você reuse o código entre os projetos ou controllers.
Construindo componentes personalizados
Suponha que sua aplicação online precisa utilizar funções complexas de matemática em
diversas partes da aplicação. Poderíamos, então, criar um component para que esta lógica seja
compartilhada entre diversos controllers.
O primeiro passo é criar um arquivo para o component e uma classe. Crie o arquivo em
/app/controllers/components/math.php. A estrutura básica do arquivo do component é
similar a apresentada abaixo.
<?php
class MathComponent extends Object {
function doComplexOperation($amount1, $amount2) {
return $amount1 + $amount2;
}
}
?>
Quando seu component estiver criado, nós podemos utilizá-lo nos controllers da aplicação
colocando o nome do component no vetor da variável $components:
// Isso faz com que o novo component possa ser acessado usando $this->Math

35. Desenvolvendo com CakePHP 34
var $components = ('Math', 'Session');
Acessando classes do MVC de dentro dos componentes
Para ter acesso a instância do controlador dentro do seu novo component, você precisa
implementar o método startup(). Este é um método especial que trás a referência do
controller como primeiro parâmetro e esta função é chamada automaticamente depois da
função beforeFilter() do controller. Se por alguma razão você não quer que o método startup()
seja executado quando o controller é instanciado, defina o valor da variável $disableStartup
para true.
Se você deseja inserir uma lógica antes que o controller seja chamado, use o método initialize()
no seu component.
<?php
class MathComponent extends Object {
// chamado antes de Controller:beforeFilter()
function initialize() {
}
// chamado depois de Controller::beforeFilter()
function startup(&$controller) {
}
function doComplexOperation($amount1, $amount2) {
return $amount1 + $amount2;
}
}
?>
Você pode também querer utilizar outros components dentro de um component
personalizado. Para isso, basta criar a variável $components na classe (assim como você faria
em um controller) como um array que contenha os nomes dos components que você deseja
utilizar.
Models (Modelos)
Introdução
Campos mágicos
Atributos
Métodos
Associações
Introdução
Um dos mais poderosos recursos do CakePHP é o mapeamento relacional fornecido pelos
models. No CakePHP, as ligações entre os models são manipuladas através de associações.