O Zend_Controller é desenhado para ser leve,
modular e flexível.
Em um design minimalista que permite flexibilidate e liberdade aos usuários
enquanto fornece uma estrutura suficiente do qual o sistema contruídos com base noZend_Controller compartilham de algumas convenções
e desenho do código similares.
O seguinte o diagrama mostra o fluxo de trabalho e como se comunicam os componentes internos:
O fluxo de trabalho do Zend_Controller é implementado
por diversos componentes. Enquanto não é necessário o completo entendimento de cada
um deles para usar o sistema, basta ter em mente o que cada componente
faz e já estará de bom tamanho.
Zend_Controller_Front orquestra a entrada
do fluxo de trabalho do sistema
Zend_Controller.
O Zend_Controller_Front
processa todas as requisições recebidas pelo servidor e é
responsável por delega-lás aos ActionControllers
(Zend_Controller_Action).
Zend_Controller_Request_Abstract
(frequentemente denominado como
Request Object)
Representa o ambiente de requisição e fornece métodos para configurar
e receber
os nomes de controles e ações e qualquer parâmetro requisitado.
Adicionalmente isso mantém a existência ou não da ação que tem que
ser executada por Zend_Controller_Dispatcher.
Extensões para a abstração de requisições objeto podem ser usadas para encapsular a entrada da requisição ambiente, permitindo que routers puxem informações sobre a requisição ambiente em ordem que foi atribuída os nomes do controller e ação.
Por padrão Zend_Controller_Request_Http é usado
para fornecer acesso à entrada de requisições
HTTP.
Zend_Controller_Router_Interface é usado
para definir routers. Routing é o processo de examinar o ambiente de
requisição para determinar qual controller e qual action do controller,
deve receber uma requisição.
Esse controller, action e parâmetros opcionais são então atribuídos
à uma requisição objeto (request object) para sere processado pelo
Zend_Controller_Dispatcher_Standard.
Routing ocorre somente uma vez: quando a requisição é inicialmente recebida
e antes do primeiro controller ser executado.
O router padrão,
Zend_Controller_Router_Rewrite, pega a
extremidade da URI como espicificado
no Zend_Controller_Request_Http e decompõe
ela em controller, action e parâmetros baseados sob o caminho informado
na URL. Como exemplo, a
URL
http://localhost/foo/bar/key/value
deve ser decodificado para usar o foo
como controller, bar como action, e
especificar o parâmetro key
com o valor de value.
Zend_Controller_Router_Rewrite
também pode ser usado para combinar arbitráriamente diretórios;
veja the router documentation para maiores informações.
Zend_Controller_Dispatcher_Interface é usado
para definir o que deve ser executado (dispatchers). Dispatching é o processo de puxar
o controller e o action do objeto requisitado e mapeando-lhes para um arquivo
de controller (ou classe) e método de action (ação) na classe controller.
Se o controller ou action não existe, é determinado apontar a execução
do controller e action padrões.
O processo atual de dispatching consiste em instânciar a classe controller
e chamar o método action da classe.
Diferentemente do routing, o qual ocorre somente na primeira vez, dispatching
ocorre em loop.
Se o status do objeto requisitado expedido (dispatched) é resetado
em qualquer ponto, o loop vai ser repetido, chamando qualquer action
que é atualmente atribuído a um objeto requisitado.
A primeira vez que o loop é finalizado com o objeto requisitado
o status dispatched atribui (Boolean
TRUE), e vai ser finalizar o processamento.
O padrão dispatcher é
Zend_Controller_Dispatcher_Standard.
É definido controllers que o MixedCasedClasses termina com a palavra
Controller, e método action que o camelCasedMethods termina com a
palavra Action:
FooController::barAction()
Nesse caso, o controller deve ser referenciado como
foo
e o action como
bar
![]() |
Convenções de Nomeamento |
|---|---|
|
Uma vez que humanos são notoriamente inconsistentes na manuntenção de case sensitivity quando links são digitados, Zend Framework atualmente normaliza informações de diretórios com lowercase (letra minúscula). Nesse caso vai afetar como seu nome de controller e actions... ou referir-se a eles em links. Se você deseja ter sua classe de controller ou nome de método de ação multriplos MixedCasedWords ou camelCaseWords, você vai precisar separar essas palavras sobre a url com '-' ou '.' (embora você possa configurar o catacter usado).
Como exemplo, se você estava indo executar a ação no
|
Zend_Controller_Action é a action base
do componente controller. Cada controller é uma simples classe que
extende da classe
Zend_Controller_Action e deve conter um ou
mais métodos de ação (action). Zend_Controller_Response_Abstract define uma
classe de base de resposta usada para colecionar e retornar respostas das
ações de controles. É colecionado ambos o cabeçalhos e conteúdo de corpo.
A resposta padrão da classe é
Zend_Controller_Response_Http, o qual é
adequado para uso com o ambiente HTTP.
O fluxo de trabalho do Zend_Controller é relativamente
simples:
Uma requisição é recebida pela Zend_Controller_Front,
o qual por sua vez chama Zend_Controller_Router_Rewrite
para determinal qual controller (e action do controller) vai ser executado (dispatch).
Zend_Controller_Router_Rewrite decompõem o
URI em ordem de atribuição do nome do
controller e action da requisitada.
Zend_Controller_Front então entra na expedição (dispatch)
do loop.
É chamado o Zend_Controller_Dispatcher_Standard,
passando a requisição para executar o controller e o action especificado na requisição
(se não usa os defaults).
Após o controller ter finalizado, o controle é retornado ao
Zend_Controller_Front. Se o controller indicou
que outro controller deve ser executado é redifinindo o status do dispatched (execução)
da requisição, o loop continua e outro dispatch é realizado. Caso controário o controle
é finalizado.