Edwilson Sousa

Hello World com Zend Framework

No post anterior mostrei a estrutura de diretórios recomendada para se utilizar o Zend Framework, agora iremos criar as primeiras linhas de código, e fazer o software mais famoso entre nós programadores, o Hello World.

Se você ainda não utilizou frameworks de desenvolvimento deve estar pensando: "ok, mas o hello world em php se resume a <?php echo 'Hello World!'; ?>", pois bem, usaremos esse exemplo de uma simples saída de string mas usando a estrutura MVC (Model View Controller) implementada em Zend Framework para gerar esse mesmo resultado, e a medida em que você for seguindo no seu projeto você verá as inúmeras vantagens de utilizar essa arquitetura.

Observe que até o momento o nosso projeto não possui sequer um arquivo no nosso diretório público (public_html, httpdocs, www, etc), nós precisaremos apenas de um arquivo .php no diretório público, e a única coisa que ele fará é disparar o inicializador do projeto (Bootstrap). Então, vamos ao que interessa...

// httpdocs/index.php
defined('APPLICATION_PATH') || define('APPLICATION_PATH', '/home/zend/application/projeto/');
defined('APPLICATION_ENV') || define('APPLICATION_ENV', 'testing');
set_include_path(implode(PATH_SEPARATOR, array(APPLICATION_PATH, "/home/zend/library/")));
 
require_once 'Zend/Application.php';
 
$application = new Zend_Application(APPLICATION_ENV, APPLICATION_PATH . '/configs/application.ini');
$application->bootstrap()->run();

6 linhas de código. É o que normalmente você precisa ter no seu arquivo index.php, aproveitamos para criar duas constantes (APPLICATON_PATH e APPLICATION_ENV), que serão usadas posteriormente pela nossa aplicação.

A constante APPLICATION_PATH contém o caminho absoluto para o seu projeto, conforme a estrutura de arquivos definida no post anterior, no meu caso, o projeto se chama "projeto" e está localizada em "/home/zend/application/projeto/", não esqueça de alterar esse caminho para o caminho exato no seu servidor.

Agora algo interessante, a constante APPLICATION_ENV, onde nós configuramos o ambiente da nossa aplicação (de teste, produção, ou desenvolvimento). Apenas alterando esse valor da constante no nosso arquivo index.php poderemos modificar completamente o comportamento da nossa aplicação, ocultando as mensagens de erro do php, conectando a uma base de dados diferente, etc, isso é muito útil quando se quer ter uma aplicação rodando em ambiente de produção e em ambiente de testes, sem que uma interfira na outra, e sem que se precise alterar inúmeras configurações para rodar no seu servidor de testes.

Configuramos também o include path do php, tudo para facilitar o nosso trabalho. Quando o php precisar incluir algum arquivo irá buscar também no APPLICATION_PATH e no diretório "/home/zend/library/", lembrando que esse último contém os arquivos do próprio framework.

Nas últimas 3 linhas a mágica começa a acontecer. Fazemos a inclusão do arquivo "Zend/Application.php", este se encarregará de chamar os outros arquivos necessários.  No próximo passo instanciamos a classe Zend_Application passando como parametro o ambiente atual (APPLICATION_ENV) e o caminho para o arquivo de configuração da nossa aplicação, que criaremos a seguir.

Antes de criarmos o arquivo de configuração da nossa aplicação, vamos apenas cuidar de mais um importantíssimo detalhe na pasta pública, o ".htaccess". Queremos que todas as nossas requisições sejam enviadas para o arquivo index.php, exceto (é lógico) as requisições de imagem, arquivos CSS e JavaScript.

Crie um arquivo .htaccess na pasta pública  com o seguinte conteúdo:

; /httpdocs/.htaccess
RewriteEngine on
 
RewriteRule !\.(js|ico|txt|gif|jpg|png|css)$ index.php

Até o momento isso é tudo que precisaremos no diretório público.

Voltando à parte divertida, agora criaremos o arquivo de configuração da nossa aplicação com o seguinte conteúdo:

; /home/zend/application/projeto/configs/application.ini
[production]
;isso é um comentário
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0
includePaths.library = APPLICATION_PATH "/library/"
 
; Bootstrap
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
; Controller
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
[staging : production]
 
[testing : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

Não se desespere (ainda), o arquivo application.ini define as configurações da nossa aplicação, nela iremos salvar as configurações de acesso ao banco de dados, o layout utilizado pela aplicação, configurações do php, etc.

Observe que a sintaxe do arquivo, apesar de não familiar a muitos, é bastante simples. Começamos com [production]. Essa tag define que essa será a sessão que define as configurações da aplicação em modo de produção, nessa sessão nós desativamos a saída de erros do PHP, e definimos algumas outras opções, das quais vale a pena destacar a chamada para o arquivo de inicalização do projeto, o Bootstrap.php.

Deixaremos a sessão staging em branco, por enquanto, e apenas iremos tornar os erros visíveis na última sessão, a "testing".

Nas duas úttimas sessões do arquivo .ini nós temos a seguinte sintaxe: [env : production] , isso apenas quer dizer que a sessão irá herdar da sessão production, isso evita ter que repetir algumas partes do código para cada sessão.

Voltaremos ao arquivo .ini posteriormente, agora iremos a mais uma etapa: o Bootstrap.

Talvez você não seja habituado ao termo (ou talvez sim), mas o bootstrap irá nos fornecer métodos para configurar a aplicação em sua inicialização, ou seja, permite que eu defina certos comportamentos e realize algumas operações enquanto carrego a aplicação, em resumo iremos "dar o boot" no nosso sistema, vamos à ele:

//home/zend/application/projeto/Boostrap.php
require_once 'Zend/Loader/Autoloader.php';
 
Zend_Loader_Autoloader::getInstance();
 
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {
    //That´s all
}

Pronto, esse é o nosso Boostrap (por enquanto).

No momento, para facilitar ao máximo, iremos deixar de lado o que podemos fazer no Boostrap, mas, observe que nesse arquivo nós incluimos mais um arquivo do ZF, o Autoloader.php, e fazemos isso para não ter que incluir mais arquivos manualmente, a instancia dessa classe se encarrega de incluir os arquivos que precisamos, à medida em que precisamos.

Ok, tudo configurado, agora estamos prontos para iniciar (iniciar? o_O OMG!)

O que fizemos até o momento foi cuidar das configurações da aplicação, agora iremos realmente fazer o que queremos: o Hello World.

Lembre-se que utilizaremos o padrao MVC, se já está familiarizado com ele sabe que teremos que implementar a lógica separadamente da saída para o usuário.

Como não entraremos em detalhes sobre banco de dados, até o momento, iremos dispensar a parte de Model, e utilizar apenas o View e o Controller.

Pois bem, os controladores da nossa aplicação deverão seguir a um padrão de nomenclatura estabelecido pelo ZF, esse padrão determina a composição do nome do arquivo e a composição da classe.

Os nossos controladores serão criados na pasta "/home/zend/application/projeto/controllers/" e o seu nome será composto por "NomeControlador" (camel cased) + Controller.php. Exemplo: para o controlador teste, o nome do arquivo seria: TesteController.php, para o controller "alterar aparencia" o nome do arquivo seria AlterarAparenciaController.php, e assim sucessivamente.

O controller será chamado quando o usuário acessar o seu nome (minúsculo) no navegador. Por exemplo: para acessar o controller teste o usuário utilizaria o endereço: http://projeto.local/teste, para acessar o controlador AlterarAparenciaController.php o usuário utilizaria o endereço: http://projeto.local/alterar_aparencia, etc.

O contolador chamado por default quando o usuário acessa a raiz do site é o IndexController.php, e será esse o arquivo que iremos criar:

// home/zend/application/projeto/controllers/IndexController.php
class IndexController extends Zend_Controller_Action {
     function indexAction(){
        Zend_Layout::getMvcInstance()->disableLayout();
        $this->view->hello = "Hello World!";
    }
}

Todos os nossos controladores deverão herdar da classe Zend_Controller_Action. Cada ação deverá iniciar com letras minúsculas, e seguidas de Action. O endereço para o acesso à uma ação será: http://projeto.local/controlador/action, exemplo: o controlador teste tem a ação andar, o usuário acessaria http://projeto.local/teste/andar e o controlador TesteController.php iria executar a ação andarAction(). No nosso caso, por se tratar do controlador index e da ação index, o usuári o pode acessar http://projeto.local/index/index/ ou simplesmente http://projeto.local/

Desativamos o layout (utilizaremos layouts depois), e logo depois enviamos para a camada View do modelo MVC a string "Hello World" .

Portanto, a última etapa será mostrar o resultado, para isso criaremos a nossa primeira view.

As views deverão ser criadas na pasta "/home/zend/application/projeto/views/scripts ", cada controlador "ganha" uma pasta com seu nome (minúsculo, e sem o "Controller"), e cada ação ganha um arquivo com o seu nome (minúsculo e sem o action). Exemplo: para o controlador teste com a ação andar iriamos criar a pasta  "/home/zend/application/projeto/views/scripts/teste " e dentro dessa pasta criaríamos o arquivo "andar.phtml" (observe a extensão: .phtml).

Para o nosso código, nós iremos criar a pasta   "/home/zend/application/projeto/views/scripts/index" e dentro dessa pasta criaremos o arquivo "index.phtml". Por último, iremos exibir o que foi enviado pelo controlador.

<?php
 // home/zend/application/projeto/views/scripts/index/index.phtml
 echo $this->hello; 
?>

Pronto, depois de percorrer esse longo caminho, ao acessar http://projeto.local/ teremos como resultado o nosso esperado "Hello World"
O próximo passo será conectar e manipular uma base de dados, usar layouts e conhecer um pouco mais do Boostrap do ZF. Espero que você volte em breve para acompanhar os próximos posts.
Não esqueça de deixar suas críticas, sugestões, dúvidas, etc. Até a próxima!