Zend_Controller
fornece os alicerces para construção de
websites baseados no padrão de projeto Modelo-Visão-Controlador
(MVC).
O sistema Zend_Controller
foi projetado para ser leve,
modular, e extensível. É um design minimalista cujo objetivo é oferecer
flexibilidade e alguma liberdade aos usuários, ao mesmo tempo em que
fornece uma estrutura que permite aos sistemas construídos com base no
Zend_Controller
compartilharem algumas convenções comuns e
padrões similares de código.
O fluxo de trabalho do Zend_Controller
é implementado
por alguns componentes. Não é necessário entender completamente a
orquestração destes componentes para usar o sistema, sendo mais útil
compreender a maneira como os processos trabalham.
Zend_Controller_Front
rege todo o fluxo de
trabalho do sistema Zend_Controller
. Trata-se de uma
implementação do padrão FrontController.
Zend_Controller_Front
processa todas as requisições
recebidas pelo servidor e atualmente é responsável por delegar
requisições para os ActionControllers
(Zend_Controller_Action
).
Zend_Controller_Router
é o roteador. Roteamento é
p processo de tomar a parte final de uma URI e desmembrá-la para
determinar qual controlador, e a respectiva ação deste controlador,
deverá receber a requisição. Esta definição de controlador, ação, e
parâmetros opcionais, está empacotada em um valor do objeto chamado
Zend_Controller_Dispatcher_Token
. Este é então
processado pelo Zend_Controller_Dispatcher
. O
roteamento ocorre somente uma vez: quando o pedido inicial é
recebido e antes do primeiro controlador ser despachado.
Zend_Controller_Dispatcher
é o despachante.
Despachar é o processo de tomar o
Zend_Controller_Dispatcher_Token
, localizar o arquivo
de controle apropriado, instanciar uma classe controladora contida
neste arquivo (deve implementar
Zend_Controller_Action
), e finalmente executar o método
de ação do objeto controlador. Diferentemente do roteamento, que
ocorre somente uma vez, os despacho são executados em um laço.
Zend_Controller_Dispatcher
é repetidamente chamado pelo
Zend_Controller_Front
até que todas as ações tenham
sido despachadas sequencialmente.
Zend_Controller_Action
é o componente controlador
base. Cada controlador é uma classe simples, que extende a classe
Zend_Controller_Action class
, e esta classe possui
métodos de ação.
O fluxo de trabalho do Zend_Controller
é
relativamente simples. Um pedido é recebido pelo
Zend_Controller_Front
, que por sua vez chama
Zend_Controller_Router
para determinar qual controlador (e
respectiva ação deste controlador) será despachado.
Zend_Controller_Router
decompõe a URI em um objeto
Zend_Controller_Dispatcher_Token
que descreve para onde
despachar. Zend_Controller_Front
entra então em um laço de
despacho. Ele chama Zend_Controller_Dispatcher
, passando-lhe
a ficha de despacho, para ser despachada ao controlador atual (e
respectiva ação). Quando o controlador termina, o controle retorna ao
Zend_Controller_Front
. Se o controlador indicar que outro
controlador deverá ser despachado para retornar uma nova ficha de
despacho, o laço continuará e outro despacho será executado. Caso
contrário, o processo termina.
Antes de poder contruir seu primeiro controlador, você precisa
entender comom o processo de roteamento funciona e como foi implementado
em Zend_Controller_Router
. Lembre-se que o fluxo de trabalho
está dividido em "roteamento", que ocorre apenas uma vez, e "despacho",
que ocorre logo após, repetidas vezes em um laço.
Zend_Controller_Front
chama
Zend_Controller_Router
para mapear uma URI para um
controlador -- e uma ação deste controlador.
Zend_Controller_Router
toma a URI e decompõe-na em objetos
Zend_Controller_Dispatcher_Token
, que são passados ao
despachante (Zend_Controller_Dispatcher
).
Este roteador emprega um mapeamento muito simples para determinar o nome do controlador e sua respectiva ação:
http://framework.zend.com/controller/action/
Observe, no exemplo acima, que o primeiro segmento conterá sempre o nome do controlador e o segundo o nome da ação.
Opcionalmente, parâmetros podem ser definidos na URI passada ao controlador. Estes tomarão a forma de pares chave/valor:
http://framework.zend.com/controller/action/key1/value1/
Se nada for informado na parte /controller/
da URI, ele
será tomado por "index
". Da mesma forma, se nada contiver a
parte /action/
, ela também será tomada por
"index
". Este exemplo ilustra:
http://framework.zend.com/roadmap/future/ Controller: roadmap Action : future http://framework.zend.com/roadmap/ Controller: roadmap Action : index http://framework.zend.com/ Controller: index Action : index
Nota | |
---|---|
Atualmente estamos desenvolvendo um novo roteador baseado em uma engine de reescrita que conferirá maior flexibilidade às funcionalidades atualmente presentes. Isto será incluído nas próximas versões do framework em um futuro bem próximo. |
O nome do controlador, de sua respectiva ação, e quaisquer
parâmetros opcionais são empacotados em uma ficha de despacho,
Zend_Controller_Dispatcher_Token
. Esta ficha é retornada para
Zend_Controller_Front
, que irá entrar em laço de despacho.
Uma vez no laço de despacho, a ficha é passada para
Zend_Controller_Dispatcher
.
A ficha de despacho é um simples valor do tipo objeto, que é passado
entre Zend_Controller_Front
e as classes que implementam as
interfaces do roteador e do despachante. Ela empacota a definição de um
controlador, uma ação, e parâmetros a serem passados à ação.
O nome do controlador é acessado por
getControllerName()
e
setControllerName()
.
O nome da ação chamada é acessada por
getActionName()
e setActionName()
.
Os parãmetros a serem passados à ação estão em um array
associativo são acessados por getParams()
e
setParams()
.