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!