Introdução ao Zend Framework

 Conhecendo o Zend Framework

appendix

 Referência do Zend Framework


  • Zend_Gdata
  • Zend_Http
  • Zend_InfoCard
  • Zend_Json
  • Zend_Layout
  • Zend_Ldap
  • Zend_Loader
  • Zend_Locale
  • Zend_Log
  • Zend_Mail
  • Zend_Markup
  • Zend_Measure
  • Zend_Memory
  • Zend_Mime
  • Zend_Navigation
  • Zend_Oauth
  • Zend_OpenId
  • Zend_Paginator
  • Zend_Pdf
  • Zend_ProgressBar
  • Zend_Queue
  • Zend_Reflection
  • Zend_Registry
  • Zend_Rest

  • Zend_Search_Lucene
  • Zend_Serializer
  • Zend_Server
  • Zend_Service
  • Zend_Session
  • Zend_Soap
  • Zend_Tag
  • Zend_Test
  • Zend_Text
  • Zend_TimeSync
  • Zend_Tool
  • Zend_Tool_Framework
  • Zend_Tool_Project
  • Zend_Translate
  • Zend_Uri
  • Zend_Validate
  • Zend_Version
  • Zend_View
  • Zend_Wildfire
  • Zend_XmlRpc
  • ZendX_Console_Process_Unix
  • ZendX_JQuery
  • Translation 12.2% Update 2011-11-16 - Revision 24447 - Version ZF 1.11.x

    Capítulo 24. Zend_Controller

    Índice

    24.1. Guia de Início Rápido do Zend_Controller
    24.1.1. Introdução
    24.1.2. Início Rápido
    24.1.2.1. Criando a Estrutura de Arquivos
    24.1.2.2. Estabelecendo seu Documento Raiz
    24.1.2.3. Criando as Regras de Reescrita
    24.1.2.4. Criando o Arquivo de Inicialização
    24.1.2.5. Criando o Controlador de Ação Padrão
    24.1.2.6. Criando o Script de Visualização
    24.1.2.7. Criando o Controlador de Erro
    24.1.2.8. Veja o Site!
    24.2. O Básico de Zend_Controller
    24.3. The Front Controller
    24.3.1. Overview
    24.3.2. Primary Methods
    24.3.2.1. getInstance()
    24.3.2.2. setControllerDirectory() and addControllerDirectory
    24.3.2.3. addModuleDirectory() and getModuleDirectory()
    24.3.2.4. dispatch()
    24.3.2.5. run()
    24.3.3. Environmental Accessor Methods
    24.3.4. Front Controller Parameters
    24.3.5. Extending the Front Controller
    24.4. The Request Object
    24.4.1. Introduction
    24.4.2. HTTP Requests
    24.4.2.1. Accessing Request Data
    24.4.2.2. Base Url and Subdirectories
    24.4.2.3. Determining the Request Method
    24.4.2.4. Detecting AJAX Requests
    24.4.3. Subclassing the Request Object
    24.5. The Standard Router
    24.5.1. Introduction
    24.5.2. Using a Router
    24.5.3. Basic Rewrite Router Operation
    24.5.4. Default Routes
    24.5.5. Base URL and Subdirectories
    24.5.6. Global Parameters
    24.5.7. Route Types
    24.5.7.1. Zend_Controller_Router_Route
    24.5.7.1.1. Variable Defaults
    24.5.7.1.2. Variable Requirements
    24.5.7.1.3. Translated segments
    24.5.7.2. Zend_Controller_Router_Route_Static
    24.5.7.3. Zend_Controller_Router_Route_Regex
    24.5.7.4. Zend_Controller_Router_Route_Hostname
    24.5.7.5. Zend_Controller_Router_Route_Chain
    24.5.7.5.1. Chain Routes via Zend_Config
    24.5.7.6. Zend_Rest_Route
    24.5.7.6.1. Zend_Rest_Route Usage
    24.5.7.6.2. Zend_Rest_Route with Zend_Config_Ini
    24.5.7.6.3. Zend_Rest_Controller
    24.5.8. Using Zend_Config with the RewriteRouter
    24.5.9. Subclassing the Router
    24.6. The Dispatcher
    24.6.1. Overview
    24.6.2. Subclassing the Dispatcher
    24.7. Action Controllers
    24.7.1. Introduction
    24.7.2. Object Initialization
    24.7.3. Pre- and Post-Dispatch Hooks
    24.7.4. Accessors
    24.7.5. View Integration
    24.7.5.1. View Initialization
    24.7.5.2. Rendering Views
    24.7.6. Utility Methods
    24.7.7. Subclassing the Action Controller
    24.8. Action Helpers
    24.8.1. Introduction
    24.8.2. Helper Initialization
    24.8.3. The Helper Broker
    24.8.4. Built-in Action Helpers
    24.8.4.1. ActionStack
    24.8.4.2. AutoComplete
    24.8.4.2.1. AutoCompletion with Dojo
    24.8.4.2.2. AutoCompletion with Scriptaculous
    24.8.4.3. ContextSwitch and AjaxContext
    24.8.4.3.1. Default Contexts Available
    24.8.4.3.2. Creating Custom Contexts
    24.8.4.3.3. Setting Contexts Per Action
    24.8.4.3.4. Initializing Context Switching
    24.8.4.3.5. Additional Functionality
    24.8.4.3.6. AjaxContext Functionality
    24.8.4.4. FlashMessenger
    24.8.4.4.1. Introduction
    24.8.4.4.2. Basic Usage Example
    24.8.4.5. JSON
    24.8.4.6. Redirector
    24.8.4.6.1. Introduction
    24.8.4.6.2. Basic Usage Examples
    24.8.4.7. ViewRenderer
    24.8.4.7.1. Introduction
    24.8.4.7.2. API
    24.8.4.7.3. Basic Usage Examples
    24.8.4.7.4. Advanced Usage Examples
    24.8.5. Writing Your Own Helpers
    24.9. The Response Object
    24.9.1. Usage
    24.9.2. Manipulating Headers
    24.9.3. Named Segments
    24.9.4. Testing for Exceptions in the Response Object
    24.9.5. Subclassing the Response Object
    24.10. Plugins
    24.10.1. Introduction
    24.10.2. Writing Plugins
    24.10.3. Using Plugins
    24.10.4. Retrieving and Manipulating Plugins
    24.10.5. Plugins Included in the Standard Distribution
    24.10.5.1. ActionStack
    24.10.5.2. Zend_Controller_Plugin_ErrorHandler
    24.10.5.2.1. Using the ErrorHandler as a 404 Handler
    24.10.5.2.2. Handling Previously Rendered Output
    24.10.5.2.3. Plugin Usage Examples
    24.10.5.2.4. Error Controller Example
    24.10.5.3. Zend_Controller_Plugin_PutHandler
    24.11. Using a Conventional Modular Directory Structure
    24.11.1. Introduction
    24.11.2. Specifying Module Controller Directories
    24.11.3. Routing to Modules
    24.11.4. Module or Global Default Controller
    24.12. MVC Exceptions
    24.12.1. Introduction
    24.12.2. Handling Exceptions
    24.12.3. MVC Exceptions You May Encounter

    24.1. Guia de Início Rápido do Zend_Controller

    24.1.1. Introdução

    Zend_Controller é o coração do sistema MVC do Zend Framework. MVC significa Model-View-Controller e é um padrão de projeto voltado para a separação da lógica de aplicação da lógica de visualização. Zend_Controller_Front implementa o padrão Front Controller, no qual todos os pedidos são interceptados pelo controlador frontal e despachados individualmente para ações baseadas no URL requerido.

    O sistema Zend_Controller foi construído com a extensibilidade em mente, tanto por derivação das classes existentes, como escrevendo novas classes que implementam as várias interfaces e classes abstratas que formam a fundação da família de classes controladoras, ou escrevendo plugins ou auxiliadores de ação para aumentar ou manipular a funcionalidade do sistema.

    24.1.2. Início Rápido

    Se você necessita de informações mais detalhadas, veja as seções seguintes. Se você quiser apenas começar rápido, continue lendo.

    24.1.2.1. Criando a Estrutura de Arquivos

    O primeiro passo é criar sua estrutura de arquivos. A estrutura típica é a seguinte:

    application/
        
    controllers/
            
    IndexController.php
        models
    /
        
    views/
            
    scripts/
                
    index/
                    
    index.phtml
            helpers
    /
            
    filters/
    html/
        .
    htaccess
        index
    .php

    24.1.2.2. Estabelecendo seu Documento Raiz

    No seu servidor web, defina seu documento raiz para o diretório html/ da estrutura de arquivos acima mencionada.

    24.1.2.3. Criando as Regras de Reescrita

    Edite o arquivo html/.htaccess acima para ficar como:

    RewriteEngine On
    RewriteCond 
    %{REQUEST_FILENAME} -[OR]
    RewriteCond %{REQUEST_FILENAME} -[OR]
    RewriteCond %{REQUEST_FILENAME} -d
    RewriteRule 
    ^.*$ - [NC,L]
    RewriteRule ^.*$ index.php [NC,L]
    [Nota] Saiba mais sobre o mod_rewrite

    As regras de reescrita acima permitem o acesso a qualquer arquivo no documento raiz de seu host virtual. Se houver arquivos que você não quer expor desta maneira, você pode ser mais restritivo em suas regras. Vá até o site do Apache para aprender mais sobre o mod_rewrite.

    Se estiver usando o IIS 7.0, utilize o seguinte como sua configuração de reescrita:

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
         <system.webServer>
             <rewrite>
                 <rules>
                     <rule name="Imported Rule 1" stopProcessing="true">
                         <match url="^.*$" />
                         <conditions logicalGrouping="MatchAny">
                             <add input="{REQUEST_FILENAME}"
                                 matchType="IsFile" pattern=""
                                 ignoreCase="false" />
                             <add input="{REQUEST_FILENAME}"
                                 matchType="IsDirectory"
                                 pattern="" ignoreCase="false" />
                         </conditions>
                         <action type="None" />
                     </rule>
                     <rule name="Imported Rule 2" stopProcessing="true">
                         <match url="^.*$" />
                         <action type="Rewrite" url="index.php" />
                     </rule>
                 </rules>
             </rewrite>
         </system.webServer>
    </configuration>

    As regras acima irão encaminhar os pedidos de recursos existentes (links simbólicos existentes, arquivos não vazios, ou diretórios não vazios) nesse sentido, e todos os outros pedidos para o controlador frontal.

    [Nota] Nota

    As regras de reescrita acima são para o Apache, para exemplos de regras de reescrita de outros servidores web, consulte a documentação do roteador.

    24.1.2.4. Criando o Arquivo de Inicialização

    O arquivo de inicialização é a página onde passam todas as requisições -- html/index.php no caso. Abra o arquivo html/index.php em um editor de sua escolha e adicione o seguinte:

    Zend_Controller_Front::run('/path/to/app/controllers');

    Isto irá instanciar e despachar o controlador frontal, que irá encaminhar as requisições para os controladores de ação.

    24.1.2.5. Criando o Controlador de Ação Padrão

    Antes de discutir sobre os controladores de ação, você deve primeiro entender como as requisições são roteadas no Zend Framework. Por padrão, o primeiro seguimento de um caminho de um URL aponta para um controlador, o segundo para uma ação. Por exemplo, dado o URL http://framework.zend.com/roadmap/components, o caminho é /roadmap/components, que irá apontar para o controlador roadmap e para a ação components. Se nenhuma ação for informada, a ação index é assumida, e se nenhum controlador for informado, o controlador index é assumido (seguindo a convenção do Apache que mapeia um DirectoryIndex automaticamente).

    O despachador do Zend_Controller toma o valor do controlador e mapeia-o para uma classe. Por padrão, ele pega o nome do controlador, com a primeira letra em maiúsculo, e acrescenta a palavra Controller. Sendo assim, em nosso exemplo acima, o controlador roadmap é mapeado para a classe RoadmapController.

    Semelhantemente, o valor da ação é mapeado para um método da classe do controlador. Por padrão, o valor é transformado em letras minúsculas, e a palavra Action é acrescentada. Sendo assim, em nosso exemplo acima, a ação components torna-se componentsAction(), e o método final chamado é RoadmapController::componentsAction().

    Então, seguindo em frente, vamos agora criar um controlador de ação padrão e um método de ação. Como mencionado anteriormente, o controlador padrão e a ação são ambos chamados index. Abra o arquivo application/controllers/IndexController.php, e introduza o seguinte:

    /** Zend_Controller_Action */
    class IndexController extends Zend_Controller_Action
    {
        public function 
    indexAction()
        {
        }
    }

    O auxiliar de ação ViewRenderer é habilitado por padrão. Isto significa que apenas definindo um método de ação simples e o script de visão correspondente, você terá o seu conteúdo mostrador imediatamente. Por padrão, Zend_View é usado como a camada de Visualização do MVC. O ViewRenderer faz alguma mágica, e usa o nome do controlador (ex.: index) e o nome da ação atual (ex.: index) para determinar qual modelo mostrar. Por padrão, modelos terminam com a extensão .phtml, então isto significa que, no exemplo acima o modelo index/index.phtml será mostrado. Adicionalmente, o ViewRenderer automaticamente assume que o diretório views/, que está no mesmo nível que do diretório do controlador, será o diretório base de visualização, e que o atual script de visualização estará no subdiretório views/scripts/, Sendo assim, o modelo mostrado é encontrado em application/views/scripts/index/index.phtml.

    24.1.2.6. Criando o Script de Visualização

    Com mensionado na seção anterior, scripts de visualização são encontrados em application/views/scripts/; O script padrão para o controlador e ação padrão está em application/views/scripts/index/index.phtml. Crie este arquivo e escreva nele algum HTML:

    <!DOCTYPE html
    PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
    >
    <
    html>
    <
    head>
      <
    meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
      <
    title>Meu primeiro aplicativo em Zend Framework</title>
    </
    head>
    <
    body>
        <
    h1>OláMundo!</h1>
    </
    body>
    </
    html>

    24.1.2.7. Criando o Controlador de Erro

    Por padrão, o plugin do manipulador de erro é registrado. Este plugin espera que um controlador para manipular erros exista. Por padrão, ele assume um ErrorController no módulo padrão com um método errorAction():

    class ErrorController extends Zend_Controller_Action
    {
        public function 
    errorAction()
        {
        }
    }

    Assumindo a estrutura de diretório já discutida, este arquivo estará em application/controllers/ErrorController.php. Você também precisará criar o script de visualização em application/views/scripts/error/error.phtml; o conteúdo do exemplo parecerá com:

    <!DOCTYPE html
    PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
    >
    <
    html>
    <
    head>
      <
    meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
      <
    title>Erro</title>
    </
    head>
    <
    body>
        <
    h1>Ocorreu um erro</h1>
        <
    p>Ocorreu um erropor favortente novamente mais tarde.</p>
    </
    body>
    </
    html>

    24.1.2.8. Veja o Site!

    Com o seu primeiro controlador e visualizador em suas mãos, você agora pode abrir o seu navegador e navegar até o site. Assumindo que o seu domínio é example.com, qualquer dos seguintes URLs irão mostrar a página que acabamos de criar:

    • http://example.com/

    • http://example.com/index

    • http://example.com/index/index

    Agora você está pronto para iniciar a criação de mais controladores e metódos de ação. Parabéns!

    digg delicious meneame google twitter technorati facebook

    Comments

    Loading...