Capítulo 2. Zend_Controller
Anterior |  | Próxima

## Capítulo 2. Zend_Controller

## 2.1. Visão Geral

### 2.1.1. Introdução

`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.

### 2.1.2. Processo de Roteamento

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`.

### 2.1.3. Ficha de Despacho

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()`.

### 2.1.4. Processo de Despacho

Despachar é o processo de tomar uma ficha, `Zend_Controller_Dispatcher_Token`, extrair a informação contida nela: um nome de controlador, um nome de ação, e parâmetros opcionais, e instanciar um controlador, chamando uma ação deste.

Anterior |  | Próxima
1.8. Zend::registry() | Principal | 2.2. Iniciando