Posts com Tag ‘zend’

Em posts anteriores, detalhamos como instalar e configurar o ZendFramework, e produzimos a parte 1 do post “ZendFramework: estruturar um novo projeto”. Agora vamos avançar mais na compreensão do funcionamento do Framework.

1. Layout

Primeiro sobre o nome “leiaute”: o significado aqui é o mesmo que “tema” ou “template”, já tão bem conhecidos no mundo da programação.
Na prática, existirá muito código HTML em comum nos diversos “views” do sistema em desenvolvimento. O que muda de uma página para outra em um sistema basicamente é o conteúdo, mantendo-se o cabeçalho, rodapé e laterais. O componente Zend_Layout fora criado para facilitar a vida do desenvolvedor na criação de leiautes. O componente Zend_Layout permite ao programador mover todo código em comum da camada de apresentação de cabeçalho, rodapé e outros, para um “script view” específico, o “leiaute”.

Um “layout” no Zend Framework é parte do MVC e utiliza-se do “ViewRenderer” que oferece uma vasta gama de recursos que são carregados automaticamente para o objeto “$view”.

O local padrão para manter os leiautes é em “application/layouts/scripts/” e há um recurso disponível para Zend_Application que configurará Zend_Layout. Utilizamos o Zend_Tool para criar o script do view para o layout e atualizar apropriadamente o arquivo “~/novo_projeto/application/configs/application.ini“. Para isto, utilize o comando a seguir (onde também está mostrado a resposta do ZF ao comando):

~/novo_projeto$ zf enable layout
A layout entry has been added to the application config file.
A default layout has been created at ~/novo_projeto/application/layouts/scripts/layout.phtml
Updating project profile '~/novo_projeto/.zfproject.xml'

Veja que o comando ao Zend_Tool criou uma pasta e um arquivo em “~/novo_projeto/application/layouts/scripts/layout.phtml“. Ele também atualizou o arquivo “~/novo_projeto/application/configs/application.ini“, onde adicionou a linha resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts/" na seção [production].

O conteúdo default do arquivo criado “/application/layouts/scripts/layout.phtml” é:
<?php echo $this->layout()->content; ?>
Esta linha carregará o conteúdo do arquivo “view script” do action sendo chamado. Por enquanto, como pode ser visto através do navegador, nada mudou como resultado da aplicação

Agora modifique o arquivo layout.phtml para que o mesmo fique assim:

<?php
$this->headMeta()->appendHttpEquiv('Content-Type', 'text/html;charset=utf-8');
echo $this->doctype(); ?>
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
   <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
   <title>Meu Projeto Zend Framework</title>
   <head>
      <?php echo $this->headMeta(); ?>
      <?php echo $this->headTitle(); ?>
      <?php echo $this->headLink()->prependStylesheet($this->baseUrl().'/css/site.css'); ?>
      <?php echo $this->headTitle(); ?>
   </head>
   <body>
      <div id="header">{Meu Cabeçalho aqui}</div>
      <div id="content">
      <?php echo $this->layout()->content; ?>
      </div>
      <div id="footer">{Meu rodapé aqui}</div>
   </body>
</html>

Acima inserimos a chamada para um arquivo CSS. Isso objetiva fazer a apresentação mais bonita. Deve-se, então, criar a pasta css e o arquivo de estilo “~/novo_projeto/public/css/site.css”, cujo conteúdo simples exemplificamos abaixo:


body,html {
margin: 0 5px;
font-family: Verdana,sans-serif;
color: #E92727;
}
h1 {
font-size: 1.4em;
color: #008000;
}
a {
color: #008000;
}

O exemplo acima mostra como o leiaute é facilmente alterável.
Agora sim, acesse as páginas do projeto
http://novo_projeto.localhost/tecnico/gerencia/add
http://novo_projeto.localhost/tecnico/gerencia/edit

e veja os efeitos produzidos, como a cor que alterou e o aparecimento do leiaute inserido. Uma página como a mostrada abaixo deve ser obtida no navegador.
Tela exemplo leiaute do ZF

Referências:
1- Instalar e configurar o ZendFramework no Debian
2- ZendFramework: estruturar um novo projeto (parte 1)
3- Tutorial ZendFramework
4- Zend Programmer’s Reference Guide

Anúncios

1. Um pouco de ideias (antes da parte prática)

O que se cria com um comando do Zend “create project” é apenas a estrutura do projeto, através de um módulo simples “default”. Nest post, mais adiante, iremos inclusive deletar esta estrutura inicial quando da criação dos novos módulos e controladores da nossa aplicação-exemplo.

Arquitetura da aplicação Zend

Toda solicitação feita ao ZendFramework possui basicamente 03 (três) elementos: Module, Controller e Action. Cada página da aplicação é conhecida como uma “action” (ação). Ações são agrupados dentro de “controllers” (controladores). Por exemplo, um certo controlador poderia ter ações como listar, arquivos e ver. E podem ser criados módulos para agrupar controladores. Vejamos as idéias conceituais básicas de cada um.

a) Módulo
Divisão lógica da aplicação, agrupando funcionalidades com objetivos distintos dos demais módulos. Os módulos devem ser utilizados para oferecer um nível maior de separação na aplicação e geralmente são usados para separar diferentes seções da aplicação e promover a reutilização de códigos. Cada módulo possui seu próprio diretório de controladores.
O Module (módulo) é o que modulariza a aplicação . Deve ser criado quando se precisa controlar várias seções distintas de uma aplicação. Um exemplo básico seria criar um módulo para a Área administrativa de uma aplicação e outro para a área Comercial.

Ao criar um projeto, o Zend cria automaticamente um module default. Caso se crie um novo Module, será necessário criar uma pasta para o novo default. O sistema MVC do Zend Framework suporta módulos para agrupamento de controladores.

b) Controller
O controller inicial de qualquer aplicação zend é o ‘index’. Ao criar um projeto, automaticamente o Zend cria o controller index. Os controllers controlam a lógica de negócio e o acesso aos dados presentes nos Actions.

Cada página da aplicação é conhecida como um Action (ação). As ações são agrupados dentro de controllers (controlador). Para o formato de URL http://novo_projeto.localhost/zf-tutorial/public/gerencia/produzir, o controlador é “Gerencia” e a ação é “produzir”. Assim é permitido agrupar ações relacionadas. Por exemplo, um controlador “Gerencia” poderia ter ações como listar, arquivos e ver.

c) Action
A camada de apresentação numa aplicação é aquela em que o usuário interage com o controller, por isto, e pelo fato do controller controlar primariamente actions que vão conter acesso a tudo o que existe no Zend e no MVC per si, a estrutura de arquivos é carregada a partir dos actions e não dos controllers em si. O action inicial de qualquer aplicação zend é o ‘index’. O action index não precisa ser chamado, pois o Zend o carrega automaticamente quando nenhum for passado.

2. Criar um projeto
Após ter instalado e configurado o ZendFramework (veja aqui), estamos prontos para começar tirar proveito do ZF. A maneira mais rápida de começar a usar a Zend_Application é utilizando os comandos disponíveis do Zend_tool. Vamos iniciar criando um novo projeto fazendo uso do Zend_tool. Abaixo é mostrado o comando para executar esta tarefa, e a resposta do sistema:

~/projetoszend$ zf create project novo_projeto
Creating project at ~/projetoszend/novo_projeto

OBS: sobre este comando veja mais detalhes em Create Your Project.
A ferramenta ZF criará um diretório chamado “novo_projeto” e preencherá com uma estrutura de diretório default do framework. Esta estrutura assume que o usuário tenha total controle sobre sua configuração do Apache, com a finalidade de manter a maior parte dos arquivos fora do diretório raiz do site. Após este comando, o usuário deverá ver os seguintes arquivos e diretórios:


novo_projeto/
 -rw-r--r--   .zfproject.xml
 drwxr-xr-x   library/
 drwxr-xr-x   application/
              -rw-r--r--   Bootstrap.php
              drwxr-xr-x   models/
              drwxr-xr-x   configs/
                           -rw-r--r--   application.ini
              drwxr-xr-x   controllers/
                           -rw-r--r--   ErrorController.php
                           -rw-r--r--   IndexController.php
              drwxr-xr-x   views/
                           drwxr-xr-x   helpers/
                           drwxr-xr-x   scripts/
                                        drwxr-xr-x   error/
                                                     -rw-r--r--   error.phtml
                                        drwxr-xr-x   index/
                                                     -rw-r--r-- index.phtml
 drwxr-xr-x   docs/
              -rw-r--r--   README.txt
 drwxr-xr-x   public/
              -rw-r--r--   .htaccess
              -rw-r--r--   index.php
 drwxr-xr-x   tests/
              -rw-r--r--   bootstrap.php
              -rw-r--r--   phpunit.xml
              drwxr-xr-x   library/
              drwxr-xr-x   application/
                           drwxr-xr-x   controllers/
                                        -rw-r--r--   IndexControllerTest.php

Estão vazias as pastas application/models/, application/views/helpers/, library/ e tests/library/ .

O diretório “application/” é onde o código da aplicação reside. Como pode-se ver, os diretórios para os arquivos model, view e controller da aplicação encontram-se separados. O diretório “public/” é o diretório de alcance publico. Isto é feito para que a maior parte dos arquivos da aplicação não sejam acessados diretamente pelo Apache e, portanto, estejam mais seguros. O controlador do Zend Frameworkʼs utiliza o Padrão de Software “Front Controller” e roteia todas as solicitações através de um único arquivo “public/index.php”.

Até aqui, se for acessada a página http://novo_projeto.localhost/ uma página em branco será mostrada no navegador.

Deve ser observado, em especial, que ao executar o comando acima, as seguintes operações especiais ocorreram:

  • criação do arquivo de Bootstrap em novo_projeto/application/Bootstrap.php;
  • criação do arquivo de configuração em novo_projeto/application/configs/application.ini, o qual é a configuração básica necessária para o Zend_Application;
  • criação do arquivo novo_projeto/public/index.php, o qual invoca o Zend_Application e faz o seu “dispatche”.

O arquivo de Bootstrap contém o seguinte conteúdo:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
}

3. Fixar o ambiente da aplicação
Um aspecto que facilita muito o desenvolvimento software é ter do sistema informações de erros. Para isto deve ser alterado a definição do ambiente de produção para “development” que é realizada no arquivo “~/novo_projeto/public/index.php”. O default é “produção”, que omite as mensagens de erros. Edite o arquivo, e altere a linha que faz a definição do ambiente conforme abaixo:

defined('APPLICATION_ENV')
|| define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : 'development'));

4. Disponibilizar as bibliotecas do Zend

Copiar a pasta Zend(aproximadamente 23MB), que se encontra dentro de /opt/ZendFramework-1.11.11/library/ para a pasta novo_projeto/library (vide post de instalação do Zend):

~/novo_projeto/library$ cp -R /opt/ZendFramework-1.11.11/library/Zend/ .

Relativo a pasta library/ , a esturutura de pastas ficará assim:


~/novo_projeto/
-rw-r--r--   .zfproject.xml
drwxr-xr-x   library/
             drwxr-xr-x   Zend/

E o interior da pasta Zend/ conterá toda a biblioteca do ZendFramework.

Agora, ao acessar a página http://novo_projeto.localhost/ , será mostrado uma página com uma figura azul do emblema do ZendFramework. Esta página fora disponibilizada, como seria de esperar, por scripts (templates) dentro da pasta application/ . Ou seja, esta visualização se deve ao arquivo novo_projeto/application/views/scripts/index/index.phtml .

Observe que a página poderia ser acessada também por http://novo_projeto.localhost/default/index/index/ , que seria a mesma coisa. Para entender, o Zend trata estes parâmetros da seguinte forma (segundo a ordem da esquerda para a direita):
default: foi interpretado pelo Zend como o nome do MODULE;
index: foi interpretado pelo Zend como o nome do CONTROLLER;
index: foi interpretado pelo Zend como o nome da ACTION.

Até aqui não criamos nenhum MÓDULO, só existe o “default” criado pelo próprio Zend quando criamos inicialmente o novo_projeto. Se tivéssemos criado módulos, a estrutura das pastas teria a seguinte aparência:

Estrutura de pastas para o ZendFramework

Se houver necessidade de se utilizar quaisquer outras bibliotecas, elas também podem ser colocas nesta pasta.

5. Entendendo alguns aspectos do funcionamento do ZF

O arquivo index.php é o ponto de entrada para a aplicação e é utilizado para criar uma instância de “Zend_Application” para inicializar a aplicação e então executá-la. Este arquivo define duas constantes: APPLICATION_PATH e APPLICATION_ENV que definem o caminho para o diretório application/ e o modo do ambiente da aplicação. O padrão é definido como “production” no index.php, mas o usuário deve configurá-lo para “development” no arquivo .htaccess adicionando esta linha:
SetEnv APPLICATION_ENV development

O component “Zend_Application” é utilizado para iniciar a aplicação e está configurado para utilizar as diretivas de configuração do arquivo application/configs/application.ini. Este arquivo também é gerado automaticamente pelo ZF. Uma classe “Bootstrap” que extende “Zend_Application_Bootstrap_Bootstrap” é fornecida no arquivo “application/Bootstrap.php” que pode ser utilizada para executar qualquer código de iniciação específico.

O “application.ini”, que está armazenado no diretório “application/configs” é carregado utilizando o component “Zend_Config_In”. O “Zend_Config_Ini” entende o conceito de herança das seções que são definidas utilizando um ponto-duplo no nome da seção.
Por exemplo:
[staging : production]
Isto significa que a seção “staging” herda todas as configurações da seção “production”. A constante APPLICATION_ENV define qual seção é carregada. Obviamente, no meio do desenvolvimento, a seção “development” é melhor e quando estiver no servidor remoto, a seção “production” deve ser utilizada. Uma boa política é colocar todas as modificações que forem feitas no arquivo “application.ini” dentro da seção “production” para que todas as configurações carreguem as alterações que se fizerem necessárias.

Quanto a estrutura de módulos, controladores, actions e páginas, a estrutura a ser criada segue a arquitetura mostrada na figura abaixo.

Estrutura de projeto com módulos, controladores, actions e páginas.

Pela figura acima, pode-se ver que:

  • cada Página (arquivo .phtml) está associada a uma determinada Action
  • um conjunto de Actions está associado a um determinado Controlador
  • Um módulo encapsula um conjunto de Controladores

6. Tratamento de Erros
O Zend_Controller_Plugin_ErrorHandler fornece um plugin “drop-in” para o tratamento de exceções lançadas por sua aplicação, incluindo as resultantes dos controladores em falta ou ações. O plugin ErrorHandler é projetado para lidar com erros do tipo HTTP 404 (página em falta) e erros do tipo 500 (erro interno). Mas não pretende capturar exceções levantadas em outros plugins. Por padrão, Zend_Controller_Plugin_ErrorHandler redireciona para ErrorController:: errorAction() no módulo padrão. O redirecionamento pode ser feito para outros endereços. Veja como fazer isto e outros detalhes de tratamento de erros em Zend_Controller_Plugin_ErrorHandler.

Dois arquivos fundamentais para tratamento de erros são:

  • O script de visualização estará em application/views/scripts/error/error.phtml
  • O controlador “ErrorController” no módulo padrão, contendo um método errorAction()”, pode ser encontrado em application/controllers/ErrorController.php

Um erro pode ser simulado para ver o controlador de erro atuando. Digite na barra de endereço do navegador um endereço inexistente, como o exemplificado abaixo, para ver este tratamento de erro em ação:
http://novo_projeto.localhost/sdasdsa

7. Criar módulos

Abaixo mostramos a criação de dois módulos para novo_projeto e as respostas do framework:


~/novo_projeto$ zf create module tecnico
Creating the following module and artifacts:
~/novo_projeto/application/modules/tecnico/controllers
~/novo_projeto/application/modules/tecnico/models
~/novo_projeto/application/modules/tecnico/views
~/novo_projeto/application/modules/tecnico/views/scripts
~/novo_projeto/application/modules/tecnico/views/helpers
~/novo_projeto/application/modules/tecnico/views/filters
Added a key for path module directory to the application.ini file
Updating project profile '~/novo_projeto/.zfproject.xml'

~/novo_projeto$ zf create module admin
Creating the following module and artifacts:
~/novo_projeto/application/modules/admin/controllers
~/novo_projeto/application/modules/admin/models
~/novo_projeto/application/modules/admin/views
~/novo_projeto/application/modules/admin/views/scripts
~/novo_projeto/application/modules/admin/views/helpers
~/novo_projeto/application/modules/admin/views/filters
Added a key for path module directory to the application.ini file
Updating project profile '~/novo_projeto/.zfproject.xml'

Abaixo transcrevemos como ficou a estrutura de pastas com a criação dos dois módulos:


~/novo_projeto/application/
-rw-r--r--   Bootstrap.php
drwxr-xr-x   configs
drwxr-xr-x   models
drwxr-xr-x   modules
             drwxr-xr-x   tecnico
                          drwxr-xr-x   controllers
                          drwxr-xr-x   models
                          drwxr-xr-x   views
                                       drwxr-xr-x   filters
                                       drwxr-xr-x   helpers
                                       drwxr-xr-x   scripts
             drwxr-xr-x   admin
                          drwxr-xr-x   controllers
                          drwxr-xr-x   models
                          drwxr-xr-x   views
                                       drwxr-xr-x   filters
                                       drwxr-xr-x   helpers
                                       drwxr-xr-x   scripts

Observe que nas pastas internas de modules/ só existem pastas, mas não existem arquivos em nenhuma destas pastas.

8. Criar os controladores para os módulos
A lógica para criar um controller é a seguinte:

zf create controller NOME_DO_CONTROLLER 1 NOME_DO_MODULE

Agora criaremos os controladores associados ao módulo “tecnico”. Estão colocados abaixo os comandos e as respostas do framework:

~/novo_projeto$ zf create controller Gerencia 1 tecnico
Creating a controller at ~/novo_projeto/application/modules/tecnico/controllers/GerenciaController.php
Creating an index action method in controller Gerencia
Creating a view script for the index action method at ~/novo_projeto/application/modules/tecnico/views/scripts/gerencia/index.phtml
Updating project profile '~/novo_projeto/.zfproject.xml'

~/novo_projeto$ zf create controller Error 1 tecnico
~/projetoszend/novo_projeto$ zf create controller error 1 default
Creating a controller at ~/novo_projeto/application/modules/tecnico/controllers/ErrorController.php
Creating an index action method in controller Error
Creating a view script for the index action method at ~/novo_projeto/application/modules/tecnico/views/scripts/error/index.phtml
Updating project profile '~/novo_projeto/.zfproject.xml'

Isto criará dois arquivos:
/novo_projeto/application/modules/tecnico/controllers/GerenciaController.php; e
/novo_projeto/application/modules/tecnico/controllers/ErrorController.php
.

9. Criar os Actions

A lógica para criar um action é a seguinte:
zf create action NOME_DO_ACTION NOME_DO_CONTROLLER 1 NOME_DO_MODULE

O valor booleano ’1′ indica que queremos que o ZF Tool crie o arquivo ‘.phtml’. Ou seja, indica que se deseja que o Zend crie NÃO SOMENTE o método Action dentro do controller para cada ação que será criada (veja logo abaixo a descrição da mudança no arquivo IndexController.php) MAS TAMBÉM o arquivo correspondente View dentro do módulo correspondente para cada ação que será criada (veja abaixo a descrição da criação do arquivo quem-somos.phtml).

Primeiro, vamos criar o Action “error” para o controller Error:

~/novo_projeto$ zf create action error Error 1 tecnico
Creating an action named error inside controller at ~/novo_projeto/application/modules/tecnico/controllers/ErrorController.php
Updating project profile '~/novo_projeto/.zfproject.xml'
Creating a view script for the error action method at ~/novo_projeto/application/modules/tecnico/views/scripts/error/error.phtml
Updating project profile '~/novo_projeto/.zfproject.xml'

Como exemplo, vamos criar quatro páginas relativas a um mesmo tema, fazendo seu agrupamento em um único controlador (Gerencia) contendo as quatro ações.
Vamos usar o controlador “Gerencia” e as quatro ações serão:


    Page                Controller        Action
Home page                Gerencia         index
Adicionar novo álbum     Gerencia         add
Editar album             Gerencia         edit
Deletar album            Gerencia         delete

Os comandos para isto são:


zf create action add Gerencia 1 tecnico
zf create action edit Gerencia 1 tecnico
zf create action delete Gerencia 1 tecnico

Aqui transcrevemos a resposta do ZendFramework para o primeiro comando:

~/novo_projeto/$ zf create action add Gerencia 1 tecnico
Creating an action named add inside controller at ~/novo_projeto/application/modules/tecnico/controllers/GerenciaController.php
Updating project profile '~/novo_projeto/.zfproject.xml'
Creating a view script for the add action method at ~/novo_projeto/application/modules/tecnico/views/scripts/gerencia/add.phtml
Updating project profile '~/novo_projeto/.zfproject.xml'

Após o primeiro comando acima, dois fatos principais foram gerados:
a) o Zendframework adicionou o método correspondente ao Action “add” no arquivo “~/novo_projeto/application/modules/tecnico/controllers/GerenciaController.php“, ficando assim:

<?php
class Tecnico_GerenciaController extends Zend_Controller_Action
{
    (....)
    public function addAction()
    {
        // action body
    }
}

b) fora criado o arquivo “~/novo_projeto/application/modules/tecnico/views/scripts/gerencia/add.phtml“. Neste momento, já se pode acessar com o navegador a página http://novo_projeto.localhost/tecnico/gerencia/add que será mostrada uma página simples com a mensagem “View script for controller Gerencia and script/action name add”.

Para os outros comandos, o raciocínio é o mesmo. As páginas poderão ser acessadas em:
http://novo_projeto.localhost/tecnico/gerencia/edit
http://novo_projeto.localhost/tecnico/gerencia/delete

Observe como ficou a pasta “~/novo_projeto/application/modules/tecnico/views/scripts/gerencia/“:

-rw-r--r-- add.phtml
-rw-r--r-- edit.phtml
-rw-r--r-- delete.phtml
-rw-r--r-- index.phtml


Com os outros comandos executados, três novos métodos: addAction, editAction e deleteAction estarão criados em GerenciaController.php, bem como os scripts apropriados para o View (que serão necessários mais adiante). Tem-se agora todas as quarto ações necessárias.

O URL para cada ação é:


                        URL                                  Action method
http://novo_projeto.localhost/tecnico/gerencia/         GerenciaController::indexAction()
http://novo_projeto.localhost/tecnico/gerencia/add      GerenciaController::addAction()
http://novo_projeto.localhost/tecnico/gerencia/edit     GerenciaController::editAction()
http://novo_projeto.localhost/tecnico/gerencia/delete   GerenciaController::deleteAction()

10. Entendendo o roteamento usado pelo ZendFramework

Um conjunto de componenetes do ZendFramework (ZF) disponibilizam um sistema MVC completo para desenvolver aplicações que separam os templates da visão da lógica do negócio e dos arquivos de controle. São dois os componentes principais que implementam o MVC: Zend_Controller (o controlador) e o Zend_View (a visão). A família de classes do componente Zend_Controller oferece um padrão de design de Controlador Frontal (Front Controller design pattern) que despacha solicitações para as ações do controlador (actions) para que todo o processamento seja centralizado.

O componente Zend_Controller é o coração do sistema MVC do Zend Framework. É através deste componente que todos as chamadas web são interceptadas pelo controlador frontal e despachadas individualmente para ações baseadas no URL requerido. O processo do Zend_Controller é relativamente simples. Uma requisição é recebida pelo Zend_Controller_Front, que por sua vez chama Zend_Controller_Router_Rewrite para determinar qual controlador (e ação deste controlador) que será chamada. Zend_Controller_Router_Rewrite decompõe o URI para poder determinar os nomes do controlador e da ação da requisição. Zend_Controller_Front então entra em um laço de despacho. Ele chama Zend_Controller_Dispatcher_Standard, passando-lhe a requisição, para ser despachada para o controlador e ação especificados na requisição (ou usa os padrões “index”). Depois que o controlador termina, o controle retorna para Zend_Controller_Front. 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. Sobre detalhes do funcionamento do ZendController veja em “O Básico de Zend_Controller“.

Por tudo que mostramos neste post, vamos tentar entendender um pouco mais como as coisas estão funcionando. A estrutura de endereçamento utilizada pelo ZendFramework é a seguinte:
http://endereço-site/MODULE/CONTROLLER/ACTION

Ao fazer acesso à http://novo_projeto.localhost/tecnico/gerencia/produtos o módulo que se está utilizando chama-se “tecnico”, o controlador chama-se “gerencia” e a ação chama-se “produtos”.

Ao fazer acesso à http://novo_projeto.localhost/tecnico/gerencia/ o módulo que se está utilizando chama-se “tecnico”, o controlador chama-se “gerencia” e a ação chama-se “index” (que é o default do Zend). Observe que existe o arquivo ~/novo_projeto/application/modules/tecnico/views/scripts/gerencia/index.phtml que fora criado automaticamente pelo Zend, e no controlador “~/novo_projeto/application/modules/tecnico/controllers/GerenciaController.php” existe a função “public function indexAction()” também criada automaticamente pelo Zend.

Ou seja, por padrão, o primeiro seguimento de um caminho de um URL aponta para um módulo, o segundo para o controlador e o terceiro para uma ação. Por exemplo, dado o URL http://framework.zend.com/modulo1/roadmap/alugar, o caminho é /modulo1/roadmap/alugar, que irá apontar para o controlador “roadmap” e para a ação “alugar” no escopo do modulo1. 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 “alugar” torna-se alugarAction(), e o método final chamado é RoadmapController::alugarAction().

Continua: veja a parte-2 deste material.

Referências:
1- Instalar e configurar o ZendFramework no Debian
2- ZendFramework: estruturar um novo projeto (parte 2)
3- Tutorial ZendFramework
4- Zend Programmer’s Reference Guide
5- ZendFramework: guia de referência do programador

Zend Framework é um framework para aplicações Web de código aberto, orientado a objetos, implementado em PHP 5 e licenciado como New BSD License. Zend Framework—freqüentemente referido como ZF—é desenvolvido com o objetivo de simplificar o desenvolvimento web enquanto promove as melhores práticas na comunidade de desenvolvedores PHP.

1. Instalar o Apache, PHP5 e MySQL

Primeiramente, instalar os pacotes necessários para se ter um servidor Web PHP funcionando. Em outro post já descrevemos este procedimento. Não vamos aqui tecer maiores detalhes novamente. Faça uso do seguinte comando:

# # apt-get install apache2 apache2-utils php5 php5-cli mysql-server-5.0 php5-mysql -y

Agora verifique se o Apache está funcionando: acesse com o navegador a URL http://localhost

Caso seja visualizada uma página do tipo “It Works”, o servidor Apache está funcionando.

Para verificar o funcionamento do PHP, crie um arquivo /var/www/index.php com o seguinte conteúdo:

<?php
phpinfo();
?>

Agora acesse o endereço http://localhost/index.php . Se as informações de configuração do PHP aparecerem, isto significará que o Apache e o interpretador PHP estão funcionando. Uma listagem semelhante a abaixo deve ser visualizada.

Tela da saída index.php

Para funcionar, o ZendFramework necessita que esteja instalada a biblioteca de abstração de banco de dados ADOdb. Essa biblioteca é que permite que o código que se escreve seja portável a diversos bancos de dados. Isso pode ser facilmente realizado através do Synaptic, ou através do comando:

# apt-get install libphp-adodb

Para entender a importância desta biblioteca, veja o exemplo abaixo:

<?php
include(‘libs/adodb.inc.php’);
# fazendo a conexão ao MYSQL
# (servidor, usuario, senha e banco)
$DB = NewADOConnection(‘mysql’);
$DB->Connect(‘localhost’,’albuquerque’,’minhasenha’, ‘meu_banco’);
?>

Assim, conecta-se ao banco MySQL.  Para mudar para uma base PostgreeSQL, basta trocar:

de:
$DB=NewADOConnection(‘mysql’);
para:
$DB=NewADOConnection(‘postgres’);

2. Verificar os pacotes instalados
Verifique se os pacotes básicos foram instalados, antes de iniciar a instalação do ZendFramework. Uma forma simples de realizar isto através da interface gráfica é utilizando o Synaptic. Os seguintes pacotes e bibliotecas devem estar instalados:

apache2
apache2-mpm-itk
apache2-utils
apache2.2-bin
apache2.2.common
libapache2-mod-php5
libapr1
libaprutil1
libaprutil1-dbd-sqlite3
libphp-adodb
php5
php5-adodb
php5-cli
php5-common
php5-mysql
php5-suhosin

3. Baixar o ZendFramework.
O Zend Framework tem uma grande variedade de opções de instalação:

a) usar o canal PEAR;
b) baixar via aptitude (ou Synaptic) a versão do ZendFramework do repositório Debian;
c) instalar a Zend Zend Server Community Edition (CE), que é uma forma agradável e fácil de iniciar o desenvolvimento com Zend Server;
d) baixar a última versão do ZendFramework da própria página oficial do framework, e instalá-la manualmente.

Neste post vamos adotar a última opção acima, ou seja, baixar a mais recente versão do framewotk diretamente da sua página oficial. Para isto, deve-se entrar na página da ZendFramework, na seção download, e escolher o pacote e versão para baixar. Basicamente, existem duas opções para download:

  • Zend Framework Full: pacote completo com todas as ferramentas internas e externas da biblioteca. Aplicativo de linha de comando para Windows e Linux. Além de testes que podem ser executados, estão presentes algumas classes adicionais e o Dojo Toolkit, pacote Javascript utilizado oficialmente.
  • Zend Framework Minimal: pacote contendo todas as classes do Zend Framework e o aplicativo de linha de comando para Windows e Linux. Não encontramos algumas estruturas adicionais, porém esta versão contém todos os arquivos necessários para programação.

Vamos fazer este post utilizando a versão “full”.

Após baixar o arquivo ZendFramework-1.11.11.tar.gz, descompacte o seu conteúdo em /opt através do seguinte comando:

# tar -xvf ZendFramework-1.11.11.tar.gz -C /opt/

Será gerado uma estrutura de diretórios da seguinte forma (obs: use o comando “tree” para isto):

. (/opt)
── ZendFramework-1.11.11
├── bin
│   ├── zf.bat
│   ├── zf.php
│   └── zf.sh
├── demos
│   └── Zend
├── externals
│   └── dojo
├── extras
│   ├── library
│   └── tests
├── incubator
├── INSTALL.txt
├── library
│   └── Zend
├── LICENSE.txt
├── README.txt
├── resources
│   └── languages
├── src
└── tests
├── AllTests.php
├── phpunit.xml
├── resources
├── runtests.sh
├── TestConfiguration.php.dist
├── TestHelper.php
└── Zend

4. Configurar o ambiente
4.1 Variável include_path do PHP

O diretório library, onde o Zend espera localizar todos os seus arquivos, deve estar incluído no include_path. Edite os arquivos /etc/php5/apache2/php.ini e /etc/php5/cli/php.ini nas seções Paths and Directories que fica aproximadamente na linha 780 (dentro da sessão “Paths and Directories”), como no exemplo abaixo:

; UNIX: "/path1:/path2"
include_path = “.:/opt/ZendFramework-1.11.11/library”

4.2 Habilitar módulo rewrite do Apache
Para habilitar o módulo execute o seguinte o seguinte comando:

# a2enmod rewrite

Também é necessário alterar o arquivo /etc/apache2/sites-available/default, na tag <Directory /var/www/> temos o parâmetro AllowOverride com o valor None. Mude-o para All.

4.3 Recarregar as configurações do Apache e do PHP

Use o seguinte comando:


# /etc/init.d/apache2 reload

4.4 Criar alias para usar linha de comando
O ZendFramework vem equipado com uma ferramenta CLI, ou “command line tool” (internamente conhecida como a ferramenta de console), é correntemente a interface primária para “dispatching” solicitações à Zend_Tool.

Para fazer uso desta ferramenta de linha de comando, deve-se criar um alias para o comando zf. Edite o arquivo /etc/bash.bashrc e adicione no seu final a seguinte linha:

alias zf=/opt/ZendFramework-1.11.11/bin/zf.sh

5. Testar o funcionamento do ZendFramework
Feche e abra um novo terminal. Qualquer usuário do sistema pode executar o Zend Framework Command Line Console Tool, basta apenas digitar zf no terminal.

a) Para visualizar qual versão do ZendFramework está instalada, executar o seguinte comando:

$ zf show version

cuja resposta deve ser algo parecido com:

Zend Framework Version: 1.11.11

b) Para que o Zend_Tool possa funcionar, deve ser possível executar o PHP. Para testar execute:

$ php -v

cuja resposta deve ser algo parecido com:
PHP 5.3.3-1ubuntu9.3 with Suhosin-Patch (cli) (built: Jan 12 2011 16:08:14)
Copyright (c) 1997-2009 The PHP Group
Zend Engine v2.3.0, Copyright (c) 1998-2010 Zend Technologies

6. Criar um projeto

6.1) Criar área do projeto no ZendFramework:

Vamos criar o projeto dentro de uma pasta na própria área do usuário. Essa pasta será a raiz de nosso servidor virtual a ser criado.  Isto facilitará a criação de arquivos já que o usuário local já terá todas as permissões para manipulação dos mesmos, não necessitando se logar como administrador. Para criar o projeto helloworld execute o seguinte comando:


$ zf create project /home/usuario/helloworld

Após este comando, uma estrutura de diretórios padrão do Zend Framework será criada.  Veja abaixo uma estrutura ideal para se iniciar um projeto (nem todas as pastas foram criadas automaticamente pelo comando acima):
Estrutura de Diretórios para iniciar um projeto.

Vamos analisar esta árvore:

  • Diretório application/: armazena todos os arquivos referentes ao aplicativo. Neste local encontramos toda a programação não visualizável em ambientes externos, ou seja, sua programação PHP. Arquivos como imagens ou que não devem sofrer processamento, como CSS estático, não devem ser armazenados neste local. Ainda neste diretório, vamos armazenar toda a arquitetura MVC, módulos criados, configurações necessárias para inicialização do aplicativo e classes de Bootstrap.
    • Diretório configs/: diretório de configuração da aplicação. Este diretório recebe todas as configurações do aplicativo. O Zend Framework carrega o application.ini em tempo de inicialização, intepretando as informações descritas. Com ele é possível trabalhar com recursos prontos sem programação. Antigamente, se você necessitava conectar ao banco de dados, era necessária a programação manual de conexão no arquivo de inicialização. Hoje, basta inserirmos algumas linhas no arquivo de configuração e todo o tratamento estará disponível, sem nenhuma codificação especial do programador. Este diretório deve armazenar qualquer programação necessária para inicializar o aplicativo, como arquivos XML contendo a estrutura inicial da barra de navegação ou qualquer característica modificável sem a necessidade de inclusão de código PHP.
    • Diretórios controllers/, models/, e views/: estes diretórios servem como os diretórios  default para o controller, model or view. Criar estes diretórios dentro do diretório application/ é o melhor leiaute para iniciar um projeto simples bem como para iniciar um projeto modular que tem controllers/models/views globais. Estes diretórios armazenam as controladoras da arquitetura MVC. As controladoras são as classes que armazenam a manipulação dos dados provenientes dos modelos e envia os processamentos prontos para a camada de visualização. Cada arquivo interno a este diretório deve armazenar somente uma classe de controladora e nomeado com o mesmo nome. Ou seja, caso exista uma controladora de “escolas”, a classe terá nome EscolasController, estendida da Zend_Controller_Action, e o arquivo deverá ser nomeado como EscolasController.php.
    • Diretórios controllers/helpers/: Estes diretórios conterão helpers de ação. Hekpes de ação serão “namespaced” bem como “Controller_Helper_” para o módulo default ou “<Module>_Controller_Helper” de outros modulos.
    • Diretório layouts/: diretório que armazena o formato da aplicação a ser construída, destinado aos layoutes do MVC. Desde que Zend_Layout é capaz de ter laiautes de MVC- e não-MVC-based, a locação deste diretório reflete que os leiautes não são relacionados 1-a-1 com os controladores e são independentes dos templates dos views/.  Participando da camada de visualização, este espaço armazena os templates utilizados para renderização da aplicação, juntamente com a classe Zend_Layout (padrão do ZF). Este diretório deve possuir o mesmo formato do views, descrito a frente. Se vamos utilizar o template layout.phtml em nosso aplicativo, ele deve ser armazenado da seguinte maneira:

    • Diretório modules/: permite ao desenvolvedor agrupar um conjunto de controladores relacionados em um grupo logicamente organizado. A estrutura abaixo deste diretório poderia ser semelhantes a estrutura abaixo do diretório  application/.  Cada módulo deve ser desenvolvido como um aplicativo qualquer, tentando manter o mínimo de dependência entre eles. Ao desenvolver um módulo admin, este deverá receber uma classe de inicialização chamada Admin_Bootstrap, assim como o inicializador do aplicativo descrito a frente. Qualquer classe pertencente a este módulo, deverá possuir o namespace Admin prefixadoEstrutura de Diretórios de modulos.
    • Diretorio views/: a camada de visualização da arquitetura MVC é encontrada no diretório views/. Respeitando esta arquitetura, não se deve desenvolver uma programação além de saída de dados, estruturas de blocos condicionais if-else ou laços de repetição como while for. Os auxiliares da camada de visualização são encontrados no diretório helpers. Já os templates de saída são criados no diretório scripts. Ao criar a controladora de produtos ProdutoController, devemos adicionar o subdiretório scripts/poduto; implementando a ação de listagem de produtos listAction à controladora, vamos incluir o arquivo de visualização scripts/produto/list.phtml. Note que todos os arquivos de saída da camada de visualização devem possuir a extensão phtmlEstrutura de diretorios View.
    • Diretório services/: este diretório é para os arquivos dos web-services da aplicação a ser desenvolvida, ou para implementar um » Service Layer  para seus models.
  • data/: este diretório fornece um lugar para armazenar dados voláteis da aplicação e possivelmente temporários. A perturbação dos dados neste diretório pode fazer com que o aplicativo falhe. Além disso, as informações contidas neste diretório pode ou não estar comprometidas com um repositório de subversão. Exemplos de coisas nesse diretório estão os arquivos de sessão, arquivos de cache, bancos de dados sqlite, logs, arquivos de uploads, índices e todas informações não existentes na instalação do aplicativo e que são gerados durante o seu ciclo de vida..
  • Diretório docs/: este directório contém documentação, tanto o gerado como os de autoria própria.
  • Diretório library/: este diretório é para bibliotecas comuns que a aplicação necessita, e deve estar no include_path do PHP. Os desenvolvedores devem colocar o código da biblioteca da aplicação sob este diretório em um espaço exclusivo, seguindo as diretrizes do guia de nomenclatura estabelecidas no » O manual de nomes do PHP, bem como os estabelecidos pela própria Zend. Este diretório pode também incluir o Zend Framework em si; se for o caso, o programador poderia guardá-lo em library/Zend/.
  • Diretório public/: este diretório contém todos os arquivos públicos de sua aplicação. index.php configura e invoca Zend_Application, que por sua vez invoca o arquivo application/Bootstrap.php, resultando em despachar o controlador frontal. A raiz do seu servidor web normalmente seria definido para este diretório.
  • Diretório scripts/: este diretório contém scripts de manutenção e/ou de instalação do sistema e banco de dados. Estes scripts podem incluir ações através de linhas de comando, cron, ou “phing build scripts” que não são executadas em tempo de execução, mas são parte do funcionamento correto do aplicativo.
  • Diretório temp/: diretório reservado para os dados transitórios do aplicativo. Estas informações não são normalmente salvos no repositório svn do projeto (deve receber a configuração svn:ignore em serviços de versionamento). Se os dados sob o diretório temp/ forem excluídos, o aplicativo deve ser capaz de continuar sendo executado com uma possível diminuição no desempenho até que os dados sejam mais uma vez restaurados ou recarregados.
  • Diretório tests/: este diretório contém testes de aplicação. Estes poderiam ser escritos à mão, baseados no PHPUnit, Zend_Test ou Selenium-RC, ou com base em alguma outro framework de testes.

6.2) Criar domínio zend.localhost no Apache

a) Copiar o conteúdo do arquivo “default” para o arquivo “zendlocal” (que será criado), o qual abrigará as configurações do novo sítio:
# cp /etc/apache2/sites-available/default /etc/apache2/sites-available/zendlocal

b) Editar o arquivo  /etc/apache2/sites-available/zendlocal . Abaixo um espelho do arquivo zendlocal após a sua edição de apontamentos para o novo sitio zend.localhost a ser criado:

<VirtualHost *:80>
ServerAdmin webmaster@localhost
ServerName zend.localhost
DocumentRoot /home/usuario/helloworld/public

<Directory />
Options FollowSymLinks
AllowOverride None
</Directory>

<Directory /home/usuario/helloworld/public>
Options Indexes FollowSymLinks MultiViews
AllowOverride All
Order allow,deny
allow from all
</Directory>

ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
<Directory "/usr/lib/cgi-bin">
AllowOverride None
Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
Order allow,deny
Allow from all
</Directory>

ErrorLog ${APACHE_LOG_DIR}/error.log
# Possible values include: debug, info, notice, warn, error, crit,
# alert, emerg.
LogLevel warn
CustomLog ${APACHE_LOG_DIR}/access.log combined
Alias /doc/ "/usr/share/doc/"

<Directory "/usr/share/doc/">
Options Indexes MultiViews FollowSymLinks
AllowOverride None
Order deny,allow
Deny from all
Allow from 127.0.0.0/255.0.0.0 ::1/128
</Directory>
</VirtualHost>

Observe que com a declaração “AllowOverride All” já estamos preparando o Apache para funcionar com o seu módulo de reescrita.

c) Habilitar o site zend.localhost:
# a2ensite zendlocal

d) Reiniciar o apache com o comando:

# /etc/init.d/apache2 reload

c) Editar o arquivo /etc/hosts caso o navegador esteja sendo executado na própria máquina onde está instalado o Apache. Neste caso, deve ser adicionando a seguinte entrada ao arquivo:

127.0.0.1 zend.localhost

6.3) Testar o funcionamento: com um navegador, constatar o funcionamento do Apache com o ZendFramework conforme nossos dois exemplos abaixo:

a) Digitar na barra de endereços http://zend.localhost

Resultado: uma página em branco deverá ser mostrada.

b) Criar um arquivo chamado /home/usuario/helloworld/public/index.html com um conteúdo simples para teste, tal como este a seguir:
<html>
<title>Testando Zend</title>
<h1>Oi, testando o Zend</h1>
</html>

Ao digital novamente na barra de endereços do navegador http://zend.localhost, será mostrada uma página com o conteúdo “Oi, testando o Zend” .

6.4) Disponibilizar as bibliotecas do Zend

Copiar a pasta Zend(aproximadamente 23MB), que se encontra dentro de /opt/ZendFramework-1.11.11/library/ para a pasta helloworld/library:

usuario@002755:~/helloworld/library$ cp -R /opt/ZendFramework-1.11.11/library/Zend/ .

A estrutura ficará parecida com esta:
. (/helloworld/library)
`– Zend
|– Acl
|– Amf
|– Application
|– Auth
|– Barcode
|– Cache
|– Captcha
|– Cloud
|– CodeGenerator
|– Config
|– Console
|– Controller
|– Crypt
|– Currency
|– Date
|– Db
|– Debug.php
|– Dojo
|– Dom
|– Feed
|– File
|– Filter
|– Form
|– Gdata
|– Http
|– InfoCard
|– Json
|– Layout
|– Ldap
|– Loader
|– Locale
|– Log
|– Mail
|– Markup
|– Measure
|– Memory
|– Mime
|– Navigation
|– Oauth
|– OpenId
|– Paginator
|– Pdf
|– ProgressBar
|– Queue
|– Reflection
|– Rest
|– Search
|– Serializer
|– Server
|– Service
|– Session
|– Soap
|– Tag
|– Test
|– Text
|– TimeSync
|– Tool
|– Translate
|– Uri
|– Validate
|– View
|– Wildfire
`– XmlRpc

6.5) Testes finais após a disponibilização da biblioteca Zend

a) Usando um navegador, acesse o endereço http://zend.localhost, a tela abaixo de boas vindas do ZendFramework será mostrada.

Tela Boas Vindas do Zend

b) Verificar o Roteamento

Para verificar se o roteamento de páginas está funcionando, visite com um navegador um endereço qualquer, interno ao projeto. Vamos visitar uma página inválida do projeto,tal como:
http://zend.localhost/exemplo.html

O roteamento estará funcionando se a página visualizada for um aviso de “An error occurred, page not found”. Caso contrário, o roteamento do projeto não está funcionando, como é caso de se ter no navegador um erro de página não encontrada gerada pelo próprio servidor Web (“Not Found The requested URL was not found on this server“).

7.Mensagem final
Para se ter um ambiente completo para desenvolvimento de aplicações, ainda falta realizar outros procedimentos. Como por exemplo, instalar banco de dados (MySQL, Postgres, …) e criar e configurar o arquivo .htaccess. Mas isto ficará para um outro post. O importante neste momento é que o ZendFramework teve sua instalação e configuração básica realizada com sucesso.

Referências:
1- Guia de Referência do programador ZendFramework
2- Instalar e configurar o ZendFramework
3- Installing Zend Framework under a Debian Linux
4- ZendFramework
5- Introdução ao Zend Framework
6- Instalar servidor LAMP (Linux + Apache + PHP + MySQL) no Debian
7- Instalar e configurar Módulos do Apache2 no Debian
8- Entendendo a Zend Framework