<sect1 id="zend.controller.basics">
    <title>Zend_Controller Básico</title>

    <para>
        O sistema <code>Zend_Controller</code> é projetado para ser leve,
        modular, e extensível. É um projeto minimalista para permitir uma
        flexibilidade e alguma liberdade para usuários enquanto provê
        estrutura suficiente para os sistemas construídos envolta do
        <code>Zend_Controller</code> compartilhar algumas convenções
        comuns e layout de código.
    </para>

    <para>
        O diagrama seguinte representa o processo, e a narrativa subseqüente
        descreve detalhadamente as interações:
    </para>

    <para>
        <inlinegraphic width="483" scale="100" align="center" valign="middle"
            fileref="../figures/MVC-Flow-Diagram.png" format="PNG" />
    </para>

    <para>
        O processo do  <code>Zend_Controller</code> é implementado por vários
        componentes. Enquanto não é necessário entender completamente
        os por menores de todos estes componentes do sistema, ter um
        conhecimento básico do processo é útil.
    </para>

        <itemizedlist>
            <listitem>
                <para>
                    <code>Zend_Controller_Front</code> orquestra todo o
                    processo do sistema <code>Zend_Controller</code>. Ele
                    é o interpretador do padrão FrontController.
                    <code>Zend_Controller_Front</code> processa todas as
                    requisições recebidas pelo servidor e é o responsável
                    direto pela delegação dos pedidos dos ActionControllers
                    (<code>Zend_Controller_Action</code>).
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>Zend_Controller_Request_Abstract</code> (muitas
                    vezes chamado de <code>Request Object</code>) representa
                    o ambiente de pedido e fornece métodos para colocação e
                    recuperação do controlador e nomes de ações e qualquer
                    parâmetros passados. Adicionalmente ele guarda o
                    registro de que a ação foi despachada ou não pelo
                    <code>Zend_Controller_Dispatcher</code>. Extensões
                    do objeto de requisição abstrata podem ser usadas
                    para encapsular todo o ambiente de requisição, permitindo
                    aos roterizadores colocarem informações no ambiente de
                    requisição para estabelecer o controlador e nomes de ação.
                </para>

                <para>
                    Por padrão, <code>Zend_Controller_Request_Http</code> é
                    usado, para fornecer acesso a todo o ambiente de pedido
                    de HTTP.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>Zend_Controller_Router_Interface</code> é usado
                    para definir os roterizadores. Roterização o processo
                    de examinação da requisição do ambiente para determinar qual
                    controlador, e ação do controlador, devem receber a
                    requisição. Este controlador, ação e parâmetros opcionais
                    são incluídos no objeto de requisição para serem processados
                    pelo <code>Zend_Controller_Dispatcher_Standard</code>.
                    Roterização ocorre somente uma vez: quando a requisição é
                    inicialmente recebida e antes do primeiro controlador ser
                    despachado.
                </para>

                <para>
                    O roterizador padrão,
                    <code>Zend_Controller_Router_Rewrite</code>, pega uma URI
                    no ponto especificado em
                    <code>Zend_Controller_Request_Http</code> e a decompõe
                    em um controlador, ação e parâmetros baseado na informação
                    do caminho da url. Por exemplo, a URL
                    <code>http://localhost/foo/bar/key/value</code> pode ser
                    decomposta para usar o controlador <code>foo</code>,
                    a ação <code>bar</code>, e o parametro especificado
                    <code>key</code> com o valor igual a <code>value</code>.
                </para>

                <para>
                    <code>Zend_Controller_Router_Rewrite</code> também pode ser
                    usado para combinar caminhos arbitrários; veja <link
                        linkend="zend.controller.router">documentação do
                    roterizador</link> para mais informações.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>Zend_Controller_Dispatcher_Interface</code> é usado para
                    definir despachantes. Despachar é o processo de pegar o
                    controlador e a ação do objeto de requisição e mapea-lo
                    para um arquivo/classe de um controlador e método de ação
                    na classe do controlador. Se o controlador ou ação não
                    forem informados, ele determina o controlador e ação padrão
                    para despachar.
                </para>

                <para>
                    O processo atual de despacho consiste em instanciar a classe
                    do controlador e chamar o método de ação nesta classe.
                    Diferente da roterização, que ocorre somente uma vez,
                    o despacho ocorre em um laço. Se o status do objeto de
                    requisição despachado é reiniciado em algum ponto, o laço
                    irá se repetir, chamando qualquer ação atualmente
                    estabelecida no objeto de requisição. A primeira vez que o
                    laço do objeto de requisição terminar com o status ativado
                    (verdadeiro boleano), ele irá finalizar o processo.
                </para>

                <para>
                    O despachador padrão é o
                    <code>Zend_Controller_Dispatcher_Standard</code>. Ele
                    define os controladores como CamelCasedClasses terminados
                    com a palavra Controller, e os métodos de ações como
                    camelCasedMethods terminadas com a palavra Action:
                    <code>FooController::barAction()</code>. Neste caso, o
                    controlador será chamado como <code>foo</code>
                    e a ação como <code>bar</code>.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>Zend_Controller_Action</code> é a ação básica
                    do componente do controlador. Cada controlador é uma
                    classe única que extende a <code>classe Zend_Controller_Action</code>
                    e deve conter um ou mais métodos de ação.
                </para>
            </listitem>

            <listitem>
                <para>
                    <code>Zend_Controller_Response_Abstract</code> define a
                    classe básica de resposta usada para coletar e retornar
                    repostas dos controladores de ação. Ela coleta tanto
                    cabeçalhos como conteúdos de corpo.
                </para>

                <para>
                    A classe de resposta padrão é
                    <code>Zend_Controller_Response_Http</code>, que é
                    conveniente para uso em um ambiente HTTP.
                </para>
            </listitem>
        </itemizedlist>

    <para>
        O processo do <code>Zend_Controller</code> é relativamente simples.
        Uma requisição é recebida pelo <code>Zend_Controller_Front</code>,
        que por sua vez chama <code>Zend_Controller_Router_Rewrite</code>
        para determinar qual controlador (e ação deste controlador) será
        chamado.
        <code>Zend_Controller_Router_Rewrite</code> decompõe o URI
        para poder determinar os nomes do controlador e da ação da requisição.
        <code>Zend_Controller_Front</code> então entrar em um laço de despacho.
        Ele chama <code>Zend_Controller_Dispatcher_Standard</code>, passando-lhe
        a requisição, para ser despachada para o controlador e ação especificados
        na requisição (ou usa os padrões). Depois que o controlador termina,
        o controle retorna para <code>Zend_Controller_Front</code>. Se o
        controlador indicar outro controlador para ser despachado através
        do reinicio do status de requisição, o laço continua e outro despacho
        é executado. De outra maneira, o processo termina.
    </para>
</sect1>

<!--
vim:se ts=4 sw=4 et:
-->
